1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2023 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
29 #include "tree-pass.h"
34 #include "regs.h" /* For reg_renumber. */
38 #include "diagnostic.h"
39 #include "fold-const.h"
41 #include "stor-layout.h"
43 #include "print-tree.h"
47 #include "cfgcleanup.h"
52 #include "internal-fn.h"
54 #include "gimple-iterator.h"
55 #include "gimple-expr.h"
56 #include "gimple-walk.h"
61 #include "gimple-pretty-print.h"
64 #include "tree-inline.h"
65 #include "value-prof.h"
66 #include "tree-ssa-live.h"
67 #include "tree-outof-ssa.h"
69 #include "insn-attr.h" /* For INSN_SCHEDULING. */
70 #include "stringpool.h"
73 #include "tree-ssa-address.h"
78 /* Some systems use __main in a way incompatible with its use in gcc, in these
79 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80 give the same symbol without quotes for an alternative entry point. You
81 must define both, or neither. */
83 #define NAME__MAIN "__main"
86 /* This variable holds information helping the rewriting of SSA trees
90 /* This variable holds the currently expanded gimple statement for purposes
91 of comminucating the profile info to the builtin expanders. */
92 gimple
*currently_expanding_gimple_stmt
;
94 static rtx
expand_debug_expr (tree
);
96 static bool defer_stack_allocation (tree
, bool);
98 static void record_alignment_for_reg_var (unsigned int);
100 /* Return an expression tree corresponding to the RHS of GIMPLE
104 gimple_assign_rhs_to_tree (gimple
*stmt
)
107 switch (gimple_assign_rhs_class (stmt
))
109 case GIMPLE_TERNARY_RHS
:
110 t
= build3 (gimple_assign_rhs_code (stmt
),
111 TREE_TYPE (gimple_assign_lhs (stmt
)),
112 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
),
113 gimple_assign_rhs3 (stmt
));
115 case GIMPLE_BINARY_RHS
:
116 t
= build2 (gimple_assign_rhs_code (stmt
),
117 TREE_TYPE (gimple_assign_lhs (stmt
)),
118 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
));
120 case GIMPLE_UNARY_RHS
:
121 t
= build1 (gimple_assign_rhs_code (stmt
),
122 TREE_TYPE (gimple_assign_lhs (stmt
)),
123 gimple_assign_rhs1 (stmt
));
125 case GIMPLE_SINGLE_RHS
:
127 t
= gimple_assign_rhs1 (stmt
);
128 /* Avoid modifying this tree in place below. */
129 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
130 && gimple_location (stmt
) != EXPR_LOCATION (t
))
131 || (gimple_block (stmt
) && currently_expanding_to_rtl
140 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
141 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
147 #ifndef STACK_ALIGNMENT_NEEDED
148 #define STACK_ALIGNMENT_NEEDED 1
151 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
153 /* Choose either CUR or NEXT as the leader DECL for a partition.
154 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
155 out of the same user variable being in multiple partitions (this is
156 less likely for compiler-introduced temps). */
159 leader_merge (tree cur
, tree next
)
161 if (cur
== NULL
|| cur
== next
)
164 if (DECL_P (cur
) && DECL_IGNORED_P (cur
))
167 if (DECL_P (next
) && DECL_IGNORED_P (next
))
173 /* Associate declaration T with storage space X. If T is no
174 SSA name this is exactly SET_DECL_RTL, otherwise make the
175 partition of T associated with X. */
177 set_rtl (tree t
, rtx x
)
179 gcc_checking_assert (!x
180 || !(TREE_CODE (t
) == SSA_NAME
|| is_gimple_reg (t
))
181 || (use_register_for_decl (t
)
183 || (GET_CODE (x
) == CONCAT
184 && (REG_P (XEXP (x
, 0))
185 || SUBREG_P (XEXP (x
, 0)))
186 && (REG_P (XEXP (x
, 1))
187 || SUBREG_P (XEXP (x
, 1))))
188 /* We need to accept PARALLELs for RESUT_DECLs
189 because of vector types with BLKmode returned
190 in multiple registers, but they are supposed
191 to be uncoalesced. */
192 || (GET_CODE (x
) == PARALLEL
194 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
195 && (GET_MODE (x
) == BLKmode
196 || !flag_tree_coalesce_vars
)))
197 : (MEM_P (x
) || x
== pc_rtx
198 || (GET_CODE (x
) == CONCAT
199 && MEM_P (XEXP (x
, 0))
200 && MEM_P (XEXP (x
, 1))))));
201 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
202 RESULT_DECLs has the expected mode. For memory, we accept
203 unpromoted modes, since that's what we're likely to get. For
204 PARM_DECLs and RESULT_DECLs, we'll have been called by
205 set_parm_rtl, which will give us the default def, so we don't
206 have to compute it ourselves. For RESULT_DECLs, we accept mode
207 mismatches too, as long as we have BLKmode or are not coalescing
208 across variables, so that we don't reject BLKmode PARALLELs or
210 gcc_checking_assert (!x
|| x
== pc_rtx
|| TREE_CODE (t
) != SSA_NAME
212 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
213 && (promote_ssa_mode (t
, NULL
) == BLKmode
214 || !flag_tree_coalesce_vars
))
215 || !use_register_for_decl (t
)
216 || GET_MODE (x
) == promote_ssa_mode (t
, NULL
));
221 tree cur
= NULL_TREE
;
229 else if (SUBREG_P (xm
))
231 gcc_assert (subreg_lowpart_p (xm
));
232 xm
= SUBREG_REG (xm
);
235 else if (GET_CODE (xm
) == CONCAT
)
240 else if (GET_CODE (xm
) == PARALLEL
)
242 xm
= XVECEXP (xm
, 0, 0);
243 gcc_assert (GET_CODE (xm
) == EXPR_LIST
);
247 else if (xm
== pc_rtx
)
252 tree next
= skip
? cur
: leader_merge (cur
, SSAVAR (t
) ? SSAVAR (t
) : t
);
257 set_mem_attributes (x
,
258 next
&& TREE_CODE (next
) == SSA_NAME
262 set_reg_attrs_for_decl_rtl (next
, x
);
266 if (TREE_CODE (t
) == SSA_NAME
)
268 int part
= var_to_partition (SA
.map
, t
);
269 if (part
!= NO_PARTITION
)
271 if (SA
.partition_to_pseudo
[part
])
272 gcc_assert (SA
.partition_to_pseudo
[part
] == x
);
273 else if (x
!= pc_rtx
)
274 SA
.partition_to_pseudo
[part
] = x
;
276 /* For the benefit of debug information at -O0 (where
277 vartracking doesn't run) record the place also in the base
278 DECL. For PARMs and RESULTs, do so only when setting the
280 if (x
&& x
!= pc_rtx
&& SSA_NAME_VAR (t
)
281 && (VAR_P (SSA_NAME_VAR (t
))
282 || SSA_NAME_IS_DEFAULT_DEF (t
)))
284 tree var
= SSA_NAME_VAR (t
);
285 /* If we don't yet have something recorded, just record it now. */
286 if (!DECL_RTL_SET_P (var
))
287 SET_DECL_RTL (var
, x
);
288 /* If we have it set already to "multiple places" don't
290 else if (DECL_RTL (var
) == pc_rtx
)
292 /* If we have something recorded and it's not the same place
293 as we want to record now, we have multiple partitions for the
294 same base variable, with different places. We can't just
295 randomly chose one, hence we have to say that we don't know.
296 This only happens with optimization, and there var-tracking
297 will figure out the right thing. */
298 else if (DECL_RTL (var
) != x
)
299 SET_DECL_RTL (var
, pc_rtx
);
306 /* This structure holds data relevant to one variable that will be
307 placed in a stack slot. */
314 /* Initially, the size of the variable. Later, the size of the partition,
315 if this variable becomes it's partition's representative. */
318 /* The *byte* alignment required for this variable. Or as, with the
319 size, the alignment for this partition. */
322 /* The partition representative. */
323 size_t representative
;
325 /* The next stack variable in the partition, or EOC. */
328 /* The numbers of conflicting stack variables. */
332 #define EOC ((size_t)-1)
334 /* We have an array of such objects while deciding allocation. */
335 static class stack_var
*stack_vars
;
336 static size_t stack_vars_alloc
;
337 static size_t stack_vars_num
;
338 static hash_map
<tree
, size_t> *decl_to_stack_part
;
340 /* Conflict bitmaps go on this obstack. This allows us to destroy
341 all of them in one big sweep. */
342 static bitmap_obstack stack_var_bitmap_obstack
;
344 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
345 is non-decreasing. */
346 static size_t *stack_vars_sorted
;
348 /* The phase of the stack frame. This is the known misalignment of
349 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
350 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
351 static int frame_phase
;
353 /* Used during expand_used_vars to remember if we saw any decls for
354 which we'd like to enable stack smashing protection. */
355 static bool has_protected_decls
;
357 /* Used during expand_used_vars. Remember if we say a character buffer
358 smaller than our cutoff threshold. Used for -Wstack-protector. */
359 static bool has_short_buffer
;
361 /* Compute the byte alignment to use for DECL. Ignore alignment
362 we can't do with expected alignment of the stack boundary. */
365 align_local_variable (tree decl
, bool really_expand
)
369 if (TREE_CODE (decl
) == SSA_NAME
)
371 tree type
= TREE_TYPE (decl
);
372 machine_mode mode
= TYPE_MODE (type
);
374 align
= TYPE_ALIGN (type
);
376 && align
< GET_MODE_ALIGNMENT (mode
))
377 align
= GET_MODE_ALIGNMENT (mode
);
380 align
= LOCAL_DECL_ALIGNMENT (decl
);
382 if (hwasan_sanitize_stack_p ())
383 align
= MAX (align
, (unsigned) HWASAN_TAG_GRANULE_SIZE
* BITS_PER_UNIT
);
385 if (TREE_CODE (decl
) != SSA_NAME
&& really_expand
)
386 /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
387 That is done before IPA and could bump alignment based on host
388 backend even for offloaded code which wants different
389 LOCAL_DECL_ALIGNMENT. */
390 SET_DECL_ALIGN (decl
, align
);
392 return align
/ BITS_PER_UNIT
;
395 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
396 down otherwise. Return truncated BASE value. */
398 static inline unsigned HOST_WIDE_INT
399 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
401 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
404 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
405 Return the frame offset. */
408 alloc_stack_frame_space (poly_int64 size
, unsigned HOST_WIDE_INT align
)
410 poly_int64 offset
, new_frame_offset
;
412 if (FRAME_GROWS_DOWNWARD
)
415 = aligned_lower_bound (frame_offset
- frame_phase
- size
,
416 align
) + frame_phase
;
417 offset
= new_frame_offset
;
422 = aligned_upper_bound (frame_offset
- frame_phase
,
423 align
) + frame_phase
;
424 offset
= new_frame_offset
;
425 new_frame_offset
+= size
;
427 frame_offset
= new_frame_offset
;
429 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
430 frame_offset
= offset
= 0;
435 /* Ensure that the stack is aligned to ALIGN bytes.
436 Return the new frame offset. */
438 align_frame_offset (unsigned HOST_WIDE_INT align
)
440 return alloc_stack_frame_space (0, align
);
443 /* Accumulate DECL into STACK_VARS. */
446 add_stack_var (tree decl
, bool really_expand
)
450 if (stack_vars_num
>= stack_vars_alloc
)
452 if (stack_vars_alloc
)
453 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
455 stack_vars_alloc
= 32;
457 = XRESIZEVEC (class stack_var
, stack_vars
, stack_vars_alloc
);
459 if (!decl_to_stack_part
)
460 decl_to_stack_part
= new hash_map
<tree
, size_t>;
462 v
= &stack_vars
[stack_vars_num
];
463 decl_to_stack_part
->put (decl
, stack_vars_num
);
466 tree size
= TREE_CODE (decl
) == SSA_NAME
467 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
468 : DECL_SIZE_UNIT (decl
);
469 v
->size
= tree_to_poly_uint64 (size
);
470 /* Ensure that all variables have size, so that &a != &b for any two
471 variables that are simultaneously live. */
472 if (known_eq (v
->size
, 0U))
474 v
->alignb
= align_local_variable (decl
, really_expand
);
475 /* An alignment of zero can mightily confuse us later. */
476 gcc_assert (v
->alignb
!= 0);
478 /* All variables are initially in their own partition. */
479 v
->representative
= stack_vars_num
;
482 /* All variables initially conflict with no other. */
485 /* Ensure that this decl doesn't get put onto the list twice. */
486 set_rtl (decl
, pc_rtx
);
491 /* Make the decls associated with luid's X and Y conflict. */
494 add_stack_var_conflict (size_t x
, size_t y
)
496 class stack_var
*a
= &stack_vars
[x
];
497 class stack_var
*b
= &stack_vars
[y
];
501 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
503 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
504 bitmap_set_bit (a
->conflicts
, y
);
505 bitmap_set_bit (b
->conflicts
, x
);
508 /* Check whether the decls associated with luid's X and Y conflict. */
511 stack_var_conflict_p (size_t x
, size_t y
)
513 class stack_var
*a
= &stack_vars
[x
];
514 class stack_var
*b
= &stack_vars
[y
];
517 /* Partitions containing an SSA name result from gimple registers
518 with things like unsupported modes. They are top-level and
519 hence conflict with everything else. */
520 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
523 if (!a
->conflicts
|| !b
->conflicts
)
525 return bitmap_bit_p (a
->conflicts
, y
);
528 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
529 enter its partition number into bitmap DATA. */
532 visit_op (gimple
*, tree op
, tree
, void *data
)
534 bitmap active
= (bitmap
)data
;
535 op
= get_base_address (op
);
538 && DECL_RTL_IF_SET (op
) == pc_rtx
)
540 size_t *v
= decl_to_stack_part
->get (op
);
542 bitmap_set_bit (active
, *v
);
547 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
548 record conflicts between it and all currently active other partitions
552 visit_conflict (gimple
*, tree op
, tree
, void *data
)
554 bitmap active
= (bitmap
)data
;
555 op
= get_base_address (op
);
558 && DECL_RTL_IF_SET (op
) == pc_rtx
)
560 size_t *v
= decl_to_stack_part
->get (op
);
561 if (v
&& bitmap_set_bit (active
, *v
))
566 gcc_assert (num
< stack_vars_num
);
567 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
568 add_stack_var_conflict (num
, i
);
574 /* Helper routine for add_scope_conflicts, calculating the active partitions
575 at the end of BB, leaving the result in WORK. We're called to generate
576 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
580 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
584 gimple_stmt_iterator gsi
;
585 walk_stmt_load_store_addr_fn visit
;
588 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
589 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
593 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
595 gimple
*stmt
= gsi_stmt (gsi
);
596 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
598 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
600 gimple
*stmt
= gsi_stmt (gsi
);
602 if (gimple_clobber_p (stmt
))
604 tree lhs
= gimple_assign_lhs (stmt
);
606 /* Nested function lowering might introduce LHSs
607 that are COMPONENT_REFs. */
610 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
611 && (v
= decl_to_stack_part
->get (lhs
)))
612 bitmap_clear_bit (work
, *v
);
614 else if (!is_gimple_debug (stmt
))
617 && visit
== visit_op
)
619 /* If this is the first real instruction in this BB we need
620 to add conflicts for everything live at this point now.
621 Unlike classical liveness for named objects we can't
622 rely on seeing a def/use of the names we're interested in.
623 There might merely be indirect loads/stores. We'd not add any
624 conflicts for such partitions. */
627 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
629 class stack_var
*a
= &stack_vars
[i
];
631 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
632 bitmap_ior_into (a
->conflicts
, work
);
634 visit
= visit_conflict
;
636 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
641 /* Generate stack partition conflicts between all partitions that are
642 simultaneously live. */
645 add_scope_conflicts (void)
649 bitmap work
= BITMAP_ALLOC (NULL
);
653 /* We approximate the live range of a stack variable by taking the first
654 mention of its name as starting point(s), and by the end-of-scope
655 death clobber added by gimplify as ending point(s) of the range.
656 This overapproximates in the case we for instance moved an address-taken
657 operation upward, without also moving a dereference to it upwards.
658 But it's conservatively correct as a variable never can hold values
659 before its name is mentioned at least once.
661 We then do a mostly classical bitmap liveness algorithm. */
663 FOR_ALL_BB_FN (bb
, cfun
)
664 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
666 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
667 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
674 for (i
= 0; i
< n_bbs
; i
++)
677 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
678 active
= (bitmap
)bb
->aux
;
679 add_scope_conflicts_1 (bb
, work
, false);
680 if (bitmap_ior_into (active
, work
))
685 FOR_EACH_BB_FN (bb
, cfun
)
686 add_scope_conflicts_1 (bb
, work
, true);
690 FOR_ALL_BB_FN (bb
, cfun
)
691 BITMAP_FREE (bb
->aux
);
694 /* A subroutine of partition_stack_vars. A comparison function for qsort,
695 sorting an array of indices by the properties of the object. */
698 stack_var_cmp (const void *a
, const void *b
)
700 size_t ia
= *(const size_t *)a
;
701 size_t ib
= *(const size_t *)b
;
702 unsigned int aligna
= stack_vars
[ia
].alignb
;
703 unsigned int alignb
= stack_vars
[ib
].alignb
;
704 poly_int64 sizea
= stack_vars
[ia
].size
;
705 poly_int64 sizeb
= stack_vars
[ib
].size
;
706 tree decla
= stack_vars
[ia
].decl
;
707 tree declb
= stack_vars
[ib
].decl
;
709 unsigned int uida
, uidb
;
711 /* Primary compare on "large" alignment. Large comes first. */
712 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
713 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
714 if (largea
!= largeb
)
715 return (int)largeb
- (int)largea
;
717 /* Secondary compare on size, decreasing */
718 int diff
= compare_sizes_for_sort (sizeb
, sizea
);
722 /* Tertiary compare on true alignment, decreasing. */
728 /* Final compare on ID for sort stability, increasing.
729 Two SSA names are compared by their version, SSA names come before
730 non-SSA names, and two normal decls are compared by their DECL_UID. */
731 if (TREE_CODE (decla
) == SSA_NAME
)
733 if (TREE_CODE (declb
) == SSA_NAME
)
734 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
738 else if (TREE_CODE (declb
) == SSA_NAME
)
741 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
749 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
750 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
752 /* If the points-to solution *PI points to variables that are in a partition
753 together with other variables add all partition members to the pointed-to
757 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
758 part_hashmap
*decls_to_partitions
,
759 hash_set
<bitmap
> *visited
, bitmap temp
)
767 /* The pointed-to vars bitmap is shared, it is enough to
769 || visited
->add (pt
->vars
))
774 /* By using a temporary bitmap to store all members of the partitions
775 we have to add we make sure to visit each of the partitions only
777 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
779 || !bitmap_bit_p (temp
, i
))
780 && (part
= decls_to_partitions
->get (i
)))
781 bitmap_ior_into (temp
, *part
);
782 if (!bitmap_empty_p (temp
))
783 bitmap_ior_into (pt
->vars
, temp
);
786 /* Update points-to sets based on partition info, so we can use them on RTL.
787 The bitmaps representing stack partitions will be saved until expand,
788 where partitioned decls used as bases in memory expressions will be
792 update_alias_info_with_stack_vars (void)
794 part_hashmap
*decls_to_partitions
= NULL
;
796 tree var
= NULL_TREE
;
798 for (i
= 0; i
< stack_vars_num
; i
++)
802 struct ptr_info_def
*pi
;
804 /* Not interested in partitions with single variable. */
805 if (stack_vars
[i
].representative
!= i
806 || stack_vars
[i
].next
== EOC
)
809 if (!decls_to_partitions
)
811 decls_to_partitions
= new part_hashmap
;
812 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
815 /* Create an SSA_NAME that points to the partition for use
816 as base during alias-oracle queries on RTL for bases that
817 have been partitioned. */
818 if (var
== NULL_TREE
)
819 var
= create_tmp_var (ptr_type_node
);
820 name
= make_ssa_name (var
);
822 /* Create bitmaps representing partitions. They will be used for
823 points-to sets later, so use GGC alloc. */
824 part
= BITMAP_GGC_ALLOC ();
825 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
827 tree decl
= stack_vars
[j
].decl
;
828 unsigned int uid
= DECL_PT_UID (decl
);
829 bitmap_set_bit (part
, uid
);
830 decls_to_partitions
->put (uid
, part
);
831 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
832 if (TREE_ADDRESSABLE (decl
))
833 TREE_ADDRESSABLE (name
) = 1;
836 /* Make the SSA name point to all partition members. */
837 pi
= get_ptr_info (name
);
838 pt_solution_set (&pi
->pt
, part
, false);
841 /* Make all points-to sets that contain one member of a partition
842 contain all members of the partition. */
843 if (decls_to_partitions
)
847 hash_set
<bitmap
> visited
;
848 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
850 FOR_EACH_SSA_NAME (i
, name
, cfun
)
852 struct ptr_info_def
*pi
;
854 if (POINTER_TYPE_P (TREE_TYPE (name
))
855 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
856 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
860 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
861 decls_to_partitions
, &visited
, temp
);
862 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped_return
,
863 decls_to_partitions
, &visited
, temp
);
864 delete decls_to_partitions
;
869 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
870 partitioning algorithm. Partitions A and B are known to be non-conflicting.
871 Merge them into a single partition A. */
874 union_stack_vars (size_t a
, size_t b
)
876 class stack_var
*vb
= &stack_vars
[b
];
880 gcc_assert (stack_vars
[b
].next
== EOC
);
881 /* Add B to A's partition. */
882 stack_vars
[b
].next
= stack_vars
[a
].next
;
883 stack_vars
[b
].representative
= a
;
884 stack_vars
[a
].next
= b
;
886 /* Make sure A is big enough to hold B. */
887 stack_vars
[a
].size
= upper_bound (stack_vars
[a
].size
, stack_vars
[b
].size
);
889 /* Update the required alignment of partition A to account for B. */
890 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
891 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
893 /* Update the interference graph and merge the conflicts. */
896 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
897 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
898 BITMAP_FREE (vb
->conflicts
);
902 /* A subroutine of expand_used_vars. Binpack the variables into
903 partitions constrained by the interference graph. The overall
904 algorithm used is as follows:
906 Sort the objects by size in descending order.
911 Look for the largest non-conflicting object B with size <= S.
918 partition_stack_vars (void)
920 size_t si
, sj
, n
= stack_vars_num
;
922 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
923 for (si
= 0; si
< n
; ++si
)
924 stack_vars_sorted
[si
] = si
;
929 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
931 for (si
= 0; si
< n
; ++si
)
933 size_t i
= stack_vars_sorted
[si
];
934 unsigned int ialign
= stack_vars
[i
].alignb
;
935 poly_int64 isize
= stack_vars
[i
].size
;
937 /* Ignore objects that aren't partition representatives. If we
938 see a var that is not a partition representative, it must
939 have been merged earlier. */
940 if (stack_vars
[i
].representative
!= i
)
943 for (sj
= si
+ 1; sj
< n
; ++sj
)
945 size_t j
= stack_vars_sorted
[sj
];
946 unsigned int jalign
= stack_vars
[j
].alignb
;
947 poly_int64 jsize
= stack_vars
[j
].size
;
949 /* Ignore objects that aren't partition representatives. */
950 if (stack_vars
[j
].representative
!= j
)
953 /* Do not mix objects of "small" (supported) alignment
954 and "large" (unsupported) alignment. */
955 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
956 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
959 /* For Address Sanitizer do not mix objects with different
960 sizes, as the shorter vars wouldn't be adequately protected.
961 Don't do that for "large" (unsupported) alignment objects,
962 those aren't protected anyway. */
963 if (asan_sanitize_stack_p ()
964 && maybe_ne (isize
, jsize
)
965 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
968 /* Ignore conflicting objects. */
969 if (stack_var_conflict_p (i
, j
))
972 /* UNION the objects, placing J at OFFSET. */
973 union_stack_vars (i
, j
);
977 update_alias_info_with_stack_vars ();
980 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
983 dump_stack_var_partition (void)
985 size_t si
, i
, j
, n
= stack_vars_num
;
987 for (si
= 0; si
< n
; ++si
)
989 i
= stack_vars_sorted
[si
];
991 /* Skip variables that aren't partition representatives, for now. */
992 if (stack_vars
[i
].representative
!= i
)
995 fprintf (dump_file
, "Partition %lu: size ", (unsigned long) i
);
996 print_dec (stack_vars
[i
].size
, dump_file
);
997 fprintf (dump_file
, " align %u\n", stack_vars
[i
].alignb
);
999 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1001 fputc ('\t', dump_file
);
1002 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
1004 fputc ('\n', dump_file
);
1008 /* Assign rtl to DECL at BASE + OFFSET. */
1011 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
1017 /* If this fails, we've overflowed the stack frame. Error nicely? */
1018 gcc_assert (known_eq (offset
, trunc_int_for_mode (offset
, Pmode
)));
1020 if (hwasan_sanitize_stack_p ())
1021 x
= targetm
.memtag
.add_tag (base
, offset
,
1022 hwasan_current_frame_tag ());
1024 x
= plus_constant (Pmode
, base
, offset
);
1026 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
1027 ? TYPE_MODE (TREE_TYPE (decl
))
1028 : DECL_MODE (decl
), x
);
1030 /* Set alignment we actually gave this decl if it isn't an SSA name.
1031 If it is we generate stack slots only accidentally so it isn't as
1032 important, we'll simply set the alignment directly on the MEM. */
1034 if (stack_vars_base_reg_p (base
))
1035 offset
-= frame_phase
;
1036 align
= known_alignment (offset
);
1037 align
*= BITS_PER_UNIT
;
1038 if (align
== 0 || align
> base_align
)
1041 if (TREE_CODE (decl
) != SSA_NAME
)
1043 /* One would think that we could assert that we're not decreasing
1044 alignment here, but (at least) the i386 port does exactly this
1045 via the MINIMUM_ALIGNMENT hook. */
1047 SET_DECL_ALIGN (decl
, align
);
1048 DECL_USER_ALIGN (decl
) = 0;
1053 set_mem_align (x
, align
);
1056 class stack_vars_data
1059 /* Vector of offset pairs, always end of some padding followed
1060 by start of the padding that needs Address Sanitizer protection.
1061 The vector is in reversed, highest offset pairs come first. */
1062 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1064 /* Vector of partition representative decls in between the paddings. */
1065 auto_vec
<tree
> asan_decl_vec
;
1067 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1070 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1071 unsigned int asan_alignb
;
1074 /* A subroutine of expand_used_vars. Give each partition representative
1075 a unique location within the stack frame. Update each partition member
1076 with that location. */
1078 expand_stack_vars (bool (*pred
) (size_t), class stack_vars_data
*data
)
1080 size_t si
, i
, j
, n
= stack_vars_num
;
1081 poly_uint64 large_size
= 0, large_alloc
= 0;
1082 rtx large_base
= NULL
;
1083 rtx large_untagged_base
= NULL
;
1084 unsigned large_align
= 0;
1085 bool large_allocation_done
= false;
1088 /* Determine if there are any variables requiring "large" alignment.
1089 Since these are dynamically allocated, we only process these if
1090 no predicate involved. */
1091 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1092 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1094 /* Find the total size of these variables. */
1095 for (si
= 0; si
< n
; ++si
)
1099 i
= stack_vars_sorted
[si
];
1100 alignb
= stack_vars
[i
].alignb
;
1102 /* All "large" alignment decls come before all "small" alignment
1103 decls, but "large" alignment decls are not sorted based on
1104 their alignment. Increase large_align to track the largest
1105 required alignment. */
1106 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1107 large_align
= alignb
* BITS_PER_UNIT
;
1109 /* Stop when we get to the first decl with "small" alignment. */
1110 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1113 /* Skip variables that aren't partition representatives. */
1114 if (stack_vars
[i
].representative
!= i
)
1117 /* Skip variables that have already had rtl assigned. See also
1118 add_stack_var where we perpetrate this pc_rtx hack. */
1119 decl
= stack_vars
[i
].decl
;
1120 if (TREE_CODE (decl
) == SSA_NAME
1121 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1122 : DECL_RTL (decl
) != pc_rtx
)
1125 large_size
= aligned_upper_bound (large_size
, alignb
);
1126 large_size
+= stack_vars
[i
].size
;
1130 for (si
= 0; si
< n
; ++si
)
1133 unsigned base_align
, alignb
;
1134 poly_int64 offset
= 0;
1136 i
= stack_vars_sorted
[si
];
1138 /* Skip variables that aren't partition representatives, for now. */
1139 if (stack_vars
[i
].representative
!= i
)
1142 /* Skip variables that have already had rtl assigned. See also
1143 add_stack_var where we perpetrate this pc_rtx hack. */
1144 decl
= stack_vars
[i
].decl
;
1145 if (TREE_CODE (decl
) == SSA_NAME
1146 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1147 : DECL_RTL (decl
) != pc_rtx
)
1150 /* Check the predicate to see whether this variable should be
1151 allocated in this pass. */
1152 if (pred
&& !pred (i
))
1155 base
= (hwasan_sanitize_stack_p ()
1156 ? hwasan_frame_base ()
1157 : virtual_stack_vars_rtx
);
1158 alignb
= stack_vars
[i
].alignb
;
1159 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1161 poly_int64 hwasan_orig_offset
;
1162 if (hwasan_sanitize_stack_p ())
1164 /* There must be no tag granule "shared" between different
1165 objects. This means that no HWASAN_TAG_GRANULE_SIZE byte
1166 chunk can have more than one object in it.
1168 We ensure this by forcing the end of the last bit of data to
1169 be aligned to HWASAN_TAG_GRANULE_SIZE bytes here, and setting
1170 the start of each variable to be aligned to
1171 HWASAN_TAG_GRANULE_SIZE bytes in `align_local_variable`.
1173 We can't align just one of the start or end, since there are
1174 untagged things stored on the stack which we do not align to
1175 HWASAN_TAG_GRANULE_SIZE bytes. If we only aligned the start
1176 or the end of tagged objects then untagged objects could end
1177 up sharing the first granule of a tagged object or sharing the
1178 last granule of a tagged object respectively. */
1179 hwasan_orig_offset
= align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1180 gcc_assert (stack_vars
[i
].alignb
>= HWASAN_TAG_GRANULE_SIZE
);
1182 /* ASAN description strings don't yet have a syntax for expressing
1183 polynomial offsets. */
1184 HOST_WIDE_INT prev_offset
;
1185 if (asan_sanitize_stack_p ()
1187 && frame_offset
.is_constant (&prev_offset
)
1188 && stack_vars
[i
].size
.is_constant ())
1190 if (data
->asan_vec
.is_empty ())
1192 align_frame_offset (ASAN_RED_ZONE_SIZE
);
1193 prev_offset
= frame_offset
.to_constant ();
1195 prev_offset
= align_base (prev_offset
,
1196 ASAN_MIN_RED_ZONE_SIZE
,
1197 !FRAME_GROWS_DOWNWARD
);
1198 tree repr_decl
= NULL_TREE
;
1199 unsigned HOST_WIDE_INT size
1200 = asan_var_and_redzone_size (stack_vars
[i
].size
.to_constant ());
1201 if (data
->asan_vec
.is_empty ())
1202 size
= MAX (size
, ASAN_RED_ZONE_SIZE
);
1204 unsigned HOST_WIDE_INT alignment
= MAX (alignb
,
1205 ASAN_MIN_RED_ZONE_SIZE
);
1206 offset
= alloc_stack_frame_space (size
, alignment
);
1208 data
->asan_vec
.safe_push (prev_offset
);
1209 /* Allocating a constant amount of space from a constant
1210 starting offset must give a constant result. */
1211 data
->asan_vec
.safe_push ((offset
+ stack_vars
[i
].size
)
1213 /* Find best representative of the partition.
1214 Prefer those with DECL_NAME, even better
1215 satisfying asan_protect_stack_decl predicate. */
1216 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1217 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1218 && DECL_NAME (stack_vars
[j
].decl
))
1220 repr_decl
= stack_vars
[j
].decl
;
1223 else if (repr_decl
== NULL_TREE
1224 && DECL_P (stack_vars
[j
].decl
)
1225 && DECL_NAME (stack_vars
[j
].decl
))
1226 repr_decl
= stack_vars
[j
].decl
;
1227 if (repr_decl
== NULL_TREE
)
1228 repr_decl
= stack_vars
[i
].decl
;
1229 data
->asan_decl_vec
.safe_push (repr_decl
);
1231 /* Make sure a representative is unpoison if another
1232 variable in the partition is handled by
1233 use-after-scope sanitization. */
1234 if (asan_handled_variables
!= NULL
1235 && !asan_handled_variables
->contains (repr_decl
))
1237 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1238 if (asan_handled_variables
->contains (stack_vars
[j
].decl
))
1241 asan_handled_variables
->add (repr_decl
);
1244 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1245 if (data
->asan_base
== NULL
)
1246 data
->asan_base
= gen_reg_rtx (Pmode
);
1247 base
= data
->asan_base
;
1249 if (!STRICT_ALIGNMENT
)
1250 base_align
= crtl
->max_used_stack_slot_alignment
;
1252 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1253 GET_MODE_ALIGNMENT (SImode
)
1254 << ASAN_SHADOW_SHIFT
);
1258 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1259 base_align
= crtl
->max_used_stack_slot_alignment
;
1261 if (hwasan_sanitize_stack_p ())
1263 /* Align again since the point of this alignment is to handle
1264 the "end" of the object (i.e. smallest address after the
1265 stack object). For FRAME_GROWS_DOWNWARD that requires
1266 aligning the stack before allocating, but for a frame that
1267 grows upwards that requires aligning the stack after
1270 Use `frame_offset` to record the offset value rather than
1271 `offset` since the `frame_offset` describes the extent
1272 allocated for this particular variable while `offset`
1273 describes the address that this variable starts at. */
1274 align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1275 hwasan_record_stack_var (virtual_stack_vars_rtx
, base
,
1276 hwasan_orig_offset
, frame_offset
);
1282 /* Large alignment is only processed in the last pass. */
1286 /* If there were any variables requiring "large" alignment, allocate
1288 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1291 rtx large_allocsize
;
1293 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1294 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1295 loffset
= alloc_stack_frame_space
1296 (rtx_to_poly_int64 (large_allocsize
),
1297 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1298 large_base
= get_dynamic_stack_base (loffset
, large_align
, base
);
1299 large_allocation_done
= true;
1302 gcc_assert (large_base
!= NULL
);
1303 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1304 offset
= large_alloc
;
1305 large_alloc
+= stack_vars
[i
].size
;
1306 if (hwasan_sanitize_stack_p ())
1308 /* An object with a large alignment requirement means that the
1309 alignment requirement is greater than the required alignment
1311 if (!large_untagged_base
)
1313 = targetm
.memtag
.untagged_pointer (large_base
, NULL_RTX
);
1314 /* Ensure the end of the variable is also aligned correctly. */
1315 poly_int64 align_again
1316 = aligned_upper_bound (large_alloc
, HWASAN_TAG_GRANULE_SIZE
);
1317 /* For large allocations we always allocate a chunk of space
1318 (which is addressed by large_untagged_base/large_base) and
1319 then use positive offsets from that. Hence the farthest
1320 offset is `align_again` and the nearest offset from the base
1322 hwasan_record_stack_var (large_untagged_base
, large_base
,
1323 offset
, align_again
);
1327 base_align
= large_align
;
1330 /* Create rtl for each variable based on their location within the
1332 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1334 expand_one_stack_var_at (stack_vars
[j
].decl
,
1335 base
, base_align
, offset
);
1337 if (hwasan_sanitize_stack_p ())
1338 hwasan_increment_frame_tag ();
1341 gcc_assert (known_eq (large_alloc
, large_size
));
1344 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1346 account_stack_vars (void)
1348 size_t si
, j
, i
, n
= stack_vars_num
;
1349 poly_uint64 size
= 0;
1351 for (si
= 0; si
< n
; ++si
)
1353 i
= stack_vars_sorted
[si
];
1355 /* Skip variables that aren't partition representatives, for now. */
1356 if (stack_vars
[i
].representative
!= i
)
1359 size
+= stack_vars
[i
].size
;
1360 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1361 set_rtl (stack_vars
[j
].decl
, NULL
);
1366 /* Record the RTL assignment X for the default def of PARM. */
1369 set_parm_rtl (tree parm
, rtx x
)
1371 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1372 || TREE_CODE (parm
) == RESULT_DECL
);
1374 if (x
&& !MEM_P (x
))
1376 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1377 TYPE_MODE (TREE_TYPE (parm
)),
1378 TYPE_ALIGN (TREE_TYPE (parm
)));
1380 /* If the variable alignment is very large we'll dynamicaly
1381 allocate it, which means that in-frame portion is just a
1382 pointer. ??? We've got a pseudo for sure here, do we
1383 actually dynamically allocate its spilling area if needed?
1384 ??? Isn't it a problem when Pmode alignment also exceeds
1385 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1386 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1387 align
= GET_MODE_ALIGNMENT (Pmode
);
1389 record_alignment_for_reg_var (align
);
1392 tree ssa
= ssa_default_def (cfun
, parm
);
1394 return set_rtl (parm
, x
);
1396 int part
= var_to_partition (SA
.map
, ssa
);
1397 gcc_assert (part
!= NO_PARTITION
);
1399 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1400 gcc_assert (changed
);
1403 gcc_assert (DECL_RTL (parm
) == x
);
1406 /* A subroutine of expand_one_var. Called to immediately assign rtl
1407 to a variable to be allocated in the stack frame. */
1410 expand_one_stack_var_1 (tree var
)
1414 unsigned byte_align
;
1416 if (TREE_CODE (var
) == SSA_NAME
)
1418 tree type
= TREE_TYPE (var
);
1419 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1422 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1424 byte_align
= align_local_variable (var
, true);
1426 /* We handle highly aligned variables in expand_stack_vars. */
1427 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1430 if (hwasan_sanitize_stack_p ())
1432 /* Allocate zero bytes to align the stack. */
1433 poly_int64 hwasan_orig_offset
1434 = align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1435 offset
= alloc_stack_frame_space (size
, byte_align
);
1436 align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1437 base
= hwasan_frame_base ();
1438 /* Use `frame_offset` to automatically account for machines where the
1439 frame grows upwards.
1441 `offset` will always point to the "start" of the stack object, which
1442 will be the smallest address, for ! FRAME_GROWS_DOWNWARD this is *not*
1443 the "furthest" offset from the base delimiting the current stack
1444 object. `frame_offset` will always delimit the extent that the frame.
1446 hwasan_record_stack_var (virtual_stack_vars_rtx
, base
,
1447 hwasan_orig_offset
, frame_offset
);
1451 offset
= alloc_stack_frame_space (size
, byte_align
);
1452 base
= virtual_stack_vars_rtx
;
1455 expand_one_stack_var_at (var
, base
,
1456 crtl
->max_used_stack_slot_alignment
, offset
);
1458 if (hwasan_sanitize_stack_p ())
1459 hwasan_increment_frame_tag ();
1462 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1463 already assigned some MEM. */
1466 expand_one_stack_var (tree var
)
1468 if (TREE_CODE (var
) == SSA_NAME
)
1470 int part
= var_to_partition (SA
.map
, var
);
1471 if (part
!= NO_PARTITION
)
1473 rtx x
= SA
.partition_to_pseudo
[part
];
1475 gcc_assert (MEM_P (x
));
1480 return expand_one_stack_var_1 (var
);
1483 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1484 that will reside in a hard register. */
1487 expand_one_hard_reg_var (tree var
)
1489 rest_of_decl_compilation (var
, 0, 0);
1492 /* Record the alignment requirements of some variable assigned to a
1496 record_alignment_for_reg_var (unsigned int align
)
1498 if (SUPPORTS_STACK_ALIGNMENT
1499 && crtl
->stack_alignment_estimated
< align
)
1501 /* stack_alignment_estimated shouldn't change after stack
1502 realign decision made */
1503 gcc_assert (!crtl
->stack_realign_processed
);
1504 crtl
->stack_alignment_estimated
= align
;
1507 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1508 So here we only make sure stack_alignment_needed >= align. */
1509 if (crtl
->stack_alignment_needed
< align
)
1510 crtl
->stack_alignment_needed
= align
;
1511 if (crtl
->max_used_stack_slot_alignment
< align
)
1512 crtl
->max_used_stack_slot_alignment
= align
;
1515 /* Create RTL for an SSA partition. */
1518 expand_one_ssa_partition (tree var
)
1520 int part
= var_to_partition (SA
.map
, var
);
1521 gcc_assert (part
!= NO_PARTITION
);
1523 if (SA
.partition_to_pseudo
[part
])
1526 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1527 TYPE_MODE (TREE_TYPE (var
)),
1528 TYPE_ALIGN (TREE_TYPE (var
)));
1530 /* If the variable alignment is very large we'll dynamicaly allocate
1531 it, which means that in-frame portion is just a pointer. */
1532 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1533 align
= GET_MODE_ALIGNMENT (Pmode
);
1535 record_alignment_for_reg_var (align
);
1537 if (!use_register_for_decl (var
))
1539 if (defer_stack_allocation (var
, true))
1540 add_stack_var (var
, true);
1542 expand_one_stack_var_1 (var
);
1546 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1547 rtx x
= gen_reg_rtx (reg_mode
);
1551 /* For a promoted variable, X will not be used directly but wrapped in a
1552 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1553 will assume that its upper bits can be inferred from its lower bits.
1554 Therefore, if X isn't initialized on every path from the entry, then
1555 we must do it manually in order to fulfill the above assumption. */
1556 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1557 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1558 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1561 /* Record the association between the RTL generated for partition PART
1562 and the underlying variable of the SSA_NAME VAR. */
1565 adjust_one_expanded_partition_var (tree var
)
1570 tree decl
= SSA_NAME_VAR (var
);
1572 int part
= var_to_partition (SA
.map
, var
);
1573 if (part
== NO_PARTITION
)
1576 rtx x
= SA
.partition_to_pseudo
[part
];
1585 /* Note if the object is a user variable. */
1586 if (decl
&& !DECL_ARTIFICIAL (decl
))
1589 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1590 mark_reg_pointer (x
, get_pointer_alignment (var
));
1593 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1594 that will reside in a pseudo register. */
1597 expand_one_register_var (tree var
)
1599 if (TREE_CODE (var
) == SSA_NAME
)
1601 int part
= var_to_partition (SA
.map
, var
);
1602 if (part
!= NO_PARTITION
)
1604 rtx x
= SA
.partition_to_pseudo
[part
];
1606 gcc_assert (REG_P (x
));
1613 tree type
= TREE_TYPE (decl
);
1614 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1615 rtx x
= gen_reg_rtx (reg_mode
);
1619 /* Note if the object is a user variable. */
1620 if (!DECL_ARTIFICIAL (decl
))
1623 if (POINTER_TYPE_P (type
))
1624 mark_reg_pointer (x
, get_pointer_alignment (var
));
1627 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1628 has some associated error, e.g. its type is error-mark. We just need
1629 to pick something that won't crash the rest of the compiler. */
1632 expand_one_error_var (tree var
)
1634 machine_mode mode
= DECL_MODE (var
);
1637 if (mode
== BLKmode
)
1638 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1639 else if (mode
== VOIDmode
)
1642 x
= gen_reg_rtx (mode
);
1644 SET_DECL_RTL (var
, x
);
1647 /* A subroutine of expand_one_var. VAR is a variable that will be
1648 allocated to the local stack frame. Return true if we wish to
1649 add VAR to STACK_VARS so that it will be coalesced with other
1650 variables. Return false to allocate VAR immediately.
1652 This function is used to reduce the number of variables considered
1653 for coalescing, which reduces the size of the quadratic problem. */
1656 defer_stack_allocation (tree var
, bool toplevel
)
1658 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1659 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1660 : DECL_SIZE_UNIT (var
);
1663 /* Whether the variable is small enough for immediate allocation not to be
1664 a problem with regard to the frame size. */
1666 = (poly_int_tree_p (size_unit
, &size
)
1667 && (estimated_poly_value (size
)
1668 < param_min_size_for_stack_sharing
));
1670 /* If stack protection is enabled, *all* stack variables must be deferred,
1671 so that we can re-order the strings to the top of the frame.
1672 Similarly for Address Sanitizer. */
1673 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1676 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1677 ? TYPE_ALIGN (TREE_TYPE (var
))
1680 /* We handle "large" alignment via dynamic allocation. We want to handle
1681 this extra complication in only one place, so defer them. */
1682 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1685 bool ignored
= TREE_CODE (var
) == SSA_NAME
1686 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1687 : DECL_IGNORED_P (var
);
1689 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1690 might be detached from their block and appear at toplevel when we reach
1691 here. We want to coalesce them with variables from other blocks when
1692 the immediate contribution to the frame size would be noticeable. */
1693 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1696 /* Variables declared in the outermost scope automatically conflict
1697 with every other variable. The only reason to want to defer them
1698 at all is that, after sorting, we can more efficiently pack
1699 small variables in the stack frame. Continue to defer at -O2. */
1700 if (toplevel
&& optimize
< 2)
1703 /* Without optimization, *most* variables are allocated from the
1704 stack, which makes the quadratic problem large exactly when we
1705 want compilation to proceed as quickly as possible. On the
1706 other hand, we don't want the function's stack frame size to
1707 get completely out of hand. So we avoid adding scalars and
1708 "small" aggregates to the list at all. */
1709 if (optimize
== 0 && smallish
)
1715 /* A subroutine of expand_used_vars. Expand one variable according to
1716 its flavor. Variables to be placed on the stack are not actually
1717 expanded yet, merely recorded.
1718 When REALLY_EXPAND is false, only add stack values to be allocated.
1719 Return stack usage this variable is supposed to take.
1723 expand_one_var (tree var
, bool toplevel
, bool really_expand
,
1724 bitmap forced_stack_var
= NULL
)
1726 unsigned int align
= BITS_PER_UNIT
;
1731 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1733 if (is_global_var (var
))
1736 /* Because we don't know if VAR will be in register or on stack,
1737 we conservatively assume it will be on stack even if VAR is
1738 eventually put into register after RA pass. For non-automatic
1739 variables, which won't be on stack, we collect alignment of
1740 type and ignore user specified alignment. Similarly for
1741 SSA_NAMEs for which use_register_for_decl returns true. */
1742 if (TREE_STATIC (var
)
1743 || DECL_EXTERNAL (var
)
1744 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1745 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1746 TYPE_MODE (TREE_TYPE (var
)),
1747 TYPE_ALIGN (TREE_TYPE (var
)));
1748 else if (DECL_HAS_VALUE_EXPR_P (var
)
1749 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1750 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1751 or variables which were assigned a stack slot already by
1752 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1753 changed from the offset chosen to it. */
1754 align
= crtl
->stack_alignment_estimated
;
1756 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1758 /* If the variable alignment is very large we'll dynamicaly allocate
1759 it, which means that in-frame portion is just a pointer. */
1760 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1761 align
= GET_MODE_ALIGNMENT (Pmode
);
1764 record_alignment_for_reg_var (align
);
1767 if (TREE_CODE (origvar
) == SSA_NAME
)
1769 gcc_assert (!VAR_P (var
)
1770 || (!DECL_EXTERNAL (var
)
1771 && !DECL_HAS_VALUE_EXPR_P (var
)
1772 && !TREE_STATIC (var
)
1773 && TREE_TYPE (var
) != error_mark_node
1774 && !DECL_HARD_REGISTER (var
)
1777 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1779 else if (DECL_EXTERNAL (var
))
1781 else if (DECL_HAS_VALUE_EXPR_P (var
))
1783 else if (TREE_STATIC (var
))
1785 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1787 else if (TREE_TYPE (var
) == error_mark_node
)
1790 expand_one_error_var (var
);
1792 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1796 expand_one_hard_reg_var (var
);
1797 if (!DECL_HARD_REGISTER (var
))
1798 /* Invalid register specification. */
1799 expand_one_error_var (var
);
1802 else if (use_register_for_decl (var
)
1803 && (!forced_stack_var
1804 || !bitmap_bit_p (forced_stack_var
, DECL_UID (var
))))
1807 expand_one_register_var (origvar
);
1809 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1810 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1812 /* Reject variables which cover more than half of the address-space. */
1815 if (DECL_NONLOCAL_FRAME (var
))
1816 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1817 "total size of local objects is too large");
1819 error_at (DECL_SOURCE_LOCATION (var
),
1820 "size of variable %q+D is too large", var
);
1821 expand_one_error_var (var
);
1824 else if (defer_stack_allocation (var
, toplevel
))
1825 add_stack_var (origvar
, really_expand
);
1830 if (lookup_attribute ("naked",
1831 DECL_ATTRIBUTES (current_function_decl
)))
1832 error ("cannot allocate stack for variable %q+D, naked function",
1835 expand_one_stack_var (origvar
);
1842 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1843 expanding variables. Those variables that can be put into registers
1844 are allocated pseudos; those that can't are put on the stack.
1846 TOPLEVEL is true if this is the outermost BLOCK. */
1849 expand_used_vars_for_block (tree block
, bool toplevel
, bitmap forced_stack_vars
)
1853 /* Expand all variables at this level. */
1854 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1856 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1857 || !DECL_NONSHAREABLE (t
)))
1858 expand_one_var (t
, toplevel
, true, forced_stack_vars
);
1860 /* Expand all variables at containing levels. */
1861 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1862 expand_used_vars_for_block (t
, false, forced_stack_vars
);
1865 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1866 and clear TREE_USED on all local variables. */
1869 clear_tree_used (tree block
)
1873 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1874 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1875 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1876 || !DECL_NONSHAREABLE (t
))
1879 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1880 clear_tree_used (t
);
1883 /* Examine TYPE and determine a bit mask of the following features. */
1885 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1886 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1887 #define SPCT_HAS_ARRAY 4
1888 #define SPCT_HAS_AGGREGATE 8
1891 stack_protect_classify_type (tree type
)
1893 unsigned int ret
= 0;
1896 switch (TREE_CODE (type
))
1899 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1900 if (t
== char_type_node
1901 || t
== signed_char_type_node
1902 || t
== unsigned_char_type_node
)
1904 unsigned HOST_WIDE_INT max
= param_ssp_buffer_size
;
1905 unsigned HOST_WIDE_INT len
;
1907 if (!TYPE_SIZE_UNIT (type
)
1908 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1911 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1914 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1916 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1919 ret
= SPCT_HAS_ARRAY
;
1923 case QUAL_UNION_TYPE
:
1925 ret
= SPCT_HAS_AGGREGATE
;
1926 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1927 if (TREE_CODE (t
) == FIELD_DECL
)
1928 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1938 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1939 part of the local stack frame. Remember if we ever return nonzero for
1940 any variable in this function. The return value is the phase number in
1941 which the variable should be allocated. */
1944 stack_protect_decl_phase (tree decl
)
1946 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1949 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1950 has_short_buffer
= true;
1952 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
1953 if (!lookup_attribute ("no_stack_protector", attribs
)
1954 && (flag_stack_protect
== SPCT_FLAG_ALL
1955 || flag_stack_protect
== SPCT_FLAG_STRONG
1956 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1957 && lookup_attribute ("stack_protect", attribs
))))
1959 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1960 && !(bits
& SPCT_HAS_AGGREGATE
))
1962 else if (bits
& SPCT_HAS_ARRAY
)
1966 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1969 has_protected_decls
= true;
1974 /* Two helper routines that check for phase 1 and phase 2. These are used
1975 as callbacks for expand_stack_vars. */
1978 stack_protect_decl_phase_1 (size_t i
)
1980 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1984 stack_protect_decl_phase_2 (size_t i
)
1986 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1989 /* And helper function that checks for asan phase (with stack protector
1990 it is phase 3). This is used as callback for expand_stack_vars.
1991 Returns true if any of the vars in the partition need to be protected. */
1994 asan_decl_phase_3 (size_t i
)
1998 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
2000 i
= stack_vars
[i
].next
;
2005 /* Ensure that variables in different stack protection phases conflict
2006 so that they are not merged and share the same stack slot.
2007 Return true if there are any address taken variables. */
2010 add_stack_protection_conflicts (void)
2012 size_t i
, j
, n
= stack_vars_num
;
2013 unsigned char *phase
;
2016 phase
= XNEWVEC (unsigned char, n
);
2017 for (i
= 0; i
< n
; ++i
)
2019 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
2020 if (TREE_ADDRESSABLE (stack_vars
[i
].decl
))
2024 for (i
= 0; i
< n
; ++i
)
2026 unsigned char ph_i
= phase
[i
];
2027 for (j
= i
+ 1; j
< n
; ++j
)
2028 if (ph_i
!= phase
[j
])
2029 add_stack_var_conflict (i
, j
);
2036 /* Create a decl for the guard at the top of the stack frame. */
2039 create_stack_guard (void)
2041 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
2042 VAR_DECL
, NULL
, ptr_type_node
);
2043 TREE_THIS_VOLATILE (guard
) = 1;
2044 TREE_USED (guard
) = 1;
2045 expand_one_stack_var (guard
);
2046 crtl
->stack_protect_guard
= guard
;
2049 /* Prepare for expanding variables. */
2051 init_vars_expansion (void)
2053 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
2054 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
2056 /* A map from decl to stack partition. */
2057 decl_to_stack_part
= new hash_map
<tree
, size_t>;
2059 /* Initialize local stack smashing state. */
2060 has_protected_decls
= false;
2061 has_short_buffer
= false;
2062 if (hwasan_sanitize_stack_p ())
2063 hwasan_record_frame_init ();
2066 /* Free up stack variable graph data. */
2068 fini_vars_expansion (void)
2070 bitmap_obstack_release (&stack_var_bitmap_obstack
);
2072 XDELETEVEC (stack_vars
);
2073 if (stack_vars_sorted
)
2074 XDELETEVEC (stack_vars_sorted
);
2076 stack_vars_sorted
= NULL
;
2077 stack_vars_alloc
= stack_vars_num
= 0;
2078 delete decl_to_stack_part
;
2079 decl_to_stack_part
= NULL
;
2082 /* Make a fair guess for the size of the stack frame of the function
2083 in NODE. This doesn't have to be exact, the result is only used in
2084 the inline heuristics. So we don't want to run the full stack var
2085 packing algorithm (which is quadratic in the number of stack vars).
2086 Instead, we calculate the total size of all stack vars. This turns
2087 out to be a pretty fair estimate -- packing of stack vars doesn't
2088 happen very often. */
2091 estimated_stack_frame_size (struct cgraph_node
*node
)
2093 poly_int64 size
= 0;
2096 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2100 init_vars_expansion ();
2102 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
2103 if (auto_var_in_fn_p (var
, fn
->decl
))
2104 size
+= expand_one_var (var
, true, false);
2106 if (stack_vars_num
> 0)
2108 /* Fake sorting the stack vars for account_stack_vars (). */
2109 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
2110 for (i
= 0; i
< stack_vars_num
; ++i
)
2111 stack_vars_sorted
[i
] = i
;
2112 size
+= account_stack_vars ();
2115 fini_vars_expansion ();
2117 return estimated_poly_value (size
);
2120 /* Check if the current function has calls that use a return slot. */
2123 stack_protect_return_slot_p ()
2127 FOR_ALL_BB_FN (bb
, cfun
)
2128 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2129 !gsi_end_p (gsi
); gsi_next (&gsi
))
2131 gimple
*stmt
= gsi_stmt (gsi
);
2132 /* This assumes that calls to internal-only functions never
2133 use a return slot. */
2134 if (is_gimple_call (stmt
)
2135 && !gimple_call_internal_p (stmt
)
2136 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2137 gimple_call_fndecl (stmt
)))
2143 /* Expand all variables used in the function. */
2146 expand_used_vars (bitmap forced_stack_vars
)
2148 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2149 auto_vec
<tree
> maybe_local_decls
;
2150 rtx_insn
*var_end_seq
= NULL
;
2153 bool gen_stack_protect_signal
= false;
2155 /* Compute the phase of the stack frame for this function. */
2157 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2158 int off
= targetm
.starting_frame_offset () % align
;
2159 frame_phase
= off
? align
- off
: 0;
2162 /* Set TREE_USED on all variables in the local_decls. */
2163 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2164 TREE_USED (var
) = 1;
2165 /* Clear TREE_USED on all variables associated with a block scope. */
2166 clear_tree_used (DECL_INITIAL (current_function_decl
));
2168 init_vars_expansion ();
2170 if (targetm
.use_pseudo_pic_reg ())
2171 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2173 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2175 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2178 tree var
= partition_to_var (SA
.map
, i
);
2180 gcc_assert (!virtual_operand_p (var
));
2182 expand_one_ssa_partition (var
);
2185 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2186 gen_stack_protect_signal
= stack_protect_return_slot_p ();
2188 /* At this point all variables on the local_decls with TREE_USED
2189 set are not associated with any block scope. Lay them out. */
2191 len
= vec_safe_length (cfun
->local_decls
);
2192 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2194 bool expand_now
= false;
2196 /* Expanded above already. */
2197 if (is_gimple_reg (var
))
2199 TREE_USED (var
) = 0;
2202 /* We didn't set a block for static or extern because it's hard
2203 to tell the difference between a global variable (re)declared
2204 in a local scope, and one that's really declared there to
2205 begin with. And it doesn't really matter much, since we're
2206 not giving them stack space. Expand them now. */
2207 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2210 /* Expand variables not associated with any block now. Those created by
2211 the optimizers could be live anywhere in the function. Those that
2212 could possibly have been scoped originally and detached from their
2213 block will have their allocation deferred so we coalesce them with
2214 others when optimization is enabled. */
2215 else if (TREE_USED (var
))
2218 /* Finally, mark all variables on the list as used. We'll use
2219 this in a moment when we expand those associated with scopes. */
2220 TREE_USED (var
) = 1;
2223 expand_one_var (var
, true, true, forced_stack_vars
);
2226 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2228 rtx rtl
= DECL_RTL_IF_SET (var
);
2230 /* Keep artificial non-ignored vars in cfun->local_decls
2231 chain until instantiate_decls. */
2232 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2233 add_local_decl (cfun
, var
);
2234 else if (rtl
== NULL_RTX
)
2235 /* If rtl isn't set yet, which can happen e.g. with
2236 -fstack-protector, retry before returning from this
2238 maybe_local_decls
.safe_push (var
);
2242 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2244 +-----------------+-----------------+
2245 | ...processed... | ...duplicates...|
2246 +-----------------+-----------------+
2248 +-- LEN points here.
2250 We just want the duplicates, as those are the artificial
2251 non-ignored vars that we want to keep until instantiate_decls.
2252 Move them down and truncate the array. */
2253 if (!vec_safe_is_empty (cfun
->local_decls
))
2254 cfun
->local_decls
->block_remove (0, len
);
2256 /* At this point, all variables within the block tree with TREE_USED
2257 set are actually used by the optimized function. Lay them out. */
2258 expand_used_vars_for_block (outer_block
, true, forced_stack_vars
);
2260 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
2261 if (stack_vars_num
> 0)
2263 bool has_addressable_vars
= false;
2265 add_scope_conflicts ();
2267 /* If stack protection is enabled, we don't share space between
2268 vulnerable data and non-vulnerable data. */
2269 if (flag_stack_protect
!= 0
2270 && !lookup_attribute ("no_stack_protector", attribs
)
2271 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2272 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2273 && lookup_attribute ("stack_protect", attribs
))))
2274 has_addressable_vars
= add_stack_protection_conflicts ();
2276 if (flag_stack_protect
== SPCT_FLAG_STRONG
&& has_addressable_vars
)
2277 gen_stack_protect_signal
= true;
2279 /* Now that we have collected all stack variables, and have computed a
2280 minimal interference graph, attempt to save some stack space. */
2281 partition_stack_vars ();
2283 dump_stack_var_partition ();
2287 if (!lookup_attribute ("no_stack_protector", attribs
))
2288 switch (flag_stack_protect
)
2291 create_stack_guard ();
2294 case SPCT_FLAG_STRONG
:
2295 if (gen_stack_protect_signal
2296 || cfun
->calls_alloca
2297 || has_protected_decls
2298 || lookup_attribute ("stack_protect", attribs
))
2299 create_stack_guard ();
2302 case SPCT_FLAG_DEFAULT
:
2303 if (cfun
->calls_alloca
2304 || has_protected_decls
2305 || lookup_attribute ("stack_protect", attribs
))
2306 create_stack_guard ();
2309 case SPCT_FLAG_EXPLICIT
:
2310 if (lookup_attribute ("stack_protect", attribs
))
2311 create_stack_guard ();
2318 /* Assign rtl to each variable based on these partitions. */
2319 if (stack_vars_num
> 0)
2321 class stack_vars_data data
;
2323 data
.asan_base
= NULL_RTX
;
2324 data
.asan_alignb
= 0;
2326 /* Reorder decls to be protected by iterating over the variables
2327 array multiple times, and allocating out of each phase in turn. */
2328 /* ??? We could probably integrate this into the qsort we did
2329 earlier, such that we naturally see these variables first,
2330 and thus naturally allocate things in the right order. */
2331 if (has_protected_decls
)
2333 /* Phase 1 contains only character arrays. */
2334 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2336 /* Phase 2 contains other kinds of arrays. */
2337 if (!lookup_attribute ("no_stack_protector", attribs
)
2338 && (flag_stack_protect
== SPCT_FLAG_ALL
2339 || flag_stack_protect
== SPCT_FLAG_STRONG
2340 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2341 && lookup_attribute ("stack_protect", attribs
))))
2342 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2345 if (asan_sanitize_stack_p ())
2346 /* Phase 3, any partitions that need asan protection
2347 in addition to phase 1 and 2. */
2348 expand_stack_vars (asan_decl_phase_3
, &data
);
2350 /* ASAN description strings don't yet have a syntax for expressing
2351 polynomial offsets. */
2352 HOST_WIDE_INT prev_offset
;
2353 if (!data
.asan_vec
.is_empty ()
2354 && frame_offset
.is_constant (&prev_offset
))
2356 HOST_WIDE_INT offset
, sz
, redzonesz
;
2357 redzonesz
= ASAN_RED_ZONE_SIZE
;
2358 sz
= data
.asan_vec
[0] - prev_offset
;
2359 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2360 && data
.asan_alignb
<= 4096
2361 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2362 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2363 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2364 /* Allocating a constant amount of space from a constant
2365 starting offset must give a constant result. */
2366 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2368 data
.asan_vec
.safe_push (prev_offset
);
2369 data
.asan_vec
.safe_push (offset
);
2370 /* Leave space for alignment if STRICT_ALIGNMENT. */
2371 if (STRICT_ALIGNMENT
)
2372 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2373 << ASAN_SHADOW_SHIFT
)
2374 / BITS_PER_UNIT
, 1);
2377 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2380 data
.asan_vec
.address (),
2381 data
.asan_decl_vec
.address (),
2382 data
.asan_vec
.length ());
2385 expand_stack_vars (NULL
, &data
);
2388 if (hwasan_sanitize_stack_p ())
2389 hwasan_emit_prologue ();
2390 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2391 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2392 virtual_stack_vars_rtx
,
2394 else if (hwasan_sanitize_allocas_p () && cfun
->calls_alloca
)
2395 /* When using out-of-line instrumentation we only want to emit one function
2396 call for clearing the tags in a region of shadow stack. When there are
2397 alloca calls in this frame we want to emit a call using the
2398 virtual_stack_dynamic_rtx, but when not we use the hwasan_frame_extent
2399 rtx we created in expand_stack_vars. */
2400 var_end_seq
= hwasan_emit_untag_frame (virtual_stack_dynamic_rtx
,
2401 virtual_stack_vars_rtx
);
2402 else if (hwasan_sanitize_stack_p ())
2403 /* If no variables were stored on the stack, `hwasan_get_frame_extent`
2404 will return NULL_RTX and hence `hwasan_emit_untag_frame` will return
2405 NULL (i.e. an empty sequence). */
2406 var_end_seq
= hwasan_emit_untag_frame (hwasan_get_frame_extent (),
2407 virtual_stack_vars_rtx
);
2409 fini_vars_expansion ();
2411 /* If there were any artificial non-ignored vars without rtl
2412 found earlier, see if deferred stack allocation hasn't assigned
2414 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2416 rtx rtl
= DECL_RTL_IF_SET (var
);
2418 /* Keep artificial non-ignored vars in cfun->local_decls
2419 chain until instantiate_decls. */
2420 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2421 add_local_decl (cfun
, var
);
2424 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2425 if (STACK_ALIGNMENT_NEEDED
)
2427 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2428 if (FRAME_GROWS_DOWNWARD
)
2429 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2431 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2438 /* If we need to produce a detailed dump, print the tree representation
2439 for STMT to the dump file. SINCE is the last RTX after which the RTL
2440 generated for STMT should have been appended. */
2443 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2445 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2447 fprintf (dump_file
, "\n;; ");
2448 print_gimple_stmt (dump_file
, stmt
, 0,
2449 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2450 fprintf (dump_file
, "\n");
2452 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2456 /* Maps the blocks that do not contain tree labels to rtx labels. */
2458 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2460 /* Returns the label_rtx expression for a label starting basic block BB. */
2462 static rtx_code_label
*
2463 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2465 if (bb
->flags
& BB_RTL
)
2466 return block_label (bb
);
2468 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2472 /* Find the tree label if it is present. */
2473 gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2475 if (!gsi_end_p (gsi
)
2476 && (lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
)))
2477 && !DECL_NONLOCAL (gimple_label_label (lab_stmt
)))
2478 return jump_target_rtx (gimple_label_label (lab_stmt
));
2480 rtx_code_label
*l
= gen_label_rtx ();
2481 lab_rtx_for_bb
->put (bb
, l
);
2486 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2487 of a basic block where we just expanded the conditional at the end,
2488 possibly clean up the CFG and instruction sequence. LAST is the
2489 last instruction before the just emitted jump sequence. */
2492 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2494 /* Special case: when jumpif decides that the condition is
2495 trivial it emits an unconditional jump (and the necessary
2496 barrier). But we still have two edges, the fallthru one is
2497 wrong. purge_dead_edges would clean this up later. Unfortunately
2498 we have to insert insns (and split edges) before
2499 find_many_sub_basic_blocks and hence before purge_dead_edges.
2500 But splitting edges might create new blocks which depend on the
2501 fact that if there are two edges there's no barrier. So the
2502 barrier would get lost and verify_flow_info would ICE. Instead
2503 of auditing all edge splitters to care for the barrier (which
2504 normally isn't there in a cleaned CFG), fix it here. */
2505 if (BARRIER_P (get_last_insn ()))
2509 /* Now, we have a single successor block, if we have insns to
2510 insert on the remaining edge we potentially will insert
2511 it at the end of this block (if the dest block isn't feasible)
2512 in order to avoid splitting the edge. This insertion will take
2513 place in front of the last jump. But we might have emitted
2514 multiple jumps (conditional and one unconditional) to the
2515 same destination. Inserting in front of the last one then
2516 is a problem. See PR 40021. We fix this by deleting all
2517 jumps except the last unconditional one. */
2518 insn
= PREV_INSN (get_last_insn ());
2519 /* Make sure we have an unconditional jump. Otherwise we're
2521 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2522 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2524 insn
= PREV_INSN (insn
);
2525 if (JUMP_P (NEXT_INSN (insn
)))
2527 if (!any_condjump_p (NEXT_INSN (insn
)))
2529 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2530 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2532 delete_insn (NEXT_INSN (insn
));
2538 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2539 Returns a new basic block if we've terminated the current basic
2540 block and created a new one. */
2543 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2545 basic_block new_bb
, dest
;
2548 rtx_insn
*last2
, *last
;
2549 enum tree_code code
;
2552 code
= gimple_cond_code (stmt
);
2553 op0
= gimple_cond_lhs (stmt
);
2554 op1
= gimple_cond_rhs (stmt
);
2555 /* We're sometimes presented with such code:
2559 This would expand to two comparisons which then later might
2560 be cleaned up by combine. But some pattern matchers like if-conversion
2561 work better when there's only one compare, so make up for this
2562 here as special exception if TER would have made the same change. */
2564 && TREE_CODE (op0
) == SSA_NAME
2565 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2566 && TREE_CODE (op1
) == INTEGER_CST
2567 && ((gimple_cond_code (stmt
) == NE_EXPR
2568 && integer_zerop (op1
))
2569 || (gimple_cond_code (stmt
) == EQ_EXPR
2570 && integer_onep (op1
)))
2571 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2573 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2574 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2576 enum tree_code code2
= gimple_assign_rhs_code (second
);
2577 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2580 op0
= gimple_assign_rhs1 (second
);
2581 op1
= gimple_assign_rhs2 (second
);
2583 /* If jumps are cheap and the target does not support conditional
2584 compare, turn some more codes into jumpy sequences. */
2585 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2586 && targetm
.gen_ccmp_first
== NULL
)
2588 if ((code2
== BIT_AND_EXPR
2589 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2590 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2591 || code2
== TRUTH_AND_EXPR
)
2593 code
= TRUTH_ANDIF_EXPR
;
2594 op0
= gimple_assign_rhs1 (second
);
2595 op1
= gimple_assign_rhs2 (second
);
2597 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2599 code
= TRUTH_ORIF_EXPR
;
2600 op0
= gimple_assign_rhs1 (second
);
2601 op1
= gimple_assign_rhs2 (second
);
2607 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2608 into (x - C2) * C3 < C4. */
2609 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2610 && TREE_CODE (op0
) == SSA_NAME
2611 && TREE_CODE (op1
) == INTEGER_CST
)
2612 code
= maybe_optimize_mod_cmp (code
, &op0
, &op1
);
2614 /* Optimize (x - y) < 0 into x < y if x - y has undefined overflow. */
2615 if (!TYPE_UNSIGNED (TREE_TYPE (op0
))
2616 && (code
== LT_EXPR
|| code
== LE_EXPR
2617 || code
== GT_EXPR
|| code
== GE_EXPR
)
2618 && integer_zerop (op1
)
2619 && TREE_CODE (op0
) == SSA_NAME
)
2620 maybe_optimize_sub_cmp_0 (code
, &op0
, &op1
);
2622 last2
= last
= get_last_insn ();
2624 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2625 set_curr_insn_location (gimple_location (stmt
));
2627 /* These flags have no purpose in RTL land. */
2628 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2629 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2631 /* We can either have a pure conditional jump with one fallthru edge or
2632 two-way jump that needs to be decomposed into two basic blocks. */
2633 if (false_edge
->dest
== bb
->next_bb
)
2635 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2636 true_edge
->probability
);
2637 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2638 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2639 set_curr_insn_location (true_edge
->goto_locus
);
2640 false_edge
->flags
|= EDGE_FALLTHRU
;
2641 maybe_cleanup_end_of_block (false_edge
, last
);
2644 if (true_edge
->dest
== bb
->next_bb
)
2646 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2647 false_edge
->probability
);
2648 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2649 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2650 set_curr_insn_location (false_edge
->goto_locus
);
2651 true_edge
->flags
|= EDGE_FALLTHRU
;
2652 maybe_cleanup_end_of_block (true_edge
, last
);
2656 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2657 true_edge
->probability
);
2658 last
= get_last_insn ();
2659 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2660 set_curr_insn_location (false_edge
->goto_locus
);
2661 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2664 if (BARRIER_P (BB_END (bb
)))
2665 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2666 update_bb_for_insn (bb
);
2668 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2669 dest
= false_edge
->dest
;
2670 redirect_edge_succ (false_edge
, new_bb
);
2671 false_edge
->flags
|= EDGE_FALLTHRU
;
2672 new_bb
->count
= false_edge
->count ();
2673 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2674 add_bb_to_loop (new_bb
, loop
);
2675 if (loop
->latch
== bb
2676 && loop
->header
== dest
)
2677 loop
->latch
= new_bb
;
2678 make_single_succ_edge (new_bb
, dest
, 0);
2679 if (BARRIER_P (BB_END (new_bb
)))
2680 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2681 update_bb_for_insn (new_bb
);
2683 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2685 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2687 set_curr_insn_location (true_edge
->goto_locus
);
2688 true_edge
->goto_locus
= curr_insn_location ();
2694 /* Mark all calls that can have a transaction restart. */
2697 mark_transaction_restart_calls (gimple
*stmt
)
2699 struct tm_restart_node dummy
;
2700 tm_restart_node
**slot
;
2702 if (!cfun
->gimple_df
->tm_restart
)
2706 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2709 struct tm_restart_node
*n
= *slot
;
2710 tree list
= n
->label_or_list
;
2713 for (insn
= next_real_insn (get_last_insn ());
2715 insn
= next_real_insn (insn
))
2718 if (TREE_CODE (list
) == LABEL_DECL
)
2719 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2721 for (; list
; list
= TREE_CHAIN (list
))
2722 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2726 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2730 expand_call_stmt (gcall
*stmt
)
2732 tree exp
, decl
, lhs
;
2736 if (gimple_call_internal_p (stmt
))
2738 expand_internal_call (stmt
);
2742 /* If this is a call to a built-in function and it has no effect other
2743 than setting the lhs, try to implement it using an internal function
2745 decl
= gimple_call_fndecl (stmt
);
2746 if (gimple_call_lhs (stmt
)
2747 && !gimple_has_side_effects (stmt
)
2748 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2750 internal_fn ifn
= replacement_internal_fn (stmt
);
2751 if (ifn
!= IFN_LAST
)
2753 expand_internal_call (ifn
, stmt
);
2758 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2760 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2761 builtin_p
= decl
&& fndecl_built_in_p (decl
);
2763 /* If this is not a builtin function, the function type through which the
2764 call is made may be different from the type of the function. */
2767 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2768 CALL_EXPR_FN (exp
));
2770 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2771 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2773 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2775 tree arg
= gimple_call_arg (stmt
, i
);
2777 /* TER addresses into arguments of builtin functions so we have a
2778 chance to infer more correct alignment information. See PR39954. */
2780 && TREE_CODE (arg
) == SSA_NAME
2781 && (def
= get_gimple_for_ssa_name (arg
))
2782 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2783 arg
= gimple_assign_rhs1 (def
);
2784 CALL_EXPR_ARG (exp
, i
) = arg
;
2787 if (gimple_has_side_effects (stmt
)
2788 /* ??? Downstream in expand_expr_real_1 we assume that expressions
2789 w/o side-effects do not throw so work around this here. */
2790 || stmt_could_throw_p (cfun
, stmt
))
2791 TREE_SIDE_EFFECTS (exp
) = 1;
2793 if (gimple_call_nothrow_p (stmt
))
2794 TREE_NOTHROW (exp
) = 1;
2796 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2797 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2798 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2800 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
2801 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2802 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2804 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2805 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2806 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2807 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2809 /* Must come after copying location. */
2810 copy_warning (exp
, stmt
);
2812 /* Ensure RTL is created for debug args. */
2813 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2815 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2820 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2822 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2823 expand_debug_expr (dtemp
);
2827 rtx_insn
*before_call
= get_last_insn ();
2828 lhs
= gimple_call_lhs (stmt
);
2830 expand_assignment (lhs
, exp
, false);
2832 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2834 /* If the gimple call is an indirect call and has 'nocf_check'
2835 attribute find a generated CALL insn to mark it as no
2836 control-flow verification is needed. */
2837 if (gimple_call_nocf_check_p (stmt
)
2838 && !gimple_call_fndecl (stmt
))
2840 rtx_insn
*last
= get_last_insn ();
2841 while (!CALL_P (last
)
2842 && last
!= before_call
)
2843 last
= PREV_INSN (last
);
2845 if (last
!= before_call
)
2846 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2849 mark_transaction_restart_calls (stmt
);
2853 /* Generate RTL for an asm statement (explicit assembler code).
2854 STRING is a STRING_CST node containing the assembler code text,
2855 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2856 insn is volatile; don't optimize it. */
2859 expand_asm_loc (tree string
, int vol
, location_t locus
)
2863 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2864 ggc_strdup (TREE_STRING_POINTER (string
)),
2867 MEM_VOLATILE_P (body
) = vol
;
2869 /* Non-empty basic ASM implicitly clobbers memory. */
2870 if (TREE_STRING_LENGTH (string
) != 0)
2873 unsigned i
, nclobbers
;
2874 auto_vec
<rtx
> input_rvec
, output_rvec
;
2875 auto_vec
<machine_mode
> input_mode
;
2876 auto_vec
<const char *> constraints
;
2877 auto_vec
<rtx
> clobber_rvec
;
2878 HARD_REG_SET clobbered_regs
;
2879 CLEAR_HARD_REG_SET (clobbered_regs
);
2881 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2882 clobber_rvec
.safe_push (clob
);
2884 if (targetm
.md_asm_adjust
)
2885 targetm
.md_asm_adjust (output_rvec
, input_rvec
, input_mode
,
2886 constraints
, clobber_rvec
, clobbered_regs
,
2890 nclobbers
= clobber_rvec
.length ();
2891 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2893 XVECEXP (body
, 0, 0) = asm_op
;
2894 for (i
= 0; i
< nclobbers
; i
++)
2895 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2901 /* Return the number of times character C occurs in string S. */
2903 n_occurrences (int c
, const char *s
)
2911 /* A subroutine of expand_asm_operands. Check that all operands have
2912 the same number of alternatives. Return true if so. */
2915 check_operand_nalternatives (const vec
<const char *> &constraints
)
2917 unsigned len
= constraints
.length();
2920 int nalternatives
= n_occurrences (',', constraints
[0]);
2922 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2924 error ("too many alternatives in %<asm%>");
2928 for (unsigned i
= 1; i
< len
; ++i
)
2929 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2931 error ("operand constraints for %<asm%> differ "
2932 "in number of alternatives");
2939 /* Check for overlap between registers marked in CLOBBERED_REGS and
2940 anything inappropriate in T. Emit error and return the register
2941 variable definition for error, NULL_TREE for ok. */
2944 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
,
2947 /* Conflicts between asm-declared register variables and the clobber
2948 list are not allowed. */
2949 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2953 error_at (loc
, "%<asm%> specifier for variable %qE conflicts with "
2954 "%<asm%> clobber list", DECL_NAME (overlap
));
2956 /* Reset registerness to stop multiple errors emitted for a single
2958 DECL_REGISTER (overlap
) = 0;
2965 /* Check that the given REGNO spanning NREGS is a valid
2966 asm clobber operand. Some HW registers cannot be
2967 saved/restored, hence they should not be clobbered by
2970 asm_clobber_reg_is_valid (int regno
, int nregs
, const char *regname
)
2972 bool is_valid
= true;
2973 HARD_REG_SET regset
;
2975 CLEAR_HARD_REG_SET (regset
);
2977 add_range_to_hard_reg_set (®set
, regno
, nregs
);
2979 /* Clobbering the PIC register is an error. */
2980 if (PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
2981 && overlaps_hard_reg_set_p (regset
, Pmode
, PIC_OFFSET_TABLE_REGNUM
))
2983 /* ??? Diagnose during gimplification? */
2984 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2987 else if (!in_hard_reg_set_p
2988 (accessible_reg_set
, reg_raw_mode
[regno
], regno
))
2990 /* ??? Diagnose during gimplification? */
2991 error ("the register %qs cannot be clobbered in %<asm%>"
2992 " for the current target", regname
);
2996 /* Clobbering the stack pointer register is deprecated. GCC expects
2997 the value of the stack pointer after an asm statement to be the same
2998 as it was before, so no asm can validly clobber the stack pointer in
2999 the usual sense. Adding the stack pointer to the clobber list has
3000 traditionally had some undocumented and somewhat obscure side-effects. */
3001 if (overlaps_hard_reg_set_p (regset
, Pmode
, STACK_POINTER_REGNUM
))
3003 crtl
->sp_is_clobbered_by_asm
= true;
3004 if (warning (OPT_Wdeprecated
, "listing the stack pointer register"
3005 " %qs in a clobber list is deprecated", regname
))
3006 inform (input_location
, "the value of the stack pointer after"
3007 " an %<asm%> statement must be the same as it was before"
3014 /* Generate RTL for an asm statement with arguments.
3015 STRING is the instruction template.
3016 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
3017 Each output or input has an expression in the TREE_VALUE and
3018 a tree list in TREE_PURPOSE which in turn contains a constraint
3019 name in TREE_VALUE (or NULL_TREE) and a constraint string
3021 CLOBBERS is a list of STRING_CST nodes each naming a hard register
3022 that is clobbered by this insn.
3024 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
3025 should be the fallthru basic block of the asm goto.
3027 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
3028 Some elements of OUTPUTS may be replaced with trees representing temporary
3029 values. The caller should copy those temporary values to the originally
3032 VOL nonzero means the insn is volatile; don't optimize it. */
3035 expand_asm_stmt (gasm
*stmt
)
3037 class save_input_location
3042 explicit save_input_location(location_t where
)
3044 old
= input_location
;
3045 input_location
= where
;
3048 ~save_input_location()
3050 input_location
= old
;
3054 location_t locus
= gimple_location (stmt
);
3056 if (gimple_asm_input_p (stmt
))
3058 const char *s
= gimple_asm_string (stmt
);
3059 tree string
= build_string (strlen (s
), s
);
3060 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
3064 /* There are some legacy diagnostics in here. */
3065 save_input_location
s_i_l(locus
);
3067 unsigned noutputs
= gimple_asm_noutputs (stmt
);
3068 unsigned ninputs
= gimple_asm_ninputs (stmt
);
3069 unsigned nlabels
= gimple_asm_nlabels (stmt
);
3071 bool error_seen
= false;
3073 /* ??? Diagnose during gimplification? */
3074 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
3076 error_at (locus
, "more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
3080 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
3081 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
3082 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
3084 /* Copy the gimple vectors into new vectors that we can manipulate. */
3086 output_tvec
.safe_grow (noutputs
, true);
3087 input_tvec
.safe_grow (ninputs
, true);
3088 constraints
.safe_grow (noutputs
+ ninputs
, true);
3090 for (i
= 0; i
< noutputs
; ++i
)
3092 tree t
= gimple_asm_output_op (stmt
, i
);
3093 output_tvec
[i
] = TREE_VALUE (t
);
3094 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
3096 for (i
= 0; i
< ninputs
; i
++)
3098 tree t
= gimple_asm_input_op (stmt
, i
);
3099 input_tvec
[i
] = TREE_VALUE (t
);
3100 constraints
[i
+ noutputs
]
3101 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
3104 /* ??? Diagnose during gimplification? */
3105 if (! check_operand_nalternatives (constraints
))
3108 /* Count the number of meaningful clobbered registers, ignoring what
3109 we would ignore later. */
3110 auto_vec
<rtx
> clobber_rvec
;
3111 HARD_REG_SET clobbered_regs
;
3112 CLEAR_HARD_REG_SET (clobbered_regs
);
3114 if (unsigned n
= gimple_asm_nclobbers (stmt
))
3116 clobber_rvec
.reserve (n
);
3117 for (i
= 0; i
< n
; i
++)
3119 tree t
= gimple_asm_clobber_op (stmt
, i
);
3120 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
3123 j
= decode_reg_name_and_count (regname
, &nregs
);
3128 /* ??? Diagnose during gimplification? */
3129 error_at (locus
, "unknown register name %qs in %<asm%>",
3135 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
3136 clobber_rvec
.safe_push (x
);
3140 /* Otherwise we should have -1 == empty string
3141 or -3 == cc, which is not a register. */
3142 gcc_assert (j
== -1 || j
== -3);
3146 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
3148 if (!asm_clobber_reg_is_valid (reg
, nregs
, regname
))
3151 SET_HARD_REG_BIT (clobbered_regs
, reg
);
3152 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
3153 clobber_rvec
.safe_push (x
);
3158 /* First pass over inputs and outputs checks validity and sets
3159 mark_addressable if needed. */
3160 /* ??? Diagnose during gimplification? */
3162 for (i
= 0; i
< noutputs
; ++i
)
3164 tree val
= output_tvec
[i
];
3165 tree type
= TREE_TYPE (val
);
3166 const char *constraint
;
3171 /* Try to parse the output constraint. If that fails, there's
3172 no point in going further. */
3173 constraint
= constraints
[i
];
3174 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
3175 &allows_mem
, &allows_reg
, &is_inout
))
3178 /* If the output is a hard register, verify it doesn't conflict with
3179 any other operand's possible hard register use. */
3181 && REG_P (DECL_RTL (val
))
3182 && HARD_REGISTER_P (DECL_RTL (val
)))
3184 unsigned j
, output_hregno
= REGNO (DECL_RTL (val
));
3185 bool early_clobber_p
= strchr (constraints
[i
], '&') != NULL
;
3186 unsigned long match
;
3188 /* Verify the other outputs do not use the same hard register. */
3189 for (j
= i
+ 1; j
< noutputs
; ++j
)
3190 if (DECL_P (output_tvec
[j
])
3191 && REG_P (DECL_RTL (output_tvec
[j
]))
3192 && HARD_REGISTER_P (DECL_RTL (output_tvec
[j
]))
3193 && output_hregno
== REGNO (DECL_RTL (output_tvec
[j
])))
3195 error_at (locus
, "invalid hard register usage between output "
3200 /* Verify matching constraint operands use the same hard register
3201 and that the non-matching constraint operands do not use the same
3202 hard register if the output is an early clobber operand. */
3203 for (j
= 0; j
< ninputs
; ++j
)
3204 if (DECL_P (input_tvec
[j
])
3205 && REG_P (DECL_RTL (input_tvec
[j
]))
3206 && HARD_REGISTER_P (DECL_RTL (input_tvec
[j
])))
3208 unsigned input_hregno
= REGNO (DECL_RTL (input_tvec
[j
]));
3209 switch (*constraints
[j
+ noutputs
])
3211 case '0': case '1': case '2': case '3': case '4':
3212 case '5': case '6': case '7': case '8': case '9':
3213 match
= strtoul (constraints
[j
+ noutputs
], NULL
, 10);
3220 && output_hregno
!= input_hregno
)
3222 error_at (locus
, "invalid hard register usage between "
3223 "output operand and matching constraint operand");
3226 else if (early_clobber_p
3228 && output_hregno
== input_hregno
)
3230 error_at (locus
, "invalid hard register usage between "
3231 "earlyclobber operand and input operand");
3241 && REG_P (DECL_RTL (val
))
3242 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
3243 mark_addressable (val
);
3246 for (i
= 0; i
< ninputs
; ++i
)
3248 bool allows_reg
, allows_mem
;
3249 const char *constraint
;
3251 constraint
= constraints
[i
+ noutputs
];
3252 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3253 constraints
.address (),
3254 &allows_mem
, &allows_reg
))
3257 if (! allows_reg
&& allows_mem
)
3258 mark_addressable (input_tvec
[i
]);
3261 /* Second pass evaluates arguments. */
3263 /* Make sure stack is consistent for asm goto. */
3265 do_pending_stack_adjust ();
3266 int old_generating_concat_p
= generating_concat_p
;
3268 /* Vector of RTX's of evaluated output operands. */
3269 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3270 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3271 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3273 output_rvec
.safe_grow (noutputs
, true);
3275 for (i
= 0; i
< noutputs
; ++i
)
3277 tree val
= output_tvec
[i
];
3278 tree type
= TREE_TYPE (val
);
3279 bool is_inout
, allows_reg
, allows_mem
, ok
;
3282 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3283 noutputs
, &allows_mem
, &allows_reg
,
3287 /* If an output operand is not a decl or indirect ref and our constraint
3288 allows a register, make a temporary to act as an intermediate.
3289 Make the asm insn write into that, then we will copy it to
3290 the real output operand. Likewise for promoted variables. */
3292 generating_concat_p
= 0;
3294 gcc_assert (TREE_CODE (val
) != INDIRECT_REF
);
3295 if (((TREE_CODE (val
) == MEM_REF
3296 && TREE_CODE (TREE_OPERAND (val
, 0)) != ADDR_EXPR
)
3299 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3300 && ! (REG_P (DECL_RTL (val
))
3301 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3304 || TREE_ADDRESSABLE (type
)
3305 || (!tree_fits_poly_int64_p (TYPE_SIZE (type
))
3306 && !known_size_p (max_int_size_in_bytes (type
))))
3308 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3309 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3311 op
= validize_mem (op
);
3313 if (! allows_reg
&& !MEM_P (op
))
3315 error_at (locus
, "output number %d not directly addressable", i
);
3318 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3319 || GET_CODE (op
) == CONCAT
)
3322 op
= gen_reg_rtx (GET_MODE (op
));
3324 generating_concat_p
= old_generating_concat_p
;
3327 emit_move_insn (op
, old_op
);
3329 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3330 emit_move_insn (old_op
, op
);
3331 after_rtl_seq
= get_insns ();
3332 after_rtl_end
= get_last_insn ();
3338 op
= assign_temp (type
, 0, 1);
3339 op
= validize_mem (op
);
3340 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3341 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3343 generating_concat_p
= old_generating_concat_p
;
3345 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3346 expand_assignment (val
, make_tree (type
, op
), false);
3347 after_rtl_seq
= get_insns ();
3348 after_rtl_end
= get_last_insn ();
3351 output_rvec
[i
] = op
;
3354 inout_opnum
.safe_push (i
);
3357 const char *str
= gimple_asm_string (stmt
);
3362 inout_opnum
.truncate (0);
3363 output_rvec
.truncate (0);
3364 clobber_rvec
.truncate (0);
3365 constraints
.truncate (0);
3366 CLEAR_HARD_REG_SET (clobbered_regs
);
3370 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3371 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3373 input_rvec
.safe_grow (ninputs
, true);
3374 input_mode
.safe_grow (ninputs
, true);
3376 generating_concat_p
= 0;
3378 for (i
= 0; i
< ninputs
; ++i
)
3380 tree val
= input_tvec
[i
];
3381 tree type
= TREE_TYPE (val
);
3382 bool allows_reg
, allows_mem
, ok
;
3383 const char *constraint
;
3386 constraint
= constraints
[i
+ noutputs
];
3387 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3388 constraints
.address (),
3389 &allows_mem
, &allows_reg
);
3392 /* EXPAND_INITIALIZER will not generate code for valid initializer
3393 constants, but will still generate code for other types of operand.
3394 This is the behavior we want for constant constraints. */
3395 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3396 allows_reg
? EXPAND_NORMAL
3397 : allows_mem
? EXPAND_MEMORY
3398 : EXPAND_INITIALIZER
);
3400 /* Never pass a CONCAT to an ASM. */
3401 if (GET_CODE (op
) == CONCAT
)
3402 op
= force_reg (GET_MODE (op
), op
);
3403 else if (MEM_P (op
))
3404 op
= validize_mem (op
);
3406 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3408 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3409 op
= force_reg (TYPE_MODE (type
), op
);
3410 else if (!allows_mem
)
3411 warning_at (locus
, 0, "%<asm%> operand %d probably does not match "
3412 "constraints", i
+ noutputs
);
3413 else if (MEM_P (op
))
3415 /* We won't recognize either volatile memory or memory
3416 with a queued address as available a memory_operand
3417 at this point. Ignore it: clearly this *is* a memory. */
3423 input_mode
[i
] = TYPE_MODE (type
);
3426 /* For in-out operands, copy output rtx to input rtx. */
3427 unsigned ninout
= inout_opnum
.length ();
3428 for (i
= 0; i
< ninout
; i
++)
3430 int j
= inout_opnum
[i
];
3431 rtx o
= output_rvec
[j
];
3433 input_rvec
.safe_push (o
);
3434 input_mode
.safe_push (GET_MODE (o
));
3437 sprintf (buffer
, "%d", j
);
3438 constraints
.safe_push (ggc_strdup (buffer
));
3442 /* Sometimes we wish to automatically clobber registers across an asm.
3443 Case in point is when the i386 backend moved from cc0 to a hard reg --
3444 maintaining source-level compatibility means automatically clobbering
3445 the flags register. */
3446 rtx_insn
*after_md_seq
= NULL
;
3447 if (targetm
.md_asm_adjust
)
3449 = targetm
.md_asm_adjust (output_rvec
, input_rvec
, input_mode
,
3450 constraints
, clobber_rvec
, clobbered_regs
,
3453 /* Do not allow the hook to change the output and input count,
3454 lest it mess up the operand numbering. */
3455 gcc_assert (output_rvec
.length() == noutputs
);
3456 gcc_assert (input_rvec
.length() == ninputs
);
3457 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3459 /* But it certainly can adjust the clobbers. */
3460 unsigned nclobbers
= clobber_rvec
.length ();
3462 /* Third pass checks for easy conflicts. */
3463 /* ??? Why are we doing this on trees instead of rtx. */
3465 bool clobber_conflict_found
= 0;
3466 for (i
= 0; i
< noutputs
; ++i
)
3467 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
, locus
))
3468 clobber_conflict_found
= 1;
3469 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3470 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
, locus
))
3471 clobber_conflict_found
= 1;
3473 /* Make vectors for the expression-rtx, constraint strings,
3474 and named operands. */
3476 rtvec argvec
= rtvec_alloc (ninputs
);
3477 rtvec constraintvec
= rtvec_alloc (ninputs
);
3478 rtvec labelvec
= rtvec_alloc (nlabels
);
3480 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3481 : GET_MODE (output_rvec
[0])),
3483 "", 0, argvec
, constraintvec
,
3485 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3487 for (i
= 0; i
< ninputs
; ++i
)
3489 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3490 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3491 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3492 constraints
[i
+ noutputs
],
3496 /* Copy labels to the vector. */
3497 rtx_code_label
*fallthru_label
= NULL
;
3500 basic_block fallthru_bb
= NULL
;
3501 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3503 fallthru_bb
= fallthru
->dest
;
3505 for (i
= 0; i
< nlabels
; ++i
)
3507 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3509 /* If asm goto has any labels in the fallthru basic block, use
3510 a label that we emit immediately after the asm goto. Expansion
3511 may insert further instructions into the same basic block after
3512 asm goto and if we don't do this, insertion of instructions on
3513 the fallthru edge might misbehave. See PR58670. */
3514 if (fallthru_bb
&& label_to_block (cfun
, label
) == fallthru_bb
)
3516 if (fallthru_label
== NULL_RTX
)
3517 fallthru_label
= gen_label_rtx ();
3521 r
= label_rtx (label
);
3522 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3526 /* Now, for each output, construct an rtx
3527 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3528 ARGVEC CONSTRAINTS OPNAMES))
3529 If there is more than one, put them inside a PARALLEL. */
3531 if (noutputs
== 0 && nclobbers
== 0)
3533 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3535 emit_jump_insn (body
);
3539 else if (noutputs
== 1 && nclobbers
== 0)
3541 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3543 emit_jump_insn (gen_rtx_SET (output_rvec
[0], body
));
3545 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3555 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3557 /* For each output operand, store a SET. */
3558 for (i
= 0; i
< noutputs
; ++i
)
3560 rtx src
, o
= output_rvec
[i
];
3563 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3568 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3569 ASM_OPERANDS_TEMPLATE (obody
),
3570 constraints
[i
], i
, argvec
,
3571 constraintvec
, labelvec
, locus
);
3572 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3574 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3577 /* If there are no outputs (but there are some clobbers)
3578 store the bare ASM_OPERANDS into the PARALLEL. */
3580 XVECEXP (body
, 0, i
++) = obody
;
3582 /* Store (clobber REG) for each clobbered register specified. */
3583 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3585 rtx clobbered_reg
= clobber_rvec
[j
];
3587 /* Do sanity check for overlap between clobbers and respectively
3588 input and outputs that hasn't been handled. Such overlap
3589 should have been detected and reported above. */
3590 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3592 /* We test the old body (obody) contents to avoid
3593 tripping over the under-construction body. */
3594 for (unsigned k
= 0; k
< noutputs
; ++k
)
3595 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3596 internal_error ("%<asm%> clobber conflict with "
3599 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3600 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3601 internal_error ("%<asm%> clobber conflict with "
3605 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3609 emit_jump_insn (body
);
3614 generating_concat_p
= old_generating_concat_p
;
3617 emit_label (fallthru_label
);
3620 emit_insn (after_md_seq
);
3624 emit_insn (after_rtl_seq
);
3630 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->succs
)
3633 for (rtx_insn
*curr
= after_rtl_seq
;
3635 curr
= NEXT_INSN (curr
))
3636 emit_insn (copy_insn (PATTERN (curr
)));
3637 rtx_insn
*copy
= get_insns ();
3639 insert_insn_on_edge (copy
, e
);
3645 crtl
->has_asm_statement
= 1;
3648 /* Emit code to jump to the address
3649 specified by the pointer expression EXP. */
3652 expand_computed_goto (tree exp
)
3654 rtx x
= expand_normal (exp
);
3656 do_pending_stack_adjust ();
3657 emit_indirect_jump (x
);
3660 /* Generate RTL code for a `goto' statement with target label LABEL.
3661 LABEL should be a LABEL_DECL tree node that was or will later be
3662 defined with `expand_label'. */
3665 expand_goto (tree label
)
3669 /* Check for a nonlocal goto to a containing function. Should have
3670 gotten translated to __builtin_nonlocal_goto. */
3671 tree context
= decl_function_context (label
);
3672 gcc_assert (!context
|| context
== current_function_decl
);
3675 emit_jump (jump_target_rtx (label
));
3678 /* Output a return with no value. */
3681 expand_null_return_1 (void)
3683 clear_pending_stack_adjust ();
3684 do_pending_stack_adjust ();
3685 emit_jump (return_label
);
3688 /* Generate RTL to return from the current function, with no value.
3689 (That is, we do not do anything about returning any value.) */
3692 expand_null_return (void)
3694 /* If this function was declared to return a value, but we
3695 didn't, clobber the return registers so that they are not
3696 propagated live to the rest of the function. */
3697 clobber_return_register ();
3699 expand_null_return_1 ();
3702 /* Generate RTL to return from the current function, with value VAL. */
3705 expand_value_return (rtx val
)
3707 /* Copy the value to the return location unless it's already there. */
3709 tree decl
= DECL_RESULT (current_function_decl
);
3710 rtx return_reg
= DECL_RTL (decl
);
3711 if (return_reg
!= val
)
3713 tree funtype
= TREE_TYPE (current_function_decl
);
3714 tree type
= TREE_TYPE (decl
);
3715 int unsignedp
= TYPE_UNSIGNED (type
);
3716 machine_mode old_mode
= DECL_MODE (decl
);
3718 if (DECL_BY_REFERENCE (decl
))
3719 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3721 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3723 if (mode
!= old_mode
)
3725 /* Some ABIs require scalar floating point modes to be returned
3726 in a wider scalar integer mode. We need to explicitly
3727 reinterpret to an integer mode of the correct precision
3728 before extending to the desired result. */
3729 if (SCALAR_INT_MODE_P (mode
)
3730 && SCALAR_FLOAT_MODE_P (old_mode
)
3731 && known_gt (GET_MODE_SIZE (mode
), GET_MODE_SIZE (old_mode
)))
3732 val
= convert_float_to_wider_int (mode
, old_mode
, val
);
3734 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3737 if (GET_CODE (return_reg
) == PARALLEL
)
3738 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3740 emit_move_insn (return_reg
, val
);
3743 expand_null_return_1 ();
3746 /* Generate RTL to evaluate the expression RETVAL and return it
3747 from the current function. */
3750 expand_return (tree retval
)
3756 /* If function wants no value, give it none. */
3757 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
3759 expand_normal (retval
);
3760 expand_null_return ();
3764 if (retval
== error_mark_node
)
3766 /* Treat this like a return of no value from a function that
3768 expand_null_return ();
3771 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3772 || TREE_CODE (retval
) == INIT_EXPR
)
3773 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3774 retval_rhs
= TREE_OPERAND (retval
, 1);
3776 retval_rhs
= retval
;
3778 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3780 /* If we are returning the RESULT_DECL, then the value has already
3781 been stored into it, so we don't have to do anything special. */
3782 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3783 expand_value_return (result_rtl
);
3785 /* If the result is an aggregate that is being returned in one (or more)
3786 registers, load the registers here. */
3788 else if (retval_rhs
!= 0
3789 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3790 && REG_P (result_rtl
))
3792 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3795 /* Use the mode of the result value on the return register. */
3796 PUT_MODE (result_rtl
, GET_MODE (val
));
3797 expand_value_return (val
);
3800 expand_null_return ();
3802 else if (retval_rhs
!= 0
3803 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3804 && (REG_P (result_rtl
)
3805 || (GET_CODE (result_rtl
) == PARALLEL
)))
3807 /* Compute the return value into a temporary (usually a pseudo reg). */
3809 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3810 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3811 val
= force_not_mem (val
);
3812 expand_value_return (val
);
3816 /* No hard reg used; calculate value into hard return reg. */
3817 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3818 expand_value_return (result_rtl
);
3822 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3823 register, tell the rtl optimizers that its value is no longer
3827 expand_clobber (tree lhs
)
3831 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3832 if (decl_rtl
&& REG_P (decl_rtl
))
3834 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3835 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3836 REGMODE_NATURAL_SIZE (decl_mode
)))
3837 emit_clobber (decl_rtl
);
3842 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3843 STMT that doesn't require special handling for outgoing edges. That
3844 is no tailcalls and no GIMPLE_COND. */
3847 expand_gimple_stmt_1 (gimple
*stmt
)
3851 set_curr_insn_location (gimple_location (stmt
));
3853 switch (gimple_code (stmt
))
3856 op0
= gimple_goto_dest (stmt
);
3857 if (TREE_CODE (op0
) == LABEL_DECL
)
3860 expand_computed_goto (op0
);
3863 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3866 case GIMPLE_PREDICT
:
3870 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3871 if (gimple_switch_num_labels (swtch
) == 1)
3872 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3874 expand_case (swtch
);
3878 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3881 expand_call_stmt (as_a
<gcall
*> (stmt
));
3886 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3888 /* If a return doesn't have a location, it very likely represents
3889 multiple user returns so we cannot let it inherit the location
3890 of the last statement of the previous basic block in RTL. */
3891 if (!gimple_has_location (stmt
))
3892 set_curr_insn_location (cfun
->function_end_locus
);
3894 if (op0
&& op0
!= error_mark_node
)
3896 tree result
= DECL_RESULT (current_function_decl
);
3898 /* If we are not returning the current function's RESULT_DECL,
3899 build an assignment to it. */
3902 /* I believe that a function's RESULT_DECL is unique. */
3903 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3905 /* ??? We'd like to use simply expand_assignment here,
3906 but this fails if the value is of BLKmode but the return
3907 decl is a register. expand_return has special handling
3908 for this combination, which eventually should move
3909 to common code. See comments there. Until then, let's
3910 build a modify expression :-/ */
3911 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3917 expand_null_return ();
3919 expand_return (op0
);
3925 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3926 tree lhs
= gimple_assign_lhs (assign_stmt
);
3928 /* Tree expand used to fiddle with |= and &= of two bitfield
3929 COMPONENT_REFs here. This can't happen with gimple, the LHS
3930 of binary assigns must be a gimple reg. */
3932 if (TREE_CODE (lhs
) != SSA_NAME
3933 || gimple_assign_rhs_class (assign_stmt
) == GIMPLE_SINGLE_RHS
)
3935 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3936 gcc_assert (gimple_assign_rhs_class (assign_stmt
)
3937 == GIMPLE_SINGLE_RHS
);
3938 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3939 /* Do not put locations on possibly shared trees. */
3940 && !is_gimple_min_invariant (rhs
))
3941 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3942 if (TREE_CLOBBER_P (rhs
))
3943 /* This is a clobber to mark the going out of scope for
3945 expand_clobber (lhs
);
3947 expand_assignment (lhs
, rhs
,
3948 gimple_assign_nontemporal_move_p (
3954 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3955 struct separate_ops ops
;
3956 bool promoted
= false;
3958 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3959 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3962 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3963 ops
.type
= TREE_TYPE (lhs
);
3964 switch (get_gimple_rhs_class (ops
.code
))
3966 case GIMPLE_TERNARY_RHS
:
3967 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3969 case GIMPLE_BINARY_RHS
:
3970 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3972 case GIMPLE_UNARY_RHS
:
3973 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3978 ops
.location
= gimple_location (stmt
);
3980 /* If we want to use a nontemporal store, force the value to
3981 register first. If we store into a promoted register,
3982 don't directly expand to target. */
3983 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3984 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3991 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3992 /* If TEMP is a VOIDmode constant, use convert_modes to make
3993 sure that we properly convert it. */
3994 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3996 temp
= convert_modes (GET_MODE (target
),
3997 TYPE_MODE (ops
.type
),
3999 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
4000 GET_MODE (target
), temp
, unsignedp
);
4003 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
4005 else if (nontemporal
&& emit_storent_insn (target
, temp
))
4009 temp
= force_operand (temp
, target
);
4011 emit_move_insn (target
, temp
);
4022 /* Expand one gimple statement STMT and return the last RTL instruction
4023 before any of the newly generated ones.
4025 In addition to generating the necessary RTL instructions this also
4026 sets REG_EH_REGION notes if necessary and sets the current source
4027 location for diagnostics. */
4030 expand_gimple_stmt (gimple
*stmt
)
4032 location_t saved_location
= input_location
;
4033 rtx_insn
*last
= get_last_insn ();
4038 /* We need to save and restore the current source location so that errors
4039 discovered during expansion are emitted with the right location. But
4040 it would be better if the diagnostic routines used the source location
4041 embedded in the tree nodes rather than globals. */
4042 if (gimple_has_location (stmt
))
4043 input_location
= gimple_location (stmt
);
4045 expand_gimple_stmt_1 (stmt
);
4047 /* Free any temporaries used to evaluate this statement. */
4050 input_location
= saved_location
;
4052 /* Mark all insns that may trap. */
4053 lp_nr
= lookup_stmt_eh_lp (stmt
);
4057 for (insn
= next_real_insn (last
); insn
;
4058 insn
= next_real_insn (insn
))
4060 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
4061 /* If we want exceptions for non-call insns, any
4062 may_trap_p instruction may throw. */
4063 && GET_CODE (PATTERN (insn
)) != CLOBBER
4064 && GET_CODE (PATTERN (insn
)) != USE
4065 && insn_could_throw_p (insn
))
4066 make_reg_eh_region_note (insn
, 0, lp_nr
);
4073 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
4074 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
4075 generated a tail call (something that might be denied by the ABI
4076 rules governing the call; see calls.cc).
4078 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
4079 can still reach the rest of BB. The case here is __builtin_sqrt,
4080 where the NaN result goes through the external function (with a
4081 tailcall) and the normal result happens via a sqrt instruction. */
4084 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
4086 rtx_insn
*last2
, *last
;
4089 profile_probability probability
;
4091 last2
= last
= expand_gimple_stmt (stmt
);
4093 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
4094 if (CALL_P (last
) && SIBLING_CALL_P (last
))
4097 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
4099 *can_fallthru
= true;
4103 /* ??? Wouldn't it be better to just reset any pending stack adjust?
4104 Any instructions emitted here are about to be deleted. */
4105 do_pending_stack_adjust ();
4107 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
4108 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
4109 EH or abnormal edges, we shouldn't have created a tail call in
4110 the first place. So it seems to me we should just be removing
4111 all edges here, or redirecting the existing fallthru edge to
4114 probability
= profile_probability::never ();
4116 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4118 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
4120 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
4121 e
->dest
->count
-= e
->count ();
4122 probability
+= e
->probability
;
4129 /* This is somewhat ugly: the call_expr expander often emits instructions
4130 after the sibcall (to perform the function return). These confuse the
4131 find_many_sub_basic_blocks code, so we need to get rid of these. */
4132 last
= NEXT_INSN (last
);
4133 gcc_assert (BARRIER_P (last
));
4135 *can_fallthru
= false;
4136 while (NEXT_INSN (last
))
4138 /* For instance an sqrt builtin expander expands if with
4139 sibcall in the then and label for `else`. */
4140 if (LABEL_P (NEXT_INSN (last
)))
4142 *can_fallthru
= true;
4145 delete_insn (NEXT_INSN (last
));
4148 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
4150 e
->probability
= probability
;
4152 update_bb_for_insn (bb
);
4154 if (NEXT_INSN (last
))
4156 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
4159 if (BARRIER_P (last
))
4160 BB_END (bb
) = PREV_INSN (last
);
4163 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
4168 /* Return the difference between the floor and the truncated result of
4169 a signed division by OP1 with remainder MOD. */
4171 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4173 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
4174 return gen_rtx_IF_THEN_ELSE
4175 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4176 gen_rtx_IF_THEN_ELSE
4177 (mode
, gen_rtx_LT (BImode
,
4178 gen_rtx_DIV (mode
, op1
, mod
),
4180 constm1_rtx
, const0_rtx
),
4184 /* Return the difference between the ceil and the truncated result of
4185 a signed division by OP1 with remainder MOD. */
4187 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4189 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
4190 return gen_rtx_IF_THEN_ELSE
4191 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4192 gen_rtx_IF_THEN_ELSE
4193 (mode
, gen_rtx_GT (BImode
,
4194 gen_rtx_DIV (mode
, op1
, mod
),
4196 const1_rtx
, const0_rtx
),
4200 /* Return the difference between the ceil and the truncated result of
4201 an unsigned division by OP1 with remainder MOD. */
4203 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
4205 /* (mod != 0 ? 1 : 0) */
4206 return gen_rtx_IF_THEN_ELSE
4207 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4208 const1_rtx
, const0_rtx
);
4211 /* Return the difference between the rounded and the truncated result
4212 of a signed division by OP1 with remainder MOD. Halfway cases are
4213 rounded away from zero, rather than to the nearest even number. */
4215 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4217 /* (abs (mod) >= abs (op1) - abs (mod)
4218 ? (op1 / mod > 0 ? 1 : -1)
4220 return gen_rtx_IF_THEN_ELSE
4221 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
4222 gen_rtx_MINUS (mode
,
4223 gen_rtx_ABS (mode
, op1
),
4224 gen_rtx_ABS (mode
, mod
))),
4225 gen_rtx_IF_THEN_ELSE
4226 (mode
, gen_rtx_GT (BImode
,
4227 gen_rtx_DIV (mode
, op1
, mod
),
4229 const1_rtx
, constm1_rtx
),
4233 /* Return the difference between the rounded and the truncated result
4234 of a unsigned division by OP1 with remainder MOD. Halfway cases
4235 are rounded away from zero, rather than to the nearest even
4238 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4240 /* (mod >= op1 - mod ? 1 : 0) */
4241 return gen_rtx_IF_THEN_ELSE
4242 (mode
, gen_rtx_GE (BImode
, mod
,
4243 gen_rtx_MINUS (mode
, op1
, mod
)),
4244 const1_rtx
, const0_rtx
);
4247 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4251 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
4254 #ifndef POINTERS_EXTEND_UNSIGNED
4255 gcc_assert (mode
== Pmode
4256 || mode
== targetm
.addr_space
.address_mode (as
));
4257 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
4261 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
4263 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
4266 /* X must have some form of address mode already. */
4267 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
4268 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
4269 x
= lowpart_subreg (mode
, x
, xmode
);
4270 else if (POINTERS_EXTEND_UNSIGNED
> 0)
4271 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
4272 else if (!POINTERS_EXTEND_UNSIGNED
)
4273 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
4276 switch (GET_CODE (x
))
4279 if ((SUBREG_PROMOTED_VAR_P (x
)
4280 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
4281 || (GET_CODE (SUBREG_REG (x
)) == PLUS
4282 && REG_P (XEXP (SUBREG_REG (x
), 0))
4283 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
4284 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
4285 && GET_MODE (SUBREG_REG (x
)) == mode
)
4286 return SUBREG_REG (x
);
4289 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4290 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4293 temp
= shallow_copy_rtx (x
);
4294 PUT_MODE (temp
, mode
);
4297 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4299 temp
= gen_rtx_CONST (mode
, temp
);
4303 if (CONST_INT_P (XEXP (x
, 1)))
4305 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4307 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4313 /* Don't know how to express ptr_extend as operation in debug info. */
4316 #endif /* POINTERS_EXTEND_UNSIGNED */
4321 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4322 by avoid_deep_ter_for_debug. */
4324 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4326 /* Split too deep TER chains for debug stmts using debug temporaries. */
4329 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4331 use_operand_p use_p
;
4333 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4335 tree use
= USE_FROM_PTR (use_p
);
4336 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4338 gimple
*g
= get_gimple_for_ssa_name (use
);
4341 if (depth
> 6 && !stmt_ends_bb_p (g
))
4343 if (deep_ter_debug_map
== NULL
)
4344 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4346 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4349 vexpr
= build_debug_expr_decl (TREE_TYPE (use
));
4350 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4351 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4352 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4353 avoid_deep_ter_for_debug (def_temp
, 0);
4356 avoid_deep_ter_for_debug (g
, depth
+ 1);
4360 /* Return an RTX equivalent to the value of the parameter DECL. */
4363 expand_debug_parm_decl (tree decl
)
4365 rtx incoming
= DECL_INCOMING_RTL (decl
);
4368 && GET_MODE (incoming
) != BLKmode
4369 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4370 || (MEM_P (incoming
)
4371 && REG_P (XEXP (incoming
, 0))
4372 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4374 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4376 #ifdef HAVE_window_save
4377 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4378 If the target machine has an explicit window save instruction, the
4379 actual entry value is the corresponding OUTGOING_REGNO instead. */
4380 if (REG_P (incoming
)
4381 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4383 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4384 OUTGOING_REGNO (REGNO (incoming
)), 0);
4385 else if (MEM_P (incoming
))
4387 rtx reg
= XEXP (incoming
, 0);
4388 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4390 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4391 incoming
= replace_equiv_address_nv (incoming
, reg
);
4394 incoming
= copy_rtx (incoming
);
4398 ENTRY_VALUE_EXP (rtl
) = incoming
;
4403 && GET_MODE (incoming
) != BLKmode
4404 && !TREE_ADDRESSABLE (decl
)
4406 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4407 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4408 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4409 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4410 return copy_rtx (incoming
);
4415 /* Return an RTX equivalent to the value of the tree expression EXP. */
4418 expand_debug_expr (tree exp
)
4420 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4421 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4422 machine_mode inner_mode
= VOIDmode
;
4423 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4425 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4427 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4429 case tcc_expression
:
4430 switch (TREE_CODE (exp
))
4435 case WIDEN_MULT_PLUS_EXPR
:
4436 case WIDEN_MULT_MINUS_EXPR
:
4439 case TRUTH_ANDIF_EXPR
:
4440 case TRUTH_ORIF_EXPR
:
4441 case TRUTH_AND_EXPR
:
4443 case TRUTH_XOR_EXPR
:
4446 case TRUTH_NOT_EXPR
:
4455 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4462 if (mode
== BLKmode
)
4464 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4467 switch (TREE_CODE (exp
))
4473 case WIDEN_LSHIFT_EXPR
:
4474 /* Ensure second operand isn't wider than the first one. */
4475 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4476 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4477 && (GET_MODE_UNIT_PRECISION (mode
)
4478 < GET_MODE_PRECISION (op1_mode
)))
4479 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4488 if (mode
== BLKmode
)
4490 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4491 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4496 case tcc_comparison
:
4497 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4505 case tcc_exceptional
:
4506 case tcc_declaration
:
4512 switch (TREE_CODE (exp
))
4515 if (!lookup_constant_def (exp
))
4517 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4518 != (size_t) TREE_STRING_LENGTH (exp
))
4520 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4521 op0
= gen_rtx_MEM (BLKmode
, op0
);
4522 set_mem_attributes (op0
, exp
, 0);
4528 if (TREE_CODE (TREE_TYPE (exp
)) == BITINT_TYPE
4529 && TYPE_MODE (TREE_TYPE (exp
)) == BLKmode
)
4534 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4538 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4541 gcc_assert (COMPLEX_MODE_P (mode
));
4542 op0
= expand_debug_expr (TREE_REALPART (exp
));
4543 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4544 return gen_rtx_CONCAT (mode
, op0
, op1
);
4546 case DEBUG_EXPR_DECL
:
4547 op0
= DECL_RTL_IF_SET (exp
);
4551 if (GET_MODE (op0
) != mode
)
4552 gcc_assert (VECTOR_TYPE_P (TREE_TYPE (exp
)));
4557 op0
= gen_rtx_DEBUG_EXPR (mode
);
4558 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4559 SET_DECL_RTL (exp
, op0
);
4569 op0
= DECL_RTL_IF_SET (exp
);
4571 /* This decl was probably optimized away. */
4573 /* At least label RTXen are sometimes replaced by
4574 NOTE_INSN_DELETED_LABEL. Any notes here are not
4575 handled by copy_rtx. */
4579 || DECL_EXTERNAL (exp
)
4580 || !TREE_STATIC (exp
)
4582 || DECL_HARD_REGISTER (exp
)
4583 || DECL_IN_CONSTANT_POOL (exp
)
4585 || symtab_node::get (exp
) == NULL
)
4588 op0
= make_decl_rtl_for_debug (exp
);
4590 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4591 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4594 else if (VAR_P (exp
)
4595 && is_global_var (exp
)
4596 && symtab_node::get (exp
) == NULL
)
4599 op0
= copy_rtx (op0
);
4601 if (GET_MODE (op0
) == BLKmode
4602 /* If op0 is not BLKmode, but mode is, adjust_mode
4603 below would ICE. While it is likely a FE bug,
4604 try to be robust here. See PR43166. */
4606 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4608 gcc_assert (MEM_P (op0
));
4609 op0
= adjust_address_nv (op0
, mode
, 0);
4619 inner_mode
= GET_MODE (op0
);
4621 if (mode
== inner_mode
)
4624 if (inner_mode
== VOIDmode
)
4626 if (TREE_CODE (exp
) == SSA_NAME
)
4627 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4629 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4630 if (mode
== inner_mode
)
4634 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4636 if (GET_MODE_UNIT_BITSIZE (mode
)
4637 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4638 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4639 else if (GET_MODE_UNIT_BITSIZE (mode
)
4640 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4641 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4643 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4645 else if (FLOAT_MODE_P (mode
))
4647 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4648 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4649 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4651 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4653 else if (FLOAT_MODE_P (inner_mode
))
4656 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4658 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4660 else if (GET_MODE_UNIT_PRECISION (mode
)
4661 == GET_MODE_UNIT_PRECISION (inner_mode
))
4662 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4663 else if (GET_MODE_UNIT_PRECISION (mode
)
4664 < GET_MODE_UNIT_PRECISION (inner_mode
))
4665 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4666 else if (UNARY_CLASS_P (exp
)
4667 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4669 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4671 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4677 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4679 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4680 TREE_OPERAND (exp
, 0),
4681 TREE_OPERAND (exp
, 1));
4683 return expand_debug_expr (newexp
);
4687 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4688 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4692 if (TREE_CODE (exp
) == MEM_REF
)
4694 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4695 || (GET_CODE (op0
) == PLUS
4696 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4697 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4698 Instead just use get_inner_reference. */
4701 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4703 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4706 op0
= plus_constant (inner_mode
, op0
, offset
);
4709 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4711 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4713 if (op0
== NULL_RTX
)
4716 op0
= gen_rtx_MEM (mode
, op0
);
4717 set_mem_attributes (op0
, exp
, 0);
4718 if (TREE_CODE (exp
) == MEM_REF
4719 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4720 set_mem_expr (op0
, NULL_TREE
);
4721 set_mem_addr_space (op0
, as
);
4725 case TARGET_MEM_REF
:
4726 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4727 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4730 op0
= expand_debug_expr
4731 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4735 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4736 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4738 if (op0
== NULL_RTX
)
4741 op0
= gen_rtx_MEM (mode
, op0
);
4743 set_mem_attributes (op0
, exp
, 0);
4744 set_mem_addr_space (op0
, as
);
4750 case ARRAY_RANGE_REF
:
4755 case VIEW_CONVERT_EXPR
:
4758 poly_int64 bitsize
, bitpos
;
4760 int reversep
, volatilep
= 0;
4762 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4763 &unsignedp
, &reversep
, &volatilep
);
4766 if (known_eq (bitsize
, 0))
4769 orig_op0
= op0
= expand_debug_expr (tem
);
4776 machine_mode addrmode
, offmode
;
4781 op0
= XEXP (op0
, 0);
4782 addrmode
= GET_MODE (op0
);
4783 if (addrmode
== VOIDmode
)
4786 op1
= expand_debug_expr (offset
);
4790 offmode
= GET_MODE (op1
);
4791 if (offmode
== VOIDmode
)
4792 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4794 if (addrmode
!= offmode
)
4795 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4797 /* Don't use offset_address here, we don't need a
4798 recognizable address, and we don't want to generate
4800 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4806 if (mode1
== VOIDmode
)
4808 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4811 mode1
= smallest_int_mode_for_size (bitsize
);
4813 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4814 if (maybe_ne (bytepos
, 0))
4816 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4817 bitpos
= num_trailing_bits (bitpos
);
4819 else if (known_eq (bitpos
, 0)
4820 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4821 op0
= adjust_address_nv (op0
, mode
, 0);
4822 else if (GET_MODE (op0
) != mode1
)
4823 op0
= adjust_address_nv (op0
, mode1
, 0);
4825 op0
= copy_rtx (op0
);
4826 if (op0
== orig_op0
)
4827 op0
= shallow_copy_rtx (op0
);
4828 if (TREE_CODE (tem
) != SSA_NAME
)
4829 set_mem_attributes (op0
, exp
, 0);
4832 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4835 if (maybe_lt (bitpos
, 0))
4838 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4842 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4843 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4845 machine_mode opmode
= GET_MODE (op0
);
4847 if (opmode
== VOIDmode
)
4848 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4850 /* This condition may hold if we're expanding the address
4851 right past the end of an array that turned out not to
4852 be addressable (i.e., the address was only computed in
4853 debug stmts). The gen_subreg below would rightfully
4854 crash, and the address doesn't really exist, so just
4856 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4859 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4860 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4863 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4864 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4866 : ZERO_EXTRACT
, mode
,
4867 GET_MODE (op0
) != VOIDmode
4869 : TYPE_MODE (TREE_TYPE (tem
)),
4870 op0
, gen_int_mode (bitsize
, word_mode
),
4871 gen_int_mode (bitpos
, word_mode
));
4876 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4879 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4882 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4885 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4887 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4890 case FIX_TRUNC_EXPR
:
4891 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4894 case POINTER_PLUS_EXPR
:
4895 /* For the rare target where pointers are not the same size as
4896 size_t, we need to check for mis-matched modes and correct
4899 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4900 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4901 && op0_mode
!= op1_mode
)
4903 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4904 /* If OP0 is a partial mode, then we must truncate, even
4905 if it has the same bitsize as OP1 as GCC's
4906 representation of partial modes is opaque. */
4907 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4908 && (GET_MODE_BITSIZE (op0_mode
)
4909 == GET_MODE_BITSIZE (op1_mode
))))
4910 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4912 /* We always sign-extend, regardless of the signedness of
4913 the operand, because the operand is always unsigned
4914 here even if the original C expression is signed. */
4915 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4919 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4922 case POINTER_DIFF_EXPR
:
4923 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4926 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4929 case TRUNC_DIV_EXPR
:
4930 case EXACT_DIV_EXPR
:
4932 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4934 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4936 case TRUNC_MOD_EXPR
:
4937 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4939 case FLOOR_DIV_EXPR
:
4941 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4944 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4945 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4946 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4947 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4950 case FLOOR_MOD_EXPR
:
4952 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4955 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4956 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4957 adj
= simplify_gen_unary (NEG
, mode
,
4958 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4960 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4966 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4967 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4968 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4969 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4973 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4974 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4975 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4976 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4982 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4983 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4984 adj
= simplify_gen_unary (NEG
, mode
,
4985 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4987 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4991 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4992 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4993 adj
= simplify_gen_unary (NEG
, mode
,
4994 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4996 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4999 case ROUND_DIV_EXPR
:
5002 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
5003 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
5004 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
5005 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
5009 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
5010 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
5011 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
5012 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
5015 case ROUND_MOD_EXPR
:
5018 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
5019 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
5020 adj
= simplify_gen_unary (NEG
, mode
,
5021 simplify_gen_binary (MULT
, mode
, adj
, op1
),
5023 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
5027 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
5028 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
5029 adj
= simplify_gen_unary (NEG
, mode
,
5030 simplify_gen_binary (MULT
, mode
, adj
, op1
),
5032 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
5036 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
5040 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
5042 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
5045 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
5048 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
5051 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
5054 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
5057 case TRUTH_AND_EXPR
:
5058 return simplify_gen_binary (AND
, mode
, op0
, op1
);
5062 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
5065 case TRUTH_XOR_EXPR
:
5066 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
5068 case TRUTH_ANDIF_EXPR
:
5069 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
5071 case TRUTH_ORIF_EXPR
:
5072 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
5074 case TRUTH_NOT_EXPR
:
5075 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
5078 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
5082 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
5086 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
5090 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
5094 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
5097 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
5099 case UNORDERED_EXPR
:
5100 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
5103 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
5106 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
5109 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
5112 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
5115 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
5118 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
5121 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
5124 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
5127 gcc_assert (COMPLEX_MODE_P (mode
));
5128 if (GET_MODE (op0
) == VOIDmode
)
5129 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
5130 if (GET_MODE (op1
) == VOIDmode
)
5131 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
5132 return gen_rtx_CONCAT (mode
, op0
, op1
);
5135 if (GET_CODE (op0
) == CONCAT
)
5136 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
5137 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
5139 GET_MODE_INNER (mode
)));
5142 scalar_mode imode
= GET_MODE_INNER (mode
);
5147 re
= adjust_address_nv (op0
, imode
, 0);
5148 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
5152 scalar_int_mode ifmode
;
5153 scalar_int_mode ihmode
;
5155 if (!int_mode_for_mode (mode
).exists (&ifmode
)
5156 || !int_mode_for_mode (imode
).exists (&ihmode
))
5158 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
5161 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
5162 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
5163 if (imode
!= ihmode
)
5164 re
= gen_rtx_SUBREG (imode
, re
, 0);
5165 im
= copy_rtx (op0
);
5167 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
5168 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
5169 if (imode
!= ihmode
)
5170 im
= gen_rtx_SUBREG (imode
, im
, 0);
5172 im
= gen_rtx_NEG (imode
, im
);
5173 return gen_rtx_CONCAT (mode
, re
, im
);
5177 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
5178 if (!op0
|| !MEM_P (op0
))
5180 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
5181 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
5182 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
5183 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
5184 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
5185 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
5187 if (handled_component_p (TREE_OPERAND (exp
, 0)))
5189 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
5192 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
5193 &bitsize
, &maxsize
, &reverse
);
5195 || TREE_CODE (decl
) == PARM_DECL
5196 || TREE_CODE (decl
) == RESULT_DECL
)
5197 && (!TREE_ADDRESSABLE (decl
)
5198 || target_for_debug_bind (decl
))
5199 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
5200 && known_gt (bitsize
, 0)
5201 && known_eq (bitsize
, maxsize
))
5203 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
5204 return plus_constant (mode
, base
, byteoffset
);
5208 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
5209 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
5212 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5215 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
5216 || (GET_CODE (op0
) == PLUS
5217 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
5218 && CONST_INT_P (XEXP (op0
, 1)))))
5220 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5223 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
5226 return plus_constant (mode
, op0
, offset
);
5233 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
5234 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
5235 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
5241 unsigned HOST_WIDE_INT i
, nelts
;
5243 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
5246 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5248 for (i
= 0; i
< nelts
; ++i
)
5250 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
5253 XVECEXP (op0
, 0, i
) = op1
;
5260 if (TREE_CLOBBER_P (exp
))
5262 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
5265 unsigned HOST_WIDE_INT nelts
;
5268 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
5269 goto flag_unsupported
;
5271 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5273 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
5275 op1
= expand_debug_expr (val
);
5278 XVECEXP (op0
, 0, i
) = op1
;
5283 op1
= expand_debug_expr
5284 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
5289 for (; i
< nelts
; i
++)
5290 XVECEXP (op0
, 0, i
) = op1
;
5296 goto flag_unsupported
;
5299 /* ??? Maybe handle some builtins? */
5304 gimple
*g
= get_gimple_for_ssa_name (exp
);
5308 if (deep_ter_debug_map
)
5310 tree
*slot
= deep_ter_debug_map
->get (exp
);
5315 t
= gimple_assign_rhs_to_tree (g
);
5316 op0
= expand_debug_expr (t
);
5322 /* If this is a reference to an incoming value of
5323 parameter that is never used in the code or where the
5324 incoming value is never used in the code, use
5325 PARM_DECL's DECL_RTL if set. */
5326 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5327 && SSA_NAME_VAR (exp
)
5328 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5329 && has_zero_uses (exp
))
5331 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5334 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5339 int part
= var_to_partition (SA
.map
, exp
);
5341 if (part
== NO_PARTITION
)
5344 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5346 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5354 /* Vector stuff. For most of the codes we don't have rtl codes. */
5355 case REALIGN_LOAD_EXPR
:
5357 case VEC_PACK_FIX_TRUNC_EXPR
:
5358 case VEC_PACK_FLOAT_EXPR
:
5359 case VEC_PACK_SAT_EXPR
:
5360 case VEC_PACK_TRUNC_EXPR
:
5361 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5362 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5363 case VEC_UNPACK_FLOAT_HI_EXPR
:
5364 case VEC_UNPACK_FLOAT_LO_EXPR
:
5365 case VEC_UNPACK_HI_EXPR
:
5366 case VEC_UNPACK_LO_EXPR
:
5367 case VEC_WIDEN_MULT_HI_EXPR
:
5368 case VEC_WIDEN_MULT_LO_EXPR
:
5369 case VEC_WIDEN_MULT_EVEN_EXPR
:
5370 case VEC_WIDEN_MULT_ODD_EXPR
:
5371 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5372 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5374 case VEC_DUPLICATE_EXPR
:
5375 case VEC_SERIES_EXPR
:
5380 case ADDR_SPACE_CONVERT_EXPR
:
5381 case FIXED_CONVERT_EXPR
:
5383 case WITH_SIZE_EXPR
:
5384 case BIT_INSERT_EXPR
:
5388 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5389 && SCALAR_INT_MODE_P (mode
))
5392 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5394 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5397 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5399 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5401 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5402 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5406 case WIDEN_MULT_EXPR
:
5407 case WIDEN_MULT_PLUS_EXPR
:
5408 case WIDEN_MULT_MINUS_EXPR
:
5409 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5410 && SCALAR_INT_MODE_P (mode
))
5412 inner_mode
= GET_MODE (op0
);
5413 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5414 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5416 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5417 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5418 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5420 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5421 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5422 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5424 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5425 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5427 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5431 case MULT_HIGHPART_EXPR
:
5432 /* ??? Similar to the above. */
5435 case WIDEN_SUM_EXPR
:
5436 case WIDEN_LSHIFT_EXPR
:
5437 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5438 && SCALAR_INT_MODE_P (mode
))
5441 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5443 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5445 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5446 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5461 /* Return an RTX equivalent to the source bind value of the tree expression
5465 expand_debug_source_expr (tree exp
)
5468 machine_mode mode
= VOIDmode
, inner_mode
;
5470 switch (TREE_CODE (exp
))
5473 if (DECL_ABSTRACT_ORIGIN (exp
))
5474 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5478 mode
= DECL_MODE (exp
);
5479 op0
= expand_debug_parm_decl (exp
);
5482 /* See if this isn't an argument that has been completely
5484 if (!DECL_RTL_SET_P (exp
)
5485 && !DECL_INCOMING_RTL (exp
)
5486 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5488 tree aexp
= DECL_ORIGIN (exp
);
5489 if (DECL_CONTEXT (aexp
)
5490 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5492 vec
<tree
, va_gc
> **debug_args
;
5495 debug_args
= decl_debug_args_lookup (current_function_decl
);
5496 if (debug_args
!= NULL
)
5498 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5501 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5511 if (op0
== NULL_RTX
)
5514 inner_mode
= GET_MODE (op0
);
5515 if (mode
== inner_mode
)
5518 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5520 if (GET_MODE_UNIT_BITSIZE (mode
)
5521 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5522 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5523 else if (GET_MODE_UNIT_BITSIZE (mode
)
5524 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5525 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5527 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5529 else if (FLOAT_MODE_P (mode
))
5531 else if (FLOAT_MODE_P (inner_mode
))
5533 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5534 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5536 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5538 else if (GET_MODE_UNIT_PRECISION (mode
)
5539 == GET_MODE_UNIT_PRECISION (inner_mode
))
5540 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5541 else if (GET_MODE_UNIT_PRECISION (mode
)
5542 < GET_MODE_UNIT_PRECISION (inner_mode
))
5543 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5544 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5545 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5547 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5552 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5553 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5554 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5557 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5561 if (exp
== NULL_RTX
)
5564 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5569 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5570 rtx dval
= make_debug_expr_from_rtl (exp
);
5572 /* Emit a debug bind insn before INSN. */
5573 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5574 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5575 VAR_INIT_STATUS_INITIALIZED
);
5577 emit_debug_insn_before (bind
, insn
);
5582 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5584 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5585 switch (*format_ptr
++)
5588 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5593 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5594 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5602 /* Expand the _LOCs in debug insns. We run this after expanding all
5603 regular insns, so that any variables referenced in the function
5604 will have their DECL_RTLs set. */
5607 expand_debug_locations (void)
5610 rtx_insn
*last
= get_last_insn ();
5611 int save_strict_alias
= flag_strict_aliasing
;
5613 /* New alias sets while setting up memory attributes cause
5614 -fcompare-debug failures, even though it doesn't bring about any
5616 flag_strict_aliasing
= 0;
5618 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5619 if (DEBUG_BIND_INSN_P (insn
))
5621 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5623 rtx_insn
*prev_insn
, *insn2
;
5626 if (value
== NULL_TREE
)
5630 if (INSN_VAR_LOCATION_STATUS (insn
)
5631 == VAR_INIT_STATUS_UNINITIALIZED
)
5632 val
= expand_debug_source_expr (value
);
5633 /* The avoid_deep_ter_for_debug function inserts
5634 debug bind stmts after SSA_NAME definition, with the
5635 SSA_NAME as the whole bind location. Disable temporarily
5636 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5637 being defined in this DEBUG_INSN. */
5638 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5640 tree
*slot
= deep_ter_debug_map
->get (value
);
5643 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5648 val
= expand_debug_expr (value
);
5650 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5653 val
= expand_debug_expr (value
);
5654 gcc_assert (last
== get_last_insn ());
5658 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5661 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5663 gcc_assert (mode
== GET_MODE (val
)
5664 || (GET_MODE (val
) == VOIDmode
5665 && (CONST_SCALAR_INT_P (val
)
5666 || GET_CODE (val
) == CONST_FIXED
5667 || GET_CODE (val
) == LABEL_REF
)));
5670 INSN_VAR_LOCATION_LOC (insn
) = val
;
5671 prev_insn
= PREV_INSN (insn
);
5672 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5673 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5676 flag_strict_aliasing
= save_strict_alias
;
5679 /* Performs swapping operands of commutative operations to expand
5680 the expensive one first. */
5683 reorder_operands (basic_block bb
)
5685 unsigned int *lattice
; /* Hold cost of each statement. */
5686 unsigned int i
= 0, n
= 0;
5687 gimple_stmt_iterator gsi
;
5693 use_operand_p use_p
;
5694 gimple
*def0
, *def1
;
5696 /* Compute cost of each statement using estimate_num_insns. */
5697 stmts
= bb_seq (bb
);
5698 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5700 stmt
= gsi_stmt (gsi
);
5701 if (!is_gimple_debug (stmt
))
5702 gimple_set_uid (stmt
, n
++);
5704 lattice
= XNEWVEC (unsigned int, n
);
5705 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5708 stmt
= gsi_stmt (gsi
);
5709 if (is_gimple_debug (stmt
))
5711 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5713 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5715 tree use
= USE_FROM_PTR (use_p
);
5717 if (TREE_CODE (use
) != SSA_NAME
)
5719 def_stmt
= get_gimple_for_ssa_name (use
);
5722 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5725 if (!is_gimple_assign (stmt
)
5726 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5728 op0
= gimple_op (stmt
, 1);
5729 op1
= gimple_op (stmt
, 2);
5730 if (TREE_CODE (op0
) != SSA_NAME
5731 || TREE_CODE (op1
) != SSA_NAME
)
5733 /* Swap operands if the second one is more expensive. */
5734 def0
= get_gimple_for_ssa_name (op0
);
5735 def1
= get_gimple_for_ssa_name (op1
);
5739 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5743 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5745 fprintf (dump_file
, "Swap operands in stmt:\n");
5746 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5747 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5748 def0
? lattice
[gimple_uid (def0
)] : 0,
5749 lattice
[gimple_uid (def1
)]);
5751 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5752 gimple_assign_rhs2_ptr (stmt
));
5758 /* Expand basic block BB from GIMPLE trees to RTL. */
5761 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5763 gimple_stmt_iterator gsi
;
5765 gimple
*stmt
= NULL
;
5766 rtx_note
*note
= NULL
;
5770 bool nondebug_stmt_seen
= false;
5773 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5776 /* Note that since we are now transitioning from GIMPLE to RTL, we
5777 cannot use the gsi_*_bb() routines because they expect the basic
5778 block to be in GIMPLE, instead of RTL. Therefore, we need to
5779 access the BB sequence directly. */
5781 reorder_operands (bb
);
5782 stmts
= bb_seq (bb
);
5783 bb
->il
.gimple
.seq
= NULL
;
5784 bb
->il
.gimple
.phi_nodes
= NULL
;
5785 rtl_profile_for_bb (bb
);
5786 init_rtl_bb_info (bb
);
5787 bb
->flags
|= BB_RTL
;
5789 /* Remove the RETURN_EXPR if we may fall though to the exit
5791 gsi
= gsi_last (stmts
);
5792 if (!gsi_end_p (gsi
)
5793 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5795 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5797 gcc_assert (single_succ_p (bb
));
5798 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5800 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5801 && !gimple_return_retval (ret_stmt
))
5803 gsi_remove (&gsi
, false);
5804 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5808 gsi
= gsi_start (stmts
);
5809 if (!gsi_end_p (gsi
))
5811 stmt
= gsi_stmt (gsi
);
5812 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5816 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5820 gcc_checking_assert (!note
);
5821 last
= get_last_insn ();
5825 expand_gimple_stmt (stmt
);
5832 BB_HEAD (bb
) = NEXT_INSN (last
);
5833 if (NOTE_P (BB_HEAD (bb
)))
5834 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5835 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5836 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5838 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5841 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5844 NOTE_BASIC_BLOCK (note
) = bb
;
5846 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5850 stmt
= gsi_stmt (gsi
);
5851 if (!is_gimple_debug (stmt
))
5852 nondebug_stmt_seen
= true;
5854 /* If this statement is a non-debug one, and we generate debug
5855 insns, then this one might be the last real use of a TERed
5856 SSA_NAME, but where there are still some debug uses further
5857 down. Expanding the current SSA name in such further debug
5858 uses by their RHS might lead to wrong debug info, as coalescing
5859 might make the operands of such RHS be placed into the same
5860 pseudo as something else. Like so:
5861 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5865 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5866 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5867 the write to a_2 would actually have clobbered the place which
5870 So, instead of that, we recognize the situation, and generate
5871 debug temporaries at the last real use of TERed SSA names:
5878 if (MAY_HAVE_DEBUG_BIND_INSNS
5880 && !is_gimple_debug (stmt
))
5886 location_t sloc
= curr_insn_location ();
5888 /* Look for SSA names that have their last use here (TERed
5889 names always have only one real use). */
5890 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5891 if ((def
= get_gimple_for_ssa_name (op
)))
5893 imm_use_iterator imm_iter
;
5894 use_operand_p use_p
;
5895 bool have_debug_uses
= false;
5897 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5899 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5901 have_debug_uses
= true;
5906 if (have_debug_uses
)
5908 /* OP is a TERed SSA name, with DEF its defining
5909 statement, and where OP is used in further debug
5910 instructions. Generate a debug temporary, and
5911 replace all uses of OP in debug insns with that
5914 tree value
= gimple_assign_rhs_to_tree (def
);
5915 tree vexpr
= build_debug_expr_decl (TREE_TYPE (value
));
5919 set_curr_insn_location (gimple_location (def
));
5922 mode
= DECL_MODE (value
);
5924 mode
= TYPE_MODE (TREE_TYPE (value
));
5925 /* FIXME: Is setting the mode really necessary? */
5926 SET_DECL_MODE (vexpr
, mode
);
5928 val
= gen_rtx_VAR_LOCATION
5929 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5931 emit_debug_insn (val
);
5933 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5935 if (!gimple_debug_bind_p (debugstmt
))
5938 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5939 SET_USE (use_p
, vexpr
);
5941 update_stmt (debugstmt
);
5945 set_curr_insn_location (sloc
);
5948 currently_expanding_gimple_stmt
= stmt
;
5950 /* Expand this statement, then evaluate the resulting RTL and
5951 fixup the CFG accordingly. */
5952 if (gimple_code (stmt
) == GIMPLE_COND
)
5954 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5957 currently_expanding_gimple_stmt
= NULL
;
5961 else if (is_gimple_debug (stmt
))
5963 location_t sloc
= curr_insn_location ();
5964 gimple_stmt_iterator nsi
= gsi
;
5969 tree value
= NULL_TREE
;
5973 if (!gimple_debug_nonbind_marker_p (stmt
))
5975 if (gimple_debug_bind_p (stmt
))
5977 var
= gimple_debug_bind_get_var (stmt
);
5979 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5980 && TREE_CODE (var
) != LABEL_DECL
5981 && !target_for_debug_bind (var
))
5982 goto delink_debug_stmt
;
5984 if (DECL_P (var
) && !VECTOR_TYPE_P (TREE_TYPE (var
)))
5985 mode
= DECL_MODE (var
);
5987 mode
= TYPE_MODE (TREE_TYPE (var
));
5989 if (gimple_debug_bind_has_value_p (stmt
))
5990 value
= gimple_debug_bind_get_value (stmt
);
5992 val
= gen_rtx_VAR_LOCATION
5993 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5995 else if (gimple_debug_source_bind_p (stmt
))
5997 var
= gimple_debug_source_bind_get_var (stmt
);
5999 value
= gimple_debug_source_bind_get_value (stmt
);
6001 if (!VECTOR_TYPE_P (TREE_TYPE (var
)))
6002 mode
= DECL_MODE (var
);
6004 mode
= TYPE_MODE (TREE_TYPE (var
));
6006 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
6007 VAR_INIT_STATUS_UNINITIALIZED
);
6012 /* If this function was first compiled with markers
6013 enabled, but they're now disable (e.g. LTO), drop
6014 them on the floor. */
6015 else if (gimple_debug_nonbind_marker_p (stmt
)
6016 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
6017 goto delink_debug_stmt
;
6018 else if (gimple_debug_begin_stmt_p (stmt
))
6019 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
6020 else if (gimple_debug_inline_entry_p (stmt
))
6021 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
6025 last
= get_last_insn ();
6027 set_curr_insn_location (gimple_location (stmt
));
6029 emit_debug_insn (val
);
6031 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6033 /* We can't dump the insn with a TREE where an RTX
6035 if (GET_CODE (val
) == VAR_LOCATION
)
6037 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
6038 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
6040 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
6041 if (GET_CODE (val
) == VAR_LOCATION
)
6042 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
6046 /* In order not to generate too many debug temporaries,
6047 we delink all uses of debug statements we already expanded.
6048 Therefore debug statements between definition and real
6049 use of TERed SSA names will continue to use the SSA name,
6050 and not be replaced with debug temps. */
6051 delink_stmt_imm_use (stmt
);
6055 if (gsi_end_p (nsi
))
6057 stmt
= gsi_stmt (nsi
);
6058 if (!is_gimple_debug (stmt
))
6062 set_curr_insn_location (sloc
);
6066 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
6068 && gimple_call_tail_p (call_stmt
)
6069 && disable_tail_calls
)
6070 gimple_call_set_tail (call_stmt
, false);
6072 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
6075 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
6082 currently_expanding_gimple_stmt
= NULL
;
6089 def_operand_p def_p
;
6090 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
6094 /* Ignore this stmt if it is in the list of
6095 replaceable expressions. */
6097 && bitmap_bit_p (SA
.values
,
6098 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
6101 last
= expand_gimple_stmt (stmt
);
6102 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
6107 currently_expanding_gimple_stmt
= NULL
;
6109 /* Expand implicit goto and convert goto_locus. */
6110 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6112 if (e
->goto_locus
!= UNKNOWN_LOCATION
|| !nondebug_stmt_seen
)
6113 set_curr_insn_location (e
->goto_locus
);
6114 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
6116 emit_jump (label_rtx_for_bb (e
->dest
));
6117 e
->flags
&= ~EDGE_FALLTHRU
;
6121 /* Expanded RTL can create a jump in the last instruction of block.
6122 This later might be assumed to be a jump to successor and break edge insertion.
6123 We need to insert dummy move to prevent this. PR41440. */
6124 if (single_succ_p (bb
)
6125 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
6126 && (last
= get_last_insn ())
6128 || (DEBUG_INSN_P (last
)
6129 && JUMP_P (prev_nondebug_insn (last
)))))
6131 rtx dummy
= gen_reg_rtx (SImode
);
6132 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
6135 do_pending_stack_adjust ();
6137 /* Find the block tail. The last insn in the block is the insn
6138 before a barrier and/or table jump insn. */
6139 last
= get_last_insn ();
6140 if (BARRIER_P (last
))
6141 last
= PREV_INSN (last
);
6142 if (JUMP_TABLE_DATA_P (last
))
6143 last
= PREV_INSN (PREV_INSN (last
));
6144 if (BARRIER_P (last
))
6145 last
= PREV_INSN (last
);
6148 update_bb_for_insn (bb
);
6154 /* Create a basic block for initialization code. */
6157 construct_init_block (void)
6159 basic_block init_block
, first_block
;
6163 /* Multiple entry points not supported yet. */
6164 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
6165 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6166 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6167 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
6168 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
6170 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
6172 /* When entry edge points to first basic block, we don't need jump,
6173 otherwise we have to jump into proper target. */
6174 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
6176 tree label
= gimple_block_label (e
->dest
);
6178 emit_jump (jump_target_rtx (label
));
6182 flags
= EDGE_FALLTHRU
;
6184 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
6186 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6187 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
6188 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6191 first_block
= e
->dest
;
6192 redirect_edge_succ (e
, init_block
);
6193 make_single_succ_edge (init_block
, first_block
, flags
);
6196 make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6199 update_bb_for_insn (init_block
);
6203 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
6204 found in the block tree. */
6207 set_block_levels (tree block
, int level
)
6211 BLOCK_NUMBER (block
) = level
;
6212 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
6213 block
= BLOCK_CHAIN (block
);
6217 /* Create a block containing landing pads and similar stuff. */
6220 construct_exit_block (void)
6222 rtx_insn
*head
= get_last_insn ();
6224 basic_block exit_block
;
6228 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
6229 rtx_insn
*orig_end
= BB_END (prev_bb
);
6231 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6233 /* Make sure the locus is set to the end of the function, so that
6234 epilogue line numbers and warnings are set properly. */
6235 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
6236 input_location
= cfun
->function_end_locus
;
6238 /* Generate rtl for function exit. */
6239 expand_function_end ();
6241 end
= get_last_insn ();
6244 /* While emitting the function end we could move end of the last basic
6246 BB_END (prev_bb
) = orig_end
;
6247 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
6248 head
= NEXT_INSN (head
);
6249 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
6250 bb count counting will be confused. Any instructions before that
6251 label are emitted for the case where PREV_BB falls through into the
6252 exit block, so append those instructions to prev_bb in that case. */
6253 if (NEXT_INSN (head
) != return_label
)
6255 while (NEXT_INSN (head
) != return_label
)
6257 if (!NOTE_P (NEXT_INSN (head
)))
6258 BB_END (prev_bb
) = NEXT_INSN (head
);
6259 head
= NEXT_INSN (head
);
6262 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
6263 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
6264 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6267 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
6269 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
6270 if (!(e
->flags
& EDGE_ABNORMAL
))
6271 redirect_edge_succ (e
, exit_block
);
6276 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6278 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6281 exit_block
->count
-= e2
->count ();
6283 update_bb_for_insn (exit_block
);
6286 /* Helper function for discover_nonconstant_array_refs.
6287 Look for ARRAY_REF nodes with non-constant indexes and mark them
6291 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
6295 bitmap forced_stack_vars
= (bitmap
)((walk_stmt_info
*)data
)->info
;
6297 if (IS_TYPE_OR_DECL_P (t
))
6299 else if (REFERENCE_CLASS_P (t
) && TREE_THIS_VOLATILE (t
))
6301 t
= get_base_address (t
);
6303 && DECL_MODE (t
) != BLKmode
6304 && !TREE_ADDRESSABLE (t
))
6305 bitmap_set_bit (forced_stack_vars
, DECL_UID (t
));
6308 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6310 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6311 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
6312 && (!TREE_OPERAND (t
, 2)
6313 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6314 || (TREE_CODE (t
) == COMPONENT_REF
6315 && (!TREE_OPERAND (t
,2)
6316 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6317 || TREE_CODE (t
) == BIT_FIELD_REF
6318 || TREE_CODE (t
) == REALPART_EXPR
6319 || TREE_CODE (t
) == IMAGPART_EXPR
6320 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
6321 || CONVERT_EXPR_P (t
))
6322 t
= TREE_OPERAND (t
, 0);
6324 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6326 t
= get_base_address (t
);
6328 && DECL_MODE (t
) != BLKmode
6329 && !TREE_ADDRESSABLE (t
))
6330 bitmap_set_bit (forced_stack_vars
, DECL_UID (t
));
6335 /* References of size POLY_INT_CST to a fixed-size object must go
6336 through memory. It's more efficient to force that here than
6337 to create temporary slots on the fly.
6338 RTL expansion expectes TARGET_MEM_REF to always address actual memory. */
6339 else if (TREE_CODE (t
) == TARGET_MEM_REF
6340 || (TREE_CODE (t
) == MEM_REF
6341 && TYPE_SIZE (TREE_TYPE (t
))
6342 && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t
)))))
6344 tree base
= get_base_address (t
);
6347 && !TREE_ADDRESSABLE (base
)
6348 && DECL_MODE (base
) != BLKmode
6349 && GET_MODE_SIZE (DECL_MODE (base
)).is_constant ())
6350 bitmap_set_bit (forced_stack_vars
, DECL_UID (base
));
6357 /* If there's a chance to get a pseudo for t then if it would be of float mode
6358 and the actual access is via an integer mode (lowered memcpy or similar
6359 access) then avoid the register expansion if the mode likely is not storage
6360 suitable for raw bits processing (like XFmode on i?86). */
6363 avoid_type_punning_on_regs (tree t
, bitmap forced_stack_vars
)
6365 machine_mode access_mode
= TYPE_MODE (TREE_TYPE (t
));
6366 if (access_mode
!= BLKmode
6367 && !SCALAR_INT_MODE_P (access_mode
))
6369 tree base
= get_base_address (t
);
6371 && !TREE_ADDRESSABLE (base
)
6372 && FLOAT_MODE_P (DECL_MODE (base
))
6373 && maybe_lt (GET_MODE_PRECISION (DECL_MODE (base
)),
6374 GET_MODE_BITSIZE (GET_MODE_INNER (DECL_MODE (base
))))
6375 /* Double check in the expensive way we really would get a pseudo. */
6376 && use_register_for_decl (base
))
6377 bitmap_set_bit (forced_stack_vars
, DECL_UID (base
));
6380 /* RTL expansion is not able to compile array references with variable
6381 offsets for arrays stored in single register. Discover such
6382 expressions and mark variables as addressable to avoid this
6386 discover_nonconstant_array_refs (bitmap forced_stack_vars
)
6389 gimple_stmt_iterator gsi
;
6391 walk_stmt_info wi
= {};
6392 wi
.info
= forced_stack_vars
;
6393 FOR_EACH_BB_FN (bb
, cfun
)
6394 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6396 gimple
*stmt
= gsi_stmt (gsi
);
6397 if (!is_gimple_debug (stmt
))
6399 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, &wi
);
6400 gcall
*call
= dyn_cast
<gcall
*> (stmt
);
6401 if (call
&& gimple_call_internal_p (call
))
6403 tree cand
= NULL_TREE
;
6404 switch (gimple_call_internal_fn (call
))
6406 case IFN_LOAD_LANES
:
6407 /* The source must be a MEM. */
6408 cand
= gimple_call_arg (call
, 0);
6410 case IFN_STORE_LANES
:
6411 /* The destination must be a MEM. */
6412 cand
= gimple_call_lhs (call
);
6418 cand
= get_base_address (cand
);
6421 && use_register_for_decl (cand
))
6422 bitmap_set_bit (forced_stack_vars
, DECL_UID (cand
));
6424 if (gimple_vdef (stmt
))
6426 tree t
= gimple_get_lhs (stmt
);
6427 if (t
&& REFERENCE_CLASS_P (t
))
6428 avoid_type_punning_on_regs (t
, forced_stack_vars
);
6434 /* This function sets crtl->args.internal_arg_pointer to a virtual
6435 register if DRAP is needed. Local register allocator will replace
6436 virtual_incoming_args_rtx with the virtual register. */
6439 expand_stack_alignment (void)
6442 unsigned int preferred_stack_boundary
;
6444 if (! SUPPORTS_STACK_ALIGNMENT
)
6447 if (cfun
->calls_alloca
6448 || cfun
->has_nonlocal_label
6449 || crtl
->has_nonlocal_goto
)
6450 crtl
->need_drap
= true;
6452 /* Call update_stack_boundary here again to update incoming stack
6453 boundary. It may set incoming stack alignment to a different
6454 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6455 use the minimum incoming stack alignment to check if it is OK
6456 to perform sibcall optimization since sibcall optimization will
6457 only align the outgoing stack to incoming stack boundary. */
6458 if (targetm
.calls
.update_stack_boundary
)
6459 targetm
.calls
.update_stack_boundary ();
6461 /* The incoming stack frame has to be aligned at least at
6462 parm_stack_boundary. */
6463 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6465 /* Update crtl->stack_alignment_estimated and use it later to align
6466 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6467 exceptions since callgraph doesn't collect incoming stack alignment
6469 if (cfun
->can_throw_non_call_exceptions
6470 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6471 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6473 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6474 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6475 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6476 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6477 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6479 gcc_assert (crtl
->stack_alignment_needed
6480 <= crtl
->stack_alignment_estimated
);
6482 crtl
->stack_realign_needed
6483 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6484 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6486 crtl
->stack_realign_processed
= true;
6488 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6490 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6491 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6493 /* stack_realign_drap and drap_rtx must match. */
6494 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6496 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6497 if (drap_rtx
!= NULL
)
6499 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6501 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6503 fixup_tail_calls ();
6509 expand_main_function (void)
6511 #if (defined(INVOKE__main) \
6512 || (!defined(HAS_INIT_SECTION) \
6513 && !defined(INIT_SECTION_ASM_OP) \
6514 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6515 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6520 /* Expand code to initialize the stack_protect_guard. This is invoked at
6521 the beginning of a function to be protected. */
6524 stack_protect_prologue (void)
6526 tree guard_decl
= targetm
.stack_protect_guard ();
6529 crtl
->stack_protect_guard_decl
= guard_decl
;
6530 x
= expand_normal (crtl
->stack_protect_guard
);
6532 if (targetm
.have_stack_protect_combined_set () && guard_decl
)
6534 gcc_assert (DECL_P (guard_decl
));
6535 y
= DECL_RTL (guard_decl
);
6537 /* Allow the target to compute address of Y and copy it to X without
6538 leaking Y into a register. This combined address + copy pattern
6539 allows the target to prevent spilling of any intermediate results by
6540 splitting it after register allocator. */
6541 if (rtx_insn
*insn
= targetm
.gen_stack_protect_combined_set (x
, y
))
6549 y
= expand_normal (guard_decl
);
6553 /* Allow the target to copy from Y to X without leaking Y into a
6555 if (targetm
.have_stack_protect_set ())
6556 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6562 /* Otherwise do a straight move. */
6563 emit_move_insn (x
, y
);
6566 /* Translate the intermediate representation contained in the CFG
6567 from GIMPLE trees to RTL.
6569 We do conversion per basic block and preserve/update the tree CFG.
6570 This implies we have to do some magic as the CFG can simultaneously
6571 consist of basic blocks containing RTL and GIMPLE trees. This can
6572 confuse the CFG hooks, so be careful to not manipulate CFG during
6577 const pass_data pass_data_expand
=
6579 RTL_PASS
, /* type */
6580 "expand", /* name */
6581 OPTGROUP_NONE
, /* optinfo_flags */
6582 TV_EXPAND
, /* tv_id */
6583 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6586 | PROP_gimple_lva
), /* properties_required */
6587 PROP_rtl
, /* properties_provided */
6588 ( PROP_ssa
| PROP_gimple
), /* properties_destroyed */
6589 0, /* todo_flags_start */
6590 0, /* todo_flags_finish */
6593 class pass_expand
: public rtl_opt_pass
6596 pass_expand (gcc::context
*ctxt
)
6597 : rtl_opt_pass (pass_data_expand
, ctxt
)
6600 /* opt_pass methods: */
6601 unsigned int execute (function
*) final override
;
6603 }; // class pass_expand
6606 pass_expand::execute (function
*fun
)
6608 basic_block bb
, init_block
;
6611 rtx_insn
*var_seq
, *var_ret_seq
;
6614 timevar_push (TV_OUT_OF_SSA
);
6615 rewrite_out_of_ssa (&SA
);
6616 timevar_pop (TV_OUT_OF_SSA
);
6617 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6619 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6621 gimple_stmt_iterator gsi
;
6622 FOR_EACH_BB_FN (bb
, cfun
)
6623 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6624 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6625 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6628 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6629 auto_bitmap forced_stack_vars
;
6630 discover_nonconstant_array_refs (forced_stack_vars
);
6632 /* Make sure all values used by the optimization passes have sane
6636 /* Some backends want to know that we are expanding to RTL. */
6637 currently_expanding_to_rtl
= 1;
6638 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6639 free_dominance_info (CDI_DOMINATORS
);
6641 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6643 insn_locations_init ();
6644 if (!DECL_IS_UNDECLARED_BUILTIN (current_function_decl
))
6646 /* Eventually, all FEs should explicitly set function_start_locus. */
6647 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6648 set_curr_insn_location
6649 (DECL_SOURCE_LOCATION (current_function_decl
));
6651 set_curr_insn_location (fun
->function_start_locus
);
6654 set_curr_insn_location (UNKNOWN_LOCATION
);
6655 prologue_location
= curr_insn_location ();
6657 #ifdef INSN_SCHEDULING
6658 init_sched_attrs ();
6661 /* Make sure first insn is a note even if we don't want linenums.
6662 This makes sure the first insn will never be deleted.
6663 Also, final expects a note to appear there. */
6664 emit_note (NOTE_INSN_DELETED
);
6666 targetm
.expand_to_rtl_hook ();
6667 crtl
->init_stack_alignment ();
6668 fun
->cfg
->max_jumptable_ents
= 0;
6670 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6671 of the function section at exapnsion time to predict distance of calls. */
6672 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6674 /* Expand the variables recorded during gimple lowering. */
6675 timevar_push (TV_VAR_EXPAND
);
6678 var_ret_seq
= expand_used_vars (forced_stack_vars
);
6680 var_seq
= get_insns ();
6682 timevar_pop (TV_VAR_EXPAND
);
6684 /* Honor stack protection warnings. */
6685 if (warn_stack_protect
)
6687 if (fun
->calls_alloca
)
6688 warning (OPT_Wstack_protector
,
6689 "stack protector not protecting local variables: "
6690 "variable length buffer");
6691 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6692 warning (OPT_Wstack_protector
,
6693 "stack protector not protecting function: "
6694 "all local arrays are less than %d bytes long",
6695 (int) param_ssp_buffer_size
);
6698 /* Temporarily mark PARM_DECLs and RESULT_DECLs we need to expand to
6699 memory addressable so expand_function_start can emit the required
6701 auto_vec
<tree
, 16> marked_parms
;
6702 for (tree parm
= DECL_ARGUMENTS (current_function_decl
); parm
;
6703 parm
= DECL_CHAIN (parm
))
6704 if (!TREE_ADDRESSABLE (parm
)
6705 && bitmap_bit_p (forced_stack_vars
, DECL_UID (parm
)))
6707 TREE_ADDRESSABLE (parm
) = 1;
6708 marked_parms
.safe_push (parm
);
6710 if (DECL_RESULT (current_function_decl
)
6711 && !TREE_ADDRESSABLE (DECL_RESULT (current_function_decl
))
6712 && bitmap_bit_p (forced_stack_vars
,
6713 DECL_UID (DECL_RESULT (current_function_decl
))))
6715 TREE_ADDRESSABLE (DECL_RESULT (current_function_decl
)) = 1;
6716 marked_parms
.safe_push (DECL_RESULT (current_function_decl
));
6719 /* Set up parameters and prepare for return, for the function. */
6720 expand_function_start (current_function_decl
);
6722 /* Clear TREE_ADDRESSABLE again. */
6723 while (!marked_parms
.is_empty ())
6724 TREE_ADDRESSABLE (marked_parms
.pop ()) = 0;
6726 /* If we emitted any instructions for setting up the variables,
6727 emit them before the FUNCTION_START note. */
6730 emit_insn_before (var_seq
, parm_birth_insn
);
6732 /* In expand_function_end we'll insert the alloca save/restore
6733 before parm_birth_insn. We've just insertted an alloca call.
6734 Adjust the pointer to match. */
6735 parm_birth_insn
= var_seq
;
6738 /* Now propagate the RTL assignment of each partition to the
6739 underlying var of each SSA_NAME. */
6742 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6744 /* We might have generated new SSA names in
6745 update_alias_info_with_stack_vars. They will have a NULL
6746 defining statements, and won't be part of the partitioning,
6748 if (!SSA_NAME_DEF_STMT (name
))
6751 adjust_one_expanded_partition_var (name
);
6754 /* Clean up RTL of variables that straddle across multiple
6755 partitions, and check that the rtl of any PARM_DECLs that are not
6756 cleaned up is that of their default defs. */
6757 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6761 /* We might have generated new SSA names in
6762 update_alias_info_with_stack_vars. They will have a NULL
6763 defining statements, and won't be part of the partitioning,
6765 if (!SSA_NAME_DEF_STMT (name
))
6767 part
= var_to_partition (SA
.map
, name
);
6768 if (part
== NO_PARTITION
)
6771 /* If this decl was marked as living in multiple places, reset
6772 this now to NULL. */
6773 tree var
= SSA_NAME_VAR (name
);
6774 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6775 SET_DECL_RTL (var
, NULL
);
6776 /* Check that the pseudos chosen by assign_parms are those of
6777 the corresponding default defs. */
6778 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6779 && (TREE_CODE (var
) == PARM_DECL
6780 || TREE_CODE (var
) == RESULT_DECL
))
6782 rtx in
= DECL_RTL_IF_SET (var
);
6784 rtx out
= SA
.partition_to_pseudo
[part
];
6785 gcc_assert (in
== out
);
6787 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6788 those expected by debug backends for each parm and for
6789 the result. This is particularly important for stabs,
6790 whose register elimination from parm's DECL_RTL may cause
6791 -fcompare-debug differences as SET_DECL_RTL changes reg's
6792 attrs. So, make sure the RTL already has the parm as the
6793 EXPR, so that it won't change. */
6794 SET_DECL_RTL (var
, NULL_RTX
);
6796 set_mem_attributes (in
, var
, true);
6797 SET_DECL_RTL (var
, in
);
6801 /* If this function is `main', emit a call to `__main'
6802 to run global initializers, etc. */
6803 if (DECL_NAME (current_function_decl
)
6804 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6805 && DECL_FILE_SCOPE_P (current_function_decl
))
6806 expand_main_function ();
6808 /* Initialize the stack_protect_guard field. This must happen after the
6809 call to __main (if any) so that the external decl is initialized. */
6810 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6811 stack_protect_prologue ();
6813 expand_phi_nodes (&SA
);
6815 /* Release any stale SSA redirection data. */
6816 redirect_edge_var_map_empty ();
6818 /* Register rtl specific functions for cfg. */
6819 rtl_register_cfg_hooks ();
6821 init_block
= construct_init_block ();
6823 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6824 remaining edges later. */
6825 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6826 e
->flags
&= ~EDGE_EXECUTABLE
;
6828 /* If the function has too many markers, drop them while expanding. */
6829 if (cfun
->debug_marker_count
6830 >= param_max_debug_marker_count
)
6831 cfun
->debug_nonbind_markers
= false;
6833 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6834 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6836 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6838 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6839 expand_debug_locations ();
6841 if (deep_ter_debug_map
)
6843 delete deep_ter_debug_map
;
6844 deep_ter_debug_map
= NULL
;
6847 /* Free stuff we no longer need after GIMPLE optimizations. */
6848 free_dominance_info (CDI_DOMINATORS
);
6849 free_dominance_info (CDI_POST_DOMINATORS
);
6850 delete_tree_cfg_annotations (fun
);
6852 timevar_push (TV_OUT_OF_SSA
);
6853 finish_out_of_ssa (&SA
);
6854 timevar_pop (TV_OUT_OF_SSA
);
6856 timevar_push (TV_POST_EXPAND
);
6857 /* We are no longer in SSA form. */
6858 fun
->gimple_df
->in_ssa_p
= false;
6859 loops_state_clear (LOOP_CLOSED_SSA
);
6861 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6862 conservatively to true until they are all profile aware. */
6863 delete lab_rtx_for_bb
;
6864 free_histograms (fun
);
6866 construct_exit_block ();
6867 insn_locations_finalize ();
6871 rtx_insn
*after
= return_label
;
6872 rtx_insn
*next
= NEXT_INSN (after
);
6873 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6875 emit_insn_after (var_ret_seq
, after
);
6878 if (hwasan_sanitize_stack_p ())
6879 hwasan_maybe_emit_frame_base_init ();
6881 /* Zap the tree EH table. */
6882 set_eh_throw_stmt_table (fun
, NULL
);
6884 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6885 split edges which edge insertions might do. */
6886 rebuild_jump_labels (get_insns ());
6888 /* If we have a single successor to the entry block, put the pending insns
6889 after parm birth, but before NOTE_INSNS_FUNCTION_BEG. */
6890 if (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6892 edge e
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6895 rtx_insn
*insns
= e
->insns
.r
;
6897 rebuild_jump_labels_chain (insns
);
6898 if (NOTE_P (parm_birth_insn
)
6899 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6900 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6902 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6906 /* Otherwise, as well as for other edges, take the usual way. */
6907 commit_edge_insertions ();
6909 /* We're done expanding trees to RTL. */
6910 currently_expanding_to_rtl
= 0;
6912 flush_mark_addressable_queue ();
6914 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6915 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6919 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6921 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6922 e
->flags
&= ~EDGE_EXECUTABLE
;
6924 /* At the moment not all abnormal edges match the RTL
6925 representation. It is safe to remove them here as
6926 find_many_sub_basic_blocks will rediscover them.
6927 In the future we should get this fixed properly. */
6928 if ((e
->flags
& EDGE_ABNORMAL
)
6929 && !(e
->flags
& EDGE_SIBCALL
))
6936 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6937 bitmap_ones (blocks
);
6938 find_many_sub_basic_blocks (blocks
);
6939 purge_all_dead_edges ();
6941 /* After initial rtl generation, call back to finish generating
6942 exception support code. We need to do this before cleaning up
6943 the CFG as the code does not expect dead landing pads. */
6944 if (fun
->eh
->region_tree
!= NULL
)
6945 finish_eh_generation ();
6947 /* Call expand_stack_alignment after finishing all
6948 updates to crtl->preferred_stack_boundary. */
6949 expand_stack_alignment ();
6951 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6953 if (crtl
->tail_call_emit
)
6954 fixup_tail_calls ();
6956 HOST_WIDE_INT patch_area_size
, patch_area_entry
;
6957 parse_and_check_patch_area (flag_patchable_function_entry
, false,
6958 &patch_area_size
, &patch_area_entry
);
6960 tree patchable_function_entry_attr
6961 = lookup_attribute ("patchable_function_entry",
6962 DECL_ATTRIBUTES (cfun
->decl
));
6963 if (patchable_function_entry_attr
)
6965 tree pp_val
= TREE_VALUE (patchable_function_entry_attr
);
6966 tree patchable_function_entry_value1
= TREE_VALUE (pp_val
);
6968 patch_area_size
= tree_to_uhwi (patchable_function_entry_value1
);
6969 patch_area_entry
= 0;
6970 if (TREE_CHAIN (pp_val
) != NULL_TREE
)
6972 tree patchable_function_entry_value2
6973 = TREE_VALUE (TREE_CHAIN (pp_val
));
6974 patch_area_entry
= tree_to_uhwi (patchable_function_entry_value2
);
6978 if (patch_area_entry
> patch_area_size
)
6980 if (patch_area_size
> 0)
6981 warning (OPT_Wattributes
,
6982 "patchable function entry %wu exceeds size %wu",
6983 patch_area_entry
, patch_area_size
);
6984 patch_area_entry
= 0;
6987 crtl
->patch_area_size
= patch_area_size
;
6988 crtl
->patch_area_entry
= patch_area_entry
;
6990 /* BB subdivision may have created basic blocks that are only reachable
6991 from unlikely bbs but not marked as such in the profile. */
6993 propagate_unlikely_bbs_forward ();
6995 /* Remove unreachable blocks, otherwise we cannot compute dominators
6996 which are needed for loop state verification. As a side-effect
6997 this also compacts blocks.
6998 ??? We cannot remove trivially dead insns here as for example
6999 the DRAP reg on i?86 is not magically live at this point.
7000 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
7001 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
7003 checking_verify_flow_info ();
7005 /* Initialize pseudos allocated for hard registers. */
7006 emit_initial_value_sets ();
7008 /* And finally unshare all RTL. */
7011 /* There's no need to defer outputting this function any more; we
7012 know we want to output it. */
7013 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
7015 /* Now that we're done expanding trees to RTL, we shouldn't have any
7016 more CONCATs anywhere. */
7017 generating_concat_p
= 0;
7022 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
7023 /* And the pass manager will dump RTL for us. */
7026 /* If we're emitting a nested function, make sure its parent gets
7027 emitted as well. Doing otherwise confuses debug info. */
7030 for (parent
= DECL_CONTEXT (current_function_decl
);
7031 parent
!= NULL_TREE
;
7032 parent
= get_containing_scope (parent
))
7033 if (TREE_CODE (parent
) == FUNCTION_DECL
)
7034 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
7037 TREE_ASM_WRITTEN (current_function_decl
) = 1;
7039 /* After expanding, the return labels are no longer needed. */
7040 return_label
= NULL
;
7041 naked_return_label
= NULL
;
7043 /* After expanding, the tm_restart map is no longer needed. */
7044 if (fun
->gimple_df
->tm_restart
)
7045 fun
->gimple_df
->tm_restart
= NULL
;
7047 /* Tag the blocks with a depth number so that change_scope can find
7048 the common parent easily. */
7049 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
7050 default_rtl_profile ();
7052 /* For -dx discard loops now, otherwise IL verify in clean_state will
7054 if (rtl_dump_and_exit
)
7056 cfun
->curr_properties
&= ~PROP_loops
;
7057 loop_optimizer_finalize ();
7060 timevar_pop (TV_POST_EXPAND
);
7068 make_pass_expand (gcc::context
*ctxt
)
7070 return new pass_expand (ctxt
);