1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2016 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 /* Return true if the current function should have its stack frame
872 protected by address sanitizer. */
875 asan_sanitize_stack_p (void)
877 return ((flag_sanitize
& SANITIZE_ADDRESS
)
879 && !lookup_attribute ("no_sanitize_address",
880 DECL_ATTRIBUTES (current_function_decl
)));
883 /* A subroutine of expand_used_vars. Binpack the variables into
884 partitions constrained by the interference graph. The overall
885 algorithm used is as follows:
887 Sort the objects by size in descending order.
892 Look for the largest non-conflicting object B with size <= S.
899 partition_stack_vars (void)
901 size_t si
, sj
, n
= stack_vars_num
;
903 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
904 for (si
= 0; si
< n
; ++si
)
905 stack_vars_sorted
[si
] = si
;
910 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
912 for (si
= 0; si
< n
; ++si
)
914 size_t i
= stack_vars_sorted
[si
];
915 unsigned int ialign
= stack_vars
[i
].alignb
;
916 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
918 /* Ignore objects that aren't partition representatives. If we
919 see a var that is not a partition representative, it must
920 have been merged earlier. */
921 if (stack_vars
[i
].representative
!= i
)
924 for (sj
= si
+ 1; sj
< n
; ++sj
)
926 size_t j
= stack_vars_sorted
[sj
];
927 unsigned int jalign
= stack_vars
[j
].alignb
;
928 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
930 /* Ignore objects that aren't partition representatives. */
931 if (stack_vars
[j
].representative
!= j
)
934 /* Do not mix objects of "small" (supported) alignment
935 and "large" (unsupported) alignment. */
936 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
937 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
940 /* For Address Sanitizer do not mix objects with different
941 sizes, as the shorter vars wouldn't be adequately protected.
942 Don't do that for "large" (unsupported) alignment objects,
943 those aren't protected anyway. */
944 if (asan_sanitize_stack_p () && isize
!= jsize
945 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
948 /* Ignore conflicting objects. */
949 if (stack_var_conflict_p (i
, j
))
952 /* UNION the objects, placing J at OFFSET. */
953 union_stack_vars (i
, j
);
957 update_alias_info_with_stack_vars ();
960 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
963 dump_stack_var_partition (void)
965 size_t si
, i
, j
, n
= stack_vars_num
;
967 for (si
= 0; si
< n
; ++si
)
969 i
= stack_vars_sorted
[si
];
971 /* Skip variables that aren't partition representatives, for now. */
972 if (stack_vars
[i
].representative
!= i
)
975 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
976 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
977 stack_vars
[i
].alignb
);
979 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
981 fputc ('\t', dump_file
);
982 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
984 fputc ('\n', dump_file
);
988 /* Assign rtl to DECL at BASE + OFFSET. */
991 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
992 HOST_WIDE_INT offset
)
997 /* If this fails, we've overflowed the stack frame. Error nicely? */
998 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
1000 x
= plus_constant (Pmode
, base
, offset
);
1001 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
1002 ? TYPE_MODE (TREE_TYPE (decl
))
1003 : DECL_MODE (SSAVAR (decl
)), x
);
1005 if (TREE_CODE (decl
) != SSA_NAME
)
1007 /* Set alignment we actually gave this decl if it isn't an SSA name.
1008 If it is we generate stack slots only accidentally so it isn't as
1009 important, we'll simply use the alignment that is already set. */
1010 if (base
== virtual_stack_vars_rtx
)
1011 offset
-= frame_phase
;
1012 align
= least_bit_hwi (offset
);
1013 align
*= BITS_PER_UNIT
;
1014 if (align
== 0 || align
> base_align
)
1017 /* One would think that we could assert that we're not decreasing
1018 alignment here, but (at least) the i386 port does exactly this
1019 via the MINIMUM_ALIGNMENT hook. */
1021 SET_DECL_ALIGN (decl
, align
);
1022 DECL_USER_ALIGN (decl
) = 0;
1028 struct stack_vars_data
1030 /* Vector of offset pairs, always end of some padding followed
1031 by start of the padding that needs Address Sanitizer protection.
1032 The vector is in reversed, highest offset pairs come first. */
1033 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1035 /* Vector of partition representative decls in between the paddings. */
1036 auto_vec
<tree
> asan_decl_vec
;
1038 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1041 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1042 unsigned int asan_alignb
;
1045 /* A subroutine of expand_used_vars. Give each partition representative
1046 a unique location within the stack frame. Update each partition member
1047 with that location. */
1050 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
1052 size_t si
, i
, j
, n
= stack_vars_num
;
1053 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
1054 rtx large_base
= NULL
;
1055 unsigned large_align
= 0;
1056 bool large_allocation_done
= false;
1059 /* Determine if there are any variables requiring "large" alignment.
1060 Since these are dynamically allocated, we only process these if
1061 no predicate involved. */
1062 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1063 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1065 /* Find the total size of these variables. */
1066 for (si
= 0; si
< n
; ++si
)
1070 i
= stack_vars_sorted
[si
];
1071 alignb
= stack_vars
[i
].alignb
;
1073 /* All "large" alignment decls come before all "small" alignment
1074 decls, but "large" alignment decls are not sorted based on
1075 their alignment. Increase large_align to track the largest
1076 required alignment. */
1077 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1078 large_align
= alignb
* BITS_PER_UNIT
;
1080 /* Stop when we get to the first decl with "small" alignment. */
1081 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1084 /* Skip variables that aren't partition representatives. */
1085 if (stack_vars
[i
].representative
!= i
)
1088 /* Skip variables that have already had rtl assigned. See also
1089 add_stack_var where we perpetrate this pc_rtx hack. */
1090 decl
= stack_vars
[i
].decl
;
1091 if (TREE_CODE (decl
) == SSA_NAME
1092 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1093 : DECL_RTL (decl
) != pc_rtx
)
1096 large_size
+= alignb
- 1;
1097 large_size
&= -(HOST_WIDE_INT
)alignb
;
1098 large_size
+= stack_vars
[i
].size
;
1102 for (si
= 0; si
< n
; ++si
)
1105 unsigned base_align
, alignb
;
1106 HOST_WIDE_INT offset
;
1108 i
= stack_vars_sorted
[si
];
1110 /* Skip variables that aren't partition representatives, for now. */
1111 if (stack_vars
[i
].representative
!= i
)
1114 /* Skip variables that have already had rtl assigned. See also
1115 add_stack_var where we perpetrate this pc_rtx hack. */
1116 decl
= stack_vars
[i
].decl
;
1117 if (TREE_CODE (decl
) == SSA_NAME
1118 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1119 : DECL_RTL (decl
) != pc_rtx
)
1122 /* Check the predicate to see whether this variable should be
1123 allocated in this pass. */
1124 if (pred
&& !pred (i
))
1127 alignb
= stack_vars
[i
].alignb
;
1128 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1130 base
= virtual_stack_vars_rtx
;
1131 if (asan_sanitize_stack_p () && pred
)
1133 HOST_WIDE_INT prev_offset
1134 = align_base (frame_offset
,
1135 MAX (alignb
, ASAN_RED_ZONE_SIZE
),
1136 !FRAME_GROWS_DOWNWARD
);
1137 tree repr_decl
= NULL_TREE
;
1139 = alloc_stack_frame_space (stack_vars
[i
].size
1140 + ASAN_RED_ZONE_SIZE
,
1141 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
1143 data
->asan_vec
.safe_push (prev_offset
);
1144 data
->asan_vec
.safe_push (offset
+ stack_vars
[i
].size
);
1145 /* Find best representative of the partition.
1146 Prefer those with DECL_NAME, even better
1147 satisfying asan_protect_stack_decl predicate. */
1148 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1149 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1150 && DECL_NAME (stack_vars
[j
].decl
))
1152 repr_decl
= stack_vars
[j
].decl
;
1155 else if (repr_decl
== NULL_TREE
1156 && DECL_P (stack_vars
[j
].decl
)
1157 && DECL_NAME (stack_vars
[j
].decl
))
1158 repr_decl
= stack_vars
[j
].decl
;
1159 if (repr_decl
== NULL_TREE
)
1160 repr_decl
= stack_vars
[i
].decl
;
1161 data
->asan_decl_vec
.safe_push (repr_decl
);
1162 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1163 if (data
->asan_base
== NULL
)
1164 data
->asan_base
= gen_reg_rtx (Pmode
);
1165 base
= data
->asan_base
;
1167 if (!STRICT_ALIGNMENT
)
1168 base_align
= crtl
->max_used_stack_slot_alignment
;
1170 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1171 GET_MODE_ALIGNMENT (SImode
)
1172 << ASAN_SHADOW_SHIFT
);
1176 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1177 base_align
= crtl
->max_used_stack_slot_alignment
;
1182 /* Large alignment is only processed in the last pass. */
1186 /* If there were any variables requiring "large" alignment, allocate
1188 if (large_size
> 0 && ! large_allocation_done
)
1190 HOST_WIDE_INT loffset
;
1191 rtx large_allocsize
;
1193 large_allocsize
= GEN_INT (large_size
);
1194 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1195 loffset
= alloc_stack_frame_space
1196 (INTVAL (large_allocsize
),
1197 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1198 large_base
= get_dynamic_stack_base (loffset
, large_align
);
1199 large_allocation_done
= true;
1201 gcc_assert (large_base
!= NULL
);
1203 large_alloc
+= alignb
- 1;
1204 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
1205 offset
= large_alloc
;
1206 large_alloc
+= stack_vars
[i
].size
;
1209 base_align
= large_align
;
1212 /* Create rtl for each variable based on their location within the
1214 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1216 expand_one_stack_var_at (stack_vars
[j
].decl
,
1222 gcc_assert (large_alloc
== large_size
);
1225 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1226 static HOST_WIDE_INT
1227 account_stack_vars (void)
1229 size_t si
, j
, i
, n
= stack_vars_num
;
1230 HOST_WIDE_INT size
= 0;
1232 for (si
= 0; si
< n
; ++si
)
1234 i
= stack_vars_sorted
[si
];
1236 /* Skip variables that aren't partition representatives, for now. */
1237 if (stack_vars
[i
].representative
!= i
)
1240 size
+= stack_vars
[i
].size
;
1241 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1242 set_rtl (stack_vars
[j
].decl
, NULL
);
1247 /* Record the RTL assignment X for the default def of PARM. */
1250 set_parm_rtl (tree parm
, rtx x
)
1252 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1253 || TREE_CODE (parm
) == RESULT_DECL
);
1255 if (x
&& !MEM_P (x
))
1257 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1258 TYPE_MODE (TREE_TYPE (parm
)),
1259 TYPE_ALIGN (TREE_TYPE (parm
)));
1261 /* If the variable alignment is very large we'll dynamicaly
1262 allocate it, which means that in-frame portion is just a
1263 pointer. ??? We've got a pseudo for sure here, do we
1264 actually dynamically allocate its spilling area if needed?
1265 ??? Isn't it a problem when POINTER_SIZE also exceeds
1266 MAX_SUPPORTED_STACK_ALIGNMENT, as on cris and lm32? */
1267 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1268 align
= POINTER_SIZE
;
1270 record_alignment_for_reg_var (align
);
1273 tree ssa
= ssa_default_def (cfun
, parm
);
1275 return set_rtl (parm
, x
);
1277 int part
= var_to_partition (SA
.map
, ssa
);
1278 gcc_assert (part
!= NO_PARTITION
);
1280 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1281 gcc_assert (changed
);
1284 gcc_assert (DECL_RTL (parm
) == x
);
1287 /* A subroutine of expand_one_var. Called to immediately assign rtl
1288 to a variable to be allocated in the stack frame. */
1291 expand_one_stack_var_1 (tree var
)
1293 HOST_WIDE_INT size
, offset
;
1294 unsigned byte_align
;
1296 if (TREE_CODE (var
) == SSA_NAME
)
1298 tree type
= TREE_TYPE (var
);
1299 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1300 byte_align
= TYPE_ALIGN_UNIT (type
);
1304 size
= tree_to_uhwi (DECL_SIZE_UNIT (var
));
1305 byte_align
= align_local_variable (var
);
1308 /* We handle highly aligned variables in expand_stack_vars. */
1309 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1311 offset
= alloc_stack_frame_space (size
, byte_align
);
1313 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1314 crtl
->max_used_stack_slot_alignment
, offset
);
1317 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1318 already assigned some MEM. */
1321 expand_one_stack_var (tree var
)
1323 if (TREE_CODE (var
) == SSA_NAME
)
1325 int part
= var_to_partition (SA
.map
, var
);
1326 if (part
!= NO_PARTITION
)
1328 rtx x
= SA
.partition_to_pseudo
[part
];
1330 gcc_assert (MEM_P (x
));
1335 return expand_one_stack_var_1 (var
);
1338 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1339 that will reside in a hard register. */
1342 expand_one_hard_reg_var (tree var
)
1344 rest_of_decl_compilation (var
, 0, 0);
1347 /* Record the alignment requirements of some variable assigned to a
1351 record_alignment_for_reg_var (unsigned int align
)
1353 if (SUPPORTS_STACK_ALIGNMENT
1354 && crtl
->stack_alignment_estimated
< align
)
1356 /* stack_alignment_estimated shouldn't change after stack
1357 realign decision made */
1358 gcc_assert (!crtl
->stack_realign_processed
);
1359 crtl
->stack_alignment_estimated
= align
;
1362 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1363 So here we only make sure stack_alignment_needed >= align. */
1364 if (crtl
->stack_alignment_needed
< align
)
1365 crtl
->stack_alignment_needed
= align
;
1366 if (crtl
->max_used_stack_slot_alignment
< align
)
1367 crtl
->max_used_stack_slot_alignment
= align
;
1370 /* Create RTL for an SSA partition. */
1373 expand_one_ssa_partition (tree var
)
1375 int part
= var_to_partition (SA
.map
, var
);
1376 gcc_assert (part
!= NO_PARTITION
);
1378 if (SA
.partition_to_pseudo
[part
])
1381 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1382 TYPE_MODE (TREE_TYPE (var
)),
1383 TYPE_ALIGN (TREE_TYPE (var
)));
1385 /* If the variable alignment is very large we'll dynamicaly allocate
1386 it, which means that in-frame portion is just a pointer. */
1387 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1388 align
= POINTER_SIZE
;
1390 record_alignment_for_reg_var (align
);
1392 if (!use_register_for_decl (var
))
1394 if (defer_stack_allocation (var
, true))
1395 add_stack_var (var
);
1397 expand_one_stack_var_1 (var
);
1401 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1403 rtx x
= gen_reg_rtx (reg_mode
);
1408 /* Record the association between the RTL generated for partition PART
1409 and the underlying variable of the SSA_NAME VAR. */
1412 adjust_one_expanded_partition_var (tree var
)
1417 tree decl
= SSA_NAME_VAR (var
);
1419 int part
= var_to_partition (SA
.map
, var
);
1420 if (part
== NO_PARTITION
)
1423 rtx x
= SA
.partition_to_pseudo
[part
];
1432 /* Note if the object is a user variable. */
1433 if (decl
&& !DECL_ARTIFICIAL (decl
))
1436 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1437 mark_reg_pointer (x
, get_pointer_alignment (var
));
1440 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1441 that will reside in a pseudo register. */
1444 expand_one_register_var (tree var
)
1446 if (TREE_CODE (var
) == SSA_NAME
)
1448 int part
= var_to_partition (SA
.map
, var
);
1449 if (part
!= NO_PARTITION
)
1451 rtx x
= SA
.partition_to_pseudo
[part
];
1453 gcc_assert (REG_P (x
));
1460 tree type
= TREE_TYPE (decl
);
1461 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1462 rtx x
= gen_reg_rtx (reg_mode
);
1466 /* Note if the object is a user variable. */
1467 if (!DECL_ARTIFICIAL (decl
))
1470 if (POINTER_TYPE_P (type
))
1471 mark_reg_pointer (x
, get_pointer_alignment (var
));
1474 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1475 has some associated error, e.g. its type is error-mark. We just need
1476 to pick something that won't crash the rest of the compiler. */
1479 expand_one_error_var (tree var
)
1481 machine_mode mode
= DECL_MODE (var
);
1484 if (mode
== BLKmode
)
1485 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1486 else if (mode
== VOIDmode
)
1489 x
= gen_reg_rtx (mode
);
1491 SET_DECL_RTL (var
, x
);
1494 /* A subroutine of expand_one_var. VAR is a variable that will be
1495 allocated to the local stack frame. Return true if we wish to
1496 add VAR to STACK_VARS so that it will be coalesced with other
1497 variables. Return false to allocate VAR immediately.
1499 This function is used to reduce the number of variables considered
1500 for coalescing, which reduces the size of the quadratic problem. */
1503 defer_stack_allocation (tree var
, bool toplevel
)
1505 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1506 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1507 : DECL_SIZE_UNIT (var
);
1509 /* Whether the variable is small enough for immediate allocation not to be
1510 a problem with regard to the frame size. */
1512 = ((HOST_WIDE_INT
) tree_to_uhwi (size_unit
)
1513 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
));
1515 /* If stack protection is enabled, *all* stack variables must be deferred,
1516 so that we can re-order the strings to the top of the frame.
1517 Similarly for Address Sanitizer. */
1518 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1521 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1522 ? TYPE_ALIGN (TREE_TYPE (var
))
1525 /* We handle "large" alignment via dynamic allocation. We want to handle
1526 this extra complication in only one place, so defer them. */
1527 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1530 bool ignored
= TREE_CODE (var
) == SSA_NAME
1531 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1532 : DECL_IGNORED_P (var
);
1534 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1535 might be detached from their block and appear at toplevel when we reach
1536 here. We want to coalesce them with variables from other blocks when
1537 the immediate contribution to the frame size would be noticeable. */
1538 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1541 /* Variables declared in the outermost scope automatically conflict
1542 with every other variable. The only reason to want to defer them
1543 at all is that, after sorting, we can more efficiently pack
1544 small variables in the stack frame. Continue to defer at -O2. */
1545 if (toplevel
&& optimize
< 2)
1548 /* Without optimization, *most* variables are allocated from the
1549 stack, which makes the quadratic problem large exactly when we
1550 want compilation to proceed as quickly as possible. On the
1551 other hand, we don't want the function's stack frame size to
1552 get completely out of hand. So we avoid adding scalars and
1553 "small" aggregates to the list at all. */
1554 if (optimize
== 0 && smallish
)
1560 /* A subroutine of expand_used_vars. Expand one variable according to
1561 its flavor. Variables to be placed on the stack are not actually
1562 expanded yet, merely recorded.
1563 When REALLY_EXPAND is false, only add stack values to be allocated.
1564 Return stack usage this variable is supposed to take.
1567 static HOST_WIDE_INT
1568 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1570 unsigned int align
= BITS_PER_UNIT
;
1575 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1577 if (is_global_var (var
))
1580 /* Because we don't know if VAR will be in register or on stack,
1581 we conservatively assume it will be on stack even if VAR is
1582 eventually put into register after RA pass. For non-automatic
1583 variables, which won't be on stack, we collect alignment of
1584 type and ignore user specified alignment. Similarly for
1585 SSA_NAMEs for which use_register_for_decl returns true. */
1586 if (TREE_STATIC (var
)
1587 || DECL_EXTERNAL (var
)
1588 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1589 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1590 TYPE_MODE (TREE_TYPE (var
)),
1591 TYPE_ALIGN (TREE_TYPE (var
)));
1592 else if (DECL_HAS_VALUE_EXPR_P (var
)
1593 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1594 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1595 or variables which were assigned a stack slot already by
1596 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1597 changed from the offset chosen to it. */
1598 align
= crtl
->stack_alignment_estimated
;
1600 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1602 /* If the variable alignment is very large we'll dynamicaly allocate
1603 it, which means that in-frame portion is just a pointer. */
1604 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1605 align
= POINTER_SIZE
;
1608 record_alignment_for_reg_var (align
);
1610 if (TREE_CODE (origvar
) == SSA_NAME
)
1612 gcc_assert (!VAR_P (var
)
1613 || (!DECL_EXTERNAL (var
)
1614 && !DECL_HAS_VALUE_EXPR_P (var
)
1615 && !TREE_STATIC (var
)
1616 && TREE_TYPE (var
) != error_mark_node
1617 && !DECL_HARD_REGISTER (var
)
1620 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1622 else if (DECL_EXTERNAL (var
))
1624 else if (DECL_HAS_VALUE_EXPR_P (var
))
1626 else if (TREE_STATIC (var
))
1628 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1630 else if (TREE_TYPE (var
) == error_mark_node
)
1633 expand_one_error_var (var
);
1635 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1639 expand_one_hard_reg_var (var
);
1640 if (!DECL_HARD_REGISTER (var
))
1641 /* Invalid register specification. */
1642 expand_one_error_var (var
);
1645 else if (use_register_for_decl (var
))
1648 expand_one_register_var (origvar
);
1650 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1652 /* Reject variables which cover more than half of the address-space. */
1655 error ("size of variable %q+D is too large", var
);
1656 expand_one_error_var (var
);
1659 else if (defer_stack_allocation (var
, toplevel
))
1660 add_stack_var (origvar
);
1665 if (lookup_attribute ("naked",
1666 DECL_ATTRIBUTES (current_function_decl
)))
1667 error ("cannot allocate stack for variable %q+D, naked function.",
1670 expand_one_stack_var (origvar
);
1674 return tree_to_uhwi (DECL_SIZE_UNIT (var
));
1679 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1680 expanding variables. Those variables that can be put into registers
1681 are allocated pseudos; those that can't are put on the stack.
1683 TOPLEVEL is true if this is the outermost BLOCK. */
1686 expand_used_vars_for_block (tree block
, bool toplevel
)
1690 /* Expand all variables at this level. */
1691 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1693 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1694 || !DECL_NONSHAREABLE (t
)))
1695 expand_one_var (t
, toplevel
, true);
1697 /* Expand all variables at containing levels. */
1698 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1699 expand_used_vars_for_block (t
, false);
1702 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1703 and clear TREE_USED on all local variables. */
1706 clear_tree_used (tree block
)
1710 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1711 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1712 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1713 || !DECL_NONSHAREABLE (t
))
1716 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1717 clear_tree_used (t
);
1721 SPCT_FLAG_DEFAULT
= 1,
1723 SPCT_FLAG_STRONG
= 3,
1724 SPCT_FLAG_EXPLICIT
= 4
1727 /* Examine TYPE and determine a bit mask of the following features. */
1729 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1730 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1731 #define SPCT_HAS_ARRAY 4
1732 #define SPCT_HAS_AGGREGATE 8
1735 stack_protect_classify_type (tree type
)
1737 unsigned int ret
= 0;
1740 switch (TREE_CODE (type
))
1743 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1744 if (t
== char_type_node
1745 || t
== signed_char_type_node
1746 || t
== unsigned_char_type_node
)
1748 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1749 unsigned HOST_WIDE_INT len
;
1751 if (!TYPE_SIZE_UNIT (type
)
1752 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1755 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1758 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1760 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1763 ret
= SPCT_HAS_ARRAY
;
1767 case QUAL_UNION_TYPE
:
1769 ret
= SPCT_HAS_AGGREGATE
;
1770 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1771 if (TREE_CODE (t
) == FIELD_DECL
)
1772 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1782 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1783 part of the local stack frame. Remember if we ever return nonzero for
1784 any variable in this function. The return value is the phase number in
1785 which the variable should be allocated. */
1788 stack_protect_decl_phase (tree decl
)
1790 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1793 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1794 has_short_buffer
= true;
1796 if (flag_stack_protect
== SPCT_FLAG_ALL
1797 || flag_stack_protect
== SPCT_FLAG_STRONG
1798 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1799 && lookup_attribute ("stack_protect",
1800 DECL_ATTRIBUTES (current_function_decl
))))
1802 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1803 && !(bits
& SPCT_HAS_AGGREGATE
))
1805 else if (bits
& SPCT_HAS_ARRAY
)
1809 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1812 has_protected_decls
= true;
1817 /* Two helper routines that check for phase 1 and phase 2. These are used
1818 as callbacks for expand_stack_vars. */
1821 stack_protect_decl_phase_1 (size_t i
)
1823 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1827 stack_protect_decl_phase_2 (size_t i
)
1829 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1832 /* And helper function that checks for asan phase (with stack protector
1833 it is phase 3). This is used as callback for expand_stack_vars.
1834 Returns true if any of the vars in the partition need to be protected. */
1837 asan_decl_phase_3 (size_t i
)
1841 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1843 i
= stack_vars
[i
].next
;
1848 /* Ensure that variables in different stack protection phases conflict
1849 so that they are not merged and share the same stack slot. */
1852 add_stack_protection_conflicts (void)
1854 size_t i
, j
, n
= stack_vars_num
;
1855 unsigned char *phase
;
1857 phase
= XNEWVEC (unsigned char, n
);
1858 for (i
= 0; i
< n
; ++i
)
1859 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1861 for (i
= 0; i
< n
; ++i
)
1863 unsigned char ph_i
= phase
[i
];
1864 for (j
= i
+ 1; j
< n
; ++j
)
1865 if (ph_i
!= phase
[j
])
1866 add_stack_var_conflict (i
, j
);
1872 /* Create a decl for the guard at the top of the stack frame. */
1875 create_stack_guard (void)
1877 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1878 VAR_DECL
, NULL
, ptr_type_node
);
1879 TREE_THIS_VOLATILE (guard
) = 1;
1880 TREE_USED (guard
) = 1;
1881 expand_one_stack_var (guard
);
1882 crtl
->stack_protect_guard
= guard
;
1885 /* Prepare for expanding variables. */
1887 init_vars_expansion (void)
1889 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1890 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1892 /* A map from decl to stack partition. */
1893 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1895 /* Initialize local stack smashing state. */
1896 has_protected_decls
= false;
1897 has_short_buffer
= false;
1900 /* Free up stack variable graph data. */
1902 fini_vars_expansion (void)
1904 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1906 XDELETEVEC (stack_vars
);
1907 if (stack_vars_sorted
)
1908 XDELETEVEC (stack_vars_sorted
);
1910 stack_vars_sorted
= NULL
;
1911 stack_vars_alloc
= stack_vars_num
= 0;
1912 delete decl_to_stack_part
;
1913 decl_to_stack_part
= NULL
;
1916 /* Make a fair guess for the size of the stack frame of the function
1917 in NODE. This doesn't have to be exact, the result is only used in
1918 the inline heuristics. So we don't want to run the full stack var
1919 packing algorithm (which is quadratic in the number of stack vars).
1920 Instead, we calculate the total size of all stack vars. This turns
1921 out to be a pretty fair estimate -- packing of stack vars doesn't
1922 happen very often. */
1925 estimated_stack_frame_size (struct cgraph_node
*node
)
1927 HOST_WIDE_INT size
= 0;
1930 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1934 init_vars_expansion ();
1936 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1937 if (auto_var_in_fn_p (var
, fn
->decl
))
1938 size
+= expand_one_var (var
, true, false);
1940 if (stack_vars_num
> 0)
1942 /* Fake sorting the stack vars for account_stack_vars (). */
1943 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1944 for (i
= 0; i
< stack_vars_num
; ++i
)
1945 stack_vars_sorted
[i
] = i
;
1946 size
+= account_stack_vars ();
1949 fini_vars_expansion ();
1954 /* Helper routine to check if a record or union contains an array field. */
1957 record_or_union_type_has_array_p (const_tree tree_type
)
1959 tree fields
= TYPE_FIELDS (tree_type
);
1962 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1963 if (TREE_CODE (f
) == FIELD_DECL
)
1965 tree field_type
= TREE_TYPE (f
);
1966 if (RECORD_OR_UNION_TYPE_P (field_type
)
1967 && record_or_union_type_has_array_p (field_type
))
1969 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1975 /* Check if the current function has local referenced variables that
1976 have their addresses taken, contain an array, or are arrays. */
1979 stack_protect_decl_p ()
1984 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1985 if (!is_global_var (var
))
1987 tree var_type
= TREE_TYPE (var
);
1989 && (TREE_CODE (var_type
) == ARRAY_TYPE
1990 || TREE_ADDRESSABLE (var
)
1991 || (RECORD_OR_UNION_TYPE_P (var_type
)
1992 && record_or_union_type_has_array_p (var_type
))))
1998 /* Check if the current function has calls that use a return slot. */
2001 stack_protect_return_slot_p ()
2005 FOR_ALL_BB_FN (bb
, cfun
)
2006 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2007 !gsi_end_p (gsi
); gsi_next (&gsi
))
2009 gimple
*stmt
= gsi_stmt (gsi
);
2010 /* This assumes that calls to internal-only functions never
2011 use a return slot. */
2012 if (is_gimple_call (stmt
)
2013 && !gimple_call_internal_p (stmt
)
2014 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2015 gimple_call_fndecl (stmt
)))
2021 /* Expand all variables used in the function. */
2024 expand_used_vars (void)
2026 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2027 auto_vec
<tree
> maybe_local_decls
;
2028 rtx_insn
*var_end_seq
= NULL
;
2031 bool gen_stack_protect_signal
= false;
2033 /* Compute the phase of the stack frame for this function. */
2035 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2036 int off
= STARTING_FRAME_OFFSET
% align
;
2037 frame_phase
= off
? align
- off
: 0;
2040 /* Set TREE_USED on all variables in the local_decls. */
2041 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2042 TREE_USED (var
) = 1;
2043 /* Clear TREE_USED on all variables associated with a block scope. */
2044 clear_tree_used (DECL_INITIAL (current_function_decl
));
2046 init_vars_expansion ();
2048 if (targetm
.use_pseudo_pic_reg ())
2049 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2051 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2053 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2056 tree var
= partition_to_var (SA
.map
, i
);
2058 gcc_assert (!virtual_operand_p (var
));
2060 expand_one_ssa_partition (var
);
2063 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2064 gen_stack_protect_signal
2065 = stack_protect_decl_p () || stack_protect_return_slot_p ();
2067 /* At this point all variables on the local_decls with TREE_USED
2068 set are not associated with any block scope. Lay them out. */
2070 len
= vec_safe_length (cfun
->local_decls
);
2071 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2073 bool expand_now
= false;
2075 /* Expanded above already. */
2076 if (is_gimple_reg (var
))
2078 TREE_USED (var
) = 0;
2081 /* We didn't set a block for static or extern because it's hard
2082 to tell the difference between a global variable (re)declared
2083 in a local scope, and one that's really declared there to
2084 begin with. And it doesn't really matter much, since we're
2085 not giving them stack space. Expand them now. */
2086 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2089 /* Expand variables not associated with any block now. Those created by
2090 the optimizers could be live anywhere in the function. Those that
2091 could possibly have been scoped originally and detached from their
2092 block will have their allocation deferred so we coalesce them with
2093 others when optimization is enabled. */
2094 else if (TREE_USED (var
))
2097 /* Finally, mark all variables on the list as used. We'll use
2098 this in a moment when we expand those associated with scopes. */
2099 TREE_USED (var
) = 1;
2102 expand_one_var (var
, true, true);
2105 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2107 rtx rtl
= DECL_RTL_IF_SET (var
);
2109 /* Keep artificial non-ignored vars in cfun->local_decls
2110 chain until instantiate_decls. */
2111 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2112 add_local_decl (cfun
, var
);
2113 else if (rtl
== NULL_RTX
)
2114 /* If rtl isn't set yet, which can happen e.g. with
2115 -fstack-protector, retry before returning from this
2117 maybe_local_decls
.safe_push (var
);
2121 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2123 +-----------------+-----------------+
2124 | ...processed... | ...duplicates...|
2125 +-----------------+-----------------+
2127 +-- LEN points here.
2129 We just want the duplicates, as those are the artificial
2130 non-ignored vars that we want to keep until instantiate_decls.
2131 Move them down and truncate the array. */
2132 if (!vec_safe_is_empty (cfun
->local_decls
))
2133 cfun
->local_decls
->block_remove (0, len
);
2135 /* At this point, all variables within the block tree with TREE_USED
2136 set are actually used by the optimized function. Lay them out. */
2137 expand_used_vars_for_block (outer_block
, true);
2139 if (stack_vars_num
> 0)
2141 add_scope_conflicts ();
2143 /* If stack protection is enabled, we don't share space between
2144 vulnerable data and non-vulnerable data. */
2145 if (flag_stack_protect
!= 0
2146 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2147 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2148 && lookup_attribute ("stack_protect",
2149 DECL_ATTRIBUTES (current_function_decl
)))))
2150 add_stack_protection_conflicts ();
2152 /* Now that we have collected all stack variables, and have computed a
2153 minimal interference graph, attempt to save some stack space. */
2154 partition_stack_vars ();
2156 dump_stack_var_partition ();
2159 switch (flag_stack_protect
)
2162 create_stack_guard ();
2165 case SPCT_FLAG_STRONG
:
2166 if (gen_stack_protect_signal
2167 || cfun
->calls_alloca
|| has_protected_decls
2168 || lookup_attribute ("stack_protect",
2169 DECL_ATTRIBUTES (current_function_decl
)))
2170 create_stack_guard ();
2173 case SPCT_FLAG_DEFAULT
:
2174 if (cfun
->calls_alloca
|| has_protected_decls
2175 || lookup_attribute ("stack_protect",
2176 DECL_ATTRIBUTES (current_function_decl
)))
2177 create_stack_guard ();
2180 case SPCT_FLAG_EXPLICIT
:
2181 if (lookup_attribute ("stack_protect",
2182 DECL_ATTRIBUTES (current_function_decl
)))
2183 create_stack_guard ();
2189 /* Assign rtl to each variable based on these partitions. */
2190 if (stack_vars_num
> 0)
2192 struct stack_vars_data data
;
2194 data
.asan_base
= NULL_RTX
;
2195 data
.asan_alignb
= 0;
2197 /* Reorder decls to be protected by iterating over the variables
2198 array multiple times, and allocating out of each phase in turn. */
2199 /* ??? We could probably integrate this into the qsort we did
2200 earlier, such that we naturally see these variables first,
2201 and thus naturally allocate things in the right order. */
2202 if (has_protected_decls
)
2204 /* Phase 1 contains only character arrays. */
2205 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2207 /* Phase 2 contains other kinds of arrays. */
2208 if (flag_stack_protect
== SPCT_FLAG_ALL
2209 || flag_stack_protect
== SPCT_FLAG_STRONG
2210 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2211 && lookup_attribute ("stack_protect",
2212 DECL_ATTRIBUTES (current_function_decl
))))
2213 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2216 if (asan_sanitize_stack_p ())
2217 /* Phase 3, any partitions that need asan protection
2218 in addition to phase 1 and 2. */
2219 expand_stack_vars (asan_decl_phase_3
, &data
);
2221 if (!data
.asan_vec
.is_empty ())
2223 HOST_WIDE_INT prev_offset
= frame_offset
;
2224 HOST_WIDE_INT offset
, sz
, redzonesz
;
2225 redzonesz
= ASAN_RED_ZONE_SIZE
;
2226 sz
= data
.asan_vec
[0] - prev_offset
;
2227 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2228 && data
.asan_alignb
<= 4096
2229 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2230 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2231 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2233 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
2234 data
.asan_vec
.safe_push (prev_offset
);
2235 data
.asan_vec
.safe_push (offset
);
2236 /* Leave space for alignment if STRICT_ALIGNMENT. */
2237 if (STRICT_ALIGNMENT
)
2238 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2239 << ASAN_SHADOW_SHIFT
)
2240 / BITS_PER_UNIT
, 1);
2243 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2246 data
.asan_vec
.address (),
2247 data
.asan_decl_vec
.address (),
2248 data
.asan_vec
.length ());
2251 expand_stack_vars (NULL
, &data
);
2254 fini_vars_expansion ();
2256 /* If there were any artificial non-ignored vars without rtl
2257 found earlier, see if deferred stack allocation hasn't assigned
2259 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2261 rtx rtl
= DECL_RTL_IF_SET (var
);
2263 /* Keep artificial non-ignored vars in cfun->local_decls
2264 chain until instantiate_decls. */
2265 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2266 add_local_decl (cfun
, var
);
2269 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2270 if (STACK_ALIGNMENT_NEEDED
)
2272 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2273 if (!FRAME_GROWS_DOWNWARD
)
2274 frame_offset
+= align
- 1;
2275 frame_offset
&= -align
;
2282 /* If we need to produce a detailed dump, print the tree representation
2283 for STMT to the dump file. SINCE is the last RTX after which the RTL
2284 generated for STMT should have been appended. */
2287 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2289 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2291 fprintf (dump_file
, "\n;; ");
2292 print_gimple_stmt (dump_file
, stmt
, 0,
2293 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2294 fprintf (dump_file
, "\n");
2296 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2300 /* Maps the blocks that do not contain tree labels to rtx labels. */
2302 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2304 /* Returns the label_rtx expression for a label starting basic block BB. */
2306 static rtx_code_label
*
2307 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2309 gimple_stmt_iterator gsi
;
2312 if (bb
->flags
& BB_RTL
)
2313 return block_label (bb
);
2315 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2319 /* Find the tree label if it is present. */
2321 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2325 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2329 lab
= gimple_label_label (lab_stmt
);
2330 if (DECL_NONLOCAL (lab
))
2333 return jump_target_rtx (lab
);
2336 rtx_code_label
*l
= gen_label_rtx ();
2337 lab_rtx_for_bb
->put (bb
, l
);
2342 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2343 of a basic block where we just expanded the conditional at the end,
2344 possibly clean up the CFG and instruction sequence. LAST is the
2345 last instruction before the just emitted jump sequence. */
2348 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2350 /* Special case: when jumpif decides that the condition is
2351 trivial it emits an unconditional jump (and the necessary
2352 barrier). But we still have two edges, the fallthru one is
2353 wrong. purge_dead_edges would clean this up later. Unfortunately
2354 we have to insert insns (and split edges) before
2355 find_many_sub_basic_blocks and hence before purge_dead_edges.
2356 But splitting edges might create new blocks which depend on the
2357 fact that if there are two edges there's no barrier. So the
2358 barrier would get lost and verify_flow_info would ICE. Instead
2359 of auditing all edge splitters to care for the barrier (which
2360 normally isn't there in a cleaned CFG), fix it here. */
2361 if (BARRIER_P (get_last_insn ()))
2365 /* Now, we have a single successor block, if we have insns to
2366 insert on the remaining edge we potentially will insert
2367 it at the end of this block (if the dest block isn't feasible)
2368 in order to avoid splitting the edge. This insertion will take
2369 place in front of the last jump. But we might have emitted
2370 multiple jumps (conditional and one unconditional) to the
2371 same destination. Inserting in front of the last one then
2372 is a problem. See PR 40021. We fix this by deleting all
2373 jumps except the last unconditional one. */
2374 insn
= PREV_INSN (get_last_insn ());
2375 /* Make sure we have an unconditional jump. Otherwise we're
2377 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2378 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2380 insn
= PREV_INSN (insn
);
2381 if (JUMP_P (NEXT_INSN (insn
)))
2383 if (!any_condjump_p (NEXT_INSN (insn
)))
2385 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2386 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2388 delete_insn (NEXT_INSN (insn
));
2394 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2395 Returns a new basic block if we've terminated the current basic
2396 block and created a new one. */
2399 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2401 basic_block new_bb
, dest
;
2405 rtx_insn
*last2
, *last
;
2406 enum tree_code code
;
2409 code
= gimple_cond_code (stmt
);
2410 op0
= gimple_cond_lhs (stmt
);
2411 op1
= gimple_cond_rhs (stmt
);
2412 /* We're sometimes presented with such code:
2416 This would expand to two comparisons which then later might
2417 be cleaned up by combine. But some pattern matchers like if-conversion
2418 work better when there's only one compare, so make up for this
2419 here as special exception if TER would have made the same change. */
2421 && TREE_CODE (op0
) == SSA_NAME
2422 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2423 && TREE_CODE (op1
) == INTEGER_CST
2424 && ((gimple_cond_code (stmt
) == NE_EXPR
2425 && integer_zerop (op1
))
2426 || (gimple_cond_code (stmt
) == EQ_EXPR
2427 && integer_onep (op1
)))
2428 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2430 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2431 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2433 enum tree_code code2
= gimple_assign_rhs_code (second
);
2434 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2437 op0
= gimple_assign_rhs1 (second
);
2438 op1
= gimple_assign_rhs2 (second
);
2440 /* If jumps are cheap and the target does not support conditional
2441 compare, turn some more codes into jumpy sequences. */
2442 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2443 && targetm
.gen_ccmp_first
== NULL
)
2445 if ((code2
== BIT_AND_EXPR
2446 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2447 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2448 || code2
== TRUTH_AND_EXPR
)
2450 code
= TRUTH_ANDIF_EXPR
;
2451 op0
= gimple_assign_rhs1 (second
);
2452 op1
= gimple_assign_rhs2 (second
);
2454 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2456 code
= TRUTH_ORIF_EXPR
;
2457 op0
= gimple_assign_rhs1 (second
);
2458 op1
= gimple_assign_rhs2 (second
);
2464 last2
= last
= get_last_insn ();
2466 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2467 set_curr_insn_location (gimple_location (stmt
));
2469 /* These flags have no purpose in RTL land. */
2470 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2471 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2473 /* We can either have a pure conditional jump with one fallthru edge or
2474 two-way jump that needs to be decomposed into two basic blocks. */
2475 if (false_edge
->dest
== bb
->next_bb
)
2477 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2478 true_edge
->probability
);
2479 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2480 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2481 set_curr_insn_location (true_edge
->goto_locus
);
2482 false_edge
->flags
|= EDGE_FALLTHRU
;
2483 maybe_cleanup_end_of_block (false_edge
, last
);
2486 if (true_edge
->dest
== bb
->next_bb
)
2488 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2489 false_edge
->probability
);
2490 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2491 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2492 set_curr_insn_location (false_edge
->goto_locus
);
2493 true_edge
->flags
|= EDGE_FALLTHRU
;
2494 maybe_cleanup_end_of_block (true_edge
, last
);
2498 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2499 true_edge
->probability
);
2500 last
= get_last_insn ();
2501 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2502 set_curr_insn_location (false_edge
->goto_locus
);
2503 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2506 if (BARRIER_P (BB_END (bb
)))
2507 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2508 update_bb_for_insn (bb
);
2510 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2511 dest
= false_edge
->dest
;
2512 redirect_edge_succ (false_edge
, new_bb
);
2513 false_edge
->flags
|= EDGE_FALLTHRU
;
2514 new_bb
->count
= false_edge
->count
;
2515 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2516 add_bb_to_loop (new_bb
, bb
->loop_father
);
2517 new_edge
= make_edge (new_bb
, dest
, 0);
2518 new_edge
->probability
= REG_BR_PROB_BASE
;
2519 new_edge
->count
= new_bb
->count
;
2520 if (BARRIER_P (BB_END (new_bb
)))
2521 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2522 update_bb_for_insn (new_bb
);
2524 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2526 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2528 set_curr_insn_location (true_edge
->goto_locus
);
2529 true_edge
->goto_locus
= curr_insn_location ();
2535 /* Mark all calls that can have a transaction restart. */
2538 mark_transaction_restart_calls (gimple
*stmt
)
2540 struct tm_restart_node dummy
;
2541 tm_restart_node
**slot
;
2543 if (!cfun
->gimple_df
->tm_restart
)
2547 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2550 struct tm_restart_node
*n
= *slot
;
2551 tree list
= n
->label_or_list
;
2554 for (insn
= next_real_insn (get_last_insn ());
2556 insn
= next_real_insn (insn
))
2559 if (TREE_CODE (list
) == LABEL_DECL
)
2560 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2562 for (; list
; list
= TREE_CHAIN (list
))
2563 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2567 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2571 expand_call_stmt (gcall
*stmt
)
2573 tree exp
, decl
, lhs
;
2577 if (gimple_call_internal_p (stmt
))
2579 expand_internal_call (stmt
);
2583 /* If this is a call to a built-in function and it has no effect other
2584 than setting the lhs, try to implement it using an internal function
2586 decl
= gimple_call_fndecl (stmt
);
2587 if (gimple_call_lhs (stmt
)
2588 && !gimple_has_side_effects (stmt
)
2589 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2591 internal_fn ifn
= replacement_internal_fn (stmt
);
2592 if (ifn
!= IFN_LAST
)
2594 expand_internal_call (ifn
, stmt
);
2599 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2601 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2602 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2604 /* If this is not a builtin function, the function type through which the
2605 call is made may be different from the type of the function. */
2608 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2609 CALL_EXPR_FN (exp
));
2611 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2612 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2614 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2616 tree arg
= gimple_call_arg (stmt
, i
);
2618 /* TER addresses into arguments of builtin functions so we have a
2619 chance to infer more correct alignment information. See PR39954. */
2621 && TREE_CODE (arg
) == SSA_NAME
2622 && (def
= get_gimple_for_ssa_name (arg
))
2623 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2624 arg
= gimple_assign_rhs1 (def
);
2625 CALL_EXPR_ARG (exp
, i
) = arg
;
2628 if (gimple_has_side_effects (stmt
))
2629 TREE_SIDE_EFFECTS (exp
) = 1;
2631 if (gimple_call_nothrow_p (stmt
))
2632 TREE_NOTHROW (exp
) = 1;
2634 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2635 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2636 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2638 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2639 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2640 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2641 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2643 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2644 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2645 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2646 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2647 CALL_WITH_BOUNDS_P (exp
) = gimple_call_with_bounds_p (stmt
);
2649 /* Ensure RTL is created for debug args. */
2650 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2652 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2657 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2659 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2660 expand_debug_expr (dtemp
);
2664 lhs
= gimple_call_lhs (stmt
);
2666 expand_assignment (lhs
, exp
, false);
2668 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2670 mark_transaction_restart_calls (stmt
);
2674 /* Generate RTL for an asm statement (explicit assembler code).
2675 STRING is a STRING_CST node containing the assembler code text,
2676 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2677 insn is volatile; don't optimize it. */
2680 expand_asm_loc (tree string
, int vol
, location_t locus
)
2684 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2685 ggc_strdup (TREE_STRING_POINTER (string
)),
2688 MEM_VOLATILE_P (body
) = vol
;
2690 /* Non-empty basic ASM implicitly clobbers memory. */
2691 if (TREE_STRING_LENGTH (string
) != 0)
2694 unsigned i
, nclobbers
;
2695 auto_vec
<rtx
> input_rvec
, output_rvec
;
2696 auto_vec
<const char *> constraints
;
2697 auto_vec
<rtx
> clobber_rvec
;
2698 HARD_REG_SET clobbered_regs
;
2699 CLEAR_HARD_REG_SET (clobbered_regs
);
2701 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2702 clobber_rvec
.safe_push (clob
);
2704 if (targetm
.md_asm_adjust
)
2705 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2706 constraints
, clobber_rvec
,
2710 nclobbers
= clobber_rvec
.length ();
2711 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2713 XVECEXP (body
, 0, 0) = asm_op
;
2714 for (i
= 0; i
< nclobbers
; i
++)
2715 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2721 /* Return the number of times character C occurs in string S. */
2723 n_occurrences (int c
, const char *s
)
2731 /* A subroutine of expand_asm_operands. Check that all operands have
2732 the same number of alternatives. Return true if so. */
2735 check_operand_nalternatives (const vec
<const char *> &constraints
)
2737 unsigned len
= constraints
.length();
2740 int nalternatives
= n_occurrences (',', constraints
[0]);
2742 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2744 error ("too many alternatives in %<asm%>");
2748 for (unsigned i
= 1; i
< len
; ++i
)
2749 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2751 error ("operand constraints for %<asm%> differ "
2752 "in number of alternatives");
2759 /* Check for overlap between registers marked in CLOBBERED_REGS and
2760 anything inappropriate in T. Emit error and return the register
2761 variable definition for error, NULL_TREE for ok. */
2764 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2766 /* Conflicts between asm-declared register variables and the clobber
2767 list are not allowed. */
2768 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2772 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2773 DECL_NAME (overlap
));
2775 /* Reset registerness to stop multiple errors emitted for a single
2777 DECL_REGISTER (overlap
) = 0;
2784 /* Generate RTL for an asm statement with arguments.
2785 STRING is the instruction template.
2786 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2787 Each output or input has an expression in the TREE_VALUE and
2788 a tree list in TREE_PURPOSE which in turn contains a constraint
2789 name in TREE_VALUE (or NULL_TREE) and a constraint string
2791 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2792 that is clobbered by this insn.
2794 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2795 should be the fallthru basic block of the asm goto.
2797 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2798 Some elements of OUTPUTS may be replaced with trees representing temporary
2799 values. The caller should copy those temporary values to the originally
2802 VOL nonzero means the insn is volatile; don't optimize it. */
2805 expand_asm_stmt (gasm
*stmt
)
2807 class save_input_location
2812 explicit save_input_location(location_t where
)
2814 old
= input_location
;
2815 input_location
= where
;
2818 ~save_input_location()
2820 input_location
= old
;
2824 location_t locus
= gimple_location (stmt
);
2826 if (gimple_asm_input_p (stmt
))
2828 const char *s
= gimple_asm_string (stmt
);
2829 tree string
= build_string (strlen (s
), s
);
2830 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
2834 /* There are some legacy diagnostics in here, and also avoids a
2835 sixth parameger to targetm.md_asm_adjust. */
2836 save_input_location
s_i_l(locus
);
2838 unsigned noutputs
= gimple_asm_noutputs (stmt
);
2839 unsigned ninputs
= gimple_asm_ninputs (stmt
);
2840 unsigned nlabels
= gimple_asm_nlabels (stmt
);
2843 /* ??? Diagnose during gimplification? */
2844 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2846 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2850 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
2851 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
2852 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
2854 /* Copy the gimple vectors into new vectors that we can manipulate. */
2856 output_tvec
.safe_grow (noutputs
);
2857 input_tvec
.safe_grow (ninputs
);
2858 constraints
.safe_grow (noutputs
+ ninputs
);
2860 for (i
= 0; i
< noutputs
; ++i
)
2862 tree t
= gimple_asm_output_op (stmt
, i
);
2863 output_tvec
[i
] = TREE_VALUE (t
);
2864 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2866 for (i
= 0; i
< ninputs
; i
++)
2868 tree t
= gimple_asm_input_op (stmt
, i
);
2869 input_tvec
[i
] = TREE_VALUE (t
);
2870 constraints
[i
+ noutputs
]
2871 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2874 /* ??? Diagnose during gimplification? */
2875 if (! check_operand_nalternatives (constraints
))
2878 /* Count the number of meaningful clobbered registers, ignoring what
2879 we would ignore later. */
2880 auto_vec
<rtx
> clobber_rvec
;
2881 HARD_REG_SET clobbered_regs
;
2882 CLEAR_HARD_REG_SET (clobbered_regs
);
2884 if (unsigned n
= gimple_asm_nclobbers (stmt
))
2886 clobber_rvec
.reserve (n
);
2887 for (i
= 0; i
< n
; i
++)
2889 tree t
= gimple_asm_clobber_op (stmt
, i
);
2890 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
2893 j
= decode_reg_name_and_count (regname
, &nregs
);
2898 /* ??? Diagnose during gimplification? */
2899 error ("unknown register name %qs in %<asm%>", regname
);
2903 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2904 clobber_rvec
.safe_push (x
);
2908 /* Otherwise we should have -1 == empty string
2909 or -3 == cc, which is not a register. */
2910 gcc_assert (j
== -1 || j
== -3);
2914 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
2916 /* Clobbering the PIC register is an error. */
2917 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2919 /* ??? Diagnose during gimplification? */
2920 error ("PIC register clobbered by %qs in %<asm%>",
2925 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2926 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
2927 clobber_rvec
.safe_push (x
);
2931 unsigned nclobbers
= clobber_rvec
.length();
2933 /* First pass over inputs and outputs checks validity and sets
2934 mark_addressable if needed. */
2935 /* ??? Diagnose during gimplification? */
2937 for (i
= 0; i
< noutputs
; ++i
)
2939 tree val
= output_tvec
[i
];
2940 tree type
= TREE_TYPE (val
);
2941 const char *constraint
;
2946 /* Try to parse the output constraint. If that fails, there's
2947 no point in going further. */
2948 constraint
= constraints
[i
];
2949 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2950 &allows_mem
, &allows_reg
, &is_inout
))
2957 && REG_P (DECL_RTL (val
))
2958 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2959 mark_addressable (val
);
2962 for (i
= 0; i
< ninputs
; ++i
)
2964 bool allows_reg
, allows_mem
;
2965 const char *constraint
;
2967 constraint
= constraints
[i
+ noutputs
];
2968 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
2969 constraints
.address (),
2970 &allows_mem
, &allows_reg
))
2973 if (! allows_reg
&& allows_mem
)
2974 mark_addressable (input_tvec
[i
]);
2977 /* Second pass evaluates arguments. */
2979 /* Make sure stack is consistent for asm goto. */
2981 do_pending_stack_adjust ();
2982 int old_generating_concat_p
= generating_concat_p
;
2984 /* Vector of RTX's of evaluated output operands. */
2985 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
2986 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
2987 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
2989 output_rvec
.safe_grow (noutputs
);
2991 for (i
= 0; i
< noutputs
; ++i
)
2993 tree val
= output_tvec
[i
];
2994 tree type
= TREE_TYPE (val
);
2995 bool is_inout
, allows_reg
, allows_mem
, ok
;
2998 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2999 noutputs
, &allows_mem
, &allows_reg
,
3003 /* If an output operand is not a decl or indirect ref and our constraint
3004 allows a register, make a temporary to act as an intermediate.
3005 Make the asm insn write into that, then we will copy it to
3006 the real output operand. Likewise for promoted variables. */
3008 generating_concat_p
= 0;
3010 if ((TREE_CODE (val
) == INDIRECT_REF
3013 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3014 && ! (REG_P (DECL_RTL (val
))
3015 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3019 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3020 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3022 op
= validize_mem (op
);
3024 if (! allows_reg
&& !MEM_P (op
))
3025 error ("output number %d not directly addressable", i
);
3026 if ((! allows_mem
&& MEM_P (op
))
3027 || GET_CODE (op
) == CONCAT
)
3030 op
= gen_reg_rtx (GET_MODE (op
));
3032 generating_concat_p
= old_generating_concat_p
;
3035 emit_move_insn (op
, old_op
);
3037 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3038 emit_move_insn (old_op
, op
);
3039 after_rtl_seq
= get_insns ();
3040 after_rtl_end
= get_last_insn ();
3046 op
= assign_temp (type
, 0, 1);
3047 op
= validize_mem (op
);
3048 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3049 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3051 generating_concat_p
= old_generating_concat_p
;
3053 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3054 expand_assignment (val
, make_tree (type
, op
), false);
3055 after_rtl_seq
= get_insns ();
3056 after_rtl_end
= get_last_insn ();
3059 output_rvec
[i
] = op
;
3062 inout_opnum
.safe_push (i
);
3065 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3066 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3068 input_rvec
.safe_grow (ninputs
);
3069 input_mode
.safe_grow (ninputs
);
3071 generating_concat_p
= 0;
3073 for (i
= 0; i
< ninputs
; ++i
)
3075 tree val
= input_tvec
[i
];
3076 tree type
= TREE_TYPE (val
);
3077 bool allows_reg
, allows_mem
, ok
;
3078 const char *constraint
;
3081 constraint
= constraints
[i
+ noutputs
];
3082 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3083 constraints
.address (),
3084 &allows_mem
, &allows_reg
);
3087 /* EXPAND_INITIALIZER will not generate code for valid initializer
3088 constants, but will still generate code for other types of operand.
3089 This is the behavior we want for constant constraints. */
3090 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3091 allows_reg
? EXPAND_NORMAL
3092 : allows_mem
? EXPAND_MEMORY
3093 : EXPAND_INITIALIZER
);
3095 /* Never pass a CONCAT to an ASM. */
3096 if (GET_CODE (op
) == CONCAT
)
3097 op
= force_reg (GET_MODE (op
), op
);
3098 else if (MEM_P (op
))
3099 op
= validize_mem (op
);
3101 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3103 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3104 op
= force_reg (TYPE_MODE (type
), op
);
3105 else if (!allows_mem
)
3106 warning (0, "asm operand %d probably doesn%'t match constraints",
3108 else if (MEM_P (op
))
3110 /* We won't recognize either volatile memory or memory
3111 with a queued address as available a memory_operand
3112 at this point. Ignore it: clearly this *is* a memory. */
3118 input_mode
[i
] = TYPE_MODE (type
);
3121 /* For in-out operands, copy output rtx to input rtx. */
3122 unsigned ninout
= inout_opnum
.length();
3123 for (i
= 0; i
< ninout
; i
++)
3125 int j
= inout_opnum
[i
];
3126 rtx o
= output_rvec
[j
];
3128 input_rvec
.safe_push (o
);
3129 input_mode
.safe_push (GET_MODE (o
));
3132 sprintf (buffer
, "%d", j
);
3133 constraints
.safe_push (ggc_strdup (buffer
));
3137 /* Sometimes we wish to automatically clobber registers across an asm.
3138 Case in point is when the i386 backend moved from cc0 to a hard reg --
3139 maintaining source-level compatibility means automatically clobbering
3140 the flags register. */
3141 rtx_insn
*after_md_seq
= NULL
;
3142 if (targetm
.md_asm_adjust
)
3143 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3144 constraints
, clobber_rvec
,
3147 /* Do not allow the hook to change the output and input count,
3148 lest it mess up the operand numbering. */
3149 gcc_assert (output_rvec
.length() == noutputs
);
3150 gcc_assert (input_rvec
.length() == ninputs
);
3151 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3153 /* But it certainly can adjust the clobbers. */
3154 nclobbers
= clobber_rvec
.length();
3156 /* Third pass checks for easy conflicts. */
3157 /* ??? Why are we doing this on trees instead of rtx. */
3159 bool clobber_conflict_found
= 0;
3160 for (i
= 0; i
< noutputs
; ++i
)
3161 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3162 clobber_conflict_found
= 1;
3163 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3164 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3165 clobber_conflict_found
= 1;
3167 /* Make vectors for the expression-rtx, constraint strings,
3168 and named operands. */
3170 rtvec argvec
= rtvec_alloc (ninputs
);
3171 rtvec constraintvec
= rtvec_alloc (ninputs
);
3172 rtvec labelvec
= rtvec_alloc (nlabels
);
3174 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3175 : GET_MODE (output_rvec
[0])),
3176 ggc_strdup (gimple_asm_string (stmt
)),
3177 empty_string
, 0, argvec
, constraintvec
,
3179 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3181 for (i
= 0; i
< ninputs
; ++i
)
3183 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3184 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3185 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3186 constraints
[i
+ noutputs
],
3190 /* Copy labels to the vector. */
3191 rtx_code_label
*fallthru_label
= NULL
;
3194 basic_block fallthru_bb
= NULL
;
3195 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3197 fallthru_bb
= fallthru
->dest
;
3199 for (i
= 0; i
< nlabels
; ++i
)
3201 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3203 /* If asm goto has any labels in the fallthru basic block, use
3204 a label that we emit immediately after the asm goto. Expansion
3205 may insert further instructions into the same basic block after
3206 asm goto and if we don't do this, insertion of instructions on
3207 the fallthru edge might misbehave. See PR58670. */
3208 if (fallthru_bb
&& label_to_block_fn (cfun
, label
) == fallthru_bb
)
3210 if (fallthru_label
== NULL_RTX
)
3211 fallthru_label
= gen_label_rtx ();
3215 r
= label_rtx (label
);
3216 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3220 /* Now, for each output, construct an rtx
3221 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3222 ARGVEC CONSTRAINTS OPNAMES))
3223 If there is more than one, put them inside a PARALLEL. */
3225 if (nlabels
> 0 && nclobbers
== 0)
3227 gcc_assert (noutputs
== 0);
3228 emit_jump_insn (body
);
3230 else if (noutputs
== 0 && nclobbers
== 0)
3232 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3235 else if (noutputs
== 1 && nclobbers
== 0)
3237 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3238 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3248 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3250 /* For each output operand, store a SET. */
3251 for (i
= 0; i
< noutputs
; ++i
)
3253 rtx src
, o
= output_rvec
[i
];
3256 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3261 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3262 ASM_OPERANDS_TEMPLATE (obody
),
3263 constraints
[i
], i
, argvec
,
3264 constraintvec
, labelvec
, locus
);
3265 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3267 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3270 /* If there are no outputs (but there are some clobbers)
3271 store the bare ASM_OPERANDS into the PARALLEL. */
3273 XVECEXP (body
, 0, i
++) = obody
;
3275 /* Store (clobber REG) for each clobbered register specified. */
3276 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3278 rtx clobbered_reg
= clobber_rvec
[j
];
3280 /* Do sanity check for overlap between clobbers and respectively
3281 input and outputs that hasn't been handled. Such overlap
3282 should have been detected and reported above. */
3283 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3285 /* We test the old body (obody) contents to avoid
3286 tripping over the under-construction body. */
3287 for (unsigned k
= 0; k
< noutputs
; ++k
)
3288 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3289 internal_error ("asm clobber conflict with output operand");
3291 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3292 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3293 internal_error ("asm clobber conflict with input operand");
3296 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3300 emit_jump_insn (body
);
3305 generating_concat_p
= old_generating_concat_p
;
3308 emit_label (fallthru_label
);
3311 emit_insn (after_md_seq
);
3313 emit_insn (after_rtl_seq
);
3316 crtl
->has_asm_statement
= 1;
3319 /* Emit code to jump to the address
3320 specified by the pointer expression EXP. */
3323 expand_computed_goto (tree exp
)
3325 rtx x
= expand_normal (exp
);
3327 do_pending_stack_adjust ();
3328 emit_indirect_jump (x
);
3331 /* Generate RTL code for a `goto' statement with target label LABEL.
3332 LABEL should be a LABEL_DECL tree node that was or will later be
3333 defined with `expand_label'. */
3336 expand_goto (tree label
)
3340 /* Check for a nonlocal goto to a containing function. Should have
3341 gotten translated to __builtin_nonlocal_goto. */
3342 tree context
= decl_function_context (label
);
3343 gcc_assert (!context
|| context
== current_function_decl
);
3346 emit_jump (jump_target_rtx (label
));
3349 /* Output a return with no value. */
3352 expand_null_return_1 (void)
3354 clear_pending_stack_adjust ();
3355 do_pending_stack_adjust ();
3356 emit_jump (return_label
);
3359 /* Generate RTL to return from the current function, with no value.
3360 (That is, we do not do anything about returning any value.) */
3363 expand_null_return (void)
3365 /* If this function was declared to return a value, but we
3366 didn't, clobber the return registers so that they are not
3367 propagated live to the rest of the function. */
3368 clobber_return_register ();
3370 expand_null_return_1 ();
3373 /* Generate RTL to return from the current function, with value VAL. */
3376 expand_value_return (rtx val
)
3378 /* Copy the value to the return location unless it's already there. */
3380 tree decl
= DECL_RESULT (current_function_decl
);
3381 rtx return_reg
= DECL_RTL (decl
);
3382 if (return_reg
!= val
)
3384 tree funtype
= TREE_TYPE (current_function_decl
);
3385 tree type
= TREE_TYPE (decl
);
3386 int unsignedp
= TYPE_UNSIGNED (type
);
3387 machine_mode old_mode
= DECL_MODE (decl
);
3389 if (DECL_BY_REFERENCE (decl
))
3390 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3392 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3394 if (mode
!= old_mode
)
3395 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3397 if (GET_CODE (return_reg
) == PARALLEL
)
3398 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3400 emit_move_insn (return_reg
, val
);
3403 expand_null_return_1 ();
3406 /* Generate RTL to evaluate the expression RETVAL and return it
3407 from the current function. */
3410 expand_return (tree retval
, tree bounds
)
3417 /* If function wants no value, give it none. */
3418 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3420 expand_normal (retval
);
3421 expand_null_return ();
3425 if (retval
== error_mark_node
)
3427 /* Treat this like a return of no value from a function that
3429 expand_null_return ();
3432 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3433 || TREE_CODE (retval
) == INIT_EXPR
)
3434 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3435 retval_rhs
= TREE_OPERAND (retval
, 1);
3437 retval_rhs
= retval
;
3439 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3441 /* Put returned bounds to the right place. */
3442 bounds_rtl
= DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl
));
3448 if (bounds
&& bounds
!= error_mark_node
)
3450 bnd
= expand_normal (bounds
);
3451 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3453 else if (REG_P (bounds_rtl
))
3456 bnd
= chkp_expand_zero_bounds ();
3459 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3460 addr
= gen_rtx_MEM (Pmode
, addr
);
3461 bnd
= targetm
.calls
.load_bounds_for_arg (addr
, NULL
, NULL
);
3464 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3470 gcc_assert (GET_CODE (bounds_rtl
) == PARALLEL
);
3473 bnd
= chkp_expand_zero_bounds ();
3476 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3477 addr
= gen_rtx_MEM (Pmode
, addr
);
3480 for (n
= 0; n
< XVECLEN (bounds_rtl
, 0); n
++)
3482 rtx slot
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 0);
3485 rtx offs
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 1);
3486 rtx from
= adjust_address (addr
, Pmode
, INTVAL (offs
));
3487 bnd
= targetm
.calls
.load_bounds_for_arg (from
, NULL
, NULL
);
3489 targetm
.calls
.store_returned_bounds (slot
, bnd
);
3493 else if (chkp_function_instrumented_p (current_function_decl
)
3494 && !BOUNDED_P (retval_rhs
)
3495 && chkp_type_has_pointer (TREE_TYPE (retval_rhs
))
3496 && TREE_CODE (retval_rhs
) != RESULT_DECL
)
3498 rtx addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3499 addr
= gen_rtx_MEM (Pmode
, addr
);
3501 gcc_assert (MEM_P (result_rtl
));
3503 chkp_copy_bounds_for_stack_parm (result_rtl
, addr
, TREE_TYPE (retval_rhs
));
3506 /* If we are returning the RESULT_DECL, then the value has already
3507 been stored into it, so we don't have to do anything special. */
3508 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3509 expand_value_return (result_rtl
);
3511 /* If the result is an aggregate that is being returned in one (or more)
3512 registers, load the registers here. */
3514 else if (retval_rhs
!= 0
3515 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3516 && REG_P (result_rtl
))
3518 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3521 /* Use the mode of the result value on the return register. */
3522 PUT_MODE (result_rtl
, GET_MODE (val
));
3523 expand_value_return (val
);
3526 expand_null_return ();
3528 else if (retval_rhs
!= 0
3529 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3530 && (REG_P (result_rtl
)
3531 || (GET_CODE (result_rtl
) == PARALLEL
)))
3533 /* Compute the return value into a temporary (usually a pseudo reg). */
3535 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3536 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3537 val
= force_not_mem (val
);
3538 expand_value_return (val
);
3542 /* No hard reg used; calculate value into hard return reg. */
3543 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3544 expand_value_return (result_rtl
);
3548 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3549 STMT that doesn't require special handling for outgoing edges. That
3550 is no tailcalls and no GIMPLE_COND. */
3553 expand_gimple_stmt_1 (gimple
*stmt
)
3557 set_curr_insn_location (gimple_location (stmt
));
3559 switch (gimple_code (stmt
))
3562 op0
= gimple_goto_dest (stmt
);
3563 if (TREE_CODE (op0
) == LABEL_DECL
)
3566 expand_computed_goto (op0
);
3569 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3572 case GIMPLE_PREDICT
:
3575 expand_case (as_a
<gswitch
*> (stmt
));
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
;
3794 last2
= last
= expand_gimple_stmt (stmt
);
3796 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3797 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3800 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3802 *can_fallthru
= true;
3806 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3807 Any instructions emitted here are about to be deleted. */
3808 do_pending_stack_adjust ();
3810 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3811 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3812 EH or abnormal edges, we shouldn't have created a tail call in
3813 the first place. So it seems to me we should just be removing
3814 all edges here, or redirecting the existing fallthru edge to
3820 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3822 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3824 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3826 e
->dest
->count
-= e
->count
;
3827 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3828 if (e
->dest
->count
< 0)
3830 if (e
->dest
->frequency
< 0)
3831 e
->dest
->frequency
= 0;
3834 probability
+= e
->probability
;
3841 /* This is somewhat ugly: the call_expr expander often emits instructions
3842 after the sibcall (to perform the function return). These confuse the
3843 find_many_sub_basic_blocks code, so we need to get rid of these. */
3844 last
= NEXT_INSN (last
);
3845 gcc_assert (BARRIER_P (last
));
3847 *can_fallthru
= false;
3848 while (NEXT_INSN (last
))
3850 /* For instance an sqrt builtin expander expands if with
3851 sibcall in the then and label for `else`. */
3852 if (LABEL_P (NEXT_INSN (last
)))
3854 *can_fallthru
= true;
3857 delete_insn (NEXT_INSN (last
));
3860 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3862 e
->probability
+= probability
;
3865 update_bb_for_insn (bb
);
3867 if (NEXT_INSN (last
))
3869 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3872 if (BARRIER_P (last
))
3873 BB_END (bb
) = PREV_INSN (last
);
3876 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3881 /* Return the difference between the floor and the truncated result of
3882 a signed division by OP1 with remainder MOD. */
3884 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3886 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3887 return gen_rtx_IF_THEN_ELSE
3888 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3889 gen_rtx_IF_THEN_ELSE
3890 (mode
, gen_rtx_LT (BImode
,
3891 gen_rtx_DIV (mode
, op1
, mod
),
3893 constm1_rtx
, const0_rtx
),
3897 /* Return the difference between the ceil and the truncated result of
3898 a signed division by OP1 with remainder MOD. */
3900 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3902 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3903 return gen_rtx_IF_THEN_ELSE
3904 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3905 gen_rtx_IF_THEN_ELSE
3906 (mode
, gen_rtx_GT (BImode
,
3907 gen_rtx_DIV (mode
, op1
, mod
),
3909 const1_rtx
, const0_rtx
),
3913 /* Return the difference between the ceil and the truncated result of
3914 an unsigned division by OP1 with remainder MOD. */
3916 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3918 /* (mod != 0 ? 1 : 0) */
3919 return gen_rtx_IF_THEN_ELSE
3920 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3921 const1_rtx
, const0_rtx
);
3924 /* Return the difference between the rounded and the truncated result
3925 of a signed division by OP1 with remainder MOD. Halfway cases are
3926 rounded away from zero, rather than to the nearest even number. */
3928 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3930 /* (abs (mod) >= abs (op1) - abs (mod)
3931 ? (op1 / mod > 0 ? 1 : -1)
3933 return gen_rtx_IF_THEN_ELSE
3934 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3935 gen_rtx_MINUS (mode
,
3936 gen_rtx_ABS (mode
, op1
),
3937 gen_rtx_ABS (mode
, mod
))),
3938 gen_rtx_IF_THEN_ELSE
3939 (mode
, gen_rtx_GT (BImode
,
3940 gen_rtx_DIV (mode
, op1
, mod
),
3942 const1_rtx
, constm1_rtx
),
3946 /* Return the difference between the rounded and the truncated result
3947 of a unsigned division by OP1 with remainder MOD. Halfway cases
3948 are rounded away from zero, rather than to the nearest even
3951 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3953 /* (mod >= op1 - mod ? 1 : 0) */
3954 return gen_rtx_IF_THEN_ELSE
3955 (mode
, gen_rtx_GE (BImode
, mod
,
3956 gen_rtx_MINUS (mode
, op1
, mod
)),
3957 const1_rtx
, const0_rtx
);
3960 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3964 convert_debug_memory_address (machine_mode mode
, rtx x
,
3967 machine_mode xmode
= GET_MODE (x
);
3969 #ifndef POINTERS_EXTEND_UNSIGNED
3970 gcc_assert (mode
== Pmode
3971 || mode
== targetm
.addr_space
.address_mode (as
));
3972 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3976 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3978 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3981 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3982 x
= lowpart_subreg (mode
, x
, xmode
);
3983 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3984 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3985 else if (!POINTERS_EXTEND_UNSIGNED
)
3986 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3989 switch (GET_CODE (x
))
3992 if ((SUBREG_PROMOTED_VAR_P (x
)
3993 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3994 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3995 && REG_P (XEXP (SUBREG_REG (x
), 0))
3996 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3997 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3998 && GET_MODE (SUBREG_REG (x
)) == mode
)
3999 return SUBREG_REG (x
);
4002 temp
= gen_rtx_LABEL_REF (mode
, LABEL_REF_LABEL (x
));
4003 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4006 temp
= shallow_copy_rtx (x
);
4007 PUT_MODE (temp
, mode
);
4010 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4012 temp
= gen_rtx_CONST (mode
, temp
);
4016 if (CONST_INT_P (XEXP (x
, 1)))
4018 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4020 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4026 /* Don't know how to express ptr_extend as operation in debug info. */
4029 #endif /* POINTERS_EXTEND_UNSIGNED */
4034 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4035 by avoid_deep_ter_for_debug. */
4037 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4039 /* Split too deep TER chains for debug stmts using debug temporaries. */
4042 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4044 use_operand_p use_p
;
4046 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4048 tree use
= USE_FROM_PTR (use_p
);
4049 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4051 gimple
*g
= get_gimple_for_ssa_name (use
);
4054 if (depth
> 6 && !stmt_ends_bb_p (g
))
4056 if (deep_ter_debug_map
== NULL
)
4057 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4059 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4062 vexpr
= make_node (DEBUG_EXPR_DECL
);
4063 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4064 DECL_ARTIFICIAL (vexpr
) = 1;
4065 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4066 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (use
));
4067 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4068 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4069 avoid_deep_ter_for_debug (def_temp
, 0);
4072 avoid_deep_ter_for_debug (g
, depth
+ 1);
4076 /* Return an RTX equivalent to the value of the parameter DECL. */
4079 expand_debug_parm_decl (tree decl
)
4081 rtx incoming
= DECL_INCOMING_RTL (decl
);
4084 && GET_MODE (incoming
) != BLKmode
4085 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4086 || (MEM_P (incoming
)
4087 && REG_P (XEXP (incoming
, 0))
4088 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4090 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4092 #ifdef HAVE_window_save
4093 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4094 If the target machine has an explicit window save instruction, the
4095 actual entry value is the corresponding OUTGOING_REGNO instead. */
4096 if (REG_P (incoming
)
4097 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4099 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4100 OUTGOING_REGNO (REGNO (incoming
)), 0);
4101 else if (MEM_P (incoming
))
4103 rtx reg
= XEXP (incoming
, 0);
4104 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4106 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4107 incoming
= replace_equiv_address_nv (incoming
, reg
);
4110 incoming
= copy_rtx (incoming
);
4114 ENTRY_VALUE_EXP (rtl
) = incoming
;
4119 && GET_MODE (incoming
) != BLKmode
4120 && !TREE_ADDRESSABLE (decl
)
4122 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4123 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4124 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4125 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4126 return copy_rtx (incoming
);
4131 /* Return an RTX equivalent to the value of the tree expression EXP. */
4134 expand_debug_expr (tree exp
)
4136 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4137 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4138 machine_mode inner_mode
= VOIDmode
;
4139 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4142 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4144 case tcc_expression
:
4145 switch (TREE_CODE (exp
))
4150 case WIDEN_MULT_PLUS_EXPR
:
4151 case WIDEN_MULT_MINUS_EXPR
:
4155 case TRUTH_ANDIF_EXPR
:
4156 case TRUTH_ORIF_EXPR
:
4157 case TRUTH_AND_EXPR
:
4159 case TRUTH_XOR_EXPR
:
4162 case TRUTH_NOT_EXPR
:
4171 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4178 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4181 switch (TREE_CODE (exp
))
4187 case WIDEN_LSHIFT_EXPR
:
4188 /* Ensure second operand isn't wider than the first one. */
4189 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4190 if (SCALAR_INT_MODE_P (inner_mode
))
4192 machine_mode opmode
= mode
;
4193 if (VECTOR_MODE_P (mode
))
4194 opmode
= GET_MODE_INNER (mode
);
4195 if (SCALAR_INT_MODE_P (opmode
)
4196 && (GET_MODE_PRECISION (opmode
)
4197 < GET_MODE_PRECISION (inner_mode
)))
4198 op1
= lowpart_subreg (opmode
, op1
, inner_mode
);
4208 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4209 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4214 case tcc_comparison
:
4215 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4223 case tcc_exceptional
:
4224 case tcc_declaration
:
4230 switch (TREE_CODE (exp
))
4233 if (!lookup_constant_def (exp
))
4235 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4236 != (size_t) TREE_STRING_LENGTH (exp
))
4238 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4239 op0
= gen_rtx_MEM (BLKmode
, op0
);
4240 set_mem_attributes (op0
, exp
, 0);
4248 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4252 gcc_assert (COMPLEX_MODE_P (mode
));
4253 op0
= expand_debug_expr (TREE_REALPART (exp
));
4254 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4255 return gen_rtx_CONCAT (mode
, op0
, op1
);
4257 case DEBUG_EXPR_DECL
:
4258 op0
= DECL_RTL_IF_SET (exp
);
4263 op0
= gen_rtx_DEBUG_EXPR (mode
);
4264 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4265 SET_DECL_RTL (exp
, op0
);
4275 op0
= DECL_RTL_IF_SET (exp
);
4277 /* This decl was probably optimized away. */
4281 || DECL_EXTERNAL (exp
)
4282 || !TREE_STATIC (exp
)
4284 || DECL_HARD_REGISTER (exp
)
4285 || DECL_IN_CONSTANT_POOL (exp
)
4286 || mode
== VOIDmode
)
4289 op0
= make_decl_rtl_for_debug (exp
);
4291 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4292 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4296 op0
= copy_rtx (op0
);
4298 if (GET_MODE (op0
) == BLKmode
4299 /* If op0 is not BLKmode, but mode is, adjust_mode
4300 below would ICE. While it is likely a FE bug,
4301 try to be robust here. See PR43166. */
4303 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4305 gcc_assert (MEM_P (op0
));
4306 op0
= adjust_address_nv (op0
, mode
, 0);
4316 inner_mode
= GET_MODE (op0
);
4318 if (mode
== inner_mode
)
4321 if (inner_mode
== VOIDmode
)
4323 if (TREE_CODE (exp
) == SSA_NAME
)
4324 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4326 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4327 if (mode
== inner_mode
)
4331 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4333 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4334 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4335 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4336 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4338 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4340 else if (FLOAT_MODE_P (mode
))
4342 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4343 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4344 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4346 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4348 else if (FLOAT_MODE_P (inner_mode
))
4351 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4353 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4355 else if (CONSTANT_P (op0
)
4356 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
4357 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4358 else if (UNARY_CLASS_P (exp
)
4359 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4361 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4363 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4369 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4371 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4372 TREE_OPERAND (exp
, 0),
4373 TREE_OPERAND (exp
, 1));
4375 return expand_debug_expr (newexp
);
4379 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4380 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4384 if (TREE_CODE (exp
) == MEM_REF
)
4386 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4387 || (GET_CODE (op0
) == PLUS
4388 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4389 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4390 Instead just use get_inner_reference. */
4393 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4394 if (!op1
|| !CONST_INT_P (op1
))
4397 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
4400 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4402 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4404 if (op0
== NULL_RTX
)
4407 op0
= gen_rtx_MEM (mode
, op0
);
4408 set_mem_attributes (op0
, exp
, 0);
4409 if (TREE_CODE (exp
) == MEM_REF
4410 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4411 set_mem_expr (op0
, NULL_TREE
);
4412 set_mem_addr_space (op0
, as
);
4416 case TARGET_MEM_REF
:
4417 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4418 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4421 op0
= expand_debug_expr
4422 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4426 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4427 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4429 if (op0
== NULL_RTX
)
4432 op0
= gen_rtx_MEM (mode
, op0
);
4434 set_mem_attributes (op0
, exp
, 0);
4435 set_mem_addr_space (op0
, as
);
4441 case ARRAY_RANGE_REF
:
4446 case VIEW_CONVERT_EXPR
:
4449 HOST_WIDE_INT bitsize
, bitpos
;
4451 int reversep
, volatilep
= 0;
4453 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4454 &unsignedp
, &reversep
, &volatilep
);
4460 orig_op0
= op0
= expand_debug_expr (tem
);
4467 machine_mode addrmode
, offmode
;
4472 op0
= XEXP (op0
, 0);
4473 addrmode
= GET_MODE (op0
);
4474 if (addrmode
== VOIDmode
)
4477 op1
= expand_debug_expr (offset
);
4481 offmode
= GET_MODE (op1
);
4482 if (offmode
== VOIDmode
)
4483 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4485 if (addrmode
!= offmode
)
4486 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4488 /* Don't use offset_address here, we don't need a
4489 recognizable address, and we don't want to generate
4491 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4497 if (mode1
== VOIDmode
)
4499 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4500 if (bitpos
>= BITS_PER_UNIT
)
4502 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4503 bitpos
%= BITS_PER_UNIT
;
4505 else if (bitpos
< 0)
4508 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4509 op0
= adjust_address_nv (op0
, mode1
, -units
);
4510 bitpos
+= units
* BITS_PER_UNIT
;
4512 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4513 op0
= adjust_address_nv (op0
, mode
, 0);
4514 else if (GET_MODE (op0
) != mode1
)
4515 op0
= adjust_address_nv (op0
, mode1
, 0);
4517 op0
= copy_rtx (op0
);
4518 if (op0
== orig_op0
)
4519 op0
= shallow_copy_rtx (op0
);
4520 set_mem_attributes (op0
, exp
, 0);
4523 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4529 if (GET_MODE (op0
) == BLKmode
)
4532 if ((bitpos
% BITS_PER_UNIT
) == 0
4533 && bitsize
== GET_MODE_BITSIZE (mode1
))
4535 machine_mode opmode
= GET_MODE (op0
);
4537 if (opmode
== VOIDmode
)
4538 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4540 /* This condition may hold if we're expanding the address
4541 right past the end of an array that turned out not to
4542 be addressable (i.e., the address was only computed in
4543 debug stmts). The gen_subreg below would rightfully
4544 crash, and the address doesn't really exist, so just
4546 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4549 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4550 return simplify_gen_subreg (mode
, op0
, opmode
,
4551 bitpos
/ BITS_PER_UNIT
);
4554 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4555 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4557 : ZERO_EXTRACT
, mode
,
4558 GET_MODE (op0
) != VOIDmode
4560 : TYPE_MODE (TREE_TYPE (tem
)),
4561 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4565 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4568 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4571 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4574 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4576 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4579 case FIX_TRUNC_EXPR
:
4580 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4583 case POINTER_PLUS_EXPR
:
4584 /* For the rare target where pointers are not the same size as
4585 size_t, we need to check for mis-matched modes and correct
4588 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4589 && GET_MODE (op0
) != GET_MODE (op1
))
4591 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4592 /* If OP0 is a partial mode, then we must truncate, even if it has
4593 the same bitsize as OP1 as GCC's representation of partial modes
4595 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4596 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4597 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4600 /* We always sign-extend, regardless of the signedness of
4601 the operand, because the operand is always unsigned
4602 here even if the original C expression is signed. */
4603 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4608 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4611 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4614 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4617 case TRUNC_DIV_EXPR
:
4618 case EXACT_DIV_EXPR
:
4620 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4622 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4624 case TRUNC_MOD_EXPR
:
4625 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4627 case FLOOR_DIV_EXPR
:
4629 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4632 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4633 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4634 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4635 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4638 case FLOOR_MOD_EXPR
:
4640 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4643 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4644 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4645 adj
= simplify_gen_unary (NEG
, mode
,
4646 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4648 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4654 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4655 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4656 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4657 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4661 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4662 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4663 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4664 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4670 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4671 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4672 adj
= simplify_gen_unary (NEG
, mode
,
4673 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4675 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4679 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4680 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4681 adj
= simplify_gen_unary (NEG
, mode
,
4682 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4684 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4687 case ROUND_DIV_EXPR
:
4690 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4691 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4692 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4693 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4697 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4698 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4699 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4700 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4703 case ROUND_MOD_EXPR
:
4706 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4707 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4708 adj
= simplify_gen_unary (NEG
, mode
,
4709 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4711 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4715 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4716 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4717 adj
= simplify_gen_unary (NEG
, mode
,
4718 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4720 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4724 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4728 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4730 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4733 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4736 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4739 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4742 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4745 case TRUTH_AND_EXPR
:
4746 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4750 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4753 case TRUTH_XOR_EXPR
:
4754 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4756 case TRUTH_ANDIF_EXPR
:
4757 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4759 case TRUTH_ORIF_EXPR
:
4760 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4762 case TRUTH_NOT_EXPR
:
4763 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4766 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4770 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4774 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4778 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4782 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4785 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4787 case UNORDERED_EXPR
:
4788 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4791 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4794 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4797 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4800 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4803 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4806 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4809 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4812 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4815 gcc_assert (COMPLEX_MODE_P (mode
));
4816 if (GET_MODE (op0
) == VOIDmode
)
4817 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4818 if (GET_MODE (op1
) == VOIDmode
)
4819 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4820 return gen_rtx_CONCAT (mode
, op0
, op1
);
4823 if (GET_CODE (op0
) == CONCAT
)
4824 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4825 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4827 GET_MODE_INNER (mode
)));
4830 machine_mode imode
= GET_MODE_INNER (mode
);
4835 re
= adjust_address_nv (op0
, imode
, 0);
4836 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4840 machine_mode ifmode
= int_mode_for_mode (mode
);
4841 machine_mode ihmode
= int_mode_for_mode (imode
);
4843 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4845 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4848 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4849 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4850 if (imode
!= ihmode
)
4851 re
= gen_rtx_SUBREG (imode
, re
, 0);
4852 im
= copy_rtx (op0
);
4854 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4855 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4856 if (imode
!= ihmode
)
4857 im
= gen_rtx_SUBREG (imode
, im
, 0);
4859 im
= gen_rtx_NEG (imode
, im
);
4860 return gen_rtx_CONCAT (mode
, re
, im
);
4864 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4865 if (!op0
|| !MEM_P (op0
))
4867 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4868 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4869 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4870 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4871 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4872 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4874 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4876 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4879 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
4880 &bitsize
, &maxsize
, &reverse
);
4882 || TREE_CODE (decl
) == PARM_DECL
4883 || TREE_CODE (decl
) == RESULT_DECL
)
4884 && (!TREE_ADDRESSABLE (decl
)
4885 || target_for_debug_bind (decl
))
4886 && (bitoffset
% BITS_PER_UNIT
) == 0
4888 && bitsize
== maxsize
)
4890 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4891 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4895 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4896 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4899 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4902 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4903 || (GET_CODE (op0
) == PLUS
4904 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4905 && CONST_INT_P (XEXP (op0
, 1)))))
4907 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4909 if (!op1
|| !CONST_INT_P (op1
))
4912 return plus_constant (mode
, op0
, INTVAL (op1
));
4919 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
4920 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4928 op0
= gen_rtx_CONCATN
4929 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4931 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4933 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4936 XVECEXP (op0
, 0, i
) = op1
;
4943 if (TREE_CLOBBER_P (exp
))
4945 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4950 op0
= gen_rtx_CONCATN
4951 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4953 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4955 op1
= expand_debug_expr (val
);
4958 XVECEXP (op0
, 0, i
) = op1
;
4961 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4963 op1
= expand_debug_expr
4964 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4969 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4970 XVECEXP (op0
, 0, i
) = op1
;
4976 goto flag_unsupported
;
4979 /* ??? Maybe handle some builtins? */
4984 gimple
*g
= get_gimple_for_ssa_name (exp
);
4988 if (deep_ter_debug_map
)
4990 tree
*slot
= deep_ter_debug_map
->get (exp
);
4995 t
= gimple_assign_rhs_to_tree (g
);
4996 op0
= expand_debug_expr (t
);
5002 /* If this is a reference to an incoming value of
5003 parameter that is never used in the code or where the
5004 incoming value is never used in the code, use
5005 PARM_DECL's DECL_RTL if set. */
5006 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5007 && SSA_NAME_VAR (exp
)
5008 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5009 && has_zero_uses (exp
))
5011 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5014 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5019 int part
= var_to_partition (SA
.map
, exp
);
5021 if (part
== NO_PARTITION
)
5024 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5026 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5034 /* Vector stuff. For most of the codes we don't have rtl codes. */
5035 case REALIGN_LOAD_EXPR
:
5036 case REDUC_MAX_EXPR
:
5037 case REDUC_MIN_EXPR
:
5038 case REDUC_PLUS_EXPR
:
5040 case VEC_PACK_FIX_TRUNC_EXPR
:
5041 case VEC_PACK_SAT_EXPR
:
5042 case VEC_PACK_TRUNC_EXPR
:
5043 case VEC_UNPACK_FLOAT_HI_EXPR
:
5044 case VEC_UNPACK_FLOAT_LO_EXPR
:
5045 case VEC_UNPACK_HI_EXPR
:
5046 case VEC_UNPACK_LO_EXPR
:
5047 case VEC_WIDEN_MULT_HI_EXPR
:
5048 case VEC_WIDEN_MULT_LO_EXPR
:
5049 case VEC_WIDEN_MULT_EVEN_EXPR
:
5050 case VEC_WIDEN_MULT_ODD_EXPR
:
5051 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5052 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5057 case ADDR_SPACE_CONVERT_EXPR
:
5058 case FIXED_CONVERT_EXPR
:
5060 case WITH_SIZE_EXPR
:
5061 case BIT_INSERT_EXPR
:
5065 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5066 && SCALAR_INT_MODE_P (mode
))
5069 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5071 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5074 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5076 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5078 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5079 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5083 case WIDEN_MULT_EXPR
:
5084 case WIDEN_MULT_PLUS_EXPR
:
5085 case WIDEN_MULT_MINUS_EXPR
:
5086 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5087 && SCALAR_INT_MODE_P (mode
))
5089 inner_mode
= GET_MODE (op0
);
5090 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5091 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5093 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5094 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5095 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5097 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5098 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5099 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5101 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5102 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5104 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5108 case MULT_HIGHPART_EXPR
:
5109 /* ??? Similar to the above. */
5112 case WIDEN_SUM_EXPR
:
5113 case WIDEN_LSHIFT_EXPR
:
5114 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5115 && SCALAR_INT_MODE_P (mode
))
5118 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5120 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5122 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5123 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5128 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
5141 /* Return an RTX equivalent to the source bind value of the tree expression
5145 expand_debug_source_expr (tree exp
)
5148 machine_mode mode
= VOIDmode
, inner_mode
;
5150 switch (TREE_CODE (exp
))
5154 mode
= DECL_MODE (exp
);
5155 op0
= expand_debug_parm_decl (exp
);
5158 /* See if this isn't an argument that has been completely
5160 if (!DECL_RTL_SET_P (exp
)
5161 && !DECL_INCOMING_RTL (exp
)
5162 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5164 tree aexp
= DECL_ORIGIN (exp
);
5165 if (DECL_CONTEXT (aexp
)
5166 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5168 vec
<tree
, va_gc
> **debug_args
;
5171 debug_args
= decl_debug_args_lookup (current_function_decl
);
5172 if (debug_args
!= NULL
)
5174 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5177 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5187 if (op0
== NULL_RTX
)
5190 inner_mode
= GET_MODE (op0
);
5191 if (mode
== inner_mode
)
5194 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5196 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
5197 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5198 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
5199 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5201 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5203 else if (FLOAT_MODE_P (mode
))
5205 else if (FLOAT_MODE_P (inner_mode
))
5207 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5208 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5210 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5212 else if (CONSTANT_P (op0
)
5213 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
5214 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5215 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5216 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5218 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5223 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5224 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5225 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5228 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5232 if (exp
== NULL_RTX
)
5235 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5240 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5241 rtx dval
= make_debug_expr_from_rtl (exp
);
5243 /* Emit a debug bind insn before INSN. */
5244 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5245 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5246 VAR_INIT_STATUS_INITIALIZED
);
5248 emit_debug_insn_before (bind
, insn
);
5253 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5255 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5256 switch (*format_ptr
++)
5259 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5264 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5265 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5273 /* Expand the _LOCs in debug insns. We run this after expanding all
5274 regular insns, so that any variables referenced in the function
5275 will have their DECL_RTLs set. */
5278 expand_debug_locations (void)
5281 rtx_insn
*last
= get_last_insn ();
5282 int save_strict_alias
= flag_strict_aliasing
;
5284 /* New alias sets while setting up memory attributes cause
5285 -fcompare-debug failures, even though it doesn't bring about any
5287 flag_strict_aliasing
= 0;
5289 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5290 if (DEBUG_INSN_P (insn
))
5292 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5294 rtx_insn
*prev_insn
, *insn2
;
5297 if (value
== NULL_TREE
)
5301 if (INSN_VAR_LOCATION_STATUS (insn
)
5302 == VAR_INIT_STATUS_UNINITIALIZED
)
5303 val
= expand_debug_source_expr (value
);
5304 /* The avoid_deep_ter_for_debug function inserts
5305 debug bind stmts after SSA_NAME definition, with the
5306 SSA_NAME as the whole bind location. Disable temporarily
5307 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5308 being defined in this DEBUG_INSN. */
5309 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5311 tree
*slot
= deep_ter_debug_map
->get (value
);
5314 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5319 val
= expand_debug_expr (value
);
5321 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5324 val
= expand_debug_expr (value
);
5325 gcc_assert (last
== get_last_insn ());
5329 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5332 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5334 gcc_assert (mode
== GET_MODE (val
)
5335 || (GET_MODE (val
) == VOIDmode
5336 && (CONST_SCALAR_INT_P (val
)
5337 || GET_CODE (val
) == CONST_FIXED
5338 || GET_CODE (val
) == LABEL_REF
)));
5341 INSN_VAR_LOCATION_LOC (insn
) = val
;
5342 prev_insn
= PREV_INSN (insn
);
5343 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5344 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5347 flag_strict_aliasing
= save_strict_alias
;
5350 /* Performs swapping operands of commutative operations to expand
5351 the expensive one first. */
5354 reorder_operands (basic_block bb
)
5356 unsigned int *lattice
; /* Hold cost of each statement. */
5357 unsigned int i
= 0, n
= 0;
5358 gimple_stmt_iterator gsi
;
5364 use_operand_p use_p
;
5365 gimple
*def0
, *def1
;
5367 /* Compute cost of each statement using estimate_num_insns. */
5368 stmts
= bb_seq (bb
);
5369 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5371 stmt
= gsi_stmt (gsi
);
5372 if (!is_gimple_debug (stmt
))
5373 gimple_set_uid (stmt
, n
++);
5375 lattice
= XNEWVEC (unsigned int, n
);
5376 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5379 stmt
= gsi_stmt (gsi
);
5380 if (is_gimple_debug (stmt
))
5382 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5384 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5386 tree use
= USE_FROM_PTR (use_p
);
5388 if (TREE_CODE (use
) != SSA_NAME
)
5390 def_stmt
= get_gimple_for_ssa_name (use
);
5393 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5396 if (!is_gimple_assign (stmt
)
5397 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5399 op0
= gimple_op (stmt
, 1);
5400 op1
= gimple_op (stmt
, 2);
5401 if (TREE_CODE (op0
) != SSA_NAME
5402 || TREE_CODE (op1
) != SSA_NAME
)
5404 /* Swap operands if the second one is more expensive. */
5405 def0
= get_gimple_for_ssa_name (op0
);
5406 def1
= get_gimple_for_ssa_name (op1
);
5410 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5414 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5416 fprintf (dump_file
, "Swap operands in stmt:\n");
5417 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5418 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5419 def0
? lattice
[gimple_uid (def0
)] : 0,
5420 lattice
[gimple_uid (def1
)]);
5422 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5423 gimple_assign_rhs2_ptr (stmt
));
5429 /* Expand basic block BB from GIMPLE trees to RTL. */
5432 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5434 gimple_stmt_iterator gsi
;
5436 gimple
*stmt
= NULL
;
5443 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5446 /* Note that since we are now transitioning from GIMPLE to RTL, we
5447 cannot use the gsi_*_bb() routines because they expect the basic
5448 block to be in GIMPLE, instead of RTL. Therefore, we need to
5449 access the BB sequence directly. */
5451 reorder_operands (bb
);
5452 stmts
= bb_seq (bb
);
5453 bb
->il
.gimple
.seq
= NULL
;
5454 bb
->il
.gimple
.phi_nodes
= NULL
;
5455 rtl_profile_for_bb (bb
);
5456 init_rtl_bb_info (bb
);
5457 bb
->flags
|= BB_RTL
;
5459 /* Remove the RETURN_EXPR if we may fall though to the exit
5461 gsi
= gsi_last (stmts
);
5462 if (!gsi_end_p (gsi
)
5463 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5465 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5467 gcc_assert (single_succ_p (bb
));
5468 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5470 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5471 && !gimple_return_retval (ret_stmt
))
5473 gsi_remove (&gsi
, false);
5474 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5478 gsi
= gsi_start (stmts
);
5479 if (!gsi_end_p (gsi
))
5481 stmt
= gsi_stmt (gsi
);
5482 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5486 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5490 last
= get_last_insn ();
5494 expand_gimple_stmt (stmt
);
5501 /* Java emits line number notes in the top of labels.
5502 ??? Make this go away once line number notes are obsoleted. */
5503 BB_HEAD (bb
) = NEXT_INSN (last
);
5504 if (NOTE_P (BB_HEAD (bb
)))
5505 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5506 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5508 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5511 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5513 NOTE_BASIC_BLOCK (note
) = bb
;
5515 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5519 stmt
= gsi_stmt (gsi
);
5521 /* If this statement is a non-debug one, and we generate debug
5522 insns, then this one might be the last real use of a TERed
5523 SSA_NAME, but where there are still some debug uses further
5524 down. Expanding the current SSA name in such further debug
5525 uses by their RHS might lead to wrong debug info, as coalescing
5526 might make the operands of such RHS be placed into the same
5527 pseudo as something else. Like so:
5528 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5532 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5533 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5534 the write to a_2 would actually have clobbered the place which
5537 So, instead of that, we recognize the situation, and generate
5538 debug temporaries at the last real use of TERed SSA names:
5545 if (MAY_HAVE_DEBUG_INSNS
5547 && !is_gimple_debug (stmt
))
5553 location_t sloc
= curr_insn_location ();
5555 /* Look for SSA names that have their last use here (TERed
5556 names always have only one real use). */
5557 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5558 if ((def
= get_gimple_for_ssa_name (op
)))
5560 imm_use_iterator imm_iter
;
5561 use_operand_p use_p
;
5562 bool have_debug_uses
= false;
5564 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5566 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5568 have_debug_uses
= true;
5573 if (have_debug_uses
)
5575 /* OP is a TERed SSA name, with DEF its defining
5576 statement, and where OP is used in further debug
5577 instructions. Generate a debug temporary, and
5578 replace all uses of OP in debug insns with that
5581 tree value
= gimple_assign_rhs_to_tree (def
);
5582 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5586 set_curr_insn_location (gimple_location (def
));
5588 DECL_ARTIFICIAL (vexpr
) = 1;
5589 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5591 mode
= DECL_MODE (value
);
5593 mode
= TYPE_MODE (TREE_TYPE (value
));
5594 DECL_MODE (vexpr
) = mode
;
5596 val
= gen_rtx_VAR_LOCATION
5597 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5599 emit_debug_insn (val
);
5601 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5603 if (!gimple_debug_bind_p (debugstmt
))
5606 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5607 SET_USE (use_p
, vexpr
);
5609 update_stmt (debugstmt
);
5613 set_curr_insn_location (sloc
);
5616 currently_expanding_gimple_stmt
= stmt
;
5618 /* Expand this statement, then evaluate the resulting RTL and
5619 fixup the CFG accordingly. */
5620 if (gimple_code (stmt
) == GIMPLE_COND
)
5622 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5626 else if (gimple_debug_bind_p (stmt
))
5628 location_t sloc
= curr_insn_location ();
5629 gimple_stmt_iterator nsi
= gsi
;
5633 tree var
= gimple_debug_bind_get_var (stmt
);
5638 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5639 && TREE_CODE (var
) != LABEL_DECL
5640 && !target_for_debug_bind (var
))
5641 goto delink_debug_stmt
;
5643 if (gimple_debug_bind_has_value_p (stmt
))
5644 value
= gimple_debug_bind_get_value (stmt
);
5648 last
= get_last_insn ();
5650 set_curr_insn_location (gimple_location (stmt
));
5653 mode
= DECL_MODE (var
);
5655 mode
= TYPE_MODE (TREE_TYPE (var
));
5657 val
= gen_rtx_VAR_LOCATION
5658 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5660 emit_debug_insn (val
);
5662 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5664 /* We can't dump the insn with a TREE where an RTX
5666 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5667 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5668 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5672 /* In order not to generate too many debug temporaries,
5673 we delink all uses of debug statements we already expanded.
5674 Therefore debug statements between definition and real
5675 use of TERed SSA names will continue to use the SSA name,
5676 and not be replaced with debug temps. */
5677 delink_stmt_imm_use (stmt
);
5681 if (gsi_end_p (nsi
))
5683 stmt
= gsi_stmt (nsi
);
5684 if (!gimple_debug_bind_p (stmt
))
5688 set_curr_insn_location (sloc
);
5690 else if (gimple_debug_source_bind_p (stmt
))
5692 location_t sloc
= curr_insn_location ();
5693 tree var
= gimple_debug_source_bind_get_var (stmt
);
5694 tree value
= gimple_debug_source_bind_get_value (stmt
);
5698 last
= get_last_insn ();
5700 set_curr_insn_location (gimple_location (stmt
));
5702 mode
= DECL_MODE (var
);
5704 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5705 VAR_INIT_STATUS_UNINITIALIZED
);
5707 emit_debug_insn (val
);
5709 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5711 /* We can't dump the insn with a TREE where an RTX
5713 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5714 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5715 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5718 set_curr_insn_location (sloc
);
5722 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5724 && gimple_call_tail_p (call_stmt
)
5725 && disable_tail_calls
)
5726 gimple_call_set_tail (call_stmt
, false);
5728 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5731 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5742 def_operand_p def_p
;
5743 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5747 /* Ignore this stmt if it is in the list of
5748 replaceable expressions. */
5750 && bitmap_bit_p (SA
.values
,
5751 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5754 last
= expand_gimple_stmt (stmt
);
5755 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5760 currently_expanding_gimple_stmt
= NULL
;
5762 /* Expand implicit goto and convert goto_locus. */
5763 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5765 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5766 set_curr_insn_location (e
->goto_locus
);
5767 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5769 emit_jump (label_rtx_for_bb (e
->dest
));
5770 e
->flags
&= ~EDGE_FALLTHRU
;
5774 /* Expanded RTL can create a jump in the last instruction of block.
5775 This later might be assumed to be a jump to successor and break edge insertion.
5776 We need to insert dummy move to prevent this. PR41440. */
5777 if (single_succ_p (bb
)
5778 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5779 && (last
= get_last_insn ())
5782 rtx dummy
= gen_reg_rtx (SImode
);
5783 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5786 do_pending_stack_adjust ();
5788 /* Find the block tail. The last insn in the block is the insn
5789 before a barrier and/or table jump insn. */
5790 last
= get_last_insn ();
5791 if (BARRIER_P (last
))
5792 last
= PREV_INSN (last
);
5793 if (JUMP_TABLE_DATA_P (last
))
5794 last
= PREV_INSN (PREV_INSN (last
));
5797 update_bb_for_insn (bb
);
5803 /* Create a basic block for initialization code. */
5806 construct_init_block (void)
5808 basic_block init_block
, first_block
;
5812 /* Multiple entry points not supported yet. */
5813 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5814 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5815 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5816 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5817 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5819 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5821 /* When entry edge points to first basic block, we don't need jump,
5822 otherwise we have to jump into proper target. */
5823 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5825 tree label
= gimple_block_label (e
->dest
);
5827 emit_jump (jump_target_rtx (label
));
5831 flags
= EDGE_FALLTHRU
;
5833 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5835 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5836 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5837 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5838 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5841 first_block
= e
->dest
;
5842 redirect_edge_succ (e
, init_block
);
5843 e
= make_edge (init_block
, first_block
, flags
);
5846 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5847 e
->probability
= REG_BR_PROB_BASE
;
5848 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5850 update_bb_for_insn (init_block
);
5854 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5855 found in the block tree. */
5858 set_block_levels (tree block
, int level
)
5862 BLOCK_NUMBER (block
) = level
;
5863 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5864 block
= BLOCK_CHAIN (block
);
5868 /* Create a block containing landing pads and similar stuff. */
5871 construct_exit_block (void)
5873 rtx_insn
*head
= get_last_insn ();
5875 basic_block exit_block
;
5879 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5880 rtx_insn
*orig_end
= BB_END (prev_bb
);
5882 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5884 /* Make sure the locus is set to the end of the function, so that
5885 epilogue line numbers and warnings are set properly. */
5886 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5887 input_location
= cfun
->function_end_locus
;
5889 /* Generate rtl for function exit. */
5890 expand_function_end ();
5892 end
= get_last_insn ();
5895 /* While emitting the function end we could move end of the last basic
5897 BB_END (prev_bb
) = orig_end
;
5898 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5899 head
= NEXT_INSN (head
);
5900 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5901 bb frequency counting will be confused. Any instructions before that
5902 label are emitted for the case where PREV_BB falls through into the
5903 exit block, so append those instructions to prev_bb in that case. */
5904 if (NEXT_INSN (head
) != return_label
)
5906 while (NEXT_INSN (head
) != return_label
)
5908 if (!NOTE_P (NEXT_INSN (head
)))
5909 BB_END (prev_bb
) = NEXT_INSN (head
);
5910 head
= NEXT_INSN (head
);
5913 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5914 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5915 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5916 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5919 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5921 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5922 if (!(e
->flags
& EDGE_ABNORMAL
))
5923 redirect_edge_succ (e
, exit_block
);
5928 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5929 e
->probability
= REG_BR_PROB_BASE
;
5930 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5931 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5934 e
->count
-= e2
->count
;
5935 exit_block
->count
-= e2
->count
;
5936 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5940 if (exit_block
->count
< 0)
5941 exit_block
->count
= 0;
5942 if (exit_block
->frequency
< 0)
5943 exit_block
->frequency
= 0;
5944 update_bb_for_insn (exit_block
);
5947 /* Helper function for discover_nonconstant_array_refs.
5948 Look for ARRAY_REF nodes with non-constant indexes and mark them
5952 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5953 void *data ATTRIBUTE_UNUSED
)
5957 if (IS_TYPE_OR_DECL_P (t
))
5959 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5961 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5962 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5963 && (!TREE_OPERAND (t
, 2)
5964 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5965 || (TREE_CODE (t
) == COMPONENT_REF
5966 && (!TREE_OPERAND (t
,2)
5967 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5968 || TREE_CODE (t
) == BIT_FIELD_REF
5969 || TREE_CODE (t
) == REALPART_EXPR
5970 || TREE_CODE (t
) == IMAGPART_EXPR
5971 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5972 || CONVERT_EXPR_P (t
))
5973 t
= TREE_OPERAND (t
, 0);
5975 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5977 t
= get_base_address (t
);
5979 && DECL_MODE (t
) != BLKmode
)
5980 TREE_ADDRESSABLE (t
) = 1;
5989 /* RTL expansion is not able to compile array references with variable
5990 offsets for arrays stored in single register. Discover such
5991 expressions and mark variables as addressable to avoid this
5995 discover_nonconstant_array_refs (void)
5998 gimple_stmt_iterator gsi
;
6000 FOR_EACH_BB_FN (bb
, cfun
)
6001 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6003 gimple
*stmt
= gsi_stmt (gsi
);
6004 if (!is_gimple_debug (stmt
))
6005 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6009 /* This function sets crtl->args.internal_arg_pointer to a virtual
6010 register if DRAP is needed. Local register allocator will replace
6011 virtual_incoming_args_rtx with the virtual register. */
6014 expand_stack_alignment (void)
6017 unsigned int preferred_stack_boundary
;
6019 if (! SUPPORTS_STACK_ALIGNMENT
)
6022 if (cfun
->calls_alloca
6023 || cfun
->has_nonlocal_label
6024 || crtl
->has_nonlocal_goto
)
6025 crtl
->need_drap
= true;
6027 /* Call update_stack_boundary here again to update incoming stack
6028 boundary. It may set incoming stack alignment to a different
6029 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6030 use the minimum incoming stack alignment to check if it is OK
6031 to perform sibcall optimization since sibcall optimization will
6032 only align the outgoing stack to incoming stack boundary. */
6033 if (targetm
.calls
.update_stack_boundary
)
6034 targetm
.calls
.update_stack_boundary ();
6036 /* The incoming stack frame has to be aligned at least at
6037 parm_stack_boundary. */
6038 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6040 /* Update crtl->stack_alignment_estimated and use it later to align
6041 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6042 exceptions since callgraph doesn't collect incoming stack alignment
6044 if (cfun
->can_throw_non_call_exceptions
6045 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6046 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6048 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6049 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6050 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6051 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6052 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6054 gcc_assert (crtl
->stack_alignment_needed
6055 <= crtl
->stack_alignment_estimated
);
6057 crtl
->stack_realign_needed
6058 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6059 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6061 crtl
->stack_realign_processed
= true;
6063 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6065 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6066 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6068 /* stack_realign_drap and drap_rtx must match. */
6069 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6071 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6072 if (NULL
!= drap_rtx
)
6074 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6076 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6078 fixup_tail_calls ();
6084 expand_main_function (void)
6086 #if (defined(INVOKE__main) \
6087 || (!defined(HAS_INIT_SECTION) \
6088 && !defined(INIT_SECTION_ASM_OP) \
6089 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6090 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
6095 /* Expand code to initialize the stack_protect_guard. This is invoked at
6096 the beginning of a function to be protected. */
6099 stack_protect_prologue (void)
6101 tree guard_decl
= targetm
.stack_protect_guard ();
6104 x
= expand_normal (crtl
->stack_protect_guard
);
6106 y
= expand_normal (guard_decl
);
6110 /* Allow the target to copy from Y to X without leaking Y into a
6112 if (targetm
.have_stack_protect_set ())
6113 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6119 /* Otherwise do a straight move. */
6120 emit_move_insn (x
, y
);
6123 /* Translate the intermediate representation contained in the CFG
6124 from GIMPLE trees to RTL.
6126 We do conversion per basic block and preserve/update the tree CFG.
6127 This implies we have to do some magic as the CFG can simultaneously
6128 consist of basic blocks containing RTL and GIMPLE trees. This can
6129 confuse the CFG hooks, so be careful to not manipulate CFG during
6134 const pass_data pass_data_expand
=
6136 RTL_PASS
, /* type */
6137 "expand", /* name */
6138 OPTGROUP_NONE
, /* optinfo_flags */
6139 TV_EXPAND
, /* tv_id */
6140 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6143 | PROP_gimple_lva
), /* properties_required */
6144 PROP_rtl
, /* properties_provided */
6145 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6146 0, /* todo_flags_start */
6147 0, /* todo_flags_finish */
6150 class pass_expand
: public rtl_opt_pass
6153 pass_expand (gcc::context
*ctxt
)
6154 : rtl_opt_pass (pass_data_expand
, ctxt
)
6157 /* opt_pass methods: */
6158 virtual unsigned int execute (function
*);
6160 }; // class pass_expand
6163 pass_expand::execute (function
*fun
)
6165 basic_block bb
, init_block
;
6168 rtx_insn
*var_seq
, *var_ret_seq
;
6171 timevar_push (TV_OUT_OF_SSA
);
6172 rewrite_out_of_ssa (&SA
);
6173 timevar_pop (TV_OUT_OF_SSA
);
6174 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6176 if (MAY_HAVE_DEBUG_STMTS
&& flag_tree_ter
)
6178 gimple_stmt_iterator gsi
;
6179 FOR_EACH_BB_FN (bb
, cfun
)
6180 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6181 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6182 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6185 /* Make sure all values used by the optimization passes have sane
6189 /* Some backends want to know that we are expanding to RTL. */
6190 currently_expanding_to_rtl
= 1;
6191 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6192 free_dominance_info (CDI_DOMINATORS
);
6194 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6196 if (chkp_function_instrumented_p (current_function_decl
))
6197 chkp_reset_rtl_bounds ();
6199 insn_locations_init ();
6200 if (!DECL_IS_BUILTIN (current_function_decl
))
6202 /* Eventually, all FEs should explicitly set function_start_locus. */
6203 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6204 set_curr_insn_location
6205 (DECL_SOURCE_LOCATION (current_function_decl
));
6207 set_curr_insn_location (fun
->function_start_locus
);
6210 set_curr_insn_location (UNKNOWN_LOCATION
);
6211 prologue_location
= curr_insn_location ();
6213 #ifdef INSN_SCHEDULING
6214 init_sched_attrs ();
6217 /* Make sure first insn is a note even if we don't want linenums.
6218 This makes sure the first insn will never be deleted.
6219 Also, final expects a note to appear there. */
6220 emit_note (NOTE_INSN_DELETED
);
6222 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6223 discover_nonconstant_array_refs ();
6225 targetm
.expand_to_rtl_hook ();
6226 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
6227 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
6228 crtl
->stack_alignment_estimated
= 0;
6229 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
6230 fun
->cfg
->max_jumptable_ents
= 0;
6232 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6233 of the function section at exapnsion time to predict distance of calls. */
6234 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6236 /* Expand the variables recorded during gimple lowering. */
6237 timevar_push (TV_VAR_EXPAND
);
6240 var_ret_seq
= expand_used_vars ();
6242 var_seq
= get_insns ();
6244 timevar_pop (TV_VAR_EXPAND
);
6246 /* Honor stack protection warnings. */
6247 if (warn_stack_protect
)
6249 if (fun
->calls_alloca
)
6250 warning (OPT_Wstack_protector
,
6251 "stack protector not protecting local variables: "
6252 "variable length buffer");
6253 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6254 warning (OPT_Wstack_protector
,
6255 "stack protector not protecting function: "
6256 "all local arrays are less than %d bytes long",
6257 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
6260 /* Set up parameters and prepare for return, for the function. */
6261 expand_function_start (current_function_decl
);
6263 /* If we emitted any instructions for setting up the variables,
6264 emit them before the FUNCTION_START note. */
6267 emit_insn_before (var_seq
, parm_birth_insn
);
6269 /* In expand_function_end we'll insert the alloca save/restore
6270 before parm_birth_insn. We've just insertted an alloca call.
6271 Adjust the pointer to match. */
6272 parm_birth_insn
= var_seq
;
6275 /* Now propagate the RTL assignment of each partition to the
6276 underlying var of each SSA_NAME. */
6279 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6281 /* We might have generated new SSA names in
6282 update_alias_info_with_stack_vars. They will have a NULL
6283 defining statements, and won't be part of the partitioning,
6285 if (!SSA_NAME_DEF_STMT (name
))
6288 adjust_one_expanded_partition_var (name
);
6291 /* Clean up RTL of variables that straddle across multiple
6292 partitions, and check that the rtl of any PARM_DECLs that are not
6293 cleaned up is that of their default defs. */
6294 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6298 /* We might have generated new SSA names in
6299 update_alias_info_with_stack_vars. They will have a NULL
6300 defining statements, and won't be part of the partitioning,
6302 if (!SSA_NAME_DEF_STMT (name
))
6304 part
= var_to_partition (SA
.map
, name
);
6305 if (part
== NO_PARTITION
)
6308 /* If this decl was marked as living in multiple places, reset
6309 this now to NULL. */
6310 tree var
= SSA_NAME_VAR (name
);
6311 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6312 SET_DECL_RTL (var
, NULL
);
6313 /* Check that the pseudos chosen by assign_parms are those of
6314 the corresponding default defs. */
6315 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6316 && (TREE_CODE (var
) == PARM_DECL
6317 || TREE_CODE (var
) == RESULT_DECL
))
6319 rtx in
= DECL_RTL_IF_SET (var
);
6321 rtx out
= SA
.partition_to_pseudo
[part
];
6322 gcc_assert (in
== out
);
6324 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6325 those expected by debug backends for each parm and for
6326 the result. This is particularly important for stabs,
6327 whose register elimination from parm's DECL_RTL may cause
6328 -fcompare-debug differences as SET_DECL_RTL changes reg's
6329 attrs. So, make sure the RTL already has the parm as the
6330 EXPR, so that it won't change. */
6331 SET_DECL_RTL (var
, NULL_RTX
);
6333 set_mem_attributes (in
, var
, true);
6334 SET_DECL_RTL (var
, in
);
6338 /* If this function is `main', emit a call to `__main'
6339 to run global initializers, etc. */
6340 if (DECL_NAME (current_function_decl
)
6341 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6342 && DECL_FILE_SCOPE_P (current_function_decl
))
6343 expand_main_function ();
6345 /* Initialize the stack_protect_guard field. This must happen after the
6346 call to __main (if any) so that the external decl is initialized. */
6347 if (crtl
->stack_protect_guard
)
6348 stack_protect_prologue ();
6350 expand_phi_nodes (&SA
);
6352 /* Release any stale SSA redirection data. */
6353 redirect_edge_var_map_empty ();
6355 /* Register rtl specific functions for cfg. */
6356 rtl_register_cfg_hooks ();
6358 init_block
= construct_init_block ();
6360 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6361 remaining edges later. */
6362 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6363 e
->flags
&= ~EDGE_EXECUTABLE
;
6365 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6366 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6368 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6370 if (MAY_HAVE_DEBUG_INSNS
)
6371 expand_debug_locations ();
6373 if (deep_ter_debug_map
)
6375 delete deep_ter_debug_map
;
6376 deep_ter_debug_map
= NULL
;
6379 /* Free stuff we no longer need after GIMPLE optimizations. */
6380 free_dominance_info (CDI_DOMINATORS
);
6381 free_dominance_info (CDI_POST_DOMINATORS
);
6382 delete_tree_cfg_annotations (fun
);
6384 timevar_push (TV_OUT_OF_SSA
);
6385 finish_out_of_ssa (&SA
);
6386 timevar_pop (TV_OUT_OF_SSA
);
6388 timevar_push (TV_POST_EXPAND
);
6389 /* We are no longer in SSA form. */
6390 fun
->gimple_df
->in_ssa_p
= false;
6391 loops_state_clear (LOOP_CLOSED_SSA
);
6393 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6394 conservatively to true until they are all profile aware. */
6395 delete lab_rtx_for_bb
;
6396 free_histograms (fun
);
6398 construct_exit_block ();
6399 insn_locations_finalize ();
6403 rtx_insn
*after
= return_label
;
6404 rtx_insn
*next
= NEXT_INSN (after
);
6405 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6407 emit_insn_after (var_ret_seq
, after
);
6410 /* Zap the tree EH table. */
6411 set_eh_throw_stmt_table (fun
, NULL
);
6413 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6414 split edges which edge insertions might do. */
6415 rebuild_jump_labels (get_insns ());
6417 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
6418 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6422 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6426 rebuild_jump_labels_chain (e
->insns
.r
);
6427 /* Put insns after parm birth, but before
6428 NOTE_INSNS_FUNCTION_BEG. */
6429 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
6430 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6432 rtx_insn
*insns
= e
->insns
.r
;
6434 if (NOTE_P (parm_birth_insn
)
6435 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6436 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6438 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6441 commit_one_edge_insertion (e
);
6448 /* We're done expanding trees to RTL. */
6449 currently_expanding_to_rtl
= 0;
6451 flush_mark_addressable_queue ();
6453 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6454 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6458 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6460 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6461 e
->flags
&= ~EDGE_EXECUTABLE
;
6463 /* At the moment not all abnormal edges match the RTL
6464 representation. It is safe to remove them here as
6465 find_many_sub_basic_blocks will rediscover them.
6466 In the future we should get this fixed properly. */
6467 if ((e
->flags
& EDGE_ABNORMAL
)
6468 && !(e
->flags
& EDGE_SIBCALL
))
6475 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6476 bitmap_ones (blocks
);
6477 find_many_sub_basic_blocks (blocks
);
6478 purge_all_dead_edges ();
6480 expand_stack_alignment ();
6482 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6484 if (crtl
->tail_call_emit
)
6485 fixup_tail_calls ();
6487 /* After initial rtl generation, call back to finish generating
6488 exception support code. We need to do this before cleaning up
6489 the CFG as the code does not expect dead landing pads. */
6490 if (fun
->eh
->region_tree
!= NULL
)
6491 finish_eh_generation ();
6493 /* Remove unreachable blocks, otherwise we cannot compute dominators
6494 which are needed for loop state verification. As a side-effect
6495 this also compacts blocks.
6496 ??? We cannot remove trivially dead insns here as for example
6497 the DRAP reg on i?86 is not magically live at this point.
6498 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6499 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6501 checking_verify_flow_info ();
6503 /* Initialize pseudos allocated for hard registers. */
6504 emit_initial_value_sets ();
6506 /* And finally unshare all RTL. */
6509 /* There's no need to defer outputting this function any more; we
6510 know we want to output it. */
6511 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6513 /* Now that we're done expanding trees to RTL, we shouldn't have any
6514 more CONCATs anywhere. */
6515 generating_concat_p
= 0;
6520 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6521 /* And the pass manager will dump RTL for us. */
6524 /* If we're emitting a nested function, make sure its parent gets
6525 emitted as well. Doing otherwise confuses debug info. */
6528 for (parent
= DECL_CONTEXT (current_function_decl
);
6529 parent
!= NULL_TREE
;
6530 parent
= get_containing_scope (parent
))
6531 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6532 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6535 /* We are now committed to emitting code for this function. Do any
6536 preparation, such as emitting abstract debug info for the inline
6537 before it gets mangled by optimization. */
6538 if (cgraph_function_possibly_inlined_p (current_function_decl
))
6539 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
6541 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6543 /* After expanding, the return labels are no longer needed. */
6544 return_label
= NULL
;
6545 naked_return_label
= NULL
;
6547 /* After expanding, the tm_restart map is no longer needed. */
6548 if (fun
->gimple_df
->tm_restart
)
6549 fun
->gimple_df
->tm_restart
= NULL
;
6551 /* Tag the blocks with a depth number so that change_scope can find
6552 the common parent easily. */
6553 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6554 default_rtl_profile ();
6556 timevar_pop (TV_POST_EXPAND
);
6564 make_pass_expand (gcc::context
*ctxt
)
6566 return new pass_expand (ctxt
);