1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
29 #include "tree-pass.h"
34 #include "regs.h" /* For reg_renumber. */
38 #include "diagnostic.h"
39 #include "fold-const.h"
41 #include "stor-layout.h"
43 #include "print-tree.h"
47 #include "cfgcleanup.h"
52 #include "internal-fn.h"
54 #include "gimple-iterator.h"
55 #include "gimple-expr.h"
56 #include "gimple-walk.h"
61 #include "gimple-pretty-print.h"
65 #include "tree-inline.h"
66 #include "value-prof.h"
67 #include "tree-ssa-live.h"
68 #include "tree-outof-ssa.h"
70 #include "insn-attr.h" /* For INSN_SCHEDULING. */
72 #include "tree-ssa-address.h"
75 #include "tree-chkp.h"
78 /* Some systems use __main in a way incompatible with its use in gcc, in these
79 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80 give the same symbol without quotes for an alternative entry point. You
81 must define both, or neither. */
83 #define NAME__MAIN "__main"
86 /* This variable holds information helping the rewriting of SSA trees
90 /* This variable holds the currently expanded gimple statement for purposes
91 of comminucating the profile info to the builtin expanders. */
92 gimple
*currently_expanding_gimple_stmt
;
94 static rtx
expand_debug_expr (tree
);
96 static bool defer_stack_allocation (tree
, bool);
98 static void record_alignment_for_reg_var (unsigned int);
100 /* Return an expression tree corresponding to the RHS of GIMPLE
104 gimple_assign_rhs_to_tree (gimple
*stmt
)
107 enum gimple_rhs_class grhs_class
;
109 grhs_class
= get_gimple_rhs_class (gimple_expr_code (stmt
));
111 if (grhs_class
== GIMPLE_TERNARY_RHS
)
112 t
= build3 (gimple_assign_rhs_code (stmt
),
113 TREE_TYPE (gimple_assign_lhs (stmt
)),
114 gimple_assign_rhs1 (stmt
),
115 gimple_assign_rhs2 (stmt
),
116 gimple_assign_rhs3 (stmt
));
117 else if (grhs_class
== GIMPLE_BINARY_RHS
)
118 t
= build2 (gimple_assign_rhs_code (stmt
),
119 TREE_TYPE (gimple_assign_lhs (stmt
)),
120 gimple_assign_rhs1 (stmt
),
121 gimple_assign_rhs2 (stmt
));
122 else if (grhs_class
== GIMPLE_UNARY_RHS
)
123 t
= build1 (gimple_assign_rhs_code (stmt
),
124 TREE_TYPE (gimple_assign_lhs (stmt
)),
125 gimple_assign_rhs1 (stmt
));
126 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
128 t
= gimple_assign_rhs1 (stmt
);
129 /* Avoid modifying this tree in place below. */
130 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
131 && gimple_location (stmt
) != EXPR_LOCATION (t
))
132 || (gimple_block (stmt
)
133 && currently_expanding_to_rtl
140 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
141 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
147 #ifndef STACK_ALIGNMENT_NEEDED
148 #define STACK_ALIGNMENT_NEEDED 1
151 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
153 /* Choose either CUR or NEXT as the leader DECL for a partition.
154 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
155 out of the same user variable being in multiple partitions (this is
156 less likely for compiler-introduced temps). */
159 leader_merge (tree cur
, tree next
)
161 if (cur
== NULL
|| cur
== next
)
164 if (DECL_P (cur
) && DECL_IGNORED_P (cur
))
167 if (DECL_P (next
) && DECL_IGNORED_P (next
))
173 /* Associate declaration T with storage space X. If T is no
174 SSA name this is exactly SET_DECL_RTL, otherwise make the
175 partition of T associated with X. */
177 set_rtl (tree t
, rtx x
)
179 gcc_checking_assert (!x
180 || !(TREE_CODE (t
) == SSA_NAME
|| is_gimple_reg (t
))
181 || (use_register_for_decl (t
)
183 || (GET_CODE (x
) == CONCAT
184 && (REG_P (XEXP (x
, 0))
185 || SUBREG_P (XEXP (x
, 0)))
186 && (REG_P (XEXP (x
, 1))
187 || SUBREG_P (XEXP (x
, 1))))
188 /* We need to accept PARALLELs for RESUT_DECLs
189 because of vector types with BLKmode returned
190 in multiple registers, but they are supposed
191 to be uncoalesced. */
192 || (GET_CODE (x
) == PARALLEL
194 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
195 && (GET_MODE (x
) == BLKmode
196 || !flag_tree_coalesce_vars
)))
197 : (MEM_P (x
) || x
== pc_rtx
198 || (GET_CODE (x
) == CONCAT
199 && MEM_P (XEXP (x
, 0))
200 && MEM_P (XEXP (x
, 1))))));
201 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
202 RESULT_DECLs has the expected mode. For memory, we accept
203 unpromoted modes, since that's what we're likely to get. For
204 PARM_DECLs and RESULT_DECLs, we'll have been called by
205 set_parm_rtl, which will give us the default def, so we don't
206 have to compute it ourselves. For RESULT_DECLs, we accept mode
207 mismatches too, as long as we have BLKmode or are not coalescing
208 across variables, so that we don't reject BLKmode PARALLELs or
210 gcc_checking_assert (!x
|| x
== pc_rtx
|| TREE_CODE (t
) != SSA_NAME
212 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
213 && (promote_ssa_mode (t
, NULL
) == BLKmode
214 || !flag_tree_coalesce_vars
))
215 || !use_register_for_decl (t
)
216 || GET_MODE (x
) == promote_ssa_mode (t
, NULL
));
221 tree cur
= NULL_TREE
;
229 else if (SUBREG_P (xm
))
231 gcc_assert (subreg_lowpart_p (xm
));
232 xm
= SUBREG_REG (xm
);
235 else if (GET_CODE (xm
) == CONCAT
)
240 else if (GET_CODE (xm
) == PARALLEL
)
242 xm
= XVECEXP (xm
, 0, 0);
243 gcc_assert (GET_CODE (xm
) == EXPR_LIST
);
247 else if (xm
== pc_rtx
)
252 tree next
= skip
? cur
: leader_merge (cur
, SSAVAR (t
) ? SSAVAR (t
) : t
);
257 set_mem_attributes (x
,
258 next
&& TREE_CODE (next
) == SSA_NAME
262 set_reg_attrs_for_decl_rtl (next
, x
);
266 if (TREE_CODE (t
) == SSA_NAME
)
268 int part
= var_to_partition (SA
.map
, t
);
269 if (part
!= NO_PARTITION
)
271 if (SA
.partition_to_pseudo
[part
])
272 gcc_assert (SA
.partition_to_pseudo
[part
] == x
);
273 else if (x
!= pc_rtx
)
274 SA
.partition_to_pseudo
[part
] = x
;
276 /* For the benefit of debug information at -O0 (where
277 vartracking doesn't run) record the place also in the base
278 DECL. For PARMs and RESULTs, do so only when setting the
280 if (x
&& x
!= pc_rtx
&& SSA_NAME_VAR (t
)
281 && (VAR_P (SSA_NAME_VAR (t
))
282 || SSA_NAME_IS_DEFAULT_DEF (t
)))
284 tree var
= SSA_NAME_VAR (t
);
285 /* If we don't yet have something recorded, just record it now. */
286 if (!DECL_RTL_SET_P (var
))
287 SET_DECL_RTL (var
, x
);
288 /* If we have it set already to "multiple places" don't
290 else if (DECL_RTL (var
) == pc_rtx
)
292 /* If we have something recorded and it's not the same place
293 as we want to record now, we have multiple partitions for the
294 same base variable, with different places. We can't just
295 randomly chose one, hence we have to say that we don't know.
296 This only happens with optimization, and there var-tracking
297 will figure out the right thing. */
298 else if (DECL_RTL (var
) != x
)
299 SET_DECL_RTL (var
, pc_rtx
);
306 /* This structure holds data relevant to one variable that will be
307 placed in a stack slot. */
313 /* Initially, the size of the variable. Later, the size of the partition,
314 if this variable becomes it's partition's representative. */
317 /* The *byte* alignment required for this variable. Or as, with the
318 size, the alignment for this partition. */
321 /* The partition representative. */
322 size_t representative
;
324 /* The next stack variable in the partition, or EOC. */
327 /* The numbers of conflicting stack variables. */
331 #define EOC ((size_t)-1)
333 /* We have an array of such objects while deciding allocation. */
334 static struct stack_var
*stack_vars
;
335 static size_t stack_vars_alloc
;
336 static size_t stack_vars_num
;
337 static hash_map
<tree
, size_t> *decl_to_stack_part
;
339 /* Conflict bitmaps go on this obstack. This allows us to destroy
340 all of them in one big sweep. */
341 static bitmap_obstack stack_var_bitmap_obstack
;
343 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
344 is non-decreasing. */
345 static size_t *stack_vars_sorted
;
347 /* The phase of the stack frame. This is the known misalignment of
348 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
349 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
350 static int frame_phase
;
352 /* Used during expand_used_vars to remember if we saw any decls for
353 which we'd like to enable stack smashing protection. */
354 static bool has_protected_decls
;
356 /* Used during expand_used_vars. Remember if we say a character buffer
357 smaller than our cutoff threshold. Used for -Wstack-protector. */
358 static bool has_short_buffer
;
360 /* Compute the byte alignment to use for DECL. Ignore alignment
361 we can't do with expected alignment of the stack boundary. */
364 align_local_variable (tree decl
)
368 if (TREE_CODE (decl
) == SSA_NAME
)
369 align
= TYPE_ALIGN (TREE_TYPE (decl
));
372 align
= LOCAL_DECL_ALIGNMENT (decl
);
373 SET_DECL_ALIGN (decl
, align
);
375 return align
/ BITS_PER_UNIT
;
378 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
379 down otherwise. Return truncated BASE value. */
381 static inline unsigned HOST_WIDE_INT
382 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
384 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
387 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
388 Return the frame offset. */
391 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
393 HOST_WIDE_INT offset
, new_frame_offset
;
395 if (FRAME_GROWS_DOWNWARD
)
398 = align_base (frame_offset
- frame_phase
- size
,
399 align
, false) + frame_phase
;
400 offset
= new_frame_offset
;
405 = align_base (frame_offset
- frame_phase
, align
, true) + frame_phase
;
406 offset
= new_frame_offset
;
407 new_frame_offset
+= size
;
409 frame_offset
= new_frame_offset
;
411 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
412 frame_offset
= offset
= 0;
417 /* Accumulate DECL into STACK_VARS. */
420 add_stack_var (tree decl
)
424 if (stack_vars_num
>= stack_vars_alloc
)
426 if (stack_vars_alloc
)
427 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
429 stack_vars_alloc
= 32;
431 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
433 if (!decl_to_stack_part
)
434 decl_to_stack_part
= new hash_map
<tree
, size_t>;
436 v
= &stack_vars
[stack_vars_num
];
437 decl_to_stack_part
->put (decl
, stack_vars_num
);
440 tree size
= TREE_CODE (decl
) == SSA_NAME
441 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
442 : DECL_SIZE_UNIT (decl
);
443 v
->size
= tree_to_uhwi (size
);
444 /* Ensure that all variables have size, so that &a != &b for any two
445 variables that are simultaneously live. */
448 v
->alignb
= align_local_variable (decl
);
449 /* An alignment of zero can mightily confuse us later. */
450 gcc_assert (v
->alignb
!= 0);
452 /* All variables are initially in their own partition. */
453 v
->representative
= stack_vars_num
;
456 /* All variables initially conflict with no other. */
459 /* Ensure that this decl doesn't get put onto the list twice. */
460 set_rtl (decl
, pc_rtx
);
465 /* Make the decls associated with luid's X and Y conflict. */
468 add_stack_var_conflict (size_t x
, size_t y
)
470 struct stack_var
*a
= &stack_vars
[x
];
471 struct stack_var
*b
= &stack_vars
[y
];
473 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
475 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
476 bitmap_set_bit (a
->conflicts
, y
);
477 bitmap_set_bit (b
->conflicts
, x
);
480 /* Check whether the decls associated with luid's X and Y conflict. */
483 stack_var_conflict_p (size_t x
, size_t y
)
485 struct stack_var
*a
= &stack_vars
[x
];
486 struct stack_var
*b
= &stack_vars
[y
];
489 /* Partitions containing an SSA name result from gimple registers
490 with things like unsupported modes. They are top-level and
491 hence conflict with everything else. */
492 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
495 if (!a
->conflicts
|| !b
->conflicts
)
497 return bitmap_bit_p (a
->conflicts
, y
);
500 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
501 enter its partition number into bitmap DATA. */
504 visit_op (gimple
*, tree op
, tree
, void *data
)
506 bitmap active
= (bitmap
)data
;
507 op
= get_base_address (op
);
510 && DECL_RTL_IF_SET (op
) == pc_rtx
)
512 size_t *v
= decl_to_stack_part
->get (op
);
514 bitmap_set_bit (active
, *v
);
519 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
520 record conflicts between it and all currently active other partitions
524 visit_conflict (gimple
*, tree op
, tree
, void *data
)
526 bitmap active
= (bitmap
)data
;
527 op
= get_base_address (op
);
530 && DECL_RTL_IF_SET (op
) == pc_rtx
)
532 size_t *v
= decl_to_stack_part
->get (op
);
533 if (v
&& bitmap_set_bit (active
, *v
))
538 gcc_assert (num
< stack_vars_num
);
539 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
540 add_stack_var_conflict (num
, i
);
546 /* Helper routine for add_scope_conflicts, calculating the active partitions
547 at the end of BB, leaving the result in WORK. We're called to generate
548 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
552 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
556 gimple_stmt_iterator gsi
;
557 walk_stmt_load_store_addr_fn visit
;
560 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
561 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
565 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
567 gimple
*stmt
= gsi_stmt (gsi
);
568 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
570 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
572 gimple
*stmt
= gsi_stmt (gsi
);
574 if (gimple_clobber_p (stmt
))
576 tree lhs
= gimple_assign_lhs (stmt
);
578 /* Nested function lowering might introduce LHSs
579 that are COMPONENT_REFs. */
582 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
583 && (v
= decl_to_stack_part
->get (lhs
)))
584 bitmap_clear_bit (work
, *v
);
586 else if (!is_gimple_debug (stmt
))
589 && visit
== visit_op
)
591 /* If this is the first real instruction in this BB we need
592 to add conflicts for everything live at this point now.
593 Unlike classical liveness for named objects we can't
594 rely on seeing a def/use of the names we're interested in.
595 There might merely be indirect loads/stores. We'd not add any
596 conflicts for such partitions. */
599 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
601 struct stack_var
*a
= &stack_vars
[i
];
603 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
604 bitmap_ior_into (a
->conflicts
, work
);
606 visit
= visit_conflict
;
608 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
613 /* Generate stack partition conflicts between all partitions that are
614 simultaneously live. */
617 add_scope_conflicts (void)
621 bitmap work
= BITMAP_ALLOC (NULL
);
625 /* We approximate the live range of a stack variable by taking the first
626 mention of its name as starting point(s), and by the end-of-scope
627 death clobber added by gimplify as ending point(s) of the range.
628 This overapproximates in the case we for instance moved an address-taken
629 operation upward, without also moving a dereference to it upwards.
630 But it's conservatively correct as a variable never can hold values
631 before its name is mentioned at least once.
633 We then do a mostly classical bitmap liveness algorithm. */
635 FOR_ALL_BB_FN (bb
, cfun
)
636 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
638 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
639 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
646 for (i
= 0; i
< n_bbs
; i
++)
649 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
650 active
= (bitmap
)bb
->aux
;
651 add_scope_conflicts_1 (bb
, work
, false);
652 if (bitmap_ior_into (active
, work
))
657 FOR_EACH_BB_FN (bb
, cfun
)
658 add_scope_conflicts_1 (bb
, work
, true);
662 FOR_ALL_BB_FN (bb
, cfun
)
663 BITMAP_FREE (bb
->aux
);
666 /* A subroutine of partition_stack_vars. A comparison function for qsort,
667 sorting an array of indices by the properties of the object. */
670 stack_var_cmp (const void *a
, const void *b
)
672 size_t ia
= *(const size_t *)a
;
673 size_t ib
= *(const size_t *)b
;
674 unsigned int aligna
= stack_vars
[ia
].alignb
;
675 unsigned int alignb
= stack_vars
[ib
].alignb
;
676 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
677 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
678 tree decla
= stack_vars
[ia
].decl
;
679 tree declb
= stack_vars
[ib
].decl
;
681 unsigned int uida
, uidb
;
683 /* Primary compare on "large" alignment. Large comes first. */
684 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
685 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
686 if (largea
!= largeb
)
687 return (int)largeb
- (int)largea
;
689 /* Secondary compare on size, decreasing */
695 /* Tertiary compare on true alignment, decreasing. */
701 /* Final compare on ID for sort stability, increasing.
702 Two SSA names are compared by their version, SSA names come before
703 non-SSA names, and two normal decls are compared by their DECL_UID. */
704 if (TREE_CODE (decla
) == SSA_NAME
)
706 if (TREE_CODE (declb
) == SSA_NAME
)
707 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
711 else if (TREE_CODE (declb
) == SSA_NAME
)
714 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
722 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
723 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
725 /* If the points-to solution *PI points to variables that are in a partition
726 together with other variables add all partition members to the pointed-to
730 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
731 part_hashmap
*decls_to_partitions
,
732 hash_set
<bitmap
> *visited
, bitmap temp
)
740 /* The pointed-to vars bitmap is shared, it is enough to
742 || visited
->add (pt
->vars
))
747 /* By using a temporary bitmap to store all members of the partitions
748 we have to add we make sure to visit each of the partitions only
750 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
752 || !bitmap_bit_p (temp
, i
))
753 && (part
= decls_to_partitions
->get (i
)))
754 bitmap_ior_into (temp
, *part
);
755 if (!bitmap_empty_p (temp
))
756 bitmap_ior_into (pt
->vars
, temp
);
759 /* Update points-to sets based on partition info, so we can use them on RTL.
760 The bitmaps representing stack partitions will be saved until expand,
761 where partitioned decls used as bases in memory expressions will be
765 update_alias_info_with_stack_vars (void)
767 part_hashmap
*decls_to_partitions
= NULL
;
769 tree var
= NULL_TREE
;
771 for (i
= 0; i
< stack_vars_num
; i
++)
775 struct ptr_info_def
*pi
;
777 /* Not interested in partitions with single variable. */
778 if (stack_vars
[i
].representative
!= i
779 || stack_vars
[i
].next
== EOC
)
782 if (!decls_to_partitions
)
784 decls_to_partitions
= new part_hashmap
;
785 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
788 /* Create an SSA_NAME that points to the partition for use
789 as base during alias-oracle queries on RTL for bases that
790 have been partitioned. */
791 if (var
== NULL_TREE
)
792 var
= create_tmp_var (ptr_type_node
);
793 name
= make_ssa_name (var
);
795 /* Create bitmaps representing partitions. They will be used for
796 points-to sets later, so use GGC alloc. */
797 part
= BITMAP_GGC_ALLOC ();
798 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
800 tree decl
= stack_vars
[j
].decl
;
801 unsigned int uid
= DECL_PT_UID (decl
);
802 bitmap_set_bit (part
, uid
);
803 decls_to_partitions
->put (uid
, part
);
804 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
805 if (TREE_ADDRESSABLE (decl
))
806 TREE_ADDRESSABLE (name
) = 1;
809 /* Make the SSA name point to all partition members. */
810 pi
= get_ptr_info (name
);
811 pt_solution_set (&pi
->pt
, part
, false);
814 /* Make all points-to sets that contain one member of a partition
815 contain all members of the partition. */
816 if (decls_to_partitions
)
820 hash_set
<bitmap
> visited
;
821 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
823 FOR_EACH_SSA_NAME (i
, name
, cfun
)
825 struct ptr_info_def
*pi
;
827 if (POINTER_TYPE_P (TREE_TYPE (name
))
828 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
829 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
833 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
834 decls_to_partitions
, &visited
, temp
);
836 delete decls_to_partitions
;
841 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
842 partitioning algorithm. Partitions A and B are known to be non-conflicting.
843 Merge them into a single partition A. */
846 union_stack_vars (size_t a
, size_t b
)
848 struct stack_var
*vb
= &stack_vars
[b
];
852 gcc_assert (stack_vars
[b
].next
== EOC
);
853 /* Add B to A's partition. */
854 stack_vars
[b
].next
= stack_vars
[a
].next
;
855 stack_vars
[b
].representative
= a
;
856 stack_vars
[a
].next
= b
;
858 /* Update the required alignment of partition A to account for B. */
859 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
860 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
862 /* Update the interference graph and merge the conflicts. */
865 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
866 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
867 BITMAP_FREE (vb
->conflicts
);
871 /* A subroutine of expand_used_vars. Binpack the variables into
872 partitions constrained by the interference graph. The overall
873 algorithm used is as follows:
875 Sort the objects by size in descending order.
880 Look for the largest non-conflicting object B with size <= S.
887 partition_stack_vars (void)
889 size_t si
, sj
, n
= stack_vars_num
;
891 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
892 for (si
= 0; si
< n
; ++si
)
893 stack_vars_sorted
[si
] = si
;
898 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
900 for (si
= 0; si
< n
; ++si
)
902 size_t i
= stack_vars_sorted
[si
];
903 unsigned int ialign
= stack_vars
[i
].alignb
;
904 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
906 /* Ignore objects that aren't partition representatives. If we
907 see a var that is not a partition representative, it must
908 have been merged earlier. */
909 if (stack_vars
[i
].representative
!= i
)
912 for (sj
= si
+ 1; sj
< n
; ++sj
)
914 size_t j
= stack_vars_sorted
[sj
];
915 unsigned int jalign
= stack_vars
[j
].alignb
;
916 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
918 /* Ignore objects that aren't partition representatives. */
919 if (stack_vars
[j
].representative
!= j
)
922 /* Do not mix objects of "small" (supported) alignment
923 and "large" (unsupported) alignment. */
924 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
925 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
928 /* For Address Sanitizer do not mix objects with different
929 sizes, as the shorter vars wouldn't be adequately protected.
930 Don't do that for "large" (unsupported) alignment objects,
931 those aren't protected anyway. */
932 if ((asan_sanitize_stack_p ())
934 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
937 /* Ignore conflicting objects. */
938 if (stack_var_conflict_p (i
, j
))
941 /* UNION the objects, placing J at OFFSET. */
942 union_stack_vars (i
, j
);
946 update_alias_info_with_stack_vars ();
949 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
952 dump_stack_var_partition (void)
954 size_t si
, i
, j
, n
= stack_vars_num
;
956 for (si
= 0; si
< n
; ++si
)
958 i
= stack_vars_sorted
[si
];
960 /* Skip variables that aren't partition representatives, for now. */
961 if (stack_vars
[i
].representative
!= i
)
964 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
965 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
966 stack_vars
[i
].alignb
);
968 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
970 fputc ('\t', dump_file
);
971 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
973 fputc ('\n', dump_file
);
977 /* Assign rtl to DECL at BASE + OFFSET. */
980 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
981 HOST_WIDE_INT offset
)
986 /* If this fails, we've overflowed the stack frame. Error nicely? */
987 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
989 x
= plus_constant (Pmode
, base
, offset
);
990 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
991 ? TYPE_MODE (TREE_TYPE (decl
))
992 : DECL_MODE (SSAVAR (decl
)), x
);
994 if (TREE_CODE (decl
) != SSA_NAME
)
996 /* Set alignment we actually gave this decl if it isn't an SSA name.
997 If it is we generate stack slots only accidentally so it isn't as
998 important, we'll simply use the alignment that is already set. */
999 if (base
== virtual_stack_vars_rtx
)
1000 offset
-= frame_phase
;
1001 align
= least_bit_hwi (offset
);
1002 align
*= BITS_PER_UNIT
;
1003 if (align
== 0 || align
> base_align
)
1006 /* One would think that we could assert that we're not decreasing
1007 alignment here, but (at least) the i386 port does exactly this
1008 via the MINIMUM_ALIGNMENT hook. */
1010 SET_DECL_ALIGN (decl
, align
);
1011 DECL_USER_ALIGN (decl
) = 0;
1017 struct stack_vars_data
1019 /* Vector of offset pairs, always end of some padding followed
1020 by start of the padding that needs Address Sanitizer protection.
1021 The vector is in reversed, highest offset pairs come first. */
1022 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1024 /* Vector of partition representative decls in between the paddings. */
1025 auto_vec
<tree
> asan_decl_vec
;
1027 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1030 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1031 unsigned int asan_alignb
;
1034 /* A subroutine of expand_used_vars. Give each partition representative
1035 a unique location within the stack frame. Update each partition member
1036 with that location. */
1039 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
1041 size_t si
, i
, j
, n
= stack_vars_num
;
1042 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
1043 rtx large_base
= NULL
;
1044 unsigned large_align
= 0;
1045 bool large_allocation_done
= false;
1048 /* Determine if there are any variables requiring "large" alignment.
1049 Since these are dynamically allocated, we only process these if
1050 no predicate involved. */
1051 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1052 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1054 /* Find the total size of these variables. */
1055 for (si
= 0; si
< n
; ++si
)
1059 i
= stack_vars_sorted
[si
];
1060 alignb
= stack_vars
[i
].alignb
;
1062 /* All "large" alignment decls come before all "small" alignment
1063 decls, but "large" alignment decls are not sorted based on
1064 their alignment. Increase large_align to track the largest
1065 required alignment. */
1066 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1067 large_align
= alignb
* BITS_PER_UNIT
;
1069 /* Stop when we get to the first decl with "small" alignment. */
1070 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1073 /* Skip variables that aren't partition representatives. */
1074 if (stack_vars
[i
].representative
!= i
)
1077 /* Skip variables that have already had rtl assigned. See also
1078 add_stack_var where we perpetrate this pc_rtx hack. */
1079 decl
= stack_vars
[i
].decl
;
1080 if (TREE_CODE (decl
) == SSA_NAME
1081 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1082 : DECL_RTL (decl
) != pc_rtx
)
1085 large_size
+= alignb
- 1;
1086 large_size
&= -(HOST_WIDE_INT
)alignb
;
1087 large_size
+= stack_vars
[i
].size
;
1091 for (si
= 0; si
< n
; ++si
)
1094 unsigned base_align
, alignb
;
1095 HOST_WIDE_INT offset
;
1097 i
= stack_vars_sorted
[si
];
1099 /* Skip variables that aren't partition representatives, for now. */
1100 if (stack_vars
[i
].representative
!= i
)
1103 /* Skip variables that have already had rtl assigned. See also
1104 add_stack_var where we perpetrate this pc_rtx hack. */
1105 decl
= stack_vars
[i
].decl
;
1106 if (TREE_CODE (decl
) == SSA_NAME
1107 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1108 : DECL_RTL (decl
) != pc_rtx
)
1111 /* Check the predicate to see whether this variable should be
1112 allocated in this pass. */
1113 if (pred
&& !pred (i
))
1116 alignb
= stack_vars
[i
].alignb
;
1117 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1119 base
= virtual_stack_vars_rtx
;
1120 if ((asan_sanitize_stack_p ())
1123 HOST_WIDE_INT prev_offset
1124 = align_base (frame_offset
,
1125 MAX (alignb
, ASAN_RED_ZONE_SIZE
),
1126 !FRAME_GROWS_DOWNWARD
);
1127 tree repr_decl
= NULL_TREE
;
1129 = alloc_stack_frame_space (stack_vars
[i
].size
1130 + ASAN_RED_ZONE_SIZE
,
1131 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
1133 data
->asan_vec
.safe_push (prev_offset
);
1134 data
->asan_vec
.safe_push (offset
+ stack_vars
[i
].size
);
1135 /* Find best representative of the partition.
1136 Prefer those with DECL_NAME, even better
1137 satisfying asan_protect_stack_decl predicate. */
1138 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1139 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1140 && DECL_NAME (stack_vars
[j
].decl
))
1142 repr_decl
= stack_vars
[j
].decl
;
1145 else if (repr_decl
== NULL_TREE
1146 && DECL_P (stack_vars
[j
].decl
)
1147 && DECL_NAME (stack_vars
[j
].decl
))
1148 repr_decl
= stack_vars
[j
].decl
;
1149 if (repr_decl
== NULL_TREE
)
1150 repr_decl
= stack_vars
[i
].decl
;
1151 data
->asan_decl_vec
.safe_push (repr_decl
);
1152 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1153 if (data
->asan_base
== NULL
)
1154 data
->asan_base
= gen_reg_rtx (Pmode
);
1155 base
= data
->asan_base
;
1157 if (!STRICT_ALIGNMENT
)
1158 base_align
= crtl
->max_used_stack_slot_alignment
;
1160 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1161 GET_MODE_ALIGNMENT (SImode
)
1162 << ASAN_SHADOW_SHIFT
);
1166 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1167 base_align
= crtl
->max_used_stack_slot_alignment
;
1172 /* Large alignment is only processed in the last pass. */
1176 /* If there were any variables requiring "large" alignment, allocate
1178 if (large_size
> 0 && ! large_allocation_done
)
1180 HOST_WIDE_INT loffset
;
1181 rtx large_allocsize
;
1183 large_allocsize
= GEN_INT (large_size
);
1184 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1185 loffset
= alloc_stack_frame_space
1186 (INTVAL (large_allocsize
),
1187 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1188 large_base
= get_dynamic_stack_base (loffset
, large_align
);
1189 large_allocation_done
= true;
1191 gcc_assert (large_base
!= NULL
);
1193 large_alloc
+= alignb
- 1;
1194 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
1195 offset
= large_alloc
;
1196 large_alloc
+= stack_vars
[i
].size
;
1199 base_align
= large_align
;
1202 /* Create rtl for each variable based on their location within the
1204 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1206 expand_one_stack_var_at (stack_vars
[j
].decl
,
1212 gcc_assert (large_alloc
== large_size
);
1215 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1216 static HOST_WIDE_INT
1217 account_stack_vars (void)
1219 size_t si
, j
, i
, n
= stack_vars_num
;
1220 HOST_WIDE_INT size
= 0;
1222 for (si
= 0; si
< n
; ++si
)
1224 i
= stack_vars_sorted
[si
];
1226 /* Skip variables that aren't partition representatives, for now. */
1227 if (stack_vars
[i
].representative
!= i
)
1230 size
+= stack_vars
[i
].size
;
1231 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1232 set_rtl (stack_vars
[j
].decl
, NULL
);
1237 /* Record the RTL assignment X for the default def of PARM. */
1240 set_parm_rtl (tree parm
, rtx x
)
1242 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1243 || TREE_CODE (parm
) == RESULT_DECL
);
1245 if (x
&& !MEM_P (x
))
1247 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1248 TYPE_MODE (TREE_TYPE (parm
)),
1249 TYPE_ALIGN (TREE_TYPE (parm
)));
1251 /* If the variable alignment is very large we'll dynamicaly
1252 allocate it, which means that in-frame portion is just a
1253 pointer. ??? We've got a pseudo for sure here, do we
1254 actually dynamically allocate its spilling area if needed?
1255 ??? Isn't it a problem when POINTER_SIZE also exceeds
1256 MAX_SUPPORTED_STACK_ALIGNMENT, as on cris and lm32? */
1257 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1258 align
= POINTER_SIZE
;
1260 record_alignment_for_reg_var (align
);
1263 tree ssa
= ssa_default_def (cfun
, parm
);
1265 return set_rtl (parm
, x
);
1267 int part
= var_to_partition (SA
.map
, ssa
);
1268 gcc_assert (part
!= NO_PARTITION
);
1270 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1271 gcc_assert (changed
);
1274 gcc_assert (DECL_RTL (parm
) == x
);
1277 /* A subroutine of expand_one_var. Called to immediately assign rtl
1278 to a variable to be allocated in the stack frame. */
1281 expand_one_stack_var_1 (tree var
)
1283 HOST_WIDE_INT size
, offset
;
1284 unsigned byte_align
;
1286 if (TREE_CODE (var
) == SSA_NAME
)
1288 tree type
= TREE_TYPE (var
);
1289 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1290 byte_align
= TYPE_ALIGN_UNIT (type
);
1294 size
= tree_to_uhwi (DECL_SIZE_UNIT (var
));
1295 byte_align
= align_local_variable (var
);
1298 /* We handle highly aligned variables in expand_stack_vars. */
1299 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1301 offset
= alloc_stack_frame_space (size
, byte_align
);
1303 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1304 crtl
->max_used_stack_slot_alignment
, offset
);
1307 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1308 already assigned some MEM. */
1311 expand_one_stack_var (tree var
)
1313 if (TREE_CODE (var
) == SSA_NAME
)
1315 int part
= var_to_partition (SA
.map
, var
);
1316 if (part
!= NO_PARTITION
)
1318 rtx x
= SA
.partition_to_pseudo
[part
];
1320 gcc_assert (MEM_P (x
));
1325 return expand_one_stack_var_1 (var
);
1328 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1329 that will reside in a hard register. */
1332 expand_one_hard_reg_var (tree var
)
1334 rest_of_decl_compilation (var
, 0, 0);
1337 /* Record the alignment requirements of some variable assigned to a
1341 record_alignment_for_reg_var (unsigned int align
)
1343 if (SUPPORTS_STACK_ALIGNMENT
1344 && crtl
->stack_alignment_estimated
< align
)
1346 /* stack_alignment_estimated shouldn't change after stack
1347 realign decision made */
1348 gcc_assert (!crtl
->stack_realign_processed
);
1349 crtl
->stack_alignment_estimated
= align
;
1352 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1353 So here we only make sure stack_alignment_needed >= align. */
1354 if (crtl
->stack_alignment_needed
< align
)
1355 crtl
->stack_alignment_needed
= align
;
1356 if (crtl
->max_used_stack_slot_alignment
< align
)
1357 crtl
->max_used_stack_slot_alignment
= align
;
1360 /* Create RTL for an SSA partition. */
1363 expand_one_ssa_partition (tree var
)
1365 int part
= var_to_partition (SA
.map
, var
);
1366 gcc_assert (part
!= NO_PARTITION
);
1368 if (SA
.partition_to_pseudo
[part
])
1371 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1372 TYPE_MODE (TREE_TYPE (var
)),
1373 TYPE_ALIGN (TREE_TYPE (var
)));
1375 /* If the variable alignment is very large we'll dynamicaly allocate
1376 it, which means that in-frame portion is just a pointer. */
1377 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1378 align
= POINTER_SIZE
;
1380 record_alignment_for_reg_var (align
);
1382 if (!use_register_for_decl (var
))
1384 if (defer_stack_allocation (var
, true))
1385 add_stack_var (var
);
1387 expand_one_stack_var_1 (var
);
1391 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1393 rtx x
= gen_reg_rtx (reg_mode
);
1398 /* Record the association between the RTL generated for partition PART
1399 and the underlying variable of the SSA_NAME VAR. */
1402 adjust_one_expanded_partition_var (tree var
)
1407 tree decl
= SSA_NAME_VAR (var
);
1409 int part
= var_to_partition (SA
.map
, var
);
1410 if (part
== NO_PARTITION
)
1413 rtx x
= SA
.partition_to_pseudo
[part
];
1422 /* Note if the object is a user variable. */
1423 if (decl
&& !DECL_ARTIFICIAL (decl
))
1426 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1427 mark_reg_pointer (x
, get_pointer_alignment (var
));
1430 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1431 that will reside in a pseudo register. */
1434 expand_one_register_var (tree var
)
1436 if (TREE_CODE (var
) == SSA_NAME
)
1438 int part
= var_to_partition (SA
.map
, var
);
1439 if (part
!= NO_PARTITION
)
1441 rtx x
= SA
.partition_to_pseudo
[part
];
1443 gcc_assert (REG_P (x
));
1450 tree type
= TREE_TYPE (decl
);
1451 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1452 rtx x
= gen_reg_rtx (reg_mode
);
1456 /* Note if the object is a user variable. */
1457 if (!DECL_ARTIFICIAL (decl
))
1460 if (POINTER_TYPE_P (type
))
1461 mark_reg_pointer (x
, get_pointer_alignment (var
));
1464 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1465 has some associated error, e.g. its type is error-mark. We just need
1466 to pick something that won't crash the rest of the compiler. */
1469 expand_one_error_var (tree var
)
1471 machine_mode mode
= DECL_MODE (var
);
1474 if (mode
== BLKmode
)
1475 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1476 else if (mode
== VOIDmode
)
1479 x
= gen_reg_rtx (mode
);
1481 SET_DECL_RTL (var
, x
);
1484 /* A subroutine of expand_one_var. VAR is a variable that will be
1485 allocated to the local stack frame. Return true if we wish to
1486 add VAR to STACK_VARS so that it will be coalesced with other
1487 variables. Return false to allocate VAR immediately.
1489 This function is used to reduce the number of variables considered
1490 for coalescing, which reduces the size of the quadratic problem. */
1493 defer_stack_allocation (tree var
, bool toplevel
)
1495 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1496 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1497 : DECL_SIZE_UNIT (var
);
1499 /* Whether the variable is small enough for immediate allocation not to be
1500 a problem with regard to the frame size. */
1502 = ((HOST_WIDE_INT
) tree_to_uhwi (size_unit
)
1503 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
));
1505 /* If stack protection is enabled, *all* stack variables must be deferred,
1506 so that we can re-order the strings to the top of the frame.
1507 Similarly for Address Sanitizer. */
1508 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1511 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1512 ? TYPE_ALIGN (TREE_TYPE (var
))
1515 /* We handle "large" alignment via dynamic allocation. We want to handle
1516 this extra complication in only one place, so defer them. */
1517 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1520 bool ignored
= TREE_CODE (var
) == SSA_NAME
1521 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1522 : DECL_IGNORED_P (var
);
1524 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1525 might be detached from their block and appear at toplevel when we reach
1526 here. We want to coalesce them with variables from other blocks when
1527 the immediate contribution to the frame size would be noticeable. */
1528 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1531 /* Variables declared in the outermost scope automatically conflict
1532 with every other variable. The only reason to want to defer them
1533 at all is that, after sorting, we can more efficiently pack
1534 small variables in the stack frame. Continue to defer at -O2. */
1535 if (toplevel
&& optimize
< 2)
1538 /* Without optimization, *most* variables are allocated from the
1539 stack, which makes the quadratic problem large exactly when we
1540 want compilation to proceed as quickly as possible. On the
1541 other hand, we don't want the function's stack frame size to
1542 get completely out of hand. So we avoid adding scalars and
1543 "small" aggregates to the list at all. */
1544 if (optimize
== 0 && smallish
)
1550 /* A subroutine of expand_used_vars. Expand one variable according to
1551 its flavor. Variables to be placed on the stack are not actually
1552 expanded yet, merely recorded.
1553 When REALLY_EXPAND is false, only add stack values to be allocated.
1554 Return stack usage this variable is supposed to take.
1557 static HOST_WIDE_INT
1558 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1560 unsigned int align
= BITS_PER_UNIT
;
1565 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1567 if (is_global_var (var
))
1570 /* Because we don't know if VAR will be in register or on stack,
1571 we conservatively assume it will be on stack even if VAR is
1572 eventually put into register after RA pass. For non-automatic
1573 variables, which won't be on stack, we collect alignment of
1574 type and ignore user specified alignment. Similarly for
1575 SSA_NAMEs for which use_register_for_decl returns true. */
1576 if (TREE_STATIC (var
)
1577 || DECL_EXTERNAL (var
)
1578 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1579 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1580 TYPE_MODE (TREE_TYPE (var
)),
1581 TYPE_ALIGN (TREE_TYPE (var
)));
1582 else if (DECL_HAS_VALUE_EXPR_P (var
)
1583 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1584 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1585 or variables which were assigned a stack slot already by
1586 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1587 changed from the offset chosen to it. */
1588 align
= crtl
->stack_alignment_estimated
;
1590 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1592 /* If the variable alignment is very large we'll dynamicaly allocate
1593 it, which means that in-frame portion is just a pointer. */
1594 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1595 align
= POINTER_SIZE
;
1598 record_alignment_for_reg_var (align
);
1600 if (TREE_CODE (origvar
) == SSA_NAME
)
1602 gcc_assert (!VAR_P (var
)
1603 || (!DECL_EXTERNAL (var
)
1604 && !DECL_HAS_VALUE_EXPR_P (var
)
1605 && !TREE_STATIC (var
)
1606 && TREE_TYPE (var
) != error_mark_node
1607 && !DECL_HARD_REGISTER (var
)
1610 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1612 else if (DECL_EXTERNAL (var
))
1614 else if (DECL_HAS_VALUE_EXPR_P (var
))
1616 else if (TREE_STATIC (var
))
1618 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1620 else if (TREE_TYPE (var
) == error_mark_node
)
1623 expand_one_error_var (var
);
1625 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1629 expand_one_hard_reg_var (var
);
1630 if (!DECL_HARD_REGISTER (var
))
1631 /* Invalid register specification. */
1632 expand_one_error_var (var
);
1635 else if (use_register_for_decl (var
))
1638 expand_one_register_var (origvar
);
1640 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1642 /* Reject variables which cover more than half of the address-space. */
1645 error ("size of variable %q+D is too large", var
);
1646 expand_one_error_var (var
);
1649 else if (defer_stack_allocation (var
, toplevel
))
1650 add_stack_var (origvar
);
1655 if (lookup_attribute ("naked",
1656 DECL_ATTRIBUTES (current_function_decl
)))
1657 error ("cannot allocate stack for variable %q+D, naked function.",
1660 expand_one_stack_var (origvar
);
1664 return tree_to_uhwi (DECL_SIZE_UNIT (var
));
1669 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1670 expanding variables. Those variables that can be put into registers
1671 are allocated pseudos; those that can't are put on the stack.
1673 TOPLEVEL is true if this is the outermost BLOCK. */
1676 expand_used_vars_for_block (tree block
, bool toplevel
)
1680 /* Expand all variables at this level. */
1681 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1683 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1684 || !DECL_NONSHAREABLE (t
)))
1685 expand_one_var (t
, toplevel
, true);
1687 /* Expand all variables at containing levels. */
1688 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1689 expand_used_vars_for_block (t
, false);
1692 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1693 and clear TREE_USED on all local variables. */
1696 clear_tree_used (tree block
)
1700 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1701 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1702 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1703 || !DECL_NONSHAREABLE (t
))
1706 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1707 clear_tree_used (t
);
1711 SPCT_FLAG_DEFAULT
= 1,
1713 SPCT_FLAG_STRONG
= 3,
1714 SPCT_FLAG_EXPLICIT
= 4
1717 /* Examine TYPE and determine a bit mask of the following features. */
1719 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1720 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1721 #define SPCT_HAS_ARRAY 4
1722 #define SPCT_HAS_AGGREGATE 8
1725 stack_protect_classify_type (tree type
)
1727 unsigned int ret
= 0;
1730 switch (TREE_CODE (type
))
1733 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1734 if (t
== char_type_node
1735 || t
== signed_char_type_node
1736 || t
== unsigned_char_type_node
)
1738 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1739 unsigned HOST_WIDE_INT len
;
1741 if (!TYPE_SIZE_UNIT (type
)
1742 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1745 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1748 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1750 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1753 ret
= SPCT_HAS_ARRAY
;
1757 case QUAL_UNION_TYPE
:
1759 ret
= SPCT_HAS_AGGREGATE
;
1760 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1761 if (TREE_CODE (t
) == FIELD_DECL
)
1762 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1772 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1773 part of the local stack frame. Remember if we ever return nonzero for
1774 any variable in this function. The return value is the phase number in
1775 which the variable should be allocated. */
1778 stack_protect_decl_phase (tree decl
)
1780 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1783 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1784 has_short_buffer
= true;
1786 if (flag_stack_protect
== SPCT_FLAG_ALL
1787 || flag_stack_protect
== SPCT_FLAG_STRONG
1788 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1789 && lookup_attribute ("stack_protect",
1790 DECL_ATTRIBUTES (current_function_decl
))))
1792 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1793 && !(bits
& SPCT_HAS_AGGREGATE
))
1795 else if (bits
& SPCT_HAS_ARRAY
)
1799 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1802 has_protected_decls
= true;
1807 /* Two helper routines that check for phase 1 and phase 2. These are used
1808 as callbacks for expand_stack_vars. */
1811 stack_protect_decl_phase_1 (size_t i
)
1813 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1817 stack_protect_decl_phase_2 (size_t i
)
1819 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1822 /* And helper function that checks for asan phase (with stack protector
1823 it is phase 3). This is used as callback for expand_stack_vars.
1824 Returns true if any of the vars in the partition need to be protected. */
1827 asan_decl_phase_3 (size_t i
)
1831 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1833 i
= stack_vars
[i
].next
;
1838 /* Ensure that variables in different stack protection phases conflict
1839 so that they are not merged and share the same stack slot. */
1842 add_stack_protection_conflicts (void)
1844 size_t i
, j
, n
= stack_vars_num
;
1845 unsigned char *phase
;
1847 phase
= XNEWVEC (unsigned char, n
);
1848 for (i
= 0; i
< n
; ++i
)
1849 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1851 for (i
= 0; i
< n
; ++i
)
1853 unsigned char ph_i
= phase
[i
];
1854 for (j
= i
+ 1; j
< n
; ++j
)
1855 if (ph_i
!= phase
[j
])
1856 add_stack_var_conflict (i
, j
);
1862 /* Create a decl for the guard at the top of the stack frame. */
1865 create_stack_guard (void)
1867 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1868 VAR_DECL
, NULL
, ptr_type_node
);
1869 TREE_THIS_VOLATILE (guard
) = 1;
1870 TREE_USED (guard
) = 1;
1871 expand_one_stack_var (guard
);
1872 crtl
->stack_protect_guard
= guard
;
1875 /* Prepare for expanding variables. */
1877 init_vars_expansion (void)
1879 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1880 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1882 /* A map from decl to stack partition. */
1883 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1885 /* Initialize local stack smashing state. */
1886 has_protected_decls
= false;
1887 has_short_buffer
= false;
1890 /* Free up stack variable graph data. */
1892 fini_vars_expansion (void)
1894 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1896 XDELETEVEC (stack_vars
);
1897 if (stack_vars_sorted
)
1898 XDELETEVEC (stack_vars_sorted
);
1900 stack_vars_sorted
= NULL
;
1901 stack_vars_alloc
= stack_vars_num
= 0;
1902 delete decl_to_stack_part
;
1903 decl_to_stack_part
= NULL
;
1906 /* Make a fair guess for the size of the stack frame of the function
1907 in NODE. This doesn't have to be exact, the result is only used in
1908 the inline heuristics. So we don't want to run the full stack var
1909 packing algorithm (which is quadratic in the number of stack vars).
1910 Instead, we calculate the total size of all stack vars. This turns
1911 out to be a pretty fair estimate -- packing of stack vars doesn't
1912 happen very often. */
1915 estimated_stack_frame_size (struct cgraph_node
*node
)
1917 HOST_WIDE_INT size
= 0;
1920 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1924 init_vars_expansion ();
1926 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1927 if (auto_var_in_fn_p (var
, fn
->decl
))
1928 size
+= expand_one_var (var
, true, false);
1930 if (stack_vars_num
> 0)
1932 /* Fake sorting the stack vars for account_stack_vars (). */
1933 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1934 for (i
= 0; i
< stack_vars_num
; ++i
)
1935 stack_vars_sorted
[i
] = i
;
1936 size
+= account_stack_vars ();
1939 fini_vars_expansion ();
1944 /* Helper routine to check if a record or union contains an array field. */
1947 record_or_union_type_has_array_p (const_tree tree_type
)
1949 tree fields
= TYPE_FIELDS (tree_type
);
1952 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1953 if (TREE_CODE (f
) == FIELD_DECL
)
1955 tree field_type
= TREE_TYPE (f
);
1956 if (RECORD_OR_UNION_TYPE_P (field_type
)
1957 && record_or_union_type_has_array_p (field_type
))
1959 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1965 /* Check if the current function has local referenced variables that
1966 have their addresses taken, contain an array, or are arrays. */
1969 stack_protect_decl_p ()
1974 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1975 if (!is_global_var (var
))
1977 tree var_type
= TREE_TYPE (var
);
1979 && (TREE_CODE (var_type
) == ARRAY_TYPE
1980 || TREE_ADDRESSABLE (var
)
1981 || (RECORD_OR_UNION_TYPE_P (var_type
)
1982 && record_or_union_type_has_array_p (var_type
))))
1988 /* Check if the current function has calls that use a return slot. */
1991 stack_protect_return_slot_p ()
1995 FOR_ALL_BB_FN (bb
, cfun
)
1996 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
1997 !gsi_end_p (gsi
); gsi_next (&gsi
))
1999 gimple
*stmt
= gsi_stmt (gsi
);
2000 /* This assumes that calls to internal-only functions never
2001 use a return slot. */
2002 if (is_gimple_call (stmt
)
2003 && !gimple_call_internal_p (stmt
)
2004 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2005 gimple_call_fndecl (stmt
)))
2011 /* Expand all variables used in the function. */
2014 expand_used_vars (void)
2016 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2017 auto_vec
<tree
> maybe_local_decls
;
2018 rtx_insn
*var_end_seq
= NULL
;
2021 bool gen_stack_protect_signal
= false;
2023 /* Compute the phase of the stack frame for this function. */
2025 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2026 int off
= STARTING_FRAME_OFFSET
% align
;
2027 frame_phase
= off
? align
- off
: 0;
2030 /* Set TREE_USED on all variables in the local_decls. */
2031 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2032 TREE_USED (var
) = 1;
2033 /* Clear TREE_USED on all variables associated with a block scope. */
2034 clear_tree_used (DECL_INITIAL (current_function_decl
));
2036 init_vars_expansion ();
2038 if (targetm
.use_pseudo_pic_reg ())
2039 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2041 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2043 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2046 tree var
= partition_to_var (SA
.map
, i
);
2048 gcc_assert (!virtual_operand_p (var
));
2050 expand_one_ssa_partition (var
);
2053 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2054 gen_stack_protect_signal
2055 = stack_protect_decl_p () || stack_protect_return_slot_p ();
2057 /* At this point all variables on the local_decls with TREE_USED
2058 set are not associated with any block scope. Lay them out. */
2060 len
= vec_safe_length (cfun
->local_decls
);
2061 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2063 bool expand_now
= false;
2065 /* Expanded above already. */
2066 if (is_gimple_reg (var
))
2068 TREE_USED (var
) = 0;
2071 /* We didn't set a block for static or extern because it's hard
2072 to tell the difference between a global variable (re)declared
2073 in a local scope, and one that's really declared there to
2074 begin with. And it doesn't really matter much, since we're
2075 not giving them stack space. Expand them now. */
2076 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2079 /* Expand variables not associated with any block now. Those created by
2080 the optimizers could be live anywhere in the function. Those that
2081 could possibly have been scoped originally and detached from their
2082 block will have their allocation deferred so we coalesce them with
2083 others when optimization is enabled. */
2084 else if (TREE_USED (var
))
2087 /* Finally, mark all variables on the list as used. We'll use
2088 this in a moment when we expand those associated with scopes. */
2089 TREE_USED (var
) = 1;
2092 expand_one_var (var
, true, true);
2095 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2097 rtx rtl
= DECL_RTL_IF_SET (var
);
2099 /* Keep artificial non-ignored vars in cfun->local_decls
2100 chain until instantiate_decls. */
2101 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2102 add_local_decl (cfun
, var
);
2103 else if (rtl
== NULL_RTX
)
2104 /* If rtl isn't set yet, which can happen e.g. with
2105 -fstack-protector, retry before returning from this
2107 maybe_local_decls
.safe_push (var
);
2111 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2113 +-----------------+-----------------+
2114 | ...processed... | ...duplicates...|
2115 +-----------------+-----------------+
2117 +-- LEN points here.
2119 We just want the duplicates, as those are the artificial
2120 non-ignored vars that we want to keep until instantiate_decls.
2121 Move them down and truncate the array. */
2122 if (!vec_safe_is_empty (cfun
->local_decls
))
2123 cfun
->local_decls
->block_remove (0, len
);
2125 /* At this point, all variables within the block tree with TREE_USED
2126 set are actually used by the optimized function. Lay them out. */
2127 expand_used_vars_for_block (outer_block
, true);
2129 if (stack_vars_num
> 0)
2131 add_scope_conflicts ();
2133 /* If stack protection is enabled, we don't share space between
2134 vulnerable data and non-vulnerable data. */
2135 if (flag_stack_protect
!= 0
2136 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2137 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2138 && lookup_attribute ("stack_protect",
2139 DECL_ATTRIBUTES (current_function_decl
)))))
2140 add_stack_protection_conflicts ();
2142 /* Now that we have collected all stack variables, and have computed a
2143 minimal interference graph, attempt to save some stack space. */
2144 partition_stack_vars ();
2146 dump_stack_var_partition ();
2149 switch (flag_stack_protect
)
2152 create_stack_guard ();
2155 case SPCT_FLAG_STRONG
:
2156 if (gen_stack_protect_signal
2157 || cfun
->calls_alloca
|| has_protected_decls
2158 || lookup_attribute ("stack_protect",
2159 DECL_ATTRIBUTES (current_function_decl
)))
2160 create_stack_guard ();
2163 case SPCT_FLAG_DEFAULT
:
2164 if (cfun
->calls_alloca
|| has_protected_decls
2165 || lookup_attribute ("stack_protect",
2166 DECL_ATTRIBUTES (current_function_decl
)))
2167 create_stack_guard ();
2170 case SPCT_FLAG_EXPLICIT
:
2171 if (lookup_attribute ("stack_protect",
2172 DECL_ATTRIBUTES (current_function_decl
)))
2173 create_stack_guard ();
2179 /* Assign rtl to each variable based on these partitions. */
2180 if (stack_vars_num
> 0)
2182 struct stack_vars_data data
;
2184 data
.asan_base
= NULL_RTX
;
2185 data
.asan_alignb
= 0;
2187 /* Reorder decls to be protected by iterating over the variables
2188 array multiple times, and allocating out of each phase in turn. */
2189 /* ??? We could probably integrate this into the qsort we did
2190 earlier, such that we naturally see these variables first,
2191 and thus naturally allocate things in the right order. */
2192 if (has_protected_decls
)
2194 /* Phase 1 contains only character arrays. */
2195 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2197 /* Phase 2 contains other kinds of arrays. */
2198 if (flag_stack_protect
== SPCT_FLAG_ALL
2199 || flag_stack_protect
== SPCT_FLAG_STRONG
2200 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2201 && lookup_attribute ("stack_protect",
2202 DECL_ATTRIBUTES (current_function_decl
))))
2203 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2206 if (asan_sanitize_stack_p ())
2207 /* Phase 3, any partitions that need asan protection
2208 in addition to phase 1 and 2. */
2209 expand_stack_vars (asan_decl_phase_3
, &data
);
2211 if (!data
.asan_vec
.is_empty ())
2213 HOST_WIDE_INT prev_offset
= frame_offset
;
2214 HOST_WIDE_INT offset
, sz
, redzonesz
;
2215 redzonesz
= ASAN_RED_ZONE_SIZE
;
2216 sz
= data
.asan_vec
[0] - prev_offset
;
2217 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2218 && data
.asan_alignb
<= 4096
2219 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2220 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2221 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2223 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
2224 data
.asan_vec
.safe_push (prev_offset
);
2225 data
.asan_vec
.safe_push (offset
);
2226 /* Leave space for alignment if STRICT_ALIGNMENT. */
2227 if (STRICT_ALIGNMENT
)
2228 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2229 << ASAN_SHADOW_SHIFT
)
2230 / BITS_PER_UNIT
, 1);
2233 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2236 data
.asan_vec
.address (),
2237 data
.asan_decl_vec
.address (),
2238 data
.asan_vec
.length ());
2241 expand_stack_vars (NULL
, &data
);
2244 fini_vars_expansion ();
2246 /* If there were any artificial non-ignored vars without rtl
2247 found earlier, see if deferred stack allocation hasn't assigned
2249 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2251 rtx rtl
= DECL_RTL_IF_SET (var
);
2253 /* Keep artificial non-ignored vars in cfun->local_decls
2254 chain until instantiate_decls. */
2255 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2256 add_local_decl (cfun
, var
);
2259 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2260 if (STACK_ALIGNMENT_NEEDED
)
2262 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2263 if (!FRAME_GROWS_DOWNWARD
)
2264 frame_offset
+= align
- 1;
2265 frame_offset
&= -align
;
2272 /* If we need to produce a detailed dump, print the tree representation
2273 for STMT to the dump file. SINCE is the last RTX after which the RTL
2274 generated for STMT should have been appended. */
2277 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2279 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2281 fprintf (dump_file
, "\n;; ");
2282 print_gimple_stmt (dump_file
, stmt
, 0,
2283 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2284 fprintf (dump_file
, "\n");
2286 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2290 /* Maps the blocks that do not contain tree labels to rtx labels. */
2292 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2294 /* Returns the label_rtx expression for a label starting basic block BB. */
2296 static rtx_code_label
*
2297 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2299 gimple_stmt_iterator gsi
;
2302 if (bb
->flags
& BB_RTL
)
2303 return block_label (bb
);
2305 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2309 /* Find the tree label if it is present. */
2311 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2315 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2319 lab
= gimple_label_label (lab_stmt
);
2320 if (DECL_NONLOCAL (lab
))
2323 return jump_target_rtx (lab
);
2326 rtx_code_label
*l
= gen_label_rtx ();
2327 lab_rtx_for_bb
->put (bb
, l
);
2332 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2333 of a basic block where we just expanded the conditional at the end,
2334 possibly clean up the CFG and instruction sequence. LAST is the
2335 last instruction before the just emitted jump sequence. */
2338 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2340 /* Special case: when jumpif decides that the condition is
2341 trivial it emits an unconditional jump (and the necessary
2342 barrier). But we still have two edges, the fallthru one is
2343 wrong. purge_dead_edges would clean this up later. Unfortunately
2344 we have to insert insns (and split edges) before
2345 find_many_sub_basic_blocks and hence before purge_dead_edges.
2346 But splitting edges might create new blocks which depend on the
2347 fact that if there are two edges there's no barrier. So the
2348 barrier would get lost and verify_flow_info would ICE. Instead
2349 of auditing all edge splitters to care for the barrier (which
2350 normally isn't there in a cleaned CFG), fix it here. */
2351 if (BARRIER_P (get_last_insn ()))
2355 /* Now, we have a single successor block, if we have insns to
2356 insert on the remaining edge we potentially will insert
2357 it at the end of this block (if the dest block isn't feasible)
2358 in order to avoid splitting the edge. This insertion will take
2359 place in front of the last jump. But we might have emitted
2360 multiple jumps (conditional and one unconditional) to the
2361 same destination. Inserting in front of the last one then
2362 is a problem. See PR 40021. We fix this by deleting all
2363 jumps except the last unconditional one. */
2364 insn
= PREV_INSN (get_last_insn ());
2365 /* Make sure we have an unconditional jump. Otherwise we're
2367 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2368 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2370 insn
= PREV_INSN (insn
);
2371 if (JUMP_P (NEXT_INSN (insn
)))
2373 if (!any_condjump_p (NEXT_INSN (insn
)))
2375 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2376 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2378 delete_insn (NEXT_INSN (insn
));
2384 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2385 Returns a new basic block if we've terminated the current basic
2386 block and created a new one. */
2389 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2391 basic_block new_bb
, dest
;
2395 rtx_insn
*last2
, *last
;
2396 enum tree_code code
;
2399 code
= gimple_cond_code (stmt
);
2400 op0
= gimple_cond_lhs (stmt
);
2401 op1
= gimple_cond_rhs (stmt
);
2402 /* We're sometimes presented with such code:
2406 This would expand to two comparisons which then later might
2407 be cleaned up by combine. But some pattern matchers like if-conversion
2408 work better when there's only one compare, so make up for this
2409 here as special exception if TER would have made the same change. */
2411 && TREE_CODE (op0
) == SSA_NAME
2412 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2413 && TREE_CODE (op1
) == INTEGER_CST
2414 && ((gimple_cond_code (stmt
) == NE_EXPR
2415 && integer_zerop (op1
))
2416 || (gimple_cond_code (stmt
) == EQ_EXPR
2417 && integer_onep (op1
)))
2418 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2420 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2421 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2423 enum tree_code code2
= gimple_assign_rhs_code (second
);
2424 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2427 op0
= gimple_assign_rhs1 (second
);
2428 op1
= gimple_assign_rhs2 (second
);
2430 /* If jumps are cheap and the target does not support conditional
2431 compare, turn some more codes into jumpy sequences. */
2432 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2433 && targetm
.gen_ccmp_first
== NULL
)
2435 if ((code2
== BIT_AND_EXPR
2436 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2437 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2438 || code2
== TRUTH_AND_EXPR
)
2440 code
= TRUTH_ANDIF_EXPR
;
2441 op0
= gimple_assign_rhs1 (second
);
2442 op1
= gimple_assign_rhs2 (second
);
2444 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2446 code
= TRUTH_ORIF_EXPR
;
2447 op0
= gimple_assign_rhs1 (second
);
2448 op1
= gimple_assign_rhs2 (second
);
2454 last2
= last
= get_last_insn ();
2456 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2457 set_curr_insn_location (gimple_location (stmt
));
2459 /* These flags have no purpose in RTL land. */
2460 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2461 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2463 /* We can either have a pure conditional jump with one fallthru edge or
2464 two-way jump that needs to be decomposed into two basic blocks. */
2465 if (false_edge
->dest
== bb
->next_bb
)
2467 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2468 true_edge
->probability
);
2469 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2470 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2471 set_curr_insn_location (true_edge
->goto_locus
);
2472 false_edge
->flags
|= EDGE_FALLTHRU
;
2473 maybe_cleanup_end_of_block (false_edge
, last
);
2476 if (true_edge
->dest
== bb
->next_bb
)
2478 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2479 false_edge
->probability
);
2480 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2481 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2482 set_curr_insn_location (false_edge
->goto_locus
);
2483 true_edge
->flags
|= EDGE_FALLTHRU
;
2484 maybe_cleanup_end_of_block (true_edge
, last
);
2488 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2489 true_edge
->probability
);
2490 last
= get_last_insn ();
2491 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2492 set_curr_insn_location (false_edge
->goto_locus
);
2493 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2496 if (BARRIER_P (BB_END (bb
)))
2497 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2498 update_bb_for_insn (bb
);
2500 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2501 dest
= false_edge
->dest
;
2502 redirect_edge_succ (false_edge
, new_bb
);
2503 false_edge
->flags
|= EDGE_FALLTHRU
;
2504 new_bb
->count
= false_edge
->count
;
2505 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2506 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2507 add_bb_to_loop (new_bb
, loop
);
2508 if (loop
->latch
== bb
2509 && loop
->header
== dest
)
2510 loop
->latch
= new_bb
;
2511 new_edge
= make_edge (new_bb
, dest
, 0);
2512 new_edge
->probability
= REG_BR_PROB_BASE
;
2513 new_edge
->count
= new_bb
->count
;
2514 if (BARRIER_P (BB_END (new_bb
)))
2515 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2516 update_bb_for_insn (new_bb
);
2518 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2520 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2522 set_curr_insn_location (true_edge
->goto_locus
);
2523 true_edge
->goto_locus
= curr_insn_location ();
2529 /* Mark all calls that can have a transaction restart. */
2532 mark_transaction_restart_calls (gimple
*stmt
)
2534 struct tm_restart_node dummy
;
2535 tm_restart_node
**slot
;
2537 if (!cfun
->gimple_df
->tm_restart
)
2541 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2544 struct tm_restart_node
*n
= *slot
;
2545 tree list
= n
->label_or_list
;
2548 for (insn
= next_real_insn (get_last_insn ());
2550 insn
= next_real_insn (insn
))
2553 if (TREE_CODE (list
) == LABEL_DECL
)
2554 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2556 for (; list
; list
= TREE_CHAIN (list
))
2557 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2561 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2565 expand_call_stmt (gcall
*stmt
)
2567 tree exp
, decl
, lhs
;
2571 if (gimple_call_internal_p (stmt
))
2573 expand_internal_call (stmt
);
2577 /* If this is a call to a built-in function and it has no effect other
2578 than setting the lhs, try to implement it using an internal function
2580 decl
= gimple_call_fndecl (stmt
);
2581 if (gimple_call_lhs (stmt
)
2582 && !gimple_has_side_effects (stmt
)
2583 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2585 internal_fn ifn
= replacement_internal_fn (stmt
);
2586 if (ifn
!= IFN_LAST
)
2588 expand_internal_call (ifn
, stmt
);
2593 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2595 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2596 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2598 /* If this is not a builtin function, the function type through which the
2599 call is made may be different from the type of the function. */
2602 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2603 CALL_EXPR_FN (exp
));
2605 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2606 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2608 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2610 tree arg
= gimple_call_arg (stmt
, i
);
2612 /* TER addresses into arguments of builtin functions so we have a
2613 chance to infer more correct alignment information. See PR39954. */
2615 && TREE_CODE (arg
) == SSA_NAME
2616 && (def
= get_gimple_for_ssa_name (arg
))
2617 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2618 arg
= gimple_assign_rhs1 (def
);
2619 CALL_EXPR_ARG (exp
, i
) = arg
;
2622 if (gimple_has_side_effects (stmt
))
2623 TREE_SIDE_EFFECTS (exp
) = 1;
2625 if (gimple_call_nothrow_p (stmt
))
2626 TREE_NOTHROW (exp
) = 1;
2628 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2629 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2630 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2632 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2633 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2634 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2635 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2637 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2638 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2639 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2640 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2641 CALL_WITH_BOUNDS_P (exp
) = gimple_call_with_bounds_p (stmt
);
2643 /* Ensure RTL is created for debug args. */
2644 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2646 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2651 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2653 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2654 expand_debug_expr (dtemp
);
2658 lhs
= gimple_call_lhs (stmt
);
2660 expand_assignment (lhs
, exp
, false);
2662 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2664 mark_transaction_restart_calls (stmt
);
2668 /* Generate RTL for an asm statement (explicit assembler code).
2669 STRING is a STRING_CST node containing the assembler code text,
2670 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2671 insn is volatile; don't optimize it. */
2674 expand_asm_loc (tree string
, int vol
, location_t locus
)
2678 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2679 ggc_strdup (TREE_STRING_POINTER (string
)),
2682 MEM_VOLATILE_P (body
) = vol
;
2684 /* Non-empty basic ASM implicitly clobbers memory. */
2685 if (TREE_STRING_LENGTH (string
) != 0)
2688 unsigned i
, nclobbers
;
2689 auto_vec
<rtx
> input_rvec
, output_rvec
;
2690 auto_vec
<const char *> constraints
;
2691 auto_vec
<rtx
> clobber_rvec
;
2692 HARD_REG_SET clobbered_regs
;
2693 CLEAR_HARD_REG_SET (clobbered_regs
);
2695 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2696 clobber_rvec
.safe_push (clob
);
2698 if (targetm
.md_asm_adjust
)
2699 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2700 constraints
, clobber_rvec
,
2704 nclobbers
= clobber_rvec
.length ();
2705 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2707 XVECEXP (body
, 0, 0) = asm_op
;
2708 for (i
= 0; i
< nclobbers
; i
++)
2709 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2715 /* Return the number of times character C occurs in string S. */
2717 n_occurrences (int c
, const char *s
)
2725 /* A subroutine of expand_asm_operands. Check that all operands have
2726 the same number of alternatives. Return true if so. */
2729 check_operand_nalternatives (const vec
<const char *> &constraints
)
2731 unsigned len
= constraints
.length();
2734 int nalternatives
= n_occurrences (',', constraints
[0]);
2736 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2738 error ("too many alternatives in %<asm%>");
2742 for (unsigned i
= 1; i
< len
; ++i
)
2743 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2745 error ("operand constraints for %<asm%> differ "
2746 "in number of alternatives");
2753 /* Check for overlap between registers marked in CLOBBERED_REGS and
2754 anything inappropriate in T. Emit error and return the register
2755 variable definition for error, NULL_TREE for ok. */
2758 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2760 /* Conflicts between asm-declared register variables and the clobber
2761 list are not allowed. */
2762 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2766 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2767 DECL_NAME (overlap
));
2769 /* Reset registerness to stop multiple errors emitted for a single
2771 DECL_REGISTER (overlap
) = 0;
2778 /* Generate RTL for an asm statement with arguments.
2779 STRING is the instruction template.
2780 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2781 Each output or input has an expression in the TREE_VALUE and
2782 a tree list in TREE_PURPOSE which in turn contains a constraint
2783 name in TREE_VALUE (or NULL_TREE) and a constraint string
2785 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2786 that is clobbered by this insn.
2788 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2789 should be the fallthru basic block of the asm goto.
2791 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2792 Some elements of OUTPUTS may be replaced with trees representing temporary
2793 values. The caller should copy those temporary values to the originally
2796 VOL nonzero means the insn is volatile; don't optimize it. */
2799 expand_asm_stmt (gasm
*stmt
)
2801 class save_input_location
2806 explicit save_input_location(location_t where
)
2808 old
= input_location
;
2809 input_location
= where
;
2812 ~save_input_location()
2814 input_location
= old
;
2818 location_t locus
= gimple_location (stmt
);
2820 if (gimple_asm_input_p (stmt
))
2822 const char *s
= gimple_asm_string (stmt
);
2823 tree string
= build_string (strlen (s
), s
);
2824 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
2828 /* There are some legacy diagnostics in here, and also avoids a
2829 sixth parameger to targetm.md_asm_adjust. */
2830 save_input_location
s_i_l(locus
);
2832 unsigned noutputs
= gimple_asm_noutputs (stmt
);
2833 unsigned ninputs
= gimple_asm_ninputs (stmt
);
2834 unsigned nlabels
= gimple_asm_nlabels (stmt
);
2837 /* ??? Diagnose during gimplification? */
2838 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2840 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2844 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
2845 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
2846 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
2848 /* Copy the gimple vectors into new vectors that we can manipulate. */
2850 output_tvec
.safe_grow (noutputs
);
2851 input_tvec
.safe_grow (ninputs
);
2852 constraints
.safe_grow (noutputs
+ ninputs
);
2854 for (i
= 0; i
< noutputs
; ++i
)
2856 tree t
= gimple_asm_output_op (stmt
, i
);
2857 output_tvec
[i
] = TREE_VALUE (t
);
2858 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2860 for (i
= 0; i
< ninputs
; i
++)
2862 tree t
= gimple_asm_input_op (stmt
, i
);
2863 input_tvec
[i
] = TREE_VALUE (t
);
2864 constraints
[i
+ noutputs
]
2865 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2868 /* ??? Diagnose during gimplification? */
2869 if (! check_operand_nalternatives (constraints
))
2872 /* Count the number of meaningful clobbered registers, ignoring what
2873 we would ignore later. */
2874 auto_vec
<rtx
> clobber_rvec
;
2875 HARD_REG_SET clobbered_regs
;
2876 CLEAR_HARD_REG_SET (clobbered_regs
);
2878 if (unsigned n
= gimple_asm_nclobbers (stmt
))
2880 clobber_rvec
.reserve (n
);
2881 for (i
= 0; i
< n
; i
++)
2883 tree t
= gimple_asm_clobber_op (stmt
, i
);
2884 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
2887 j
= decode_reg_name_and_count (regname
, &nregs
);
2892 /* ??? Diagnose during gimplification? */
2893 error ("unknown register name %qs in %<asm%>", regname
);
2897 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2898 clobber_rvec
.safe_push (x
);
2902 /* Otherwise we should have -1 == empty string
2903 or -3 == cc, which is not a register. */
2904 gcc_assert (j
== -1 || j
== -3);
2908 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
2910 /* Clobbering the PIC register is an error. */
2911 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2913 /* ??? Diagnose during gimplification? */
2914 error ("PIC register clobbered by %qs in %<asm%>",
2919 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2920 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
2921 clobber_rvec
.safe_push (x
);
2925 unsigned nclobbers
= clobber_rvec
.length();
2927 /* First pass over inputs and outputs checks validity and sets
2928 mark_addressable if needed. */
2929 /* ??? Diagnose during gimplification? */
2931 for (i
= 0; i
< noutputs
; ++i
)
2933 tree val
= output_tvec
[i
];
2934 tree type
= TREE_TYPE (val
);
2935 const char *constraint
;
2940 /* Try to parse the output constraint. If that fails, there's
2941 no point in going further. */
2942 constraint
= constraints
[i
];
2943 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2944 &allows_mem
, &allows_reg
, &is_inout
))
2951 && REG_P (DECL_RTL (val
))
2952 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2953 mark_addressable (val
);
2956 for (i
= 0; i
< ninputs
; ++i
)
2958 bool allows_reg
, allows_mem
;
2959 const char *constraint
;
2961 constraint
= constraints
[i
+ noutputs
];
2962 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
2963 constraints
.address (),
2964 &allows_mem
, &allows_reg
))
2967 if (! allows_reg
&& allows_mem
)
2968 mark_addressable (input_tvec
[i
]);
2971 /* Second pass evaluates arguments. */
2973 /* Make sure stack is consistent for asm goto. */
2975 do_pending_stack_adjust ();
2976 int old_generating_concat_p
= generating_concat_p
;
2978 /* Vector of RTX's of evaluated output operands. */
2979 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
2980 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
2981 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
2983 output_rvec
.safe_grow (noutputs
);
2985 for (i
= 0; i
< noutputs
; ++i
)
2987 tree val
= output_tvec
[i
];
2988 tree type
= TREE_TYPE (val
);
2989 bool is_inout
, allows_reg
, allows_mem
, ok
;
2992 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2993 noutputs
, &allows_mem
, &allows_reg
,
2997 /* If an output operand is not a decl or indirect ref and our constraint
2998 allows a register, make a temporary to act as an intermediate.
2999 Make the asm insn write into that, then we will copy it to
3000 the real output operand. Likewise for promoted variables. */
3002 generating_concat_p
= 0;
3004 if ((TREE_CODE (val
) == INDIRECT_REF
3007 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3008 && ! (REG_P (DECL_RTL (val
))
3009 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3013 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3014 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3016 op
= validize_mem (op
);
3018 if (! allows_reg
&& !MEM_P (op
))
3019 error ("output number %d not directly addressable", i
);
3020 if ((! allows_mem
&& MEM_P (op
))
3021 || GET_CODE (op
) == CONCAT
)
3024 op
= gen_reg_rtx (GET_MODE (op
));
3026 generating_concat_p
= old_generating_concat_p
;
3029 emit_move_insn (op
, old_op
);
3031 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3032 emit_move_insn (old_op
, op
);
3033 after_rtl_seq
= get_insns ();
3034 after_rtl_end
= get_last_insn ();
3040 op
= assign_temp (type
, 0, 1);
3041 op
= validize_mem (op
);
3042 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3043 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3045 generating_concat_p
= old_generating_concat_p
;
3047 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3048 expand_assignment (val
, make_tree (type
, op
), false);
3049 after_rtl_seq
= get_insns ();
3050 after_rtl_end
= get_last_insn ();
3053 output_rvec
[i
] = op
;
3056 inout_opnum
.safe_push (i
);
3059 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3060 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3062 input_rvec
.safe_grow (ninputs
);
3063 input_mode
.safe_grow (ninputs
);
3065 generating_concat_p
= 0;
3067 for (i
= 0; i
< ninputs
; ++i
)
3069 tree val
= input_tvec
[i
];
3070 tree type
= TREE_TYPE (val
);
3071 bool allows_reg
, allows_mem
, ok
;
3072 const char *constraint
;
3075 constraint
= constraints
[i
+ noutputs
];
3076 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3077 constraints
.address (),
3078 &allows_mem
, &allows_reg
);
3081 /* EXPAND_INITIALIZER will not generate code for valid initializer
3082 constants, but will still generate code for other types of operand.
3083 This is the behavior we want for constant constraints. */
3084 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3085 allows_reg
? EXPAND_NORMAL
3086 : allows_mem
? EXPAND_MEMORY
3087 : EXPAND_INITIALIZER
);
3089 /* Never pass a CONCAT to an ASM. */
3090 if (GET_CODE (op
) == CONCAT
)
3091 op
= force_reg (GET_MODE (op
), op
);
3092 else if (MEM_P (op
))
3093 op
= validize_mem (op
);
3095 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3097 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3098 op
= force_reg (TYPE_MODE (type
), op
);
3099 else if (!allows_mem
)
3100 warning (0, "asm operand %d probably doesn%'t match constraints",
3102 else if (MEM_P (op
))
3104 /* We won't recognize either volatile memory or memory
3105 with a queued address as available a memory_operand
3106 at this point. Ignore it: clearly this *is* a memory. */
3112 input_mode
[i
] = TYPE_MODE (type
);
3115 /* For in-out operands, copy output rtx to input rtx. */
3116 unsigned ninout
= inout_opnum
.length();
3117 for (i
= 0; i
< ninout
; i
++)
3119 int j
= inout_opnum
[i
];
3120 rtx o
= output_rvec
[j
];
3122 input_rvec
.safe_push (o
);
3123 input_mode
.safe_push (GET_MODE (o
));
3126 sprintf (buffer
, "%d", j
);
3127 constraints
.safe_push (ggc_strdup (buffer
));
3131 /* Sometimes we wish to automatically clobber registers across an asm.
3132 Case in point is when the i386 backend moved from cc0 to a hard reg --
3133 maintaining source-level compatibility means automatically clobbering
3134 the flags register. */
3135 rtx_insn
*after_md_seq
= NULL
;
3136 if (targetm
.md_asm_adjust
)
3137 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3138 constraints
, clobber_rvec
,
3141 /* Do not allow the hook to change the output and input count,
3142 lest it mess up the operand numbering. */
3143 gcc_assert (output_rvec
.length() == noutputs
);
3144 gcc_assert (input_rvec
.length() == ninputs
);
3145 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3147 /* But it certainly can adjust the clobbers. */
3148 nclobbers
= clobber_rvec
.length();
3150 /* Third pass checks for easy conflicts. */
3151 /* ??? Why are we doing this on trees instead of rtx. */
3153 bool clobber_conflict_found
= 0;
3154 for (i
= 0; i
< noutputs
; ++i
)
3155 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3156 clobber_conflict_found
= 1;
3157 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3158 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3159 clobber_conflict_found
= 1;
3161 /* Make vectors for the expression-rtx, constraint strings,
3162 and named operands. */
3164 rtvec argvec
= rtvec_alloc (ninputs
);
3165 rtvec constraintvec
= rtvec_alloc (ninputs
);
3166 rtvec labelvec
= rtvec_alloc (nlabels
);
3168 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3169 : GET_MODE (output_rvec
[0])),
3170 ggc_strdup (gimple_asm_string (stmt
)),
3171 empty_string
, 0, argvec
, constraintvec
,
3173 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3175 for (i
= 0; i
< ninputs
; ++i
)
3177 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3178 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3179 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3180 constraints
[i
+ noutputs
],
3184 /* Copy labels to the vector. */
3185 rtx_code_label
*fallthru_label
= NULL
;
3188 basic_block fallthru_bb
= NULL
;
3189 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3191 fallthru_bb
= fallthru
->dest
;
3193 for (i
= 0; i
< nlabels
; ++i
)
3195 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3197 /* If asm goto has any labels in the fallthru basic block, use
3198 a label that we emit immediately after the asm goto. Expansion
3199 may insert further instructions into the same basic block after
3200 asm goto and if we don't do this, insertion of instructions on
3201 the fallthru edge might misbehave. See PR58670. */
3202 if (fallthru_bb
&& label_to_block_fn (cfun
, label
) == fallthru_bb
)
3204 if (fallthru_label
== NULL_RTX
)
3205 fallthru_label
= gen_label_rtx ();
3209 r
= label_rtx (label
);
3210 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3214 /* Now, for each output, construct an rtx
3215 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3216 ARGVEC CONSTRAINTS OPNAMES))
3217 If there is more than one, put them inside a PARALLEL. */
3219 if (nlabels
> 0 && nclobbers
== 0)
3221 gcc_assert (noutputs
== 0);
3222 emit_jump_insn (body
);
3224 else if (noutputs
== 0 && nclobbers
== 0)
3226 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3229 else if (noutputs
== 1 && nclobbers
== 0)
3231 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3232 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3242 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3244 /* For each output operand, store a SET. */
3245 for (i
= 0; i
< noutputs
; ++i
)
3247 rtx src
, o
= output_rvec
[i
];
3250 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3255 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3256 ASM_OPERANDS_TEMPLATE (obody
),
3257 constraints
[i
], i
, argvec
,
3258 constraintvec
, labelvec
, locus
);
3259 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3261 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3264 /* If there are no outputs (but there are some clobbers)
3265 store the bare ASM_OPERANDS into the PARALLEL. */
3267 XVECEXP (body
, 0, i
++) = obody
;
3269 /* Store (clobber REG) for each clobbered register specified. */
3270 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3272 rtx clobbered_reg
= clobber_rvec
[j
];
3274 /* Do sanity check for overlap between clobbers and respectively
3275 input and outputs that hasn't been handled. Such overlap
3276 should have been detected and reported above. */
3277 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3279 /* We test the old body (obody) contents to avoid
3280 tripping over the under-construction body. */
3281 for (unsigned k
= 0; k
< noutputs
; ++k
)
3282 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3283 internal_error ("asm clobber conflict with output operand");
3285 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3286 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3287 internal_error ("asm clobber conflict with input operand");
3290 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3294 emit_jump_insn (body
);
3299 generating_concat_p
= old_generating_concat_p
;
3302 emit_label (fallthru_label
);
3305 emit_insn (after_md_seq
);
3307 emit_insn (after_rtl_seq
);
3310 crtl
->has_asm_statement
= 1;
3313 /* Emit code to jump to the address
3314 specified by the pointer expression EXP. */
3317 expand_computed_goto (tree exp
)
3319 rtx x
= expand_normal (exp
);
3321 do_pending_stack_adjust ();
3322 emit_indirect_jump (x
);
3325 /* Generate RTL code for a `goto' statement with target label LABEL.
3326 LABEL should be a LABEL_DECL tree node that was or will later be
3327 defined with `expand_label'. */
3330 expand_goto (tree label
)
3334 /* Check for a nonlocal goto to a containing function. Should have
3335 gotten translated to __builtin_nonlocal_goto. */
3336 tree context
= decl_function_context (label
);
3337 gcc_assert (!context
|| context
== current_function_decl
);
3340 emit_jump (jump_target_rtx (label
));
3343 /* Output a return with no value. */
3346 expand_null_return_1 (void)
3348 clear_pending_stack_adjust ();
3349 do_pending_stack_adjust ();
3350 emit_jump (return_label
);
3353 /* Generate RTL to return from the current function, with no value.
3354 (That is, we do not do anything about returning any value.) */
3357 expand_null_return (void)
3359 /* If this function was declared to return a value, but we
3360 didn't, clobber the return registers so that they are not
3361 propagated live to the rest of the function. */
3362 clobber_return_register ();
3364 expand_null_return_1 ();
3367 /* Generate RTL to return from the current function, with value VAL. */
3370 expand_value_return (rtx val
)
3372 /* Copy the value to the return location unless it's already there. */
3374 tree decl
= DECL_RESULT (current_function_decl
);
3375 rtx return_reg
= DECL_RTL (decl
);
3376 if (return_reg
!= val
)
3378 tree funtype
= TREE_TYPE (current_function_decl
);
3379 tree type
= TREE_TYPE (decl
);
3380 int unsignedp
= TYPE_UNSIGNED (type
);
3381 machine_mode old_mode
= DECL_MODE (decl
);
3383 if (DECL_BY_REFERENCE (decl
))
3384 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3386 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3388 if (mode
!= old_mode
)
3389 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3391 if (GET_CODE (return_reg
) == PARALLEL
)
3392 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3394 emit_move_insn (return_reg
, val
);
3397 expand_null_return_1 ();
3400 /* Generate RTL to evaluate the expression RETVAL and return it
3401 from the current function. */
3404 expand_return (tree retval
, tree bounds
)
3411 /* If function wants no value, give it none. */
3412 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3414 expand_normal (retval
);
3415 expand_null_return ();
3419 if (retval
== error_mark_node
)
3421 /* Treat this like a return of no value from a function that
3423 expand_null_return ();
3426 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3427 || TREE_CODE (retval
) == INIT_EXPR
)
3428 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3429 retval_rhs
= TREE_OPERAND (retval
, 1);
3431 retval_rhs
= retval
;
3433 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3435 /* Put returned bounds to the right place. */
3436 bounds_rtl
= DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl
));
3442 if (bounds
&& bounds
!= error_mark_node
)
3444 bnd
= expand_normal (bounds
);
3445 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3447 else if (REG_P (bounds_rtl
))
3450 bnd
= chkp_expand_zero_bounds ();
3453 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3454 addr
= gen_rtx_MEM (Pmode
, addr
);
3455 bnd
= targetm
.calls
.load_bounds_for_arg (addr
, NULL
, NULL
);
3458 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3464 gcc_assert (GET_CODE (bounds_rtl
) == PARALLEL
);
3467 bnd
= chkp_expand_zero_bounds ();
3470 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3471 addr
= gen_rtx_MEM (Pmode
, addr
);
3474 for (n
= 0; n
< XVECLEN (bounds_rtl
, 0); n
++)
3476 rtx slot
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 0);
3479 rtx offs
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 1);
3480 rtx from
= adjust_address (addr
, Pmode
, INTVAL (offs
));
3481 bnd
= targetm
.calls
.load_bounds_for_arg (from
, NULL
, NULL
);
3483 targetm
.calls
.store_returned_bounds (slot
, bnd
);
3487 else if (chkp_function_instrumented_p (current_function_decl
)
3488 && !BOUNDED_P (retval_rhs
)
3489 && chkp_type_has_pointer (TREE_TYPE (retval_rhs
))
3490 && TREE_CODE (retval_rhs
) != RESULT_DECL
)
3492 rtx addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3493 addr
= gen_rtx_MEM (Pmode
, addr
);
3495 gcc_assert (MEM_P (result_rtl
));
3497 chkp_copy_bounds_for_stack_parm (result_rtl
, addr
, TREE_TYPE (retval_rhs
));
3500 /* If we are returning the RESULT_DECL, then the value has already
3501 been stored into it, so we don't have to do anything special. */
3502 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3503 expand_value_return (result_rtl
);
3505 /* If the result is an aggregate that is being returned in one (or more)
3506 registers, load the registers here. */
3508 else if (retval_rhs
!= 0
3509 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3510 && REG_P (result_rtl
))
3512 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3515 /* Use the mode of the result value on the return register. */
3516 PUT_MODE (result_rtl
, GET_MODE (val
));
3517 expand_value_return (val
);
3520 expand_null_return ();
3522 else if (retval_rhs
!= 0
3523 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3524 && (REG_P (result_rtl
)
3525 || (GET_CODE (result_rtl
) == PARALLEL
)))
3527 /* Compute the return value into a temporary (usually a pseudo reg). */
3529 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3530 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3531 val
= force_not_mem (val
);
3532 expand_value_return (val
);
3536 /* No hard reg used; calculate value into hard return reg. */
3537 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3538 expand_value_return (result_rtl
);
3542 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3543 STMT that doesn't require special handling for outgoing edges. That
3544 is no tailcalls and no GIMPLE_COND. */
3547 expand_gimple_stmt_1 (gimple
*stmt
)
3551 set_curr_insn_location (gimple_location (stmt
));
3553 switch (gimple_code (stmt
))
3556 op0
= gimple_goto_dest (stmt
);
3557 if (TREE_CODE (op0
) == LABEL_DECL
)
3560 expand_computed_goto (op0
);
3563 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3566 case GIMPLE_PREDICT
:
3570 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3571 if (gimple_switch_num_labels (swtch
) == 1)
3572 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3574 expand_case (swtch
);
3578 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3581 expand_call_stmt (as_a
<gcall
*> (stmt
));
3586 tree bnd
= gimple_return_retbnd (as_a
<greturn
*> (stmt
));
3587 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3589 if (op0
&& op0
!= error_mark_node
)
3591 tree result
= DECL_RESULT (current_function_decl
);
3593 /* Mark we have return statement with missing bounds. */
3595 && chkp_function_instrumented_p (cfun
->decl
)
3597 bnd
= error_mark_node
;
3599 /* If we are not returning the current function's RESULT_DECL,
3600 build an assignment to it. */
3603 /* I believe that a function's RESULT_DECL is unique. */
3604 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3606 /* ??? We'd like to use simply expand_assignment here,
3607 but this fails if the value is of BLKmode but the return
3608 decl is a register. expand_return has special handling
3609 for this combination, which eventually should move
3610 to common code. See comments there. Until then, let's
3611 build a modify expression :-/ */
3612 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3618 expand_null_return ();
3620 expand_return (op0
, bnd
);
3626 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3627 tree lhs
= gimple_assign_lhs (assign_stmt
);
3629 /* Tree expand used to fiddle with |= and &= of two bitfield
3630 COMPONENT_REFs here. This can't happen with gimple, the LHS
3631 of binary assigns must be a gimple reg. */
3633 if (TREE_CODE (lhs
) != SSA_NAME
3634 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3635 == GIMPLE_SINGLE_RHS
)
3637 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3638 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3639 == GIMPLE_SINGLE_RHS
);
3640 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3641 /* Do not put locations on possibly shared trees. */
3642 && !is_gimple_min_invariant (rhs
))
3643 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3644 if (TREE_CLOBBER_P (rhs
))
3645 /* This is a clobber to mark the going out of scope for
3649 expand_assignment (lhs
, rhs
,
3650 gimple_assign_nontemporal_move_p (
3656 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3657 struct separate_ops ops
;
3658 bool promoted
= false;
3660 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3661 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3664 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3665 ops
.type
= TREE_TYPE (lhs
);
3666 switch (get_gimple_rhs_class (ops
.code
))
3668 case GIMPLE_TERNARY_RHS
:
3669 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3671 case GIMPLE_BINARY_RHS
:
3672 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3674 case GIMPLE_UNARY_RHS
:
3675 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3680 ops
.location
= gimple_location (stmt
);
3682 /* If we want to use a nontemporal store, force the value to
3683 register first. If we store into a promoted register,
3684 don't directly expand to target. */
3685 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3686 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3693 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3694 /* If TEMP is a VOIDmode constant, use convert_modes to make
3695 sure that we properly convert it. */
3696 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3698 temp
= convert_modes (GET_MODE (target
),
3699 TYPE_MODE (ops
.type
),
3701 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3702 GET_MODE (target
), temp
, unsignedp
);
3705 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3707 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3711 temp
= force_operand (temp
, target
);
3713 emit_move_insn (target
, temp
);
3724 /* Expand one gimple statement STMT and return the last RTL instruction
3725 before any of the newly generated ones.
3727 In addition to generating the necessary RTL instructions this also
3728 sets REG_EH_REGION notes if necessary and sets the current source
3729 location for diagnostics. */
3732 expand_gimple_stmt (gimple
*stmt
)
3734 location_t saved_location
= input_location
;
3735 rtx_insn
*last
= get_last_insn ();
3740 /* We need to save and restore the current source location so that errors
3741 discovered during expansion are emitted with the right location. But
3742 it would be better if the diagnostic routines used the source location
3743 embedded in the tree nodes rather than globals. */
3744 if (gimple_has_location (stmt
))
3745 input_location
= gimple_location (stmt
);
3747 expand_gimple_stmt_1 (stmt
);
3749 /* Free any temporaries used to evaluate this statement. */
3752 input_location
= saved_location
;
3754 /* Mark all insns that may trap. */
3755 lp_nr
= lookup_stmt_eh_lp (stmt
);
3759 for (insn
= next_real_insn (last
); insn
;
3760 insn
= next_real_insn (insn
))
3762 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3763 /* If we want exceptions for non-call insns, any
3764 may_trap_p instruction may throw. */
3765 && GET_CODE (PATTERN (insn
)) != CLOBBER
3766 && GET_CODE (PATTERN (insn
)) != USE
3767 && insn_could_throw_p (insn
))
3768 make_reg_eh_region_note (insn
, 0, lp_nr
);
3775 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3776 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3777 generated a tail call (something that might be denied by the ABI
3778 rules governing the call; see calls.c).
3780 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3781 can still reach the rest of BB. The case here is __builtin_sqrt,
3782 where the NaN result goes through the external function (with a
3783 tailcall) and the normal result happens via a sqrt instruction. */
3786 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3788 rtx_insn
*last2
, *last
;
3793 last2
= last
= expand_gimple_stmt (stmt
);
3795 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3796 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3799 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3801 *can_fallthru
= true;
3805 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3806 Any instructions emitted here are about to be deleted. */
3807 do_pending_stack_adjust ();
3809 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3810 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3811 EH or abnormal edges, we shouldn't have created a tail call in
3812 the first place. So it seems to me we should just be removing
3813 all edges here, or redirecting the existing fallthru edge to
3817 profile_count count
= profile_count::zero ();
3819 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3821 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3823 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3825 e
->dest
->count
-= e
->count
;
3826 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3827 if (e
->dest
->frequency
< 0)
3828 e
->dest
->frequency
= 0;
3831 probability
+= e
->probability
;
3838 /* This is somewhat ugly: the call_expr expander often emits instructions
3839 after the sibcall (to perform the function return). These confuse the
3840 find_many_sub_basic_blocks code, so we need to get rid of these. */
3841 last
= NEXT_INSN (last
);
3842 gcc_assert (BARRIER_P (last
));
3844 *can_fallthru
= false;
3845 while (NEXT_INSN (last
))
3847 /* For instance an sqrt builtin expander expands if with
3848 sibcall in the then and label for `else`. */
3849 if (LABEL_P (NEXT_INSN (last
)))
3851 *can_fallthru
= true;
3854 delete_insn (NEXT_INSN (last
));
3857 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3859 e
->probability
= probability
;
3862 update_bb_for_insn (bb
);
3864 if (NEXT_INSN (last
))
3866 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3869 if (BARRIER_P (last
))
3870 BB_END (bb
) = PREV_INSN (last
);
3873 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3878 /* Return the difference between the floor and the truncated result of
3879 a signed division by OP1 with remainder MOD. */
3881 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3883 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3884 return gen_rtx_IF_THEN_ELSE
3885 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3886 gen_rtx_IF_THEN_ELSE
3887 (mode
, gen_rtx_LT (BImode
,
3888 gen_rtx_DIV (mode
, op1
, mod
),
3890 constm1_rtx
, const0_rtx
),
3894 /* Return the difference between the ceil and the truncated result of
3895 a signed division by OP1 with remainder MOD. */
3897 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3899 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3900 return gen_rtx_IF_THEN_ELSE
3901 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3902 gen_rtx_IF_THEN_ELSE
3903 (mode
, gen_rtx_GT (BImode
,
3904 gen_rtx_DIV (mode
, op1
, mod
),
3906 const1_rtx
, const0_rtx
),
3910 /* Return the difference between the ceil and the truncated result of
3911 an unsigned division by OP1 with remainder MOD. */
3913 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3915 /* (mod != 0 ? 1 : 0) */
3916 return gen_rtx_IF_THEN_ELSE
3917 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3918 const1_rtx
, const0_rtx
);
3921 /* Return the difference between the rounded and the truncated result
3922 of a signed division by OP1 with remainder MOD. Halfway cases are
3923 rounded away from zero, rather than to the nearest even number. */
3925 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3927 /* (abs (mod) >= abs (op1) - abs (mod)
3928 ? (op1 / mod > 0 ? 1 : -1)
3930 return gen_rtx_IF_THEN_ELSE
3931 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3932 gen_rtx_MINUS (mode
,
3933 gen_rtx_ABS (mode
, op1
),
3934 gen_rtx_ABS (mode
, mod
))),
3935 gen_rtx_IF_THEN_ELSE
3936 (mode
, gen_rtx_GT (BImode
,
3937 gen_rtx_DIV (mode
, op1
, mod
),
3939 const1_rtx
, constm1_rtx
),
3943 /* Return the difference between the rounded and the truncated result
3944 of a unsigned division by OP1 with remainder MOD. Halfway cases
3945 are rounded away from zero, rather than to the nearest even
3948 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3950 /* (mod >= op1 - mod ? 1 : 0) */
3951 return gen_rtx_IF_THEN_ELSE
3952 (mode
, gen_rtx_GE (BImode
, mod
,
3953 gen_rtx_MINUS (mode
, op1
, mod
)),
3954 const1_rtx
, const0_rtx
);
3957 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3961 convert_debug_memory_address (machine_mode mode
, rtx x
,
3964 machine_mode xmode
= GET_MODE (x
);
3966 #ifndef POINTERS_EXTEND_UNSIGNED
3967 gcc_assert (mode
== Pmode
3968 || mode
== targetm
.addr_space
.address_mode (as
));
3969 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3973 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3975 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3978 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3979 x
= lowpart_subreg (mode
, x
, xmode
);
3980 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3981 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3982 else if (!POINTERS_EXTEND_UNSIGNED
)
3983 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3986 switch (GET_CODE (x
))
3989 if ((SUBREG_PROMOTED_VAR_P (x
)
3990 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3991 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3992 && REG_P (XEXP (SUBREG_REG (x
), 0))
3993 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3994 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3995 && GET_MODE (SUBREG_REG (x
)) == mode
)
3996 return SUBREG_REG (x
);
3999 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4000 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4003 temp
= shallow_copy_rtx (x
);
4004 PUT_MODE (temp
, mode
);
4007 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4009 temp
= gen_rtx_CONST (mode
, temp
);
4013 if (CONST_INT_P (XEXP (x
, 1)))
4015 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4017 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4023 /* Don't know how to express ptr_extend as operation in debug info. */
4026 #endif /* POINTERS_EXTEND_UNSIGNED */
4031 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4032 by avoid_deep_ter_for_debug. */
4034 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4036 /* Split too deep TER chains for debug stmts using debug temporaries. */
4039 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4041 use_operand_p use_p
;
4043 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4045 tree use
= USE_FROM_PTR (use_p
);
4046 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4048 gimple
*g
= get_gimple_for_ssa_name (use
);
4051 if (depth
> 6 && !stmt_ends_bb_p (g
))
4053 if (deep_ter_debug_map
== NULL
)
4054 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4056 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4059 vexpr
= make_node (DEBUG_EXPR_DECL
);
4060 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4061 DECL_ARTIFICIAL (vexpr
) = 1;
4062 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4063 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4064 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4065 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4066 avoid_deep_ter_for_debug (def_temp
, 0);
4069 avoid_deep_ter_for_debug (g
, depth
+ 1);
4073 /* Return an RTX equivalent to the value of the parameter DECL. */
4076 expand_debug_parm_decl (tree decl
)
4078 rtx incoming
= DECL_INCOMING_RTL (decl
);
4081 && GET_MODE (incoming
) != BLKmode
4082 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4083 || (MEM_P (incoming
)
4084 && REG_P (XEXP (incoming
, 0))
4085 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4087 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4089 #ifdef HAVE_window_save
4090 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4091 If the target machine has an explicit window save instruction, the
4092 actual entry value is the corresponding OUTGOING_REGNO instead. */
4093 if (REG_P (incoming
)
4094 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4096 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4097 OUTGOING_REGNO (REGNO (incoming
)), 0);
4098 else if (MEM_P (incoming
))
4100 rtx reg
= XEXP (incoming
, 0);
4101 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4103 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4104 incoming
= replace_equiv_address_nv (incoming
, reg
);
4107 incoming
= copy_rtx (incoming
);
4111 ENTRY_VALUE_EXP (rtl
) = incoming
;
4116 && GET_MODE (incoming
) != BLKmode
4117 && !TREE_ADDRESSABLE (decl
)
4119 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4120 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4121 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4122 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4123 return copy_rtx (incoming
);
4128 /* Return an RTX equivalent to the value of the tree expression EXP. */
4131 expand_debug_expr (tree exp
)
4133 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4134 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4135 machine_mode inner_mode
= VOIDmode
;
4136 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4139 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4141 case tcc_expression
:
4142 switch (TREE_CODE (exp
))
4147 case WIDEN_MULT_PLUS_EXPR
:
4148 case WIDEN_MULT_MINUS_EXPR
:
4152 case TRUTH_ANDIF_EXPR
:
4153 case TRUTH_ORIF_EXPR
:
4154 case TRUTH_AND_EXPR
:
4156 case TRUTH_XOR_EXPR
:
4159 case TRUTH_NOT_EXPR
:
4168 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4175 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4178 switch (TREE_CODE (exp
))
4184 case WIDEN_LSHIFT_EXPR
:
4185 /* Ensure second operand isn't wider than the first one. */
4186 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4187 if (SCALAR_INT_MODE_P (inner_mode
))
4189 machine_mode opmode
= mode
;
4190 if (VECTOR_MODE_P (mode
))
4191 opmode
= GET_MODE_INNER (mode
);
4192 if (SCALAR_INT_MODE_P (opmode
)
4193 && (GET_MODE_PRECISION (opmode
)
4194 < GET_MODE_PRECISION (inner_mode
)))
4195 op1
= lowpart_subreg (opmode
, op1
, inner_mode
);
4205 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4206 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4211 case tcc_comparison
:
4212 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4220 case tcc_exceptional
:
4221 case tcc_declaration
:
4227 switch (TREE_CODE (exp
))
4230 if (!lookup_constant_def (exp
))
4232 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4233 != (size_t) TREE_STRING_LENGTH (exp
))
4235 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4236 op0
= gen_rtx_MEM (BLKmode
, op0
);
4237 set_mem_attributes (op0
, exp
, 0);
4245 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4249 gcc_assert (COMPLEX_MODE_P (mode
));
4250 op0
= expand_debug_expr (TREE_REALPART (exp
));
4251 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4252 return gen_rtx_CONCAT (mode
, op0
, op1
);
4254 case DEBUG_EXPR_DECL
:
4255 op0
= DECL_RTL_IF_SET (exp
);
4260 op0
= gen_rtx_DEBUG_EXPR (mode
);
4261 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4262 SET_DECL_RTL (exp
, op0
);
4272 op0
= DECL_RTL_IF_SET (exp
);
4274 /* This decl was probably optimized away. */
4278 || DECL_EXTERNAL (exp
)
4279 || !TREE_STATIC (exp
)
4281 || DECL_HARD_REGISTER (exp
)
4282 || DECL_IN_CONSTANT_POOL (exp
)
4283 || mode
== VOIDmode
)
4286 op0
= make_decl_rtl_for_debug (exp
);
4288 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4289 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4293 op0
= copy_rtx (op0
);
4295 if (GET_MODE (op0
) == BLKmode
4296 /* If op0 is not BLKmode, but mode is, adjust_mode
4297 below would ICE. While it is likely a FE bug,
4298 try to be robust here. See PR43166. */
4300 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4302 gcc_assert (MEM_P (op0
));
4303 op0
= adjust_address_nv (op0
, mode
, 0);
4313 inner_mode
= GET_MODE (op0
);
4315 if (mode
== inner_mode
)
4318 if (inner_mode
== VOIDmode
)
4320 if (TREE_CODE (exp
) == SSA_NAME
)
4321 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4323 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4324 if (mode
== inner_mode
)
4328 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4330 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4331 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4332 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4333 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4335 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4337 else if (FLOAT_MODE_P (mode
))
4339 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4340 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4341 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4343 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4345 else if (FLOAT_MODE_P (inner_mode
))
4348 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4350 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4352 else if (CONSTANT_P (op0
)
4353 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
4354 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4355 else if (UNARY_CLASS_P (exp
)
4356 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4358 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4360 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4366 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4368 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4369 TREE_OPERAND (exp
, 0),
4370 TREE_OPERAND (exp
, 1));
4372 return expand_debug_expr (newexp
);
4376 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4377 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4381 if (TREE_CODE (exp
) == MEM_REF
)
4383 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4384 || (GET_CODE (op0
) == PLUS
4385 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4386 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4387 Instead just use get_inner_reference. */
4390 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4391 if (!op1
|| !CONST_INT_P (op1
))
4394 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
4397 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4399 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4401 if (op0
== NULL_RTX
)
4404 op0
= gen_rtx_MEM (mode
, op0
);
4405 set_mem_attributes (op0
, exp
, 0);
4406 if (TREE_CODE (exp
) == MEM_REF
4407 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4408 set_mem_expr (op0
, NULL_TREE
);
4409 set_mem_addr_space (op0
, as
);
4413 case TARGET_MEM_REF
:
4414 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4415 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4418 op0
= expand_debug_expr
4419 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4423 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4424 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4426 if (op0
== NULL_RTX
)
4429 op0
= gen_rtx_MEM (mode
, op0
);
4431 set_mem_attributes (op0
, exp
, 0);
4432 set_mem_addr_space (op0
, as
);
4438 case ARRAY_RANGE_REF
:
4443 case VIEW_CONVERT_EXPR
:
4446 HOST_WIDE_INT bitsize
, bitpos
;
4448 int reversep
, volatilep
= 0;
4450 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4451 &unsignedp
, &reversep
, &volatilep
);
4457 orig_op0
= op0
= expand_debug_expr (tem
);
4464 machine_mode addrmode
, offmode
;
4469 op0
= XEXP (op0
, 0);
4470 addrmode
= GET_MODE (op0
);
4471 if (addrmode
== VOIDmode
)
4474 op1
= expand_debug_expr (offset
);
4478 offmode
= GET_MODE (op1
);
4479 if (offmode
== VOIDmode
)
4480 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4482 if (addrmode
!= offmode
)
4483 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4485 /* Don't use offset_address here, we don't need a
4486 recognizable address, and we don't want to generate
4488 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4494 if (mode1
== VOIDmode
)
4496 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4497 if (bitpos
>= BITS_PER_UNIT
)
4499 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4500 bitpos
%= BITS_PER_UNIT
;
4502 else if (bitpos
< 0)
4505 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4506 op0
= adjust_address_nv (op0
, mode1
, -units
);
4507 bitpos
+= units
* BITS_PER_UNIT
;
4509 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4510 op0
= adjust_address_nv (op0
, mode
, 0);
4511 else if (GET_MODE (op0
) != mode1
)
4512 op0
= adjust_address_nv (op0
, mode1
, 0);
4514 op0
= copy_rtx (op0
);
4515 if (op0
== orig_op0
)
4516 op0
= shallow_copy_rtx (op0
);
4517 set_mem_attributes (op0
, exp
, 0);
4520 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4526 if (GET_MODE (op0
) == BLKmode
)
4529 if ((bitpos
% BITS_PER_UNIT
) == 0
4530 && bitsize
== GET_MODE_BITSIZE (mode1
))
4532 machine_mode opmode
= GET_MODE (op0
);
4534 if (opmode
== VOIDmode
)
4535 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4537 /* This condition may hold if we're expanding the address
4538 right past the end of an array that turned out not to
4539 be addressable (i.e., the address was only computed in
4540 debug stmts). The gen_subreg below would rightfully
4541 crash, and the address doesn't really exist, so just
4543 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4546 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4547 return simplify_gen_subreg (mode
, op0
, opmode
,
4548 bitpos
/ BITS_PER_UNIT
);
4551 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4552 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4554 : ZERO_EXTRACT
, mode
,
4555 GET_MODE (op0
) != VOIDmode
4557 : TYPE_MODE (TREE_TYPE (tem
)),
4558 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4562 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4565 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4568 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4571 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4573 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4576 case FIX_TRUNC_EXPR
:
4577 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4580 case POINTER_PLUS_EXPR
:
4581 /* For the rare target where pointers are not the same size as
4582 size_t, we need to check for mis-matched modes and correct
4585 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4586 && GET_MODE (op0
) != GET_MODE (op1
))
4588 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4589 /* If OP0 is a partial mode, then we must truncate, even if it has
4590 the same bitsize as OP1 as GCC's representation of partial modes
4592 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4593 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4594 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4597 /* We always sign-extend, regardless of the signedness of
4598 the operand, because the operand is always unsigned
4599 here even if the original C expression is signed. */
4600 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4605 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4608 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4611 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4614 case TRUNC_DIV_EXPR
:
4615 case EXACT_DIV_EXPR
:
4617 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4619 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4621 case TRUNC_MOD_EXPR
:
4622 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4624 case FLOOR_DIV_EXPR
:
4626 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4629 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4630 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4631 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4632 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4635 case FLOOR_MOD_EXPR
:
4637 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4640 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4641 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4642 adj
= simplify_gen_unary (NEG
, mode
,
4643 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4645 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4651 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4652 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4653 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4654 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4658 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4659 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4660 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4661 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4667 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4668 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4669 adj
= simplify_gen_unary (NEG
, mode
,
4670 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4672 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4676 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4677 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4678 adj
= simplify_gen_unary (NEG
, mode
,
4679 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4681 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4684 case ROUND_DIV_EXPR
:
4687 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4688 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4689 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4690 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4694 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4695 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4696 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4697 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4700 case ROUND_MOD_EXPR
:
4703 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4704 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4705 adj
= simplify_gen_unary (NEG
, mode
,
4706 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4708 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4712 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4713 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4714 adj
= simplify_gen_unary (NEG
, mode
,
4715 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4717 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4721 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4725 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4727 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4730 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4733 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4736 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4739 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4742 case TRUTH_AND_EXPR
:
4743 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4747 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4750 case TRUTH_XOR_EXPR
:
4751 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4753 case TRUTH_ANDIF_EXPR
:
4754 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4756 case TRUTH_ORIF_EXPR
:
4757 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4759 case TRUTH_NOT_EXPR
:
4760 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4763 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4767 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4771 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4775 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4779 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4782 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4784 case UNORDERED_EXPR
:
4785 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4788 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4791 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4794 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4797 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4800 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4803 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4806 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4809 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4812 gcc_assert (COMPLEX_MODE_P (mode
));
4813 if (GET_MODE (op0
) == VOIDmode
)
4814 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4815 if (GET_MODE (op1
) == VOIDmode
)
4816 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4817 return gen_rtx_CONCAT (mode
, op0
, op1
);
4820 if (GET_CODE (op0
) == CONCAT
)
4821 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4822 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4824 GET_MODE_INNER (mode
)));
4827 machine_mode imode
= GET_MODE_INNER (mode
);
4832 re
= adjust_address_nv (op0
, imode
, 0);
4833 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4837 machine_mode ifmode
= int_mode_for_mode (mode
);
4838 machine_mode ihmode
= int_mode_for_mode (imode
);
4840 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4842 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4845 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4846 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4847 if (imode
!= ihmode
)
4848 re
= gen_rtx_SUBREG (imode
, re
, 0);
4849 im
= copy_rtx (op0
);
4851 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4852 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4853 if (imode
!= ihmode
)
4854 im
= gen_rtx_SUBREG (imode
, im
, 0);
4856 im
= gen_rtx_NEG (imode
, im
);
4857 return gen_rtx_CONCAT (mode
, re
, im
);
4861 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4862 if (!op0
|| !MEM_P (op0
))
4864 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4865 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4866 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4867 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4868 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4869 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4871 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4873 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4876 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
4877 &bitsize
, &maxsize
, &reverse
);
4879 || TREE_CODE (decl
) == PARM_DECL
4880 || TREE_CODE (decl
) == RESULT_DECL
)
4881 && (!TREE_ADDRESSABLE (decl
)
4882 || target_for_debug_bind (decl
))
4883 && (bitoffset
% BITS_PER_UNIT
) == 0
4885 && bitsize
== maxsize
)
4887 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4888 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4892 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4893 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4896 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4899 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4900 || (GET_CODE (op0
) == PLUS
4901 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4902 && CONST_INT_P (XEXP (op0
, 1)))))
4904 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4906 if (!op1
|| !CONST_INT_P (op1
))
4909 return plus_constant (mode
, op0
, INTVAL (op1
));
4916 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
4917 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4925 op0
= gen_rtx_CONCATN
4926 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4928 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4930 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4933 XVECEXP (op0
, 0, i
) = op1
;
4940 if (TREE_CLOBBER_P (exp
))
4942 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4947 op0
= gen_rtx_CONCATN
4948 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4950 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4952 op1
= expand_debug_expr (val
);
4955 XVECEXP (op0
, 0, i
) = op1
;
4958 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4960 op1
= expand_debug_expr
4961 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4966 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4967 XVECEXP (op0
, 0, i
) = op1
;
4973 goto flag_unsupported
;
4976 /* ??? Maybe handle some builtins? */
4981 gimple
*g
= get_gimple_for_ssa_name (exp
);
4985 if (deep_ter_debug_map
)
4987 tree
*slot
= deep_ter_debug_map
->get (exp
);
4992 t
= gimple_assign_rhs_to_tree (g
);
4993 op0
= expand_debug_expr (t
);
4999 /* If this is a reference to an incoming value of
5000 parameter that is never used in the code or where the
5001 incoming value is never used in the code, use
5002 PARM_DECL's DECL_RTL if set. */
5003 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5004 && SSA_NAME_VAR (exp
)
5005 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5006 && has_zero_uses (exp
))
5008 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5011 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5016 int part
= var_to_partition (SA
.map
, exp
);
5018 if (part
== NO_PARTITION
)
5021 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5023 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5031 /* Vector stuff. For most of the codes we don't have rtl codes. */
5032 case REALIGN_LOAD_EXPR
:
5033 case REDUC_MAX_EXPR
:
5034 case REDUC_MIN_EXPR
:
5035 case REDUC_PLUS_EXPR
:
5037 case VEC_PACK_FIX_TRUNC_EXPR
:
5038 case VEC_PACK_SAT_EXPR
:
5039 case VEC_PACK_TRUNC_EXPR
:
5040 case VEC_UNPACK_FLOAT_HI_EXPR
:
5041 case VEC_UNPACK_FLOAT_LO_EXPR
:
5042 case VEC_UNPACK_HI_EXPR
:
5043 case VEC_UNPACK_LO_EXPR
:
5044 case VEC_WIDEN_MULT_HI_EXPR
:
5045 case VEC_WIDEN_MULT_LO_EXPR
:
5046 case VEC_WIDEN_MULT_EVEN_EXPR
:
5047 case VEC_WIDEN_MULT_ODD_EXPR
:
5048 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5049 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5054 case ADDR_SPACE_CONVERT_EXPR
:
5055 case FIXED_CONVERT_EXPR
:
5057 case WITH_SIZE_EXPR
:
5058 case BIT_INSERT_EXPR
:
5062 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5063 && SCALAR_INT_MODE_P (mode
))
5066 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5068 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5071 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5073 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5075 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5076 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5080 case WIDEN_MULT_EXPR
:
5081 case WIDEN_MULT_PLUS_EXPR
:
5082 case WIDEN_MULT_MINUS_EXPR
:
5083 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5084 && SCALAR_INT_MODE_P (mode
))
5086 inner_mode
= GET_MODE (op0
);
5087 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5088 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5090 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5091 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5092 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5094 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5095 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5096 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5098 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5099 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5101 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5105 case MULT_HIGHPART_EXPR
:
5106 /* ??? Similar to the above. */
5109 case WIDEN_SUM_EXPR
:
5110 case WIDEN_LSHIFT_EXPR
:
5111 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5112 && SCALAR_INT_MODE_P (mode
))
5115 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5117 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5119 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5120 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5125 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
5138 /* Return an RTX equivalent to the source bind value of the tree expression
5142 expand_debug_source_expr (tree exp
)
5145 machine_mode mode
= VOIDmode
, inner_mode
;
5147 switch (TREE_CODE (exp
))
5151 mode
= DECL_MODE (exp
);
5152 op0
= expand_debug_parm_decl (exp
);
5155 /* See if this isn't an argument that has been completely
5157 if (!DECL_RTL_SET_P (exp
)
5158 && !DECL_INCOMING_RTL (exp
)
5159 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5161 tree aexp
= DECL_ORIGIN (exp
);
5162 if (DECL_CONTEXT (aexp
)
5163 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5165 vec
<tree
, va_gc
> **debug_args
;
5168 debug_args
= decl_debug_args_lookup (current_function_decl
);
5169 if (debug_args
!= NULL
)
5171 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5174 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5184 if (op0
== NULL_RTX
)
5187 inner_mode
= GET_MODE (op0
);
5188 if (mode
== inner_mode
)
5191 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5193 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
5194 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5195 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
5196 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5198 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5200 else if (FLOAT_MODE_P (mode
))
5202 else if (FLOAT_MODE_P (inner_mode
))
5204 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5205 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5207 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5209 else if (CONSTANT_P (op0
)
5210 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
5211 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5212 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5213 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5215 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5220 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5221 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5222 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5225 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5229 if (exp
== NULL_RTX
)
5232 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5237 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5238 rtx dval
= make_debug_expr_from_rtl (exp
);
5240 /* Emit a debug bind insn before INSN. */
5241 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5242 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5243 VAR_INIT_STATUS_INITIALIZED
);
5245 emit_debug_insn_before (bind
, insn
);
5250 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5252 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5253 switch (*format_ptr
++)
5256 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5261 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5262 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5270 /* Expand the _LOCs in debug insns. We run this after expanding all
5271 regular insns, so that any variables referenced in the function
5272 will have their DECL_RTLs set. */
5275 expand_debug_locations (void)
5278 rtx_insn
*last
= get_last_insn ();
5279 int save_strict_alias
= flag_strict_aliasing
;
5281 /* New alias sets while setting up memory attributes cause
5282 -fcompare-debug failures, even though it doesn't bring about any
5284 flag_strict_aliasing
= 0;
5286 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5287 if (DEBUG_INSN_P (insn
))
5289 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5291 rtx_insn
*prev_insn
, *insn2
;
5294 if (value
== NULL_TREE
)
5298 if (INSN_VAR_LOCATION_STATUS (insn
)
5299 == VAR_INIT_STATUS_UNINITIALIZED
)
5300 val
= expand_debug_source_expr (value
);
5301 /* The avoid_deep_ter_for_debug function inserts
5302 debug bind stmts after SSA_NAME definition, with the
5303 SSA_NAME as the whole bind location. Disable temporarily
5304 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5305 being defined in this DEBUG_INSN. */
5306 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5308 tree
*slot
= deep_ter_debug_map
->get (value
);
5311 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5316 val
= expand_debug_expr (value
);
5318 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5321 val
= expand_debug_expr (value
);
5322 gcc_assert (last
== get_last_insn ());
5326 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5329 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5331 gcc_assert (mode
== GET_MODE (val
)
5332 || (GET_MODE (val
) == VOIDmode
5333 && (CONST_SCALAR_INT_P (val
)
5334 || GET_CODE (val
) == CONST_FIXED
5335 || GET_CODE (val
) == LABEL_REF
)));
5338 INSN_VAR_LOCATION_LOC (insn
) = val
;
5339 prev_insn
= PREV_INSN (insn
);
5340 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5341 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5344 flag_strict_aliasing
= save_strict_alias
;
5347 /* Performs swapping operands of commutative operations to expand
5348 the expensive one first. */
5351 reorder_operands (basic_block bb
)
5353 unsigned int *lattice
; /* Hold cost of each statement. */
5354 unsigned int i
= 0, n
= 0;
5355 gimple_stmt_iterator gsi
;
5361 use_operand_p use_p
;
5362 gimple
*def0
, *def1
;
5364 /* Compute cost of each statement using estimate_num_insns. */
5365 stmts
= bb_seq (bb
);
5366 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5368 stmt
= gsi_stmt (gsi
);
5369 if (!is_gimple_debug (stmt
))
5370 gimple_set_uid (stmt
, n
++);
5372 lattice
= XNEWVEC (unsigned int, n
);
5373 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5376 stmt
= gsi_stmt (gsi
);
5377 if (is_gimple_debug (stmt
))
5379 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5381 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5383 tree use
= USE_FROM_PTR (use_p
);
5385 if (TREE_CODE (use
) != SSA_NAME
)
5387 def_stmt
= get_gimple_for_ssa_name (use
);
5390 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5393 if (!is_gimple_assign (stmt
)
5394 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5396 op0
= gimple_op (stmt
, 1);
5397 op1
= gimple_op (stmt
, 2);
5398 if (TREE_CODE (op0
) != SSA_NAME
5399 || TREE_CODE (op1
) != SSA_NAME
)
5401 /* Swap operands if the second one is more expensive. */
5402 def0
= get_gimple_for_ssa_name (op0
);
5403 def1
= get_gimple_for_ssa_name (op1
);
5407 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5411 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5413 fprintf (dump_file
, "Swap operands in stmt:\n");
5414 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5415 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5416 def0
? lattice
[gimple_uid (def0
)] : 0,
5417 lattice
[gimple_uid (def1
)]);
5419 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5420 gimple_assign_rhs2_ptr (stmt
));
5426 /* Expand basic block BB from GIMPLE trees to RTL. */
5429 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5431 gimple_stmt_iterator gsi
;
5433 gimple
*stmt
= NULL
;
5440 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5443 /* Note that since we are now transitioning from GIMPLE to RTL, we
5444 cannot use the gsi_*_bb() routines because they expect the basic
5445 block to be in GIMPLE, instead of RTL. Therefore, we need to
5446 access the BB sequence directly. */
5448 reorder_operands (bb
);
5449 stmts
= bb_seq (bb
);
5450 bb
->il
.gimple
.seq
= NULL
;
5451 bb
->il
.gimple
.phi_nodes
= NULL
;
5452 rtl_profile_for_bb (bb
);
5453 init_rtl_bb_info (bb
);
5454 bb
->flags
|= BB_RTL
;
5456 /* Remove the RETURN_EXPR if we may fall though to the exit
5458 gsi
= gsi_last (stmts
);
5459 if (!gsi_end_p (gsi
)
5460 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5462 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5464 gcc_assert (single_succ_p (bb
));
5465 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5467 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5468 && !gimple_return_retval (ret_stmt
))
5470 gsi_remove (&gsi
, false);
5471 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5475 gsi
= gsi_start (stmts
);
5476 if (!gsi_end_p (gsi
))
5478 stmt
= gsi_stmt (gsi
);
5479 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5483 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5487 last
= get_last_insn ();
5491 expand_gimple_stmt (stmt
);
5498 /* Java emits line number notes in the top of labels.
5499 ??? Make this go away once line number notes are obsoleted. */
5500 BB_HEAD (bb
) = NEXT_INSN (last
);
5501 if (NOTE_P (BB_HEAD (bb
)))
5502 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5503 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5505 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5508 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5510 NOTE_BASIC_BLOCK (note
) = bb
;
5512 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5516 stmt
= gsi_stmt (gsi
);
5518 /* If this statement is a non-debug one, and we generate debug
5519 insns, then this one might be the last real use of a TERed
5520 SSA_NAME, but where there are still some debug uses further
5521 down. Expanding the current SSA name in such further debug
5522 uses by their RHS might lead to wrong debug info, as coalescing
5523 might make the operands of such RHS be placed into the same
5524 pseudo as something else. Like so:
5525 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5529 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5530 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5531 the write to a_2 would actually have clobbered the place which
5534 So, instead of that, we recognize the situation, and generate
5535 debug temporaries at the last real use of TERed SSA names:
5542 if (MAY_HAVE_DEBUG_INSNS
5544 && !is_gimple_debug (stmt
))
5550 location_t sloc
= curr_insn_location ();
5552 /* Look for SSA names that have their last use here (TERed
5553 names always have only one real use). */
5554 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5555 if ((def
= get_gimple_for_ssa_name (op
)))
5557 imm_use_iterator imm_iter
;
5558 use_operand_p use_p
;
5559 bool have_debug_uses
= false;
5561 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5563 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5565 have_debug_uses
= true;
5570 if (have_debug_uses
)
5572 /* OP is a TERed SSA name, with DEF its defining
5573 statement, and where OP is used in further debug
5574 instructions. Generate a debug temporary, and
5575 replace all uses of OP in debug insns with that
5578 tree value
= gimple_assign_rhs_to_tree (def
);
5579 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5583 set_curr_insn_location (gimple_location (def
));
5585 DECL_ARTIFICIAL (vexpr
) = 1;
5586 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5588 mode
= DECL_MODE (value
);
5590 mode
= TYPE_MODE (TREE_TYPE (value
));
5591 SET_DECL_MODE (vexpr
, mode
);
5593 val
= gen_rtx_VAR_LOCATION
5594 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5596 emit_debug_insn (val
);
5598 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5600 if (!gimple_debug_bind_p (debugstmt
))
5603 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5604 SET_USE (use_p
, vexpr
);
5606 update_stmt (debugstmt
);
5610 set_curr_insn_location (sloc
);
5613 currently_expanding_gimple_stmt
= stmt
;
5615 /* Expand this statement, then evaluate the resulting RTL and
5616 fixup the CFG accordingly. */
5617 if (gimple_code (stmt
) == GIMPLE_COND
)
5619 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5623 else if (gimple_debug_bind_p (stmt
))
5625 location_t sloc
= curr_insn_location ();
5626 gimple_stmt_iterator nsi
= gsi
;
5630 tree var
= gimple_debug_bind_get_var (stmt
);
5635 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5636 && TREE_CODE (var
) != LABEL_DECL
5637 && !target_for_debug_bind (var
))
5638 goto delink_debug_stmt
;
5640 if (gimple_debug_bind_has_value_p (stmt
))
5641 value
= gimple_debug_bind_get_value (stmt
);
5645 last
= get_last_insn ();
5647 set_curr_insn_location (gimple_location (stmt
));
5650 mode
= DECL_MODE (var
);
5652 mode
= TYPE_MODE (TREE_TYPE (var
));
5654 val
= gen_rtx_VAR_LOCATION
5655 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5657 emit_debug_insn (val
);
5659 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5661 /* We can't dump the insn with a TREE where an RTX
5663 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5664 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5665 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5669 /* In order not to generate too many debug temporaries,
5670 we delink all uses of debug statements we already expanded.
5671 Therefore debug statements between definition and real
5672 use of TERed SSA names will continue to use the SSA name,
5673 and not be replaced with debug temps. */
5674 delink_stmt_imm_use (stmt
);
5678 if (gsi_end_p (nsi
))
5680 stmt
= gsi_stmt (nsi
);
5681 if (!gimple_debug_bind_p (stmt
))
5685 set_curr_insn_location (sloc
);
5687 else if (gimple_debug_source_bind_p (stmt
))
5689 location_t sloc
= curr_insn_location ();
5690 tree var
= gimple_debug_source_bind_get_var (stmt
);
5691 tree value
= gimple_debug_source_bind_get_value (stmt
);
5695 last
= get_last_insn ();
5697 set_curr_insn_location (gimple_location (stmt
));
5699 mode
= DECL_MODE (var
);
5701 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5702 VAR_INIT_STATUS_UNINITIALIZED
);
5704 emit_debug_insn (val
);
5706 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5708 /* We can't dump the insn with a TREE where an RTX
5710 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5711 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5712 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5715 set_curr_insn_location (sloc
);
5719 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5721 && gimple_call_tail_p (call_stmt
)
5722 && disable_tail_calls
)
5723 gimple_call_set_tail (call_stmt
, false);
5725 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5728 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5739 def_operand_p def_p
;
5740 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5744 /* Ignore this stmt if it is in the list of
5745 replaceable expressions. */
5747 && bitmap_bit_p (SA
.values
,
5748 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5751 last
= expand_gimple_stmt (stmt
);
5752 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5757 currently_expanding_gimple_stmt
= NULL
;
5759 /* Expand implicit goto and convert goto_locus. */
5760 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5762 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5763 set_curr_insn_location (e
->goto_locus
);
5764 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5766 emit_jump (label_rtx_for_bb (e
->dest
));
5767 e
->flags
&= ~EDGE_FALLTHRU
;
5771 /* Expanded RTL can create a jump in the last instruction of block.
5772 This later might be assumed to be a jump to successor and break edge insertion.
5773 We need to insert dummy move to prevent this. PR41440. */
5774 if (single_succ_p (bb
)
5775 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5776 && (last
= get_last_insn ())
5778 || (DEBUG_INSN_P (last
)
5779 && JUMP_P (prev_nondebug_insn (last
)))))
5781 rtx dummy
= gen_reg_rtx (SImode
);
5782 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5785 do_pending_stack_adjust ();
5787 /* Find the block tail. The last insn in the block is the insn
5788 before a barrier and/or table jump insn. */
5789 last
= get_last_insn ();
5790 if (BARRIER_P (last
))
5791 last
= PREV_INSN (last
);
5792 if (JUMP_TABLE_DATA_P (last
))
5793 last
= PREV_INSN (PREV_INSN (last
));
5796 update_bb_for_insn (bb
);
5802 /* Create a basic block for initialization code. */
5805 construct_init_block (void)
5807 basic_block init_block
, first_block
;
5811 /* Multiple entry points not supported yet. */
5812 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5813 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5814 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5815 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5816 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5818 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5820 /* When entry edge points to first basic block, we don't need jump,
5821 otherwise we have to jump into proper target. */
5822 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5824 tree label
= gimple_block_label (e
->dest
);
5826 emit_jump (jump_target_rtx (label
));
5830 flags
= EDGE_FALLTHRU
;
5832 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5834 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5835 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5836 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5837 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5840 first_block
= e
->dest
;
5841 redirect_edge_succ (e
, init_block
);
5842 e
= make_edge (init_block
, first_block
, flags
);
5845 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5846 e
->probability
= REG_BR_PROB_BASE
;
5847 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5849 update_bb_for_insn (init_block
);
5853 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5854 found in the block tree. */
5857 set_block_levels (tree block
, int level
)
5861 BLOCK_NUMBER (block
) = level
;
5862 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5863 block
= BLOCK_CHAIN (block
);
5867 /* Create a block containing landing pads and similar stuff. */
5870 construct_exit_block (void)
5872 rtx_insn
*head
= get_last_insn ();
5874 basic_block exit_block
;
5878 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5879 rtx_insn
*orig_end
= BB_END (prev_bb
);
5881 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5883 /* Make sure the locus is set to the end of the function, so that
5884 epilogue line numbers and warnings are set properly. */
5885 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5886 input_location
= cfun
->function_end_locus
;
5888 /* Generate rtl for function exit. */
5889 expand_function_end ();
5891 end
= get_last_insn ();
5894 /* While emitting the function end we could move end of the last basic
5896 BB_END (prev_bb
) = orig_end
;
5897 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5898 head
= NEXT_INSN (head
);
5899 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5900 bb frequency counting will be confused. Any instructions before that
5901 label are emitted for the case where PREV_BB falls through into the
5902 exit block, so append those instructions to prev_bb in that case. */
5903 if (NEXT_INSN (head
) != return_label
)
5905 while (NEXT_INSN (head
) != return_label
)
5907 if (!NOTE_P (NEXT_INSN (head
)))
5908 BB_END (prev_bb
) = NEXT_INSN (head
);
5909 head
= NEXT_INSN (head
);
5912 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5913 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5914 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5915 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5918 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5920 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5921 if (!(e
->flags
& EDGE_ABNORMAL
))
5922 redirect_edge_succ (e
, exit_block
);
5927 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5928 e
->probability
= REG_BR_PROB_BASE
;
5929 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5930 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5933 e
->count
-= e2
->count
;
5934 exit_block
->count
-= e2
->count
;
5935 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5937 if (exit_block
->frequency
< 0)
5938 exit_block
->frequency
= 0;
5939 update_bb_for_insn (exit_block
);
5942 /* Helper function for discover_nonconstant_array_refs.
5943 Look for ARRAY_REF nodes with non-constant indexes and mark them
5947 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5948 void *data ATTRIBUTE_UNUSED
)
5952 if (IS_TYPE_OR_DECL_P (t
))
5954 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5956 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5957 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5958 && (!TREE_OPERAND (t
, 2)
5959 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5960 || (TREE_CODE (t
) == COMPONENT_REF
5961 && (!TREE_OPERAND (t
,2)
5962 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5963 || TREE_CODE (t
) == BIT_FIELD_REF
5964 || TREE_CODE (t
) == REALPART_EXPR
5965 || TREE_CODE (t
) == IMAGPART_EXPR
5966 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5967 || CONVERT_EXPR_P (t
))
5968 t
= TREE_OPERAND (t
, 0);
5970 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5972 t
= get_base_address (t
);
5974 && DECL_MODE (t
) != BLKmode
)
5975 TREE_ADDRESSABLE (t
) = 1;
5984 /* RTL expansion is not able to compile array references with variable
5985 offsets for arrays stored in single register. Discover such
5986 expressions and mark variables as addressable to avoid this
5990 discover_nonconstant_array_refs (void)
5993 gimple_stmt_iterator gsi
;
5995 FOR_EACH_BB_FN (bb
, cfun
)
5996 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5998 gimple
*stmt
= gsi_stmt (gsi
);
5999 if (!is_gimple_debug (stmt
))
6000 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6004 /* This function sets crtl->args.internal_arg_pointer to a virtual
6005 register if DRAP is needed. Local register allocator will replace
6006 virtual_incoming_args_rtx with the virtual register. */
6009 expand_stack_alignment (void)
6012 unsigned int preferred_stack_boundary
;
6014 if (! SUPPORTS_STACK_ALIGNMENT
)
6017 if (cfun
->calls_alloca
6018 || cfun
->has_nonlocal_label
6019 || crtl
->has_nonlocal_goto
)
6020 crtl
->need_drap
= true;
6022 /* Call update_stack_boundary here again to update incoming stack
6023 boundary. It may set incoming stack alignment to a different
6024 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6025 use the minimum incoming stack alignment to check if it is OK
6026 to perform sibcall optimization since sibcall optimization will
6027 only align the outgoing stack to incoming stack boundary. */
6028 if (targetm
.calls
.update_stack_boundary
)
6029 targetm
.calls
.update_stack_boundary ();
6031 /* The incoming stack frame has to be aligned at least at
6032 parm_stack_boundary. */
6033 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6035 /* Update crtl->stack_alignment_estimated and use it later to align
6036 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6037 exceptions since callgraph doesn't collect incoming stack alignment
6039 if (cfun
->can_throw_non_call_exceptions
6040 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6041 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6043 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6044 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6045 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6046 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6047 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6049 gcc_assert (crtl
->stack_alignment_needed
6050 <= crtl
->stack_alignment_estimated
);
6052 crtl
->stack_realign_needed
6053 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6054 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6056 crtl
->stack_realign_processed
= true;
6058 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6060 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6061 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6063 /* stack_realign_drap and drap_rtx must match. */
6064 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6066 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6067 if (NULL
!= drap_rtx
)
6069 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6071 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6073 fixup_tail_calls ();
6079 expand_main_function (void)
6081 #if (defined(INVOKE__main) \
6082 || (!defined(HAS_INIT_SECTION) \
6083 && !defined(INIT_SECTION_ASM_OP) \
6084 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6085 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
6090 /* Expand code to initialize the stack_protect_guard. This is invoked at
6091 the beginning of a function to be protected. */
6094 stack_protect_prologue (void)
6096 tree guard_decl
= targetm
.stack_protect_guard ();
6099 x
= expand_normal (crtl
->stack_protect_guard
);
6101 y
= expand_normal (guard_decl
);
6105 /* Allow the target to copy from Y to X without leaking Y into a
6107 if (targetm
.have_stack_protect_set ())
6108 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6114 /* Otherwise do a straight move. */
6115 emit_move_insn (x
, y
);
6118 /* Translate the intermediate representation contained in the CFG
6119 from GIMPLE trees to RTL.
6121 We do conversion per basic block and preserve/update the tree CFG.
6122 This implies we have to do some magic as the CFG can simultaneously
6123 consist of basic blocks containing RTL and GIMPLE trees. This can
6124 confuse the CFG hooks, so be careful to not manipulate CFG during
6129 const pass_data pass_data_expand
=
6131 RTL_PASS
, /* type */
6132 "expand", /* name */
6133 OPTGROUP_NONE
, /* optinfo_flags */
6134 TV_EXPAND
, /* tv_id */
6135 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6138 | PROP_gimple_lva
), /* properties_required */
6139 PROP_rtl
, /* properties_provided */
6140 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6141 0, /* todo_flags_start */
6142 0, /* todo_flags_finish */
6145 class pass_expand
: public rtl_opt_pass
6148 pass_expand (gcc::context
*ctxt
)
6149 : rtl_opt_pass (pass_data_expand
, ctxt
)
6152 /* opt_pass methods: */
6153 virtual unsigned int execute (function
*);
6155 }; // class pass_expand
6158 pass_expand::execute (function
*fun
)
6160 basic_block bb
, init_block
;
6163 rtx_insn
*var_seq
, *var_ret_seq
;
6166 timevar_push (TV_OUT_OF_SSA
);
6167 rewrite_out_of_ssa (&SA
);
6168 timevar_pop (TV_OUT_OF_SSA
);
6169 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6171 if (MAY_HAVE_DEBUG_STMTS
&& flag_tree_ter
)
6173 gimple_stmt_iterator gsi
;
6174 FOR_EACH_BB_FN (bb
, cfun
)
6175 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6176 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6177 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6180 /* Make sure all values used by the optimization passes have sane
6184 /* Some backends want to know that we are expanding to RTL. */
6185 currently_expanding_to_rtl
= 1;
6186 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6187 free_dominance_info (CDI_DOMINATORS
);
6189 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6191 if (chkp_function_instrumented_p (current_function_decl
))
6192 chkp_reset_rtl_bounds ();
6194 insn_locations_init ();
6195 if (!DECL_IS_BUILTIN (current_function_decl
))
6197 /* Eventually, all FEs should explicitly set function_start_locus. */
6198 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6199 set_curr_insn_location
6200 (DECL_SOURCE_LOCATION (current_function_decl
));
6202 set_curr_insn_location (fun
->function_start_locus
);
6205 set_curr_insn_location (UNKNOWN_LOCATION
);
6206 prologue_location
= curr_insn_location ();
6208 #ifdef INSN_SCHEDULING
6209 init_sched_attrs ();
6212 /* Make sure first insn is a note even if we don't want linenums.
6213 This makes sure the first insn will never be deleted.
6214 Also, final expects a note to appear there. */
6215 emit_note (NOTE_INSN_DELETED
);
6217 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6218 discover_nonconstant_array_refs ();
6220 targetm
.expand_to_rtl_hook ();
6221 crtl
->init_stack_alignment ();
6222 fun
->cfg
->max_jumptable_ents
= 0;
6224 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6225 of the function section at exapnsion time to predict distance of calls. */
6226 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6228 /* Expand the variables recorded during gimple lowering. */
6229 timevar_push (TV_VAR_EXPAND
);
6232 var_ret_seq
= expand_used_vars ();
6234 var_seq
= get_insns ();
6236 timevar_pop (TV_VAR_EXPAND
);
6238 /* Honor stack protection warnings. */
6239 if (warn_stack_protect
)
6241 if (fun
->calls_alloca
)
6242 warning (OPT_Wstack_protector
,
6243 "stack protector not protecting local variables: "
6244 "variable length buffer");
6245 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6246 warning (OPT_Wstack_protector
,
6247 "stack protector not protecting function: "
6248 "all local arrays are less than %d bytes long",
6249 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
6252 /* Set up parameters and prepare for return, for the function. */
6253 expand_function_start (current_function_decl
);
6255 /* If we emitted any instructions for setting up the variables,
6256 emit them before the FUNCTION_START note. */
6259 emit_insn_before (var_seq
, parm_birth_insn
);
6261 /* In expand_function_end we'll insert the alloca save/restore
6262 before parm_birth_insn. We've just insertted an alloca call.
6263 Adjust the pointer to match. */
6264 parm_birth_insn
= var_seq
;
6267 /* Now propagate the RTL assignment of each partition to the
6268 underlying var of each SSA_NAME. */
6271 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6273 /* We might have generated new SSA names in
6274 update_alias_info_with_stack_vars. They will have a NULL
6275 defining statements, and won't be part of the partitioning,
6277 if (!SSA_NAME_DEF_STMT (name
))
6280 adjust_one_expanded_partition_var (name
);
6283 /* Clean up RTL of variables that straddle across multiple
6284 partitions, and check that the rtl of any PARM_DECLs that are not
6285 cleaned up is that of their default defs. */
6286 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6290 /* We might have generated new SSA names in
6291 update_alias_info_with_stack_vars. They will have a NULL
6292 defining statements, and won't be part of the partitioning,
6294 if (!SSA_NAME_DEF_STMT (name
))
6296 part
= var_to_partition (SA
.map
, name
);
6297 if (part
== NO_PARTITION
)
6300 /* If this decl was marked as living in multiple places, reset
6301 this now to NULL. */
6302 tree var
= SSA_NAME_VAR (name
);
6303 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6304 SET_DECL_RTL (var
, NULL
);
6305 /* Check that the pseudos chosen by assign_parms are those of
6306 the corresponding default defs. */
6307 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6308 && (TREE_CODE (var
) == PARM_DECL
6309 || TREE_CODE (var
) == RESULT_DECL
))
6311 rtx in
= DECL_RTL_IF_SET (var
);
6313 rtx out
= SA
.partition_to_pseudo
[part
];
6314 gcc_assert (in
== out
);
6316 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6317 those expected by debug backends for each parm and for
6318 the result. This is particularly important for stabs,
6319 whose register elimination from parm's DECL_RTL may cause
6320 -fcompare-debug differences as SET_DECL_RTL changes reg's
6321 attrs. So, make sure the RTL already has the parm as the
6322 EXPR, so that it won't change. */
6323 SET_DECL_RTL (var
, NULL_RTX
);
6325 set_mem_attributes (in
, var
, true);
6326 SET_DECL_RTL (var
, in
);
6330 /* If this function is `main', emit a call to `__main'
6331 to run global initializers, etc. */
6332 if (DECL_NAME (current_function_decl
)
6333 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6334 && DECL_FILE_SCOPE_P (current_function_decl
))
6335 expand_main_function ();
6337 /* Initialize the stack_protect_guard field. This must happen after the
6338 call to __main (if any) so that the external decl is initialized. */
6339 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6340 stack_protect_prologue ();
6342 expand_phi_nodes (&SA
);
6344 /* Release any stale SSA redirection data. */
6345 redirect_edge_var_map_empty ();
6347 /* Register rtl specific functions for cfg. */
6348 rtl_register_cfg_hooks ();
6350 init_block
= construct_init_block ();
6352 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6353 remaining edges later. */
6354 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6355 e
->flags
&= ~EDGE_EXECUTABLE
;
6357 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6358 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6360 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6362 if (MAY_HAVE_DEBUG_INSNS
)
6363 expand_debug_locations ();
6365 if (deep_ter_debug_map
)
6367 delete deep_ter_debug_map
;
6368 deep_ter_debug_map
= NULL
;
6371 /* Free stuff we no longer need after GIMPLE optimizations. */
6372 free_dominance_info (CDI_DOMINATORS
);
6373 free_dominance_info (CDI_POST_DOMINATORS
);
6374 delete_tree_cfg_annotations (fun
);
6376 timevar_push (TV_OUT_OF_SSA
);
6377 finish_out_of_ssa (&SA
);
6378 timevar_pop (TV_OUT_OF_SSA
);
6380 timevar_push (TV_POST_EXPAND
);
6381 /* We are no longer in SSA form. */
6382 fun
->gimple_df
->in_ssa_p
= false;
6383 loops_state_clear (LOOP_CLOSED_SSA
);
6385 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6386 conservatively to true until they are all profile aware. */
6387 delete lab_rtx_for_bb
;
6388 free_histograms (fun
);
6390 construct_exit_block ();
6391 insn_locations_finalize ();
6395 rtx_insn
*after
= return_label
;
6396 rtx_insn
*next
= NEXT_INSN (after
);
6397 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6399 emit_insn_after (var_ret_seq
, after
);
6402 /* Zap the tree EH table. */
6403 set_eh_throw_stmt_table (fun
, NULL
);
6405 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6406 split edges which edge insertions might do. */
6407 rebuild_jump_labels (get_insns ());
6409 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
6410 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6414 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6418 rebuild_jump_labels_chain (e
->insns
.r
);
6419 /* Put insns after parm birth, but before
6420 NOTE_INSNS_FUNCTION_BEG. */
6421 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
6422 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6424 rtx_insn
*insns
= e
->insns
.r
;
6426 if (NOTE_P (parm_birth_insn
)
6427 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6428 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6430 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6433 commit_one_edge_insertion (e
);
6440 /* We're done expanding trees to RTL. */
6441 currently_expanding_to_rtl
= 0;
6443 flush_mark_addressable_queue ();
6445 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6446 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6450 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6452 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6453 e
->flags
&= ~EDGE_EXECUTABLE
;
6455 /* At the moment not all abnormal edges match the RTL
6456 representation. It is safe to remove them here as
6457 find_many_sub_basic_blocks will rediscover them.
6458 In the future we should get this fixed properly. */
6459 if ((e
->flags
& EDGE_ABNORMAL
)
6460 && !(e
->flags
& EDGE_SIBCALL
))
6467 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6468 bitmap_ones (blocks
);
6469 find_many_sub_basic_blocks (blocks
);
6470 purge_all_dead_edges ();
6472 expand_stack_alignment ();
6474 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6476 if (crtl
->tail_call_emit
)
6477 fixup_tail_calls ();
6479 /* After initial rtl generation, call back to finish generating
6480 exception support code. We need to do this before cleaning up
6481 the CFG as the code does not expect dead landing pads. */
6482 if (fun
->eh
->region_tree
!= NULL
)
6483 finish_eh_generation ();
6485 /* Remove unreachable blocks, otherwise we cannot compute dominators
6486 which are needed for loop state verification. As a side-effect
6487 this also compacts blocks.
6488 ??? We cannot remove trivially dead insns here as for example
6489 the DRAP reg on i?86 is not magically live at this point.
6490 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6491 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6493 checking_verify_flow_info ();
6495 /* Initialize pseudos allocated for hard registers. */
6496 emit_initial_value_sets ();
6498 /* And finally unshare all RTL. */
6501 /* There's no need to defer outputting this function any more; we
6502 know we want to output it. */
6503 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6505 /* Now that we're done expanding trees to RTL, we shouldn't have any
6506 more CONCATs anywhere. */
6507 generating_concat_p
= 0;
6512 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6513 /* And the pass manager will dump RTL for us. */
6516 /* If we're emitting a nested function, make sure its parent gets
6517 emitted as well. Doing otherwise confuses debug info. */
6520 for (parent
= DECL_CONTEXT (current_function_decl
);
6521 parent
!= NULL_TREE
;
6522 parent
= get_containing_scope (parent
))
6523 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6524 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6527 /* We are now committed to emitting code for this function. Do any
6528 preparation, such as emitting abstract debug info for the inline
6529 before it gets mangled by optimization. */
6530 if (cgraph_function_possibly_inlined_p (current_function_decl
))
6531 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
6533 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6535 /* After expanding, the return labels are no longer needed. */
6536 return_label
= NULL
;
6537 naked_return_label
= NULL
;
6539 /* After expanding, the tm_restart map is no longer needed. */
6540 if (fun
->gimple_df
->tm_restart
)
6541 fun
->gimple_df
->tm_restart
= NULL
;
6543 /* Tag the blocks with a depth number so that change_scope can find
6544 the common parent easily. */
6545 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6546 default_rtl_profile ();
6548 /* For -dx discard loops now, otherwise IL verify in clean_state will
6550 if (rtl_dump_and_exit
)
6552 cfun
->curr_properties
&= ~PROP_loops
;
6553 loop_optimizer_finalize ();
6556 timevar_pop (TV_POST_EXPAND
);
6564 make_pass_expand (gcc::context
*ctxt
)
6566 return new pass_expand (ctxt
);