1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2015 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"
25 #include "hard-reg-set.h"
29 #include "double-int.h"
36 #include "fold-const.h"
37 #include "stringpool.h"
39 #include "stor-layout.h"
41 #include "print-tree.h"
46 #include "dominance.h"
51 #include "cfgcleanup.h"
52 #include "basic-block.h"
53 #include "insn-codes.h"
56 #include "statistics.h"
58 #include "fixed-value.h"
59 #include "insn-config.h"
66 #include "langhooks.h"
68 #include "tree-ssa-alias.h"
69 #include "internal-fn.h"
71 #include "gimple-expr.h"
74 #include "gimple-iterator.h"
75 #include "gimple-walk.h"
76 #include "gimple-ssa.h"
78 #include "plugin-api.h"
82 #include "tree-phinodes.h"
83 #include "ssa-iterators.h"
84 #include "tree-ssanames.h"
87 #include "tree-pass.h"
89 #include "diagnostic.h"
90 #include "gimple-pretty-print.h"
94 #include "tree-inline.h"
95 #include "value-prof.h"
97 #include "tree-ssa-live.h"
98 #include "tree-outof-ssa.h"
101 #include "regs.h" /* For reg_renumber. */
102 #include "insn-attr.h" /* For INSN_SCHEDULING. */
104 #include "tree-ssa-address.h"
107 #include "builtins.h"
108 #include "tree-chkp.h"
109 #include "rtl-chkp.h"
111 /* Some systems use __main in a way incompatible with its use in gcc, in these
112 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
113 give the same symbol without quotes for an alternative entry point. You
114 must define both, or neither. */
116 #define NAME__MAIN "__main"
119 /* This variable holds information helping the rewriting of SSA trees
123 /* This variable holds the currently expanded gimple statement for purposes
124 of comminucating the profile info to the builtin expanders. */
125 gimple currently_expanding_gimple_stmt
;
127 static rtx
expand_debug_expr (tree
);
129 /* Return an expression tree corresponding to the RHS of GIMPLE
133 gimple_assign_rhs_to_tree (gimple stmt
)
136 enum gimple_rhs_class grhs_class
;
138 grhs_class
= get_gimple_rhs_class (gimple_expr_code (stmt
));
140 if (grhs_class
== GIMPLE_TERNARY_RHS
)
141 t
= build3 (gimple_assign_rhs_code (stmt
),
142 TREE_TYPE (gimple_assign_lhs (stmt
)),
143 gimple_assign_rhs1 (stmt
),
144 gimple_assign_rhs2 (stmt
),
145 gimple_assign_rhs3 (stmt
));
146 else if (grhs_class
== GIMPLE_BINARY_RHS
)
147 t
= build2 (gimple_assign_rhs_code (stmt
),
148 TREE_TYPE (gimple_assign_lhs (stmt
)),
149 gimple_assign_rhs1 (stmt
),
150 gimple_assign_rhs2 (stmt
));
151 else if (grhs_class
== GIMPLE_UNARY_RHS
)
152 t
= build1 (gimple_assign_rhs_code (stmt
),
153 TREE_TYPE (gimple_assign_lhs (stmt
)),
154 gimple_assign_rhs1 (stmt
));
155 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
157 t
= gimple_assign_rhs1 (stmt
);
158 /* Avoid modifying this tree in place below. */
159 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
160 && gimple_location (stmt
) != EXPR_LOCATION (t
))
161 || (gimple_block (stmt
)
162 && currently_expanding_to_rtl
169 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
170 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
176 #ifndef STACK_ALIGNMENT_NEEDED
177 #define STACK_ALIGNMENT_NEEDED 1
180 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
182 /* Associate declaration T with storage space X. If T is no
183 SSA name this is exactly SET_DECL_RTL, otherwise make the
184 partition of T associated with X. */
186 set_rtl (tree t
, rtx x
)
188 if (TREE_CODE (t
) == SSA_NAME
)
190 SA
.partition_to_pseudo
[var_to_partition (SA
.map
, t
)] = x
;
192 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t
), x
);
193 /* For the benefit of debug information at -O0 (where vartracking
194 doesn't run) record the place also in the base DECL if it's
195 a normal variable (not a parameter). */
196 if (x
&& x
!= pc_rtx
&& TREE_CODE (SSA_NAME_VAR (t
)) == VAR_DECL
)
198 tree var
= SSA_NAME_VAR (t
);
199 /* If we don't yet have something recorded, just record it now. */
200 if (!DECL_RTL_SET_P (var
))
201 SET_DECL_RTL (var
, x
);
202 /* If we have it set already to "multiple places" don't
204 else if (DECL_RTL (var
) == pc_rtx
)
206 /* If we have something recorded and it's not the same place
207 as we want to record now, we have multiple partitions for the
208 same base variable, with different places. We can't just
209 randomly chose one, hence we have to say that we don't know.
210 This only happens with optimization, and there var-tracking
211 will figure out the right thing. */
212 else if (DECL_RTL (var
) != x
)
213 SET_DECL_RTL (var
, pc_rtx
);
220 /* This structure holds data relevant to one variable that will be
221 placed in a stack slot. */
227 /* Initially, the size of the variable. Later, the size of the partition,
228 if this variable becomes it's partition's representative. */
231 /* The *byte* alignment required for this variable. Or as, with the
232 size, the alignment for this partition. */
235 /* The partition representative. */
236 size_t representative
;
238 /* The next stack variable in the partition, or EOC. */
241 /* The numbers of conflicting stack variables. */
245 #define EOC ((size_t)-1)
247 /* We have an array of such objects while deciding allocation. */
248 static struct stack_var
*stack_vars
;
249 static size_t stack_vars_alloc
;
250 static size_t stack_vars_num
;
251 static hash_map
<tree
, size_t> *decl_to_stack_part
;
253 /* Conflict bitmaps go on this obstack. This allows us to destroy
254 all of them in one big sweep. */
255 static bitmap_obstack stack_var_bitmap_obstack
;
257 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
258 is non-decreasing. */
259 static size_t *stack_vars_sorted
;
261 /* The phase of the stack frame. This is the known misalignment of
262 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
263 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
264 static int frame_phase
;
266 /* Used during expand_used_vars to remember if we saw any decls for
267 which we'd like to enable stack smashing protection. */
268 static bool has_protected_decls
;
270 /* Used during expand_used_vars. Remember if we say a character buffer
271 smaller than our cutoff threshold. Used for -Wstack-protector. */
272 static bool has_short_buffer
;
274 /* Compute the byte alignment to use for DECL. Ignore alignment
275 we can't do with expected alignment of the stack boundary. */
278 align_local_variable (tree decl
)
280 unsigned int align
= LOCAL_DECL_ALIGNMENT (decl
);
281 DECL_ALIGN (decl
) = align
;
282 return align
/ BITS_PER_UNIT
;
285 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
286 down otherwise. Return truncated BASE value. */
288 static inline unsigned HOST_WIDE_INT
289 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
291 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
294 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
295 Return the frame offset. */
298 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
300 HOST_WIDE_INT offset
, new_frame_offset
;
302 if (FRAME_GROWS_DOWNWARD
)
305 = align_base (frame_offset
- frame_phase
- size
,
306 align
, false) + frame_phase
;
307 offset
= new_frame_offset
;
312 = align_base (frame_offset
- frame_phase
, align
, true) + frame_phase
;
313 offset
= new_frame_offset
;
314 new_frame_offset
+= size
;
316 frame_offset
= new_frame_offset
;
318 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
319 frame_offset
= offset
= 0;
324 /* Accumulate DECL into STACK_VARS. */
327 add_stack_var (tree decl
)
331 if (stack_vars_num
>= stack_vars_alloc
)
333 if (stack_vars_alloc
)
334 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
336 stack_vars_alloc
= 32;
338 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
340 if (!decl_to_stack_part
)
341 decl_to_stack_part
= new hash_map
<tree
, size_t>;
343 v
= &stack_vars
[stack_vars_num
];
344 decl_to_stack_part
->put (decl
, stack_vars_num
);
347 v
->size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (decl
)));
348 /* Ensure that all variables have size, so that &a != &b for any two
349 variables that are simultaneously live. */
352 v
->alignb
= align_local_variable (SSAVAR (decl
));
353 /* An alignment of zero can mightily confuse us later. */
354 gcc_assert (v
->alignb
!= 0);
356 /* All variables are initially in their own partition. */
357 v
->representative
= stack_vars_num
;
360 /* All variables initially conflict with no other. */
363 /* Ensure that this decl doesn't get put onto the list twice. */
364 set_rtl (decl
, pc_rtx
);
369 /* Make the decls associated with luid's X and Y conflict. */
372 add_stack_var_conflict (size_t x
, size_t y
)
374 struct stack_var
*a
= &stack_vars
[x
];
375 struct stack_var
*b
= &stack_vars
[y
];
377 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
379 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
380 bitmap_set_bit (a
->conflicts
, y
);
381 bitmap_set_bit (b
->conflicts
, x
);
384 /* Check whether the decls associated with luid's X and Y conflict. */
387 stack_var_conflict_p (size_t x
, size_t y
)
389 struct stack_var
*a
= &stack_vars
[x
];
390 struct stack_var
*b
= &stack_vars
[y
];
393 /* Partitions containing an SSA name result from gimple registers
394 with things like unsupported modes. They are top-level and
395 hence conflict with everything else. */
396 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
399 if (!a
->conflicts
|| !b
->conflicts
)
401 return bitmap_bit_p (a
->conflicts
, y
);
404 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
405 enter its partition number into bitmap DATA. */
408 visit_op (gimple
, tree op
, tree
, void *data
)
410 bitmap active
= (bitmap
)data
;
411 op
= get_base_address (op
);
414 && DECL_RTL_IF_SET (op
) == pc_rtx
)
416 size_t *v
= decl_to_stack_part
->get (op
);
418 bitmap_set_bit (active
, *v
);
423 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
424 record conflicts between it and all currently active other partitions
428 visit_conflict (gimple
, tree op
, tree
, void *data
)
430 bitmap active
= (bitmap
)data
;
431 op
= get_base_address (op
);
434 && DECL_RTL_IF_SET (op
) == pc_rtx
)
436 size_t *v
= decl_to_stack_part
->get (op
);
437 if (v
&& bitmap_set_bit (active
, *v
))
442 gcc_assert (num
< stack_vars_num
);
443 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
444 add_stack_var_conflict (num
, i
);
450 /* Helper routine for add_scope_conflicts, calculating the active partitions
451 at the end of BB, leaving the result in WORK. We're called to generate
452 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
456 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
460 gimple_stmt_iterator gsi
;
461 walk_stmt_load_store_addr_fn visit
;
464 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
465 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
469 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
471 gimple stmt
= gsi_stmt (gsi
);
472 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
474 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
476 gimple stmt
= gsi_stmt (gsi
);
478 if (gimple_clobber_p (stmt
))
480 tree lhs
= gimple_assign_lhs (stmt
);
482 /* Nested function lowering might introduce LHSs
483 that are COMPONENT_REFs. */
484 if (TREE_CODE (lhs
) != VAR_DECL
)
486 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
487 && (v
= decl_to_stack_part
->get (lhs
)))
488 bitmap_clear_bit (work
, *v
);
490 else if (!is_gimple_debug (stmt
))
493 && visit
== visit_op
)
495 /* If this is the first real instruction in this BB we need
496 to add conflicts for everything live at this point now.
497 Unlike classical liveness for named objects we can't
498 rely on seeing a def/use of the names we're interested in.
499 There might merely be indirect loads/stores. We'd not add any
500 conflicts for such partitions. */
503 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
505 struct stack_var
*a
= &stack_vars
[i
];
507 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
508 bitmap_ior_into (a
->conflicts
, work
);
510 visit
= visit_conflict
;
512 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
517 /* Generate stack partition conflicts between all partitions that are
518 simultaneously live. */
521 add_scope_conflicts (void)
525 bitmap work
= BITMAP_ALLOC (NULL
);
529 /* We approximate the live range of a stack variable by taking the first
530 mention of its name as starting point(s), and by the end-of-scope
531 death clobber added by gimplify as ending point(s) of the range.
532 This overapproximates in the case we for instance moved an address-taken
533 operation upward, without also moving a dereference to it upwards.
534 But it's conservatively correct as a variable never can hold values
535 before its name is mentioned at least once.
537 We then do a mostly classical bitmap liveness algorithm. */
539 FOR_ALL_BB_FN (bb
, cfun
)
540 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
542 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
543 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
550 for (i
= 0; i
< n_bbs
; i
++)
553 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
554 active
= (bitmap
)bb
->aux
;
555 add_scope_conflicts_1 (bb
, work
, false);
556 if (bitmap_ior_into (active
, work
))
561 FOR_EACH_BB_FN (bb
, cfun
)
562 add_scope_conflicts_1 (bb
, work
, true);
566 FOR_ALL_BB_FN (bb
, cfun
)
567 BITMAP_FREE (bb
->aux
);
570 /* A subroutine of partition_stack_vars. A comparison function for qsort,
571 sorting an array of indices by the properties of the object. */
574 stack_var_cmp (const void *a
, const void *b
)
576 size_t ia
= *(const size_t *)a
;
577 size_t ib
= *(const size_t *)b
;
578 unsigned int aligna
= stack_vars
[ia
].alignb
;
579 unsigned int alignb
= stack_vars
[ib
].alignb
;
580 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
581 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
582 tree decla
= stack_vars
[ia
].decl
;
583 tree declb
= stack_vars
[ib
].decl
;
585 unsigned int uida
, uidb
;
587 /* Primary compare on "large" alignment. Large comes first. */
588 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
589 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
590 if (largea
!= largeb
)
591 return (int)largeb
- (int)largea
;
593 /* Secondary compare on size, decreasing */
599 /* Tertiary compare on true alignment, decreasing. */
605 /* Final compare on ID for sort stability, increasing.
606 Two SSA names are compared by their version, SSA names come before
607 non-SSA names, and two normal decls are compared by their DECL_UID. */
608 if (TREE_CODE (decla
) == SSA_NAME
)
610 if (TREE_CODE (declb
) == SSA_NAME
)
611 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
615 else if (TREE_CODE (declb
) == SSA_NAME
)
618 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
626 struct part_traits
: default_hashmap_traits
631 { return e
.m_value
== reinterpret_cast<void *> (1); }
633 template<typename T
> static bool is_empty (T
&e
) { return e
.m_value
== NULL
; }
637 { e
.m_value
= reinterpret_cast<T
> (1); }
642 { e
.m_value
= NULL
; }
645 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
647 /* If the points-to solution *PI points to variables that are in a partition
648 together with other variables add all partition members to the pointed-to
652 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
653 part_hashmap
*decls_to_partitions
,
654 hash_set
<bitmap
> *visited
, bitmap temp
)
662 /* The pointed-to vars bitmap is shared, it is enough to
664 || visited
->add (pt
->vars
))
669 /* By using a temporary bitmap to store all members of the partitions
670 we have to add we make sure to visit each of the partitions only
672 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
674 || !bitmap_bit_p (temp
, i
))
675 && (part
= decls_to_partitions
->get (i
)))
676 bitmap_ior_into (temp
, *part
);
677 if (!bitmap_empty_p (temp
))
678 bitmap_ior_into (pt
->vars
, temp
);
681 /* Update points-to sets based on partition info, so we can use them on RTL.
682 The bitmaps representing stack partitions will be saved until expand,
683 where partitioned decls used as bases in memory expressions will be
687 update_alias_info_with_stack_vars (void)
689 part_hashmap
*decls_to_partitions
= NULL
;
691 tree var
= NULL_TREE
;
693 for (i
= 0; i
< stack_vars_num
; i
++)
697 struct ptr_info_def
*pi
;
699 /* Not interested in partitions with single variable. */
700 if (stack_vars
[i
].representative
!= i
701 || stack_vars
[i
].next
== EOC
)
704 if (!decls_to_partitions
)
706 decls_to_partitions
= new part_hashmap
;
707 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
710 /* Create an SSA_NAME that points to the partition for use
711 as base during alias-oracle queries on RTL for bases that
712 have been partitioned. */
713 if (var
== NULL_TREE
)
714 var
= create_tmp_var (ptr_type_node
);
715 name
= make_ssa_name (var
);
717 /* Create bitmaps representing partitions. They will be used for
718 points-to sets later, so use GGC alloc. */
719 part
= BITMAP_GGC_ALLOC ();
720 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
722 tree decl
= stack_vars
[j
].decl
;
723 unsigned int uid
= DECL_PT_UID (decl
);
724 bitmap_set_bit (part
, uid
);
725 decls_to_partitions
->put (uid
, part
);
726 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
727 if (TREE_ADDRESSABLE (decl
))
728 TREE_ADDRESSABLE (name
) = 1;
731 /* Make the SSA name point to all partition members. */
732 pi
= get_ptr_info (name
);
733 pt_solution_set (&pi
->pt
, part
, false);
736 /* Make all points-to sets that contain one member of a partition
737 contain all members of the partition. */
738 if (decls_to_partitions
)
741 hash_set
<bitmap
> visited
;
742 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
744 for (i
= 1; i
< num_ssa_names
; i
++)
746 tree name
= ssa_name (i
);
747 struct ptr_info_def
*pi
;
750 && POINTER_TYPE_P (TREE_TYPE (name
))
751 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
752 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
756 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
757 decls_to_partitions
, &visited
, temp
);
759 delete decls_to_partitions
;
764 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
765 partitioning algorithm. Partitions A and B are known to be non-conflicting.
766 Merge them into a single partition A. */
769 union_stack_vars (size_t a
, size_t b
)
771 struct stack_var
*vb
= &stack_vars
[b
];
775 gcc_assert (stack_vars
[b
].next
== EOC
);
776 /* Add B to A's partition. */
777 stack_vars
[b
].next
= stack_vars
[a
].next
;
778 stack_vars
[b
].representative
= a
;
779 stack_vars
[a
].next
= b
;
781 /* Update the required alignment of partition A to account for B. */
782 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
783 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
785 /* Update the interference graph and merge the conflicts. */
788 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
789 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
790 BITMAP_FREE (vb
->conflicts
);
794 /* A subroutine of expand_used_vars. Binpack the variables into
795 partitions constrained by the interference graph. The overall
796 algorithm used is as follows:
798 Sort the objects by size in descending order.
803 Look for the largest non-conflicting object B with size <= S.
810 partition_stack_vars (void)
812 size_t si
, sj
, n
= stack_vars_num
;
814 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
815 for (si
= 0; si
< n
; ++si
)
816 stack_vars_sorted
[si
] = si
;
821 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
823 for (si
= 0; si
< n
; ++si
)
825 size_t i
= stack_vars_sorted
[si
];
826 unsigned int ialign
= stack_vars
[i
].alignb
;
827 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
829 /* Ignore objects that aren't partition representatives. If we
830 see a var that is not a partition representative, it must
831 have been merged earlier. */
832 if (stack_vars
[i
].representative
!= i
)
835 for (sj
= si
+ 1; sj
< n
; ++sj
)
837 size_t j
= stack_vars_sorted
[sj
];
838 unsigned int jalign
= stack_vars
[j
].alignb
;
839 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
841 /* Ignore objects that aren't partition representatives. */
842 if (stack_vars
[j
].representative
!= j
)
845 /* Do not mix objects of "small" (supported) alignment
846 and "large" (unsupported) alignment. */
847 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
848 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
851 /* For Address Sanitizer do not mix objects with different
852 sizes, as the shorter vars wouldn't be adequately protected.
853 Don't do that for "large" (unsupported) alignment objects,
854 those aren't protected anyway. */
855 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
&& isize
!= jsize
856 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
859 /* Ignore conflicting objects. */
860 if (stack_var_conflict_p (i
, j
))
863 /* UNION the objects, placing J at OFFSET. */
864 union_stack_vars (i
, j
);
868 update_alias_info_with_stack_vars ();
871 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
874 dump_stack_var_partition (void)
876 size_t si
, i
, j
, n
= stack_vars_num
;
878 for (si
= 0; si
< n
; ++si
)
880 i
= stack_vars_sorted
[si
];
882 /* Skip variables that aren't partition representatives, for now. */
883 if (stack_vars
[i
].representative
!= i
)
886 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
887 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
888 stack_vars
[i
].alignb
);
890 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
892 fputc ('\t', dump_file
);
893 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
895 fputc ('\n', dump_file
);
899 /* Assign rtl to DECL at BASE + OFFSET. */
902 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
903 HOST_WIDE_INT offset
)
908 /* If this fails, we've overflowed the stack frame. Error nicely? */
909 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
911 x
= plus_constant (Pmode
, base
, offset
);
912 x
= gen_rtx_MEM (DECL_MODE (SSAVAR (decl
)), x
);
914 if (TREE_CODE (decl
) != SSA_NAME
)
916 /* Set alignment we actually gave this decl if it isn't an SSA name.
917 If it is we generate stack slots only accidentally so it isn't as
918 important, we'll simply use the alignment that is already set. */
919 if (base
== virtual_stack_vars_rtx
)
920 offset
-= frame_phase
;
921 align
= offset
& -offset
;
922 align
*= BITS_PER_UNIT
;
923 if (align
== 0 || align
> base_align
)
926 /* One would think that we could assert that we're not decreasing
927 alignment here, but (at least) the i386 port does exactly this
928 via the MINIMUM_ALIGNMENT hook. */
930 DECL_ALIGN (decl
) = align
;
931 DECL_USER_ALIGN (decl
) = 0;
934 set_mem_attributes (x
, SSAVAR (decl
), true);
938 struct stack_vars_data
940 /* Vector of offset pairs, always end of some padding followed
941 by start of the padding that needs Address Sanitizer protection.
942 The vector is in reversed, highest offset pairs come first. */
943 vec
<HOST_WIDE_INT
> asan_vec
;
945 /* Vector of partition representative decls in between the paddings. */
946 vec
<tree
> asan_decl_vec
;
948 /* Base pseudo register for Address Sanitizer protected automatic vars. */
951 /* Alignment needed for the Address Sanitizer protected automatic vars. */
952 unsigned int asan_alignb
;
955 /* A subroutine of expand_used_vars. Give each partition representative
956 a unique location within the stack frame. Update each partition member
957 with that location. */
960 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
962 size_t si
, i
, j
, n
= stack_vars_num
;
963 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
964 rtx large_base
= NULL
;
965 unsigned large_align
= 0;
968 /* Determine if there are any variables requiring "large" alignment.
969 Since these are dynamically allocated, we only process these if
970 no predicate involved. */
971 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
972 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
974 /* Find the total size of these variables. */
975 for (si
= 0; si
< n
; ++si
)
979 i
= stack_vars_sorted
[si
];
980 alignb
= stack_vars
[i
].alignb
;
982 /* All "large" alignment decls come before all "small" alignment
983 decls, but "large" alignment decls are not sorted based on
984 their alignment. Increase large_align to track the largest
985 required alignment. */
986 if ((alignb
* BITS_PER_UNIT
) > large_align
)
987 large_align
= alignb
* BITS_PER_UNIT
;
989 /* Stop when we get to the first decl with "small" alignment. */
990 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
993 /* Skip variables that aren't partition representatives. */
994 if (stack_vars
[i
].representative
!= i
)
997 /* Skip variables that have already had rtl assigned. See also
998 add_stack_var where we perpetrate this pc_rtx hack. */
999 decl
= stack_vars
[i
].decl
;
1000 if ((TREE_CODE (decl
) == SSA_NAME
1001 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
1002 : DECL_RTL (decl
)) != pc_rtx
)
1005 large_size
+= alignb
- 1;
1006 large_size
&= -(HOST_WIDE_INT
)alignb
;
1007 large_size
+= stack_vars
[i
].size
;
1010 /* If there were any, allocate space. */
1012 large_base
= allocate_dynamic_stack_space (GEN_INT (large_size
), 0,
1016 for (si
= 0; si
< n
; ++si
)
1019 unsigned base_align
, alignb
;
1020 HOST_WIDE_INT offset
;
1022 i
= stack_vars_sorted
[si
];
1024 /* Skip variables that aren't partition representatives, for now. */
1025 if (stack_vars
[i
].representative
!= i
)
1028 /* Skip variables that have already had rtl assigned. See also
1029 add_stack_var where we perpetrate this pc_rtx hack. */
1030 decl
= stack_vars
[i
].decl
;
1031 if ((TREE_CODE (decl
) == SSA_NAME
1032 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
1033 : DECL_RTL (decl
)) != pc_rtx
)
1036 /* Check the predicate to see whether this variable should be
1037 allocated in this pass. */
1038 if (pred
&& !pred (i
))
1041 alignb
= stack_vars
[i
].alignb
;
1042 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1044 base
= virtual_stack_vars_rtx
;
1045 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
&& pred
)
1047 HOST_WIDE_INT prev_offset
1048 = align_base (frame_offset
,
1049 MAX (alignb
, ASAN_RED_ZONE_SIZE
),
1050 FRAME_GROWS_DOWNWARD
);
1051 tree repr_decl
= NULL_TREE
;
1053 = alloc_stack_frame_space (stack_vars
[i
].size
1054 + ASAN_RED_ZONE_SIZE
,
1055 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
1057 data
->asan_vec
.safe_push (prev_offset
);
1058 data
->asan_vec
.safe_push (offset
+ stack_vars
[i
].size
);
1059 /* Find best representative of the partition.
1060 Prefer those with DECL_NAME, even better
1061 satisfying asan_protect_stack_decl predicate. */
1062 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1063 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1064 && DECL_NAME (stack_vars
[j
].decl
))
1066 repr_decl
= stack_vars
[j
].decl
;
1069 else if (repr_decl
== NULL_TREE
1070 && DECL_P (stack_vars
[j
].decl
)
1071 && DECL_NAME (stack_vars
[j
].decl
))
1072 repr_decl
= stack_vars
[j
].decl
;
1073 if (repr_decl
== NULL_TREE
)
1074 repr_decl
= stack_vars
[i
].decl
;
1075 data
->asan_decl_vec
.safe_push (repr_decl
);
1076 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1077 if (data
->asan_base
== NULL
)
1078 data
->asan_base
= gen_reg_rtx (Pmode
);
1079 base
= data
->asan_base
;
1081 if (!STRICT_ALIGNMENT
)
1082 base_align
= crtl
->max_used_stack_slot_alignment
;
1084 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1085 GET_MODE_ALIGNMENT (SImode
)
1086 << ASAN_SHADOW_SHIFT
);
1090 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1091 base_align
= crtl
->max_used_stack_slot_alignment
;
1096 /* Large alignment is only processed in the last pass. */
1099 gcc_assert (large_base
!= NULL
);
1101 large_alloc
+= alignb
- 1;
1102 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
1103 offset
= large_alloc
;
1104 large_alloc
+= stack_vars
[i
].size
;
1107 base_align
= large_align
;
1110 /* Create rtl for each variable based on their location within the
1112 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1114 expand_one_stack_var_at (stack_vars
[j
].decl
,
1120 gcc_assert (large_alloc
== large_size
);
1123 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1124 static HOST_WIDE_INT
1125 account_stack_vars (void)
1127 size_t si
, j
, i
, n
= stack_vars_num
;
1128 HOST_WIDE_INT size
= 0;
1130 for (si
= 0; si
< n
; ++si
)
1132 i
= stack_vars_sorted
[si
];
1134 /* Skip variables that aren't partition representatives, for now. */
1135 if (stack_vars
[i
].representative
!= i
)
1138 size
+= stack_vars
[i
].size
;
1139 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1140 set_rtl (stack_vars
[j
].decl
, NULL
);
1145 /* A subroutine of expand_one_var. Called to immediately assign rtl
1146 to a variable to be allocated in the stack frame. */
1149 expand_one_stack_var (tree var
)
1151 HOST_WIDE_INT size
, offset
;
1152 unsigned byte_align
;
1154 size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (var
)));
1155 byte_align
= align_local_variable (SSAVAR (var
));
1157 /* We handle highly aligned variables in expand_stack_vars. */
1158 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1160 offset
= alloc_stack_frame_space (size
, byte_align
);
1162 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1163 crtl
->max_used_stack_slot_alignment
, offset
);
1166 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1167 that will reside in a hard register. */
1170 expand_one_hard_reg_var (tree var
)
1172 rest_of_decl_compilation (var
, 0, 0);
1175 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1176 that will reside in a pseudo register. */
1179 expand_one_register_var (tree var
)
1181 tree decl
= SSAVAR (var
);
1182 tree type
= TREE_TYPE (decl
);
1183 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1184 rtx x
= gen_reg_rtx (reg_mode
);
1188 /* Note if the object is a user variable. */
1189 if (!DECL_ARTIFICIAL (decl
))
1192 if (POINTER_TYPE_P (type
))
1193 mark_reg_pointer (x
, get_pointer_alignment (var
));
1196 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1197 has some associated error, e.g. its type is error-mark. We just need
1198 to pick something that won't crash the rest of the compiler. */
1201 expand_one_error_var (tree var
)
1203 machine_mode mode
= DECL_MODE (var
);
1206 if (mode
== BLKmode
)
1207 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1208 else if (mode
== VOIDmode
)
1211 x
= gen_reg_rtx (mode
);
1213 SET_DECL_RTL (var
, x
);
1216 /* A subroutine of expand_one_var. VAR is a variable that will be
1217 allocated to the local stack frame. Return true if we wish to
1218 add VAR to STACK_VARS so that it will be coalesced with other
1219 variables. Return false to allocate VAR immediately.
1221 This function is used to reduce the number of variables considered
1222 for coalescing, which reduces the size of the quadratic problem. */
1225 defer_stack_allocation (tree var
, bool toplevel
)
1227 /* Whether the variable is small enough for immediate allocation not to be
1228 a problem with regard to the frame size. */
1230 = ((HOST_WIDE_INT
) tree_to_uhwi (DECL_SIZE_UNIT (var
))
1231 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
));
1233 /* If stack protection is enabled, *all* stack variables must be deferred,
1234 so that we can re-order the strings to the top of the frame.
1235 Similarly for Address Sanitizer. */
1236 if (flag_stack_protect
|| ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
))
1239 /* We handle "large" alignment via dynamic allocation. We want to handle
1240 this extra complication in only one place, so defer them. */
1241 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
1244 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1245 might be detached from their block and appear at toplevel when we reach
1246 here. We want to coalesce them with variables from other blocks when
1247 the immediate contribution to the frame size would be noticeable. */
1248 if (toplevel
&& optimize
> 0 && DECL_IGNORED_P (var
) && !smallish
)
1251 /* Variables declared in the outermost scope automatically conflict
1252 with every other variable. The only reason to want to defer them
1253 at all is that, after sorting, we can more efficiently pack
1254 small variables in the stack frame. Continue to defer at -O2. */
1255 if (toplevel
&& optimize
< 2)
1258 /* Without optimization, *most* variables are allocated from the
1259 stack, which makes the quadratic problem large exactly when we
1260 want compilation to proceed as quickly as possible. On the
1261 other hand, we don't want the function's stack frame size to
1262 get completely out of hand. So we avoid adding scalars and
1263 "small" aggregates to the list at all. */
1264 if (optimize
== 0 && smallish
)
1270 /* A subroutine of expand_used_vars. Expand one variable according to
1271 its flavor. Variables to be placed on the stack are not actually
1272 expanded yet, merely recorded.
1273 When REALLY_EXPAND is false, only add stack values to be allocated.
1274 Return stack usage this variable is supposed to take.
1277 static HOST_WIDE_INT
1278 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1280 unsigned int align
= BITS_PER_UNIT
;
1285 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1287 /* Because we don't know if VAR will be in register or on stack,
1288 we conservatively assume it will be on stack even if VAR is
1289 eventually put into register after RA pass. For non-automatic
1290 variables, which won't be on stack, we collect alignment of
1291 type and ignore user specified alignment. Similarly for
1292 SSA_NAMEs for which use_register_for_decl returns true. */
1293 if (TREE_STATIC (var
)
1294 || DECL_EXTERNAL (var
)
1295 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1296 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1297 TYPE_MODE (TREE_TYPE (var
)),
1298 TYPE_ALIGN (TREE_TYPE (var
)));
1299 else if (DECL_HAS_VALUE_EXPR_P (var
)
1300 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1301 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1302 or variables which were assigned a stack slot already by
1303 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1304 changed from the offset chosen to it. */
1305 align
= crtl
->stack_alignment_estimated
;
1307 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1309 /* If the variable alignment is very large we'll dynamicaly allocate
1310 it, which means that in-frame portion is just a pointer. */
1311 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1312 align
= POINTER_SIZE
;
1315 if (SUPPORTS_STACK_ALIGNMENT
1316 && crtl
->stack_alignment_estimated
< align
)
1318 /* stack_alignment_estimated shouldn't change after stack
1319 realign decision made */
1320 gcc_assert (!crtl
->stack_realign_processed
);
1321 crtl
->stack_alignment_estimated
= align
;
1324 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1325 So here we only make sure stack_alignment_needed >= align. */
1326 if (crtl
->stack_alignment_needed
< align
)
1327 crtl
->stack_alignment_needed
= align
;
1328 if (crtl
->max_used_stack_slot_alignment
< align
)
1329 crtl
->max_used_stack_slot_alignment
= align
;
1331 if (TREE_CODE (origvar
) == SSA_NAME
)
1333 gcc_assert (TREE_CODE (var
) != VAR_DECL
1334 || (!DECL_EXTERNAL (var
)
1335 && !DECL_HAS_VALUE_EXPR_P (var
)
1336 && !TREE_STATIC (var
)
1337 && TREE_TYPE (var
) != error_mark_node
1338 && !DECL_HARD_REGISTER (var
)
1341 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1343 else if (DECL_EXTERNAL (var
))
1345 else if (DECL_HAS_VALUE_EXPR_P (var
))
1347 else if (TREE_STATIC (var
))
1349 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1351 else if (TREE_TYPE (var
) == error_mark_node
)
1354 expand_one_error_var (var
);
1356 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1360 expand_one_hard_reg_var (var
);
1361 if (!DECL_HARD_REGISTER (var
))
1362 /* Invalid register specification. */
1363 expand_one_error_var (var
);
1366 else if (use_register_for_decl (var
))
1369 expand_one_register_var (origvar
);
1371 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1373 /* Reject variables which cover more than half of the address-space. */
1376 error ("size of variable %q+D is too large", var
);
1377 expand_one_error_var (var
);
1380 else if (defer_stack_allocation (var
, toplevel
))
1381 add_stack_var (origvar
);
1385 expand_one_stack_var (origvar
);
1386 return tree_to_uhwi (DECL_SIZE_UNIT (var
));
1391 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1392 expanding variables. Those variables that can be put into registers
1393 are allocated pseudos; those that can't are put on the stack.
1395 TOPLEVEL is true if this is the outermost BLOCK. */
1398 expand_used_vars_for_block (tree block
, bool toplevel
)
1402 /* Expand all variables at this level. */
1403 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1405 && ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1406 || !DECL_NONSHAREABLE (t
)))
1407 expand_one_var (t
, toplevel
, true);
1409 /* Expand all variables at containing levels. */
1410 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1411 expand_used_vars_for_block (t
, false);
1414 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1415 and clear TREE_USED on all local variables. */
1418 clear_tree_used (tree block
)
1422 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1423 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1424 if ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1425 || !DECL_NONSHAREABLE (t
))
1428 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1429 clear_tree_used (t
);
1433 SPCT_FLAG_DEFAULT
= 1,
1435 SPCT_FLAG_STRONG
= 3,
1436 SPCT_FLAG_EXPLICIT
= 4
1439 /* Examine TYPE and determine a bit mask of the following features. */
1441 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1442 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1443 #define SPCT_HAS_ARRAY 4
1444 #define SPCT_HAS_AGGREGATE 8
1447 stack_protect_classify_type (tree type
)
1449 unsigned int ret
= 0;
1452 switch (TREE_CODE (type
))
1455 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1456 if (t
== char_type_node
1457 || t
== signed_char_type_node
1458 || t
== unsigned_char_type_node
)
1460 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1461 unsigned HOST_WIDE_INT len
;
1463 if (!TYPE_SIZE_UNIT (type
)
1464 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1467 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1470 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1472 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1475 ret
= SPCT_HAS_ARRAY
;
1479 case QUAL_UNION_TYPE
:
1481 ret
= SPCT_HAS_AGGREGATE
;
1482 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1483 if (TREE_CODE (t
) == FIELD_DECL
)
1484 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1494 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1495 part of the local stack frame. Remember if we ever return nonzero for
1496 any variable in this function. The return value is the phase number in
1497 which the variable should be allocated. */
1500 stack_protect_decl_phase (tree decl
)
1502 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1505 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1506 has_short_buffer
= true;
1508 if (flag_stack_protect
== SPCT_FLAG_ALL
1509 || flag_stack_protect
== SPCT_FLAG_STRONG
1510 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1511 && lookup_attribute ("stack_protect",
1512 DECL_ATTRIBUTES (current_function_decl
))))
1514 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1515 && !(bits
& SPCT_HAS_AGGREGATE
))
1517 else if (bits
& SPCT_HAS_ARRAY
)
1521 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1524 has_protected_decls
= true;
1529 /* Two helper routines that check for phase 1 and phase 2. These are used
1530 as callbacks for expand_stack_vars. */
1533 stack_protect_decl_phase_1 (size_t i
)
1535 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1539 stack_protect_decl_phase_2 (size_t i
)
1541 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1544 /* And helper function that checks for asan phase (with stack protector
1545 it is phase 3). This is used as callback for expand_stack_vars.
1546 Returns true if any of the vars in the partition need to be protected. */
1549 asan_decl_phase_3 (size_t i
)
1553 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1555 i
= stack_vars
[i
].next
;
1560 /* Ensure that variables in different stack protection phases conflict
1561 so that they are not merged and share the same stack slot. */
1564 add_stack_protection_conflicts (void)
1566 size_t i
, j
, n
= stack_vars_num
;
1567 unsigned char *phase
;
1569 phase
= XNEWVEC (unsigned char, n
);
1570 for (i
= 0; i
< n
; ++i
)
1571 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1573 for (i
= 0; i
< n
; ++i
)
1575 unsigned char ph_i
= phase
[i
];
1576 for (j
= i
+ 1; j
< n
; ++j
)
1577 if (ph_i
!= phase
[j
])
1578 add_stack_var_conflict (i
, j
);
1584 /* Create a decl for the guard at the top of the stack frame. */
1587 create_stack_guard (void)
1589 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1590 VAR_DECL
, NULL
, ptr_type_node
);
1591 TREE_THIS_VOLATILE (guard
) = 1;
1592 TREE_USED (guard
) = 1;
1593 expand_one_stack_var (guard
);
1594 crtl
->stack_protect_guard
= guard
;
1597 /* Prepare for expanding variables. */
1599 init_vars_expansion (void)
1601 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1602 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1604 /* A map from decl to stack partition. */
1605 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1607 /* Initialize local stack smashing state. */
1608 has_protected_decls
= false;
1609 has_short_buffer
= false;
1612 /* Free up stack variable graph data. */
1614 fini_vars_expansion (void)
1616 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1618 XDELETEVEC (stack_vars
);
1619 if (stack_vars_sorted
)
1620 XDELETEVEC (stack_vars_sorted
);
1622 stack_vars_sorted
= NULL
;
1623 stack_vars_alloc
= stack_vars_num
= 0;
1624 delete decl_to_stack_part
;
1625 decl_to_stack_part
= NULL
;
1628 /* Make a fair guess for the size of the stack frame of the function
1629 in NODE. This doesn't have to be exact, the result is only used in
1630 the inline heuristics. So we don't want to run the full stack var
1631 packing algorithm (which is quadratic in the number of stack vars).
1632 Instead, we calculate the total size of all stack vars. This turns
1633 out to be a pretty fair estimate -- packing of stack vars doesn't
1634 happen very often. */
1637 estimated_stack_frame_size (struct cgraph_node
*node
)
1639 HOST_WIDE_INT size
= 0;
1642 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1646 init_vars_expansion ();
1648 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1649 if (auto_var_in_fn_p (var
, fn
->decl
))
1650 size
+= expand_one_var (var
, true, false);
1652 if (stack_vars_num
> 0)
1654 /* Fake sorting the stack vars for account_stack_vars (). */
1655 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1656 for (i
= 0; i
< stack_vars_num
; ++i
)
1657 stack_vars_sorted
[i
] = i
;
1658 size
+= account_stack_vars ();
1661 fini_vars_expansion ();
1666 /* Helper routine to check if a record or union contains an array field. */
1669 record_or_union_type_has_array_p (const_tree tree_type
)
1671 tree fields
= TYPE_FIELDS (tree_type
);
1674 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1675 if (TREE_CODE (f
) == FIELD_DECL
)
1677 tree field_type
= TREE_TYPE (f
);
1678 if (RECORD_OR_UNION_TYPE_P (field_type
)
1679 && record_or_union_type_has_array_p (field_type
))
1681 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1687 /* Check if the current function has local referenced variables that
1688 have their addresses taken, contain an array, or are arrays. */
1691 stack_protect_decl_p ()
1696 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1697 if (!is_global_var (var
))
1699 tree var_type
= TREE_TYPE (var
);
1700 if (TREE_CODE (var
) == VAR_DECL
1701 && (TREE_CODE (var_type
) == ARRAY_TYPE
1702 || TREE_ADDRESSABLE (var
)
1703 || (RECORD_OR_UNION_TYPE_P (var_type
)
1704 && record_or_union_type_has_array_p (var_type
))))
1710 /* Check if the current function has calls that use a return slot. */
1713 stack_protect_return_slot_p ()
1717 FOR_ALL_BB_FN (bb
, cfun
)
1718 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
1719 !gsi_end_p (gsi
); gsi_next (&gsi
))
1721 gimple stmt
= gsi_stmt (gsi
);
1722 /* This assumes that calls to internal-only functions never
1723 use a return slot. */
1724 if (is_gimple_call (stmt
)
1725 && !gimple_call_internal_p (stmt
)
1726 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
1727 gimple_call_fndecl (stmt
)))
1733 /* Expand all variables used in the function. */
1736 expand_used_vars (void)
1738 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1739 vec
<tree
> maybe_local_decls
= vNULL
;
1740 rtx_insn
*var_end_seq
= NULL
;
1743 bool gen_stack_protect_signal
= false;
1745 /* Compute the phase of the stack frame for this function. */
1747 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1748 int off
= STARTING_FRAME_OFFSET
% align
;
1749 frame_phase
= off
? align
- off
: 0;
1752 /* Set TREE_USED on all variables in the local_decls. */
1753 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1754 TREE_USED (var
) = 1;
1755 /* Clear TREE_USED on all variables associated with a block scope. */
1756 clear_tree_used (DECL_INITIAL (current_function_decl
));
1758 init_vars_expansion ();
1760 if (targetm
.use_pseudo_pic_reg ())
1761 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
1763 hash_map
<tree
, tree
> ssa_name_decls
;
1764 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1766 tree var
= partition_to_var (SA
.map
, i
);
1768 gcc_assert (!virtual_operand_p (var
));
1770 /* Assign decls to each SSA name partition, share decls for partitions
1771 we could have coalesced (those with the same type). */
1772 if (SSA_NAME_VAR (var
) == NULL_TREE
)
1774 tree
*slot
= &ssa_name_decls
.get_or_insert (TREE_TYPE (var
));
1776 *slot
= create_tmp_reg (TREE_TYPE (var
));
1777 replace_ssa_name_symbol (var
, *slot
);
1780 /* Always allocate space for partitions based on VAR_DECLs. But for
1781 those based on PARM_DECLs or RESULT_DECLs and which matter for the
1782 debug info, there is no need to do so if optimization is disabled
1783 because all the SSA_NAMEs based on these DECLs have been coalesced
1784 into a single partition, which is thus assigned the canonical RTL
1785 location of the DECLs. If in_lto_p, we can't rely on optimize,
1786 a function could be compiled with -O1 -flto first and only the
1787 link performed at -O0. */
1788 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1789 expand_one_var (var
, true, true);
1790 else if (DECL_IGNORED_P (SSA_NAME_VAR (var
)) || optimize
|| in_lto_p
)
1792 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1793 contain the default def (representing the parm or result itself)
1794 we don't do anything here. But those which don't contain the
1795 default def (representing a temporary based on the parm/result)
1796 we need to allocate space just like for normal VAR_DECLs. */
1797 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1799 expand_one_var (var
, true, true);
1800 gcc_assert (SA
.partition_to_pseudo
[i
]);
1805 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1806 gen_stack_protect_signal
1807 = stack_protect_decl_p () || stack_protect_return_slot_p ();
1809 /* At this point all variables on the local_decls with TREE_USED
1810 set are not associated with any block scope. Lay them out. */
1812 len
= vec_safe_length (cfun
->local_decls
);
1813 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1815 bool expand_now
= false;
1817 /* Expanded above already. */
1818 if (is_gimple_reg (var
))
1820 TREE_USED (var
) = 0;
1823 /* We didn't set a block for static or extern because it's hard
1824 to tell the difference between a global variable (re)declared
1825 in a local scope, and one that's really declared there to
1826 begin with. And it doesn't really matter much, since we're
1827 not giving them stack space. Expand them now. */
1828 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1831 /* Expand variables not associated with any block now. Those created by
1832 the optimizers could be live anywhere in the function. Those that
1833 could possibly have been scoped originally and detached from their
1834 block will have their allocation deferred so we coalesce them with
1835 others when optimization is enabled. */
1836 else if (TREE_USED (var
))
1839 /* Finally, mark all variables on the list as used. We'll use
1840 this in a moment when we expand those associated with scopes. */
1841 TREE_USED (var
) = 1;
1844 expand_one_var (var
, true, true);
1847 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1849 rtx rtl
= DECL_RTL_IF_SET (var
);
1851 /* Keep artificial non-ignored vars in cfun->local_decls
1852 chain until instantiate_decls. */
1853 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1854 add_local_decl (cfun
, var
);
1855 else if (rtl
== NULL_RTX
)
1856 /* If rtl isn't set yet, which can happen e.g. with
1857 -fstack-protector, retry before returning from this
1859 maybe_local_decls
.safe_push (var
);
1863 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1865 +-----------------+-----------------+
1866 | ...processed... | ...duplicates...|
1867 +-----------------+-----------------+
1869 +-- LEN points here.
1871 We just want the duplicates, as those are the artificial
1872 non-ignored vars that we want to keep until instantiate_decls.
1873 Move them down and truncate the array. */
1874 if (!vec_safe_is_empty (cfun
->local_decls
))
1875 cfun
->local_decls
->block_remove (0, len
);
1877 /* At this point, all variables within the block tree with TREE_USED
1878 set are actually used by the optimized function. Lay them out. */
1879 expand_used_vars_for_block (outer_block
, true);
1881 if (stack_vars_num
> 0)
1883 add_scope_conflicts ();
1885 /* If stack protection is enabled, we don't share space between
1886 vulnerable data and non-vulnerable data. */
1887 if (flag_stack_protect
!= 0
1888 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
1889 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1890 && lookup_attribute ("stack_protect",
1891 DECL_ATTRIBUTES (current_function_decl
)))))
1892 add_stack_protection_conflicts ();
1894 /* Now that we have collected all stack variables, and have computed a
1895 minimal interference graph, attempt to save some stack space. */
1896 partition_stack_vars ();
1898 dump_stack_var_partition ();
1901 switch (flag_stack_protect
)
1904 create_stack_guard ();
1907 case SPCT_FLAG_STRONG
:
1908 if (gen_stack_protect_signal
1909 || cfun
->calls_alloca
|| has_protected_decls
1910 || lookup_attribute ("stack_protect",
1911 DECL_ATTRIBUTES (current_function_decl
)))
1912 create_stack_guard ();
1915 case SPCT_FLAG_DEFAULT
:
1916 if (cfun
->calls_alloca
|| has_protected_decls
1917 || lookup_attribute ("stack_protect",
1918 DECL_ATTRIBUTES (current_function_decl
)))
1919 create_stack_guard ();
1922 case SPCT_FLAG_EXPLICIT
:
1923 if (lookup_attribute ("stack_protect",
1924 DECL_ATTRIBUTES (current_function_decl
)))
1925 create_stack_guard ();
1931 /* Assign rtl to each variable based on these partitions. */
1932 if (stack_vars_num
> 0)
1934 struct stack_vars_data data
;
1936 data
.asan_vec
= vNULL
;
1937 data
.asan_decl_vec
= vNULL
;
1938 data
.asan_base
= NULL_RTX
;
1939 data
.asan_alignb
= 0;
1941 /* Reorder decls to be protected by iterating over the variables
1942 array multiple times, and allocating out of each phase in turn. */
1943 /* ??? We could probably integrate this into the qsort we did
1944 earlier, such that we naturally see these variables first,
1945 and thus naturally allocate things in the right order. */
1946 if (has_protected_decls
)
1948 /* Phase 1 contains only character arrays. */
1949 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
1951 /* Phase 2 contains other kinds of arrays. */
1952 if (flag_stack_protect
== SPCT_FLAG_ALL
1953 || flag_stack_protect
== SPCT_FLAG_STRONG
1954 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1955 && lookup_attribute ("stack_protect",
1956 DECL_ATTRIBUTES (current_function_decl
))))
1957 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
1960 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
)
1961 /* Phase 3, any partitions that need asan protection
1962 in addition to phase 1 and 2. */
1963 expand_stack_vars (asan_decl_phase_3
, &data
);
1965 if (!data
.asan_vec
.is_empty ())
1967 HOST_WIDE_INT prev_offset
= frame_offset
;
1968 HOST_WIDE_INT offset
, sz
, redzonesz
;
1969 redzonesz
= ASAN_RED_ZONE_SIZE
;
1970 sz
= data
.asan_vec
[0] - prev_offset
;
1971 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
1972 && data
.asan_alignb
<= 4096
1973 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
1974 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
1975 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
1977 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
1978 data
.asan_vec
.safe_push (prev_offset
);
1979 data
.asan_vec
.safe_push (offset
);
1980 /* Leave space for alignment if STRICT_ALIGNMENT. */
1981 if (STRICT_ALIGNMENT
)
1982 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
1983 << ASAN_SHADOW_SHIFT
)
1984 / BITS_PER_UNIT
, 1);
1987 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
1990 data
.asan_vec
.address (),
1991 data
.asan_decl_vec
.address (),
1992 data
.asan_vec
.length ());
1995 expand_stack_vars (NULL
, &data
);
1997 data
.asan_vec
.release ();
1998 data
.asan_decl_vec
.release ();
2001 fini_vars_expansion ();
2003 /* If there were any artificial non-ignored vars without rtl
2004 found earlier, see if deferred stack allocation hasn't assigned
2006 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2008 rtx rtl
= DECL_RTL_IF_SET (var
);
2010 /* Keep artificial non-ignored vars in cfun->local_decls
2011 chain until instantiate_decls. */
2012 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2013 add_local_decl (cfun
, var
);
2015 maybe_local_decls
.release ();
2017 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2018 if (STACK_ALIGNMENT_NEEDED
)
2020 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2021 if (!FRAME_GROWS_DOWNWARD
)
2022 frame_offset
+= align
- 1;
2023 frame_offset
&= -align
;
2030 /* If we need to produce a detailed dump, print the tree representation
2031 for STMT to the dump file. SINCE is the last RTX after which the RTL
2032 generated for STMT should have been appended. */
2035 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx_insn
*since
)
2037 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2039 fprintf (dump_file
, "\n;; ");
2040 print_gimple_stmt (dump_file
, stmt
, 0,
2041 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2042 fprintf (dump_file
, "\n");
2044 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2048 /* Maps the blocks that do not contain tree labels to rtx labels. */
2050 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2052 /* Returns the label_rtx expression for a label starting basic block BB. */
2055 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2057 gimple_stmt_iterator gsi
;
2060 if (bb
->flags
& BB_RTL
)
2061 return block_label (bb
);
2063 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2067 /* Find the tree label if it is present. */
2069 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2073 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2077 lab
= gimple_label_label (lab_stmt
);
2078 if (DECL_NONLOCAL (lab
))
2081 return label_rtx (lab
);
2084 rtx_code_label
*l
= gen_label_rtx ();
2085 lab_rtx_for_bb
->put (bb
, l
);
2090 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2091 of a basic block where we just expanded the conditional at the end,
2092 possibly clean up the CFG and instruction sequence. LAST is the
2093 last instruction before the just emitted jump sequence. */
2096 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2098 /* Special case: when jumpif decides that the condition is
2099 trivial it emits an unconditional jump (and the necessary
2100 barrier). But we still have two edges, the fallthru one is
2101 wrong. purge_dead_edges would clean this up later. Unfortunately
2102 we have to insert insns (and split edges) before
2103 find_many_sub_basic_blocks and hence before purge_dead_edges.
2104 But splitting edges might create new blocks which depend on the
2105 fact that if there are two edges there's no barrier. So the
2106 barrier would get lost and verify_flow_info would ICE. Instead
2107 of auditing all edge splitters to care for the barrier (which
2108 normally isn't there in a cleaned CFG), fix it here. */
2109 if (BARRIER_P (get_last_insn ()))
2113 /* Now, we have a single successor block, if we have insns to
2114 insert on the remaining edge we potentially will insert
2115 it at the end of this block (if the dest block isn't feasible)
2116 in order to avoid splitting the edge. This insertion will take
2117 place in front of the last jump. But we might have emitted
2118 multiple jumps (conditional and one unconditional) to the
2119 same destination. Inserting in front of the last one then
2120 is a problem. See PR 40021. We fix this by deleting all
2121 jumps except the last unconditional one. */
2122 insn
= PREV_INSN (get_last_insn ());
2123 /* Make sure we have an unconditional jump. Otherwise we're
2125 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2126 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2128 insn
= PREV_INSN (insn
);
2129 if (JUMP_P (NEXT_INSN (insn
)))
2131 if (!any_condjump_p (NEXT_INSN (insn
)))
2133 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2134 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2136 delete_insn (NEXT_INSN (insn
));
2142 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2143 Returns a new basic block if we've terminated the current basic
2144 block and created a new one. */
2147 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2149 basic_block new_bb
, dest
;
2153 rtx_insn
*last2
, *last
;
2154 enum tree_code code
;
2157 code
= gimple_cond_code (stmt
);
2158 op0
= gimple_cond_lhs (stmt
);
2159 op1
= gimple_cond_rhs (stmt
);
2160 /* We're sometimes presented with such code:
2164 This would expand to two comparisons which then later might
2165 be cleaned up by combine. But some pattern matchers like if-conversion
2166 work better when there's only one compare, so make up for this
2167 here as special exception if TER would have made the same change. */
2169 && TREE_CODE (op0
) == SSA_NAME
2170 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2171 && TREE_CODE (op1
) == INTEGER_CST
2172 && ((gimple_cond_code (stmt
) == NE_EXPR
2173 && integer_zerop (op1
))
2174 || (gimple_cond_code (stmt
) == EQ_EXPR
2175 && integer_onep (op1
)))
2176 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2178 gimple second
= SSA_NAME_DEF_STMT (op0
);
2179 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2181 enum tree_code code2
= gimple_assign_rhs_code (second
);
2182 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2185 op0
= gimple_assign_rhs1 (second
);
2186 op1
= gimple_assign_rhs2 (second
);
2188 /* If jumps are cheap and the target does not support conditional
2189 compare, turn some more codes into jumpy sequences. */
2190 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2191 && targetm
.gen_ccmp_first
== NULL
)
2193 if ((code2
== BIT_AND_EXPR
2194 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2195 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2196 || code2
== TRUTH_AND_EXPR
)
2198 code
= TRUTH_ANDIF_EXPR
;
2199 op0
= gimple_assign_rhs1 (second
);
2200 op1
= gimple_assign_rhs2 (second
);
2202 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2204 code
= TRUTH_ORIF_EXPR
;
2205 op0
= gimple_assign_rhs1 (second
);
2206 op1
= gimple_assign_rhs2 (second
);
2212 last2
= last
= get_last_insn ();
2214 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2215 set_curr_insn_location (gimple_location (stmt
));
2217 /* These flags have no purpose in RTL land. */
2218 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2219 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2221 /* We can either have a pure conditional jump with one fallthru edge or
2222 two-way jump that needs to be decomposed into two basic blocks. */
2223 if (false_edge
->dest
== bb
->next_bb
)
2225 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2226 true_edge
->probability
);
2227 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2228 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2229 set_curr_insn_location (true_edge
->goto_locus
);
2230 false_edge
->flags
|= EDGE_FALLTHRU
;
2231 maybe_cleanup_end_of_block (false_edge
, last
);
2234 if (true_edge
->dest
== bb
->next_bb
)
2236 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2237 false_edge
->probability
);
2238 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2239 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2240 set_curr_insn_location (false_edge
->goto_locus
);
2241 true_edge
->flags
|= EDGE_FALLTHRU
;
2242 maybe_cleanup_end_of_block (true_edge
, last
);
2246 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2247 true_edge
->probability
);
2248 last
= get_last_insn ();
2249 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2250 set_curr_insn_location (false_edge
->goto_locus
);
2251 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2254 if (BARRIER_P (BB_END (bb
)))
2255 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2256 update_bb_for_insn (bb
);
2258 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2259 dest
= false_edge
->dest
;
2260 redirect_edge_succ (false_edge
, new_bb
);
2261 false_edge
->flags
|= EDGE_FALLTHRU
;
2262 new_bb
->count
= false_edge
->count
;
2263 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2264 add_bb_to_loop (new_bb
, bb
->loop_father
);
2265 new_edge
= make_edge (new_bb
, dest
, 0);
2266 new_edge
->probability
= REG_BR_PROB_BASE
;
2267 new_edge
->count
= new_bb
->count
;
2268 if (BARRIER_P (BB_END (new_bb
)))
2269 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2270 update_bb_for_insn (new_bb
);
2272 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2274 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2276 set_curr_insn_location (true_edge
->goto_locus
);
2277 true_edge
->goto_locus
= curr_insn_location ();
2283 /* Mark all calls that can have a transaction restart. */
2286 mark_transaction_restart_calls (gimple stmt
)
2288 struct tm_restart_node dummy
;
2289 tm_restart_node
**slot
;
2291 if (!cfun
->gimple_df
->tm_restart
)
2295 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2298 struct tm_restart_node
*n
= *slot
;
2299 tree list
= n
->label_or_list
;
2302 for (insn
= next_real_insn (get_last_insn ());
2304 insn
= next_real_insn (insn
))
2307 if (TREE_CODE (list
) == LABEL_DECL
)
2308 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2310 for (; list
; list
= TREE_CHAIN (list
))
2311 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2315 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2319 expand_call_stmt (gcall
*stmt
)
2321 tree exp
, decl
, lhs
;
2325 if (gimple_call_internal_p (stmt
))
2327 expand_internal_call (stmt
);
2331 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2333 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2334 decl
= gimple_call_fndecl (stmt
);
2335 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2337 /* If this is not a builtin function, the function type through which the
2338 call is made may be different from the type of the function. */
2341 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2342 CALL_EXPR_FN (exp
));
2344 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2345 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2347 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2349 tree arg
= gimple_call_arg (stmt
, i
);
2351 /* TER addresses into arguments of builtin functions so we have a
2352 chance to infer more correct alignment information. See PR39954. */
2354 && TREE_CODE (arg
) == SSA_NAME
2355 && (def
= get_gimple_for_ssa_name (arg
))
2356 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2357 arg
= gimple_assign_rhs1 (def
);
2358 CALL_EXPR_ARG (exp
, i
) = arg
;
2361 if (gimple_has_side_effects (stmt
))
2362 TREE_SIDE_EFFECTS (exp
) = 1;
2364 if (gimple_call_nothrow_p (stmt
))
2365 TREE_NOTHROW (exp
) = 1;
2367 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2368 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2370 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2371 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2372 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2373 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2375 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2376 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2377 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2378 CALL_WITH_BOUNDS_P (exp
) = gimple_call_with_bounds_p (stmt
);
2380 /* Ensure RTL is created for debug args. */
2381 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2383 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2388 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2390 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2391 expand_debug_expr (dtemp
);
2395 lhs
= gimple_call_lhs (stmt
);
2397 expand_assignment (lhs
, exp
, false);
2399 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2401 mark_transaction_restart_calls (stmt
);
2405 /* Generate RTL for an asm statement (explicit assembler code).
2406 STRING is a STRING_CST node containing the assembler code text,
2407 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2408 insn is volatile; don't optimize it. */
2411 expand_asm_loc (tree string
, int vol
, location_t locus
)
2415 if (TREE_CODE (string
) == ADDR_EXPR
)
2416 string
= TREE_OPERAND (string
, 0);
2418 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2419 ggc_strdup (TREE_STRING_POINTER (string
)),
2422 MEM_VOLATILE_P (body
) = vol
;
2427 /* Return the number of times character C occurs in string S. */
2429 n_occurrences (int c
, const char *s
)
2437 /* A subroutine of expand_asm_operands. Check that all operands have
2438 the same number of alternatives. Return true if so. */
2441 check_operand_nalternatives (tree outputs
, tree inputs
)
2443 if (outputs
|| inputs
)
2445 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
2447 = n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp
)));
2450 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2452 error ("too many alternatives in %<asm%>");
2459 const char *constraint
2460 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp
)));
2462 if (n_occurrences (',', constraint
) != nalternatives
)
2464 error ("operand constraints for %<asm%> differ "
2465 "in number of alternatives");
2469 if (TREE_CHAIN (tmp
))
2470 tmp
= TREE_CHAIN (tmp
);
2472 tmp
= next
, next
= 0;
2479 /* Check for overlap between registers marked in CLOBBERED_REGS and
2480 anything inappropriate in T. Emit error and return the register
2481 variable definition for error, NULL_TREE for ok. */
2484 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2486 /* Conflicts between asm-declared register variables and the clobber
2487 list are not allowed. */
2488 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2492 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2493 DECL_NAME (overlap
));
2495 /* Reset registerness to stop multiple errors emitted for a single
2497 DECL_REGISTER (overlap
) = 0;
2504 /* Generate RTL for an asm statement with arguments.
2505 STRING is the instruction template.
2506 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2507 Each output or input has an expression in the TREE_VALUE and
2508 a tree list in TREE_PURPOSE which in turn contains a constraint
2509 name in TREE_VALUE (or NULL_TREE) and a constraint string
2511 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2512 that is clobbered by this insn.
2514 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2515 should be the fallthru basic block of the asm goto.
2517 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2518 Some elements of OUTPUTS may be replaced with trees representing temporary
2519 values. The caller should copy those temporary values to the originally
2522 VOL nonzero means the insn is volatile; don't optimize it. */
2525 expand_asm_operands (tree string
, tree outputs
, tree inputs
,
2526 tree clobbers
, tree labels
, basic_block fallthru_bb
,
2527 int vol
, location_t locus
)
2529 rtvec argvec
, constraintvec
, labelvec
;
2531 int ninputs
= list_length (inputs
);
2532 int noutputs
= list_length (outputs
);
2533 int nlabels
= list_length (labels
);
2536 HARD_REG_SET clobbered_regs
;
2537 int clobber_conflict_found
= 0;
2541 /* Vector of RTX's of evaluated output operands. */
2542 rtx
*output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2543 int *inout_opnum
= XALLOCAVEC (int, noutputs
);
2544 rtx
*real_output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2545 machine_mode
*inout_mode
= XALLOCAVEC (machine_mode
, noutputs
);
2546 const char **constraints
= XALLOCAVEC (const char *, noutputs
+ ninputs
);
2547 int old_generating_concat_p
= generating_concat_p
;
2548 rtx_code_label
*fallthru_label
= NULL
;
2550 /* An ASM with no outputs needs to be treated as volatile, for now. */
2554 if (! check_operand_nalternatives (outputs
, inputs
))
2557 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
2559 /* Collect constraints. */
2561 for (t
= outputs
; t
; t
= TREE_CHAIN (t
), i
++)
2562 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2563 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), i
++)
2564 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2566 /* Sometimes we wish to automatically clobber registers across an asm.
2567 Case in point is when the i386 backend moved from cc0 to a hard reg --
2568 maintaining source-level compatibility means automatically clobbering
2569 the flags register. */
2570 clobbers
= targetm
.md_asm_clobbers (outputs
, inputs
, clobbers
);
2572 /* Count the number of meaningful clobbered registers, ignoring what
2573 we would ignore later. */
2575 CLEAR_HARD_REG_SET (clobbered_regs
);
2576 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2578 const char *regname
;
2581 if (TREE_VALUE (tail
) == error_mark_node
)
2583 regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2585 i
= decode_reg_name_and_count (regname
, &nregs
);
2589 error ("unknown register name %qs in %<asm%>", regname
);
2591 /* Mark clobbered registers. */
2596 for (reg
= i
; reg
< i
+ nregs
; reg
++)
2600 /* Clobbering the PIC register is an error. */
2601 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2603 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2607 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2612 /* First pass over inputs and outputs checks validity and sets
2613 mark_addressable if needed. */
2616 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2618 tree val
= TREE_VALUE (tail
);
2619 tree type
= TREE_TYPE (val
);
2620 const char *constraint
;
2625 /* If there's an erroneous arg, emit no insn. */
2626 if (type
== error_mark_node
)
2629 /* Try to parse the output constraint. If that fails, there's
2630 no point in going further. */
2631 constraint
= constraints
[i
];
2632 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2633 &allows_mem
, &allows_reg
, &is_inout
))
2640 && REG_P (DECL_RTL (val
))
2641 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2642 mark_addressable (val
);
2649 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2651 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2655 for (i
= 0, tail
= inputs
; tail
; i
++, tail
= TREE_CHAIN (tail
))
2657 bool allows_reg
, allows_mem
;
2658 const char *constraint
;
2660 /* If there's an erroneous arg, emit no insn, because the ASM_INPUT
2661 would get VOIDmode and that could cause a crash in reload. */
2662 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
2665 constraint
= constraints
[i
+ noutputs
];
2666 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2667 constraints
, &allows_mem
, &allows_reg
))
2670 if (! allows_reg
&& allows_mem
)
2671 mark_addressable (TREE_VALUE (tail
));
2674 /* Second pass evaluates arguments. */
2676 /* Make sure stack is consistent for asm goto. */
2678 do_pending_stack_adjust ();
2681 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2683 tree val
= TREE_VALUE (tail
);
2684 tree type
= TREE_TYPE (val
);
2691 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2692 noutputs
, &allows_mem
, &allows_reg
,
2696 /* If an output operand is not a decl or indirect ref and our constraint
2697 allows a register, make a temporary to act as an intermediate.
2698 Make the asm insn write into that, then our caller will copy it to
2699 the real output operand. Likewise for promoted variables. */
2701 generating_concat_p
= 0;
2703 real_output_rtx
[i
] = NULL_RTX
;
2704 if ((TREE_CODE (val
) == INDIRECT_REF
2707 && (allows_mem
|| REG_P (DECL_RTL (val
)))
2708 && ! (REG_P (DECL_RTL (val
))
2709 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
2713 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2714 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
2716 op
= validize_mem (op
);
2718 if (! allows_reg
&& !MEM_P (op
))
2719 error ("output number %d not directly addressable", i
);
2720 if ((! allows_mem
&& MEM_P (op
))
2721 || GET_CODE (op
) == CONCAT
)
2723 real_output_rtx
[i
] = op
;
2724 op
= gen_reg_rtx (GET_MODE (op
));
2726 emit_move_insn (op
, real_output_rtx
[i
]);
2731 op
= assign_temp (type
, 0, 1);
2732 op
= validize_mem (op
);
2733 if (!MEM_P (op
) && TREE_CODE (TREE_VALUE (tail
)) == SSA_NAME
)
2734 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (TREE_VALUE (tail
)), op
);
2735 TREE_VALUE (tail
) = make_tree (type
, op
);
2739 generating_concat_p
= old_generating_concat_p
;
2743 inout_mode
[ninout
] = TYPE_MODE (type
);
2744 inout_opnum
[ninout
++] = i
;
2747 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2748 clobber_conflict_found
= 1;
2751 /* Make vectors for the expression-rtx, constraint strings,
2752 and named operands. */
2754 argvec
= rtvec_alloc (ninputs
);
2755 constraintvec
= rtvec_alloc (ninputs
);
2756 labelvec
= rtvec_alloc (nlabels
);
2758 body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
2759 : GET_MODE (output_rtx
[0])),
2760 ggc_strdup (TREE_STRING_POINTER (string
)),
2761 empty_string
, 0, argvec
, constraintvec
,
2764 MEM_VOLATILE_P (body
) = vol
;
2766 /* Eval the inputs and put them into ARGVEC.
2767 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
2769 for (i
= 0, tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
), ++i
)
2771 bool allows_reg
, allows_mem
;
2772 const char *constraint
;
2777 constraint
= constraints
[i
+ noutputs
];
2778 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2779 constraints
, &allows_mem
, &allows_reg
);
2782 generating_concat_p
= 0;
2784 val
= TREE_VALUE (tail
);
2785 type
= TREE_TYPE (val
);
2786 /* EXPAND_INITIALIZER will not generate code for valid initializer
2787 constants, but will still generate code for other types of operand.
2788 This is the behavior we want for constant constraints. */
2789 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2790 allows_reg
? EXPAND_NORMAL
2791 : allows_mem
? EXPAND_MEMORY
2792 : EXPAND_INITIALIZER
);
2794 /* Never pass a CONCAT to an ASM. */
2795 if (GET_CODE (op
) == CONCAT
)
2796 op
= force_reg (GET_MODE (op
), op
);
2797 else if (MEM_P (op
))
2798 op
= validize_mem (op
);
2800 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
2802 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
2803 op
= force_reg (TYPE_MODE (type
), op
);
2804 else if (!allows_mem
)
2805 warning (0, "asm operand %d probably doesn%'t match constraints",
2807 else if (MEM_P (op
))
2809 /* We won't recognize either volatile memory or memory
2810 with a queued address as available a memory_operand
2811 at this point. Ignore it: clearly this *is* a memory. */
2817 generating_concat_p
= old_generating_concat_p
;
2818 ASM_OPERANDS_INPUT (body
, i
) = op
;
2820 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
2821 = gen_rtx_ASM_INPUT_loc (TYPE_MODE (type
),
2822 ggc_strdup (constraints
[i
+ noutputs
]),
2825 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2826 clobber_conflict_found
= 1;
2829 /* Protect all the operands from the queue now that they have all been
2832 generating_concat_p
= 0;
2834 /* For in-out operands, copy output rtx to input rtx. */
2835 for (i
= 0; i
< ninout
; i
++)
2837 int j
= inout_opnum
[i
];
2840 ASM_OPERANDS_INPUT (body
, ninputs
- ninout
+ i
)
2843 sprintf (buffer
, "%d", j
);
2844 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, ninputs
- ninout
+ i
)
2845 = gen_rtx_ASM_INPUT_loc (inout_mode
[i
], ggc_strdup (buffer
), locus
);
2848 /* Copy labels to the vector. */
2849 for (i
= 0, tail
= labels
; i
< nlabels
; ++i
, tail
= TREE_CHAIN (tail
))
2852 /* If asm goto has any labels in the fallthru basic block, use
2853 a label that we emit immediately after the asm goto. Expansion
2854 may insert further instructions into the same basic block after
2855 asm goto and if we don't do this, insertion of instructions on
2856 the fallthru edge might misbehave. See PR58670. */
2858 && label_to_block_fn (cfun
, TREE_VALUE (tail
)) == fallthru_bb
)
2860 if (fallthru_label
== NULL_RTX
)
2861 fallthru_label
= gen_label_rtx ();
2865 r
= label_rtx (TREE_VALUE (tail
));
2866 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
2869 generating_concat_p
= old_generating_concat_p
;
2871 /* Now, for each output, construct an rtx
2872 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
2873 ARGVEC CONSTRAINTS OPNAMES))
2874 If there is more than one, put them inside a PARALLEL. */
2876 if (nlabels
> 0 && nclobbers
== 0)
2878 gcc_assert (noutputs
== 0);
2879 emit_jump_insn (body
);
2881 else if (noutputs
== 0 && nclobbers
== 0)
2883 /* No output operands: put in a raw ASM_OPERANDS rtx. */
2886 else if (noutputs
== 1 && nclobbers
== 0)
2888 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = ggc_strdup (constraints
[0]);
2889 emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
2899 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
2901 /* For each output operand, store a SET. */
2902 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2904 XVECEXP (body
, 0, i
)
2905 = gen_rtx_SET (VOIDmode
,
2907 gen_rtx_ASM_OPERANDS
2908 (GET_MODE (output_rtx
[i
]),
2909 ggc_strdup (TREE_STRING_POINTER (string
)),
2910 ggc_strdup (constraints
[i
]),
2911 i
, argvec
, constraintvec
, labelvec
, locus
));
2913 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
2916 /* If there are no outputs (but there are some clobbers)
2917 store the bare ASM_OPERANDS into the PARALLEL. */
2920 XVECEXP (body
, 0, i
++) = obody
;
2922 /* Store (clobber REG) for each clobbered register specified. */
2924 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2926 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2928 int j
= decode_reg_name_and_count (regname
, &nregs
);
2933 if (j
== -3) /* `cc', which is not a register */
2936 if (j
== -4) /* `memory', don't cache memory across asm */
2938 XVECEXP (body
, 0, i
++)
2939 = gen_rtx_CLOBBER (VOIDmode
,
2942 gen_rtx_SCRATCH (VOIDmode
)));
2946 /* Ignore unknown register, error already signaled. */
2950 for (reg
= j
; reg
< j
+ nregs
; reg
++)
2952 /* Use QImode since that's guaranteed to clobber just
2954 clobbered_reg
= gen_rtx_REG (QImode
, reg
);
2956 /* Do sanity check for overlap between clobbers and
2957 respectively input and outputs that hasn't been
2958 handled. Such overlap should have been detected and
2960 if (!clobber_conflict_found
)
2964 /* We test the old body (obody) contents to avoid
2965 tripping over the under-construction body. */
2966 for (opno
= 0; opno
< noutputs
; opno
++)
2967 if (reg_overlap_mentioned_p (clobbered_reg
,
2970 ("asm clobber conflict with output operand");
2972 for (opno
= 0; opno
< ninputs
- ninout
; opno
++)
2973 if (reg_overlap_mentioned_p (clobbered_reg
,
2974 ASM_OPERANDS_INPUT (obody
,
2977 ("asm clobber conflict with input operand");
2980 XVECEXP (body
, 0, i
++)
2981 = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
2986 emit_jump_insn (body
);
2992 emit_label (fallthru_label
);
2994 /* For any outputs that needed reloading into registers, spill them
2995 back to where they belong. */
2996 for (i
= 0; i
< noutputs
; ++i
)
2997 if (real_output_rtx
[i
])
2998 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
3000 crtl
->has_asm_statement
= 1;
3006 expand_asm_stmt (gasm
*stmt
)
3009 tree outputs
, tail
, t
;
3013 tree str
, out
, in
, cl
, labels
;
3014 location_t locus
= gimple_location (stmt
);
3015 basic_block fallthru_bb
= NULL
;
3017 /* Meh... convert the gimple asm operands into real tree lists.
3018 Eventually we should make all routines work on the vectors instead
3019 of relying on TREE_CHAIN. */
3021 n
= gimple_asm_noutputs (stmt
);
3024 t
= out
= gimple_asm_output_op (stmt
, 0);
3025 for (i
= 1; i
< n
; i
++)
3026 t
= TREE_CHAIN (t
) = gimple_asm_output_op (stmt
, i
);
3030 n
= gimple_asm_ninputs (stmt
);
3033 t
= in
= gimple_asm_input_op (stmt
, 0);
3034 for (i
= 1; i
< n
; i
++)
3035 t
= TREE_CHAIN (t
) = gimple_asm_input_op (stmt
, i
);
3039 n
= gimple_asm_nclobbers (stmt
);
3042 t
= cl
= gimple_asm_clobber_op (stmt
, 0);
3043 for (i
= 1; i
< n
; i
++)
3044 t
= TREE_CHAIN (t
) = gimple_asm_clobber_op (stmt
, i
);
3048 n
= gimple_asm_nlabels (stmt
);
3051 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3053 fallthru_bb
= fallthru
->dest
;
3054 t
= labels
= gimple_asm_label_op (stmt
, 0);
3055 for (i
= 1; i
< n
; i
++)
3056 t
= TREE_CHAIN (t
) = gimple_asm_label_op (stmt
, i
);
3059 s
= gimple_asm_string (stmt
);
3060 str
= build_string (strlen (s
), s
);
3062 if (gimple_asm_input_p (stmt
))
3064 expand_asm_loc (str
, gimple_asm_volatile_p (stmt
), locus
);
3069 noutputs
= gimple_asm_noutputs (stmt
);
3070 /* o[I] is the place that output number I should be written. */
3071 o
= (tree
*) alloca (noutputs
* sizeof (tree
));
3073 /* Record the contents of OUTPUTS before it is modified. */
3074 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
3075 o
[i
] = TREE_VALUE (tail
);
3077 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
3078 OUTPUTS some trees for where the values were actually stored. */
3079 expand_asm_operands (str
, outputs
, in
, cl
, labels
, fallthru_bb
,
3080 gimple_asm_volatile_p (stmt
), locus
);
3082 /* Copy all the intermediate outputs into the specified outputs. */
3083 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
3085 if (o
[i
] != TREE_VALUE (tail
))
3087 expand_assignment (o
[i
], TREE_VALUE (tail
), false);
3090 /* Restore the original value so that it's correct the next
3091 time we expand this function. */
3092 TREE_VALUE (tail
) = o
[i
];
3097 /* Emit code to jump to the address
3098 specified by the pointer expression EXP. */
3101 expand_computed_goto (tree exp
)
3103 rtx x
= expand_normal (exp
);
3105 do_pending_stack_adjust ();
3106 emit_indirect_jump (x
);
3109 /* Generate RTL code for a `goto' statement with target label LABEL.
3110 LABEL should be a LABEL_DECL tree node that was or will later be
3111 defined with `expand_label'. */
3114 expand_goto (tree label
)
3116 #ifdef ENABLE_CHECKING
3117 /* Check for a nonlocal goto to a containing function. Should have
3118 gotten translated to __builtin_nonlocal_goto. */
3119 tree context
= decl_function_context (label
);
3120 gcc_assert (!context
|| context
== current_function_decl
);
3123 emit_jump (label_rtx (label
));
3126 /* Output a return with no value. */
3129 expand_null_return_1 (void)
3131 clear_pending_stack_adjust ();
3132 do_pending_stack_adjust ();
3133 emit_jump (return_label
);
3136 /* Generate RTL to return from the current function, with no value.
3137 (That is, we do not do anything about returning any value.) */
3140 expand_null_return (void)
3142 /* If this function was declared to return a value, but we
3143 didn't, clobber the return registers so that they are not
3144 propagated live to the rest of the function. */
3145 clobber_return_register ();
3147 expand_null_return_1 ();
3150 /* Generate RTL to return from the current function, with value VAL. */
3153 expand_value_return (rtx val
)
3155 /* Copy the value to the return location unless it's already there. */
3157 tree decl
= DECL_RESULT (current_function_decl
);
3158 rtx return_reg
= DECL_RTL (decl
);
3159 if (return_reg
!= val
)
3161 tree funtype
= TREE_TYPE (current_function_decl
);
3162 tree type
= TREE_TYPE (decl
);
3163 int unsignedp
= TYPE_UNSIGNED (type
);
3164 machine_mode old_mode
= DECL_MODE (decl
);
3166 if (DECL_BY_REFERENCE (decl
))
3167 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3169 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3171 if (mode
!= old_mode
)
3172 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3174 if (GET_CODE (return_reg
) == PARALLEL
)
3175 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3177 emit_move_insn (return_reg
, val
);
3180 expand_null_return_1 ();
3183 /* Generate RTL to evaluate the expression RETVAL and return it
3184 from the current function. */
3187 expand_return (tree retval
, tree bounds
)
3194 /* If function wants no value, give it none. */
3195 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3197 expand_normal (retval
);
3198 expand_null_return ();
3202 if (retval
== error_mark_node
)
3204 /* Treat this like a return of no value from a function that
3206 expand_null_return ();
3209 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3210 || TREE_CODE (retval
) == INIT_EXPR
)
3211 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3212 retval_rhs
= TREE_OPERAND (retval
, 1);
3214 retval_rhs
= retval
;
3216 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3218 /* Put returned bounds to the right place. */
3219 bounds_rtl
= DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl
));
3225 if (bounds
&& bounds
!= error_mark_node
)
3227 bnd
= expand_normal (bounds
);
3228 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3230 else if (REG_P (bounds_rtl
))
3233 bnd
= chkp_expand_zero_bounds ();
3236 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3237 addr
= gen_rtx_MEM (Pmode
, addr
);
3238 bnd
= targetm
.calls
.load_bounds_for_arg (addr
, NULL
, NULL
);
3241 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3247 gcc_assert (GET_CODE (bounds_rtl
) == PARALLEL
);
3250 bnd
= chkp_expand_zero_bounds ();
3253 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3254 addr
= gen_rtx_MEM (Pmode
, addr
);
3257 for (n
= 0; n
< XVECLEN (bounds_rtl
, 0); n
++)
3259 rtx slot
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 0);
3262 rtx offs
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 1);
3263 rtx from
= adjust_address (addr
, Pmode
, INTVAL (offs
));
3264 bnd
= targetm
.calls
.load_bounds_for_arg (from
, NULL
, NULL
);
3266 targetm
.calls
.store_returned_bounds (slot
, bnd
);
3270 else if (chkp_function_instrumented_p (current_function_decl
)
3271 && !BOUNDED_P (retval_rhs
)
3272 && chkp_type_has_pointer (TREE_TYPE (retval_rhs
))
3273 && TREE_CODE (retval_rhs
) != RESULT_DECL
)
3275 rtx addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3276 addr
= gen_rtx_MEM (Pmode
, addr
);
3278 gcc_assert (MEM_P (result_rtl
));
3280 chkp_copy_bounds_for_stack_parm (result_rtl
, addr
, TREE_TYPE (retval_rhs
));
3283 /* If we are returning the RESULT_DECL, then the value has already
3284 been stored into it, so we don't have to do anything special. */
3285 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3286 expand_value_return (result_rtl
);
3288 /* If the result is an aggregate that is being returned in one (or more)
3289 registers, load the registers here. */
3291 else if (retval_rhs
!= 0
3292 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3293 && REG_P (result_rtl
))
3295 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3298 /* Use the mode of the result value on the return register. */
3299 PUT_MODE (result_rtl
, GET_MODE (val
));
3300 expand_value_return (val
);
3303 expand_null_return ();
3305 else if (retval_rhs
!= 0
3306 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3307 && (REG_P (result_rtl
)
3308 || (GET_CODE (result_rtl
) == PARALLEL
)))
3310 /* Compute the return value into a temporary (usually a pseudo reg). */
3312 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3313 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3314 val
= force_not_mem (val
);
3315 expand_value_return (val
);
3319 /* No hard reg used; calculate value into hard return reg. */
3320 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3321 expand_value_return (result_rtl
);
3325 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3326 STMT that doesn't require special handling for outgoing edges. That
3327 is no tailcalls and no GIMPLE_COND. */
3330 expand_gimple_stmt_1 (gimple stmt
)
3334 set_curr_insn_location (gimple_location (stmt
));
3336 switch (gimple_code (stmt
))
3339 op0
= gimple_goto_dest (stmt
);
3340 if (TREE_CODE (op0
) == LABEL_DECL
)
3343 expand_computed_goto (op0
);
3346 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3349 case GIMPLE_PREDICT
:
3352 expand_case (as_a
<gswitch
*> (stmt
));
3355 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3358 expand_call_stmt (as_a
<gcall
*> (stmt
));
3363 tree bnd
= gimple_return_retbnd (as_a
<greturn
*> (stmt
));
3364 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3366 if (op0
&& op0
!= error_mark_node
)
3368 tree result
= DECL_RESULT (current_function_decl
);
3370 /* If we are not returning the current function's RESULT_DECL,
3371 build an assignment to it. */
3374 /* I believe that a function's RESULT_DECL is unique. */
3375 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3377 /* ??? We'd like to use simply expand_assignment here,
3378 but this fails if the value is of BLKmode but the return
3379 decl is a register. expand_return has special handling
3380 for this combination, which eventually should move
3381 to common code. See comments there. Until then, let's
3382 build a modify expression :-/ */
3383 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3386 /* Mark we have return statement with missing bounds. */
3387 if (!bnd
&& chkp_function_instrumented_p (cfun
->decl
))
3388 bnd
= error_mark_node
;
3392 expand_null_return ();
3394 expand_return (op0
, bnd
);
3400 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3401 tree lhs
= gimple_assign_lhs (assign_stmt
);
3403 /* Tree expand used to fiddle with |= and &= of two bitfield
3404 COMPONENT_REFs here. This can't happen with gimple, the LHS
3405 of binary assigns must be a gimple reg. */
3407 if (TREE_CODE (lhs
) != SSA_NAME
3408 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3409 == GIMPLE_SINGLE_RHS
)
3411 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3412 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3413 == GIMPLE_SINGLE_RHS
);
3414 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
3415 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3416 if (TREE_CLOBBER_P (rhs
))
3417 /* This is a clobber to mark the going out of scope for
3421 expand_assignment (lhs
, rhs
,
3422 gimple_assign_nontemporal_move_p (
3428 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3429 struct separate_ops ops
;
3430 bool promoted
= false;
3432 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3433 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3436 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3437 ops
.type
= TREE_TYPE (lhs
);
3438 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
3440 case GIMPLE_TERNARY_RHS
:
3441 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3443 case GIMPLE_BINARY_RHS
:
3444 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3446 case GIMPLE_UNARY_RHS
:
3447 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3452 ops
.location
= gimple_location (stmt
);
3454 /* If we want to use a nontemporal store, force the value to
3455 register first. If we store into a promoted register,
3456 don't directly expand to target. */
3457 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3458 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3465 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3466 /* If TEMP is a VOIDmode constant, use convert_modes to make
3467 sure that we properly convert it. */
3468 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3470 temp
= convert_modes (GET_MODE (target
),
3471 TYPE_MODE (ops
.type
),
3473 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3474 GET_MODE (target
), temp
, unsignedp
);
3477 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3479 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3483 temp
= force_operand (temp
, target
);
3485 emit_move_insn (target
, temp
);
3496 /* Expand one gimple statement STMT and return the last RTL instruction
3497 before any of the newly generated ones.
3499 In addition to generating the necessary RTL instructions this also
3500 sets REG_EH_REGION notes if necessary and sets the current source
3501 location for diagnostics. */
3504 expand_gimple_stmt (gimple stmt
)
3506 location_t saved_location
= input_location
;
3507 rtx_insn
*last
= get_last_insn ();
3512 /* We need to save and restore the current source location so that errors
3513 discovered during expansion are emitted with the right location. But
3514 it would be better if the diagnostic routines used the source location
3515 embedded in the tree nodes rather than globals. */
3516 if (gimple_has_location (stmt
))
3517 input_location
= gimple_location (stmt
);
3519 expand_gimple_stmt_1 (stmt
);
3521 /* Free any temporaries used to evaluate this statement. */
3524 input_location
= saved_location
;
3526 /* Mark all insns that may trap. */
3527 lp_nr
= lookup_stmt_eh_lp (stmt
);
3531 for (insn
= next_real_insn (last
); insn
;
3532 insn
= next_real_insn (insn
))
3534 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3535 /* If we want exceptions for non-call insns, any
3536 may_trap_p instruction may throw. */
3537 && GET_CODE (PATTERN (insn
)) != CLOBBER
3538 && GET_CODE (PATTERN (insn
)) != USE
3539 && insn_could_throw_p (insn
))
3540 make_reg_eh_region_note (insn
, 0, lp_nr
);
3547 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3548 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3549 generated a tail call (something that might be denied by the ABI
3550 rules governing the call; see calls.c).
3552 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3553 can still reach the rest of BB. The case here is __builtin_sqrt,
3554 where the NaN result goes through the external function (with a
3555 tailcall) and the normal result happens via a sqrt instruction. */
3558 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3560 rtx_insn
*last2
, *last
;
3566 last2
= last
= expand_gimple_stmt (stmt
);
3568 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3569 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3572 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3574 *can_fallthru
= true;
3578 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3579 Any instructions emitted here are about to be deleted. */
3580 do_pending_stack_adjust ();
3582 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3583 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3584 EH or abnormal edges, we shouldn't have created a tail call in
3585 the first place. So it seems to me we should just be removing
3586 all edges here, or redirecting the existing fallthru edge to
3592 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3594 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3596 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3598 e
->dest
->count
-= e
->count
;
3599 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3600 if (e
->dest
->count
< 0)
3602 if (e
->dest
->frequency
< 0)
3603 e
->dest
->frequency
= 0;
3606 probability
+= e
->probability
;
3613 /* This is somewhat ugly: the call_expr expander often emits instructions
3614 after the sibcall (to perform the function return). These confuse the
3615 find_many_sub_basic_blocks code, so we need to get rid of these. */
3616 last
= NEXT_INSN (last
);
3617 gcc_assert (BARRIER_P (last
));
3619 *can_fallthru
= false;
3620 while (NEXT_INSN (last
))
3622 /* For instance an sqrt builtin expander expands if with
3623 sibcall in the then and label for `else`. */
3624 if (LABEL_P (NEXT_INSN (last
)))
3626 *can_fallthru
= true;
3629 delete_insn (NEXT_INSN (last
));
3632 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3634 e
->probability
+= probability
;
3637 update_bb_for_insn (bb
);
3639 if (NEXT_INSN (last
))
3641 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3644 if (BARRIER_P (last
))
3645 BB_END (bb
) = PREV_INSN (last
);
3648 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3653 /* Return the difference between the floor and the truncated result of
3654 a signed division by OP1 with remainder MOD. */
3656 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3658 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3659 return gen_rtx_IF_THEN_ELSE
3660 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3661 gen_rtx_IF_THEN_ELSE
3662 (mode
, gen_rtx_LT (BImode
,
3663 gen_rtx_DIV (mode
, op1
, mod
),
3665 constm1_rtx
, const0_rtx
),
3669 /* Return the difference between the ceil and the truncated result of
3670 a signed division by OP1 with remainder MOD. */
3672 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3674 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3675 return gen_rtx_IF_THEN_ELSE
3676 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3677 gen_rtx_IF_THEN_ELSE
3678 (mode
, gen_rtx_GT (BImode
,
3679 gen_rtx_DIV (mode
, op1
, mod
),
3681 const1_rtx
, const0_rtx
),
3685 /* Return the difference between the ceil and the truncated result of
3686 an unsigned division by OP1 with remainder MOD. */
3688 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3690 /* (mod != 0 ? 1 : 0) */
3691 return gen_rtx_IF_THEN_ELSE
3692 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3693 const1_rtx
, const0_rtx
);
3696 /* Return the difference between the rounded and the truncated result
3697 of a signed division by OP1 with remainder MOD. Halfway cases are
3698 rounded away from zero, rather than to the nearest even number. */
3700 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3702 /* (abs (mod) >= abs (op1) - abs (mod)
3703 ? (op1 / mod > 0 ? 1 : -1)
3705 return gen_rtx_IF_THEN_ELSE
3706 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3707 gen_rtx_MINUS (mode
,
3708 gen_rtx_ABS (mode
, op1
),
3709 gen_rtx_ABS (mode
, mod
))),
3710 gen_rtx_IF_THEN_ELSE
3711 (mode
, gen_rtx_GT (BImode
,
3712 gen_rtx_DIV (mode
, op1
, mod
),
3714 const1_rtx
, constm1_rtx
),
3718 /* Return the difference between the rounded and the truncated result
3719 of a unsigned division by OP1 with remainder MOD. Halfway cases
3720 are rounded away from zero, rather than to the nearest even
3723 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3725 /* (mod >= op1 - mod ? 1 : 0) */
3726 return gen_rtx_IF_THEN_ELSE
3727 (mode
, gen_rtx_GE (BImode
, mod
,
3728 gen_rtx_MINUS (mode
, op1
, mod
)),
3729 const1_rtx
, const0_rtx
);
3732 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3736 convert_debug_memory_address (machine_mode mode
, rtx x
,
3739 machine_mode xmode
= GET_MODE (x
);
3741 #ifndef POINTERS_EXTEND_UNSIGNED
3742 gcc_assert (mode
== Pmode
3743 || mode
== targetm
.addr_space
.address_mode (as
));
3744 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3748 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3750 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3753 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3754 x
= simplify_gen_subreg (mode
, x
, xmode
,
3755 subreg_lowpart_offset
3757 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3758 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3759 else if (!POINTERS_EXTEND_UNSIGNED
)
3760 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3763 switch (GET_CODE (x
))
3766 if ((SUBREG_PROMOTED_VAR_P (x
)
3767 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3768 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3769 && REG_P (XEXP (SUBREG_REG (x
), 0))
3770 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3771 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3772 && GET_MODE (SUBREG_REG (x
)) == mode
)
3773 return SUBREG_REG (x
);
3776 temp
= gen_rtx_LABEL_REF (mode
, LABEL_REF_LABEL (x
));
3777 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
3780 temp
= shallow_copy_rtx (x
);
3781 PUT_MODE (temp
, mode
);
3784 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3786 temp
= gen_rtx_CONST (mode
, temp
);
3790 if (CONST_INT_P (XEXP (x
, 1)))
3792 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3794 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
3800 /* Don't know how to express ptr_extend as operation in debug info. */
3803 #endif /* POINTERS_EXTEND_UNSIGNED */
3808 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
3809 by avoid_deep_ter_for_debug. */
3811 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
3813 /* Split too deep TER chains for debug stmts using debug temporaries. */
3816 avoid_deep_ter_for_debug (gimple stmt
, int depth
)
3818 use_operand_p use_p
;
3820 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
3822 tree use
= USE_FROM_PTR (use_p
);
3823 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
3825 gimple g
= get_gimple_for_ssa_name (use
);
3828 if (depth
> 6 && !stmt_ends_bb_p (g
))
3830 if (deep_ter_debug_map
== NULL
)
3831 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
3833 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
3836 vexpr
= make_node (DEBUG_EXPR_DECL
);
3837 gimple def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
3838 DECL_ARTIFICIAL (vexpr
) = 1;
3839 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
3840 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (use
));
3841 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
3842 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
3843 avoid_deep_ter_for_debug (def_temp
, 0);
3846 avoid_deep_ter_for_debug (g
, depth
+ 1);
3850 /* Return an RTX equivalent to the value of the parameter DECL. */
3853 expand_debug_parm_decl (tree decl
)
3855 rtx incoming
= DECL_INCOMING_RTL (decl
);
3858 && GET_MODE (incoming
) != BLKmode
3859 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
3860 || (MEM_P (incoming
)
3861 && REG_P (XEXP (incoming
, 0))
3862 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
3864 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
3866 #ifdef HAVE_window_save
3867 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
3868 If the target machine has an explicit window save instruction, the
3869 actual entry value is the corresponding OUTGOING_REGNO instead. */
3870 if (REG_P (incoming
)
3871 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
3873 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
3874 OUTGOING_REGNO (REGNO (incoming
)), 0);
3875 else if (MEM_P (incoming
))
3877 rtx reg
= XEXP (incoming
, 0);
3878 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
3880 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
3881 incoming
= replace_equiv_address_nv (incoming
, reg
);
3884 incoming
= copy_rtx (incoming
);
3888 ENTRY_VALUE_EXP (rtl
) = incoming
;
3893 && GET_MODE (incoming
) != BLKmode
3894 && !TREE_ADDRESSABLE (decl
)
3896 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
3897 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
3898 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
3899 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
3900 return copy_rtx (incoming
);
3905 /* Return an RTX equivalent to the value of the tree expression EXP. */
3908 expand_debug_expr (tree exp
)
3910 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
3911 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
3912 machine_mode inner_mode
= VOIDmode
;
3913 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
3916 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
3918 case tcc_expression
:
3919 switch (TREE_CODE (exp
))
3924 case WIDEN_MULT_PLUS_EXPR
:
3925 case WIDEN_MULT_MINUS_EXPR
:
3929 case TRUTH_ANDIF_EXPR
:
3930 case TRUTH_ORIF_EXPR
:
3931 case TRUTH_AND_EXPR
:
3933 case TRUTH_XOR_EXPR
:
3936 case TRUTH_NOT_EXPR
:
3945 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
3952 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3955 switch (TREE_CODE (exp
))
3961 case WIDEN_LSHIFT_EXPR
:
3962 /* Ensure second operand isn't wider than the first one. */
3963 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
3964 if (SCALAR_INT_MODE_P (inner_mode
))
3966 machine_mode opmode
= mode
;
3967 if (VECTOR_MODE_P (mode
))
3968 opmode
= GET_MODE_INNER (mode
);
3969 if (SCALAR_INT_MODE_P (opmode
)
3970 && (GET_MODE_PRECISION (opmode
)
3971 < GET_MODE_PRECISION (inner_mode
)))
3972 op1
= simplify_gen_subreg (opmode
, op1
, inner_mode
,
3973 subreg_lowpart_offset (opmode
,
3984 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3985 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3990 case tcc_comparison
:
3991 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3999 case tcc_exceptional
:
4000 case tcc_declaration
:
4006 switch (TREE_CODE (exp
))
4009 if (!lookup_constant_def (exp
))
4011 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4012 != (size_t) TREE_STRING_LENGTH (exp
))
4014 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4015 op0
= gen_rtx_MEM (BLKmode
, op0
);
4016 set_mem_attributes (op0
, exp
, 0);
4019 /* Fall through... */
4024 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4028 gcc_assert (COMPLEX_MODE_P (mode
));
4029 op0
= expand_debug_expr (TREE_REALPART (exp
));
4030 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4031 return gen_rtx_CONCAT (mode
, op0
, op1
);
4033 case DEBUG_EXPR_DECL
:
4034 op0
= DECL_RTL_IF_SET (exp
);
4039 op0
= gen_rtx_DEBUG_EXPR (mode
);
4040 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4041 SET_DECL_RTL (exp
, op0
);
4051 op0
= DECL_RTL_IF_SET (exp
);
4053 /* This decl was probably optimized away. */
4056 if (TREE_CODE (exp
) != VAR_DECL
4057 || DECL_EXTERNAL (exp
)
4058 || !TREE_STATIC (exp
)
4060 || DECL_HARD_REGISTER (exp
)
4061 || DECL_IN_CONSTANT_POOL (exp
)
4062 || mode
== VOIDmode
)
4065 op0
= make_decl_rtl_for_debug (exp
);
4067 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4068 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4072 op0
= copy_rtx (op0
);
4074 if (GET_MODE (op0
) == BLKmode
4075 /* If op0 is not BLKmode, but mode is, adjust_mode
4076 below would ICE. While it is likely a FE bug,
4077 try to be robust here. See PR43166. */
4079 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4081 gcc_assert (MEM_P (op0
));
4082 op0
= adjust_address_nv (op0
, mode
, 0);
4092 inner_mode
= GET_MODE (op0
);
4094 if (mode
== inner_mode
)
4097 if (inner_mode
== VOIDmode
)
4099 if (TREE_CODE (exp
) == SSA_NAME
)
4100 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4102 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4103 if (mode
== inner_mode
)
4107 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4109 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4110 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4111 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4112 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4114 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4116 else if (FLOAT_MODE_P (mode
))
4118 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4119 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4120 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4122 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4124 else if (FLOAT_MODE_P (inner_mode
))
4127 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4129 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4131 else if (CONSTANT_P (op0
)
4132 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
4133 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4134 subreg_lowpart_offset (mode
,
4136 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
4137 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4139 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4141 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4147 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4149 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4150 TREE_OPERAND (exp
, 0),
4151 TREE_OPERAND (exp
, 1));
4153 return expand_debug_expr (newexp
);
4157 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4158 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4162 if (TREE_CODE (exp
) == MEM_REF
)
4164 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4165 || (GET_CODE (op0
) == PLUS
4166 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4167 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4168 Instead just use get_inner_reference. */
4171 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4172 if (!op1
|| !CONST_INT_P (op1
))
4175 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
4178 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4180 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4182 if (op0
== NULL_RTX
)
4185 op0
= gen_rtx_MEM (mode
, op0
);
4186 set_mem_attributes (op0
, exp
, 0);
4187 if (TREE_CODE (exp
) == MEM_REF
4188 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4189 set_mem_expr (op0
, NULL_TREE
);
4190 set_mem_addr_space (op0
, as
);
4194 case TARGET_MEM_REF
:
4195 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4196 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4199 op0
= expand_debug_expr
4200 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4204 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4205 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4207 if (op0
== NULL_RTX
)
4210 op0
= gen_rtx_MEM (mode
, op0
);
4212 set_mem_attributes (op0
, exp
, 0);
4213 set_mem_addr_space (op0
, as
);
4219 case ARRAY_RANGE_REF
:
4224 case VIEW_CONVERT_EXPR
:
4227 HOST_WIDE_INT bitsize
, bitpos
;
4230 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
4231 &mode1
, &unsignedp
, &volatilep
, false);
4237 orig_op0
= op0
= expand_debug_expr (tem
);
4244 machine_mode addrmode
, offmode
;
4249 op0
= XEXP (op0
, 0);
4250 addrmode
= GET_MODE (op0
);
4251 if (addrmode
== VOIDmode
)
4254 op1
= expand_debug_expr (offset
);
4258 offmode
= GET_MODE (op1
);
4259 if (offmode
== VOIDmode
)
4260 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4262 if (addrmode
!= offmode
)
4263 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
4264 subreg_lowpart_offset (addrmode
,
4267 /* Don't use offset_address here, we don't need a
4268 recognizable address, and we don't want to generate
4270 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4276 if (mode1
== VOIDmode
)
4278 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4279 if (bitpos
>= BITS_PER_UNIT
)
4281 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4282 bitpos
%= BITS_PER_UNIT
;
4284 else if (bitpos
< 0)
4287 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4288 op0
= adjust_address_nv (op0
, mode1
, units
);
4289 bitpos
+= units
* BITS_PER_UNIT
;
4291 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4292 op0
= adjust_address_nv (op0
, mode
, 0);
4293 else if (GET_MODE (op0
) != mode1
)
4294 op0
= adjust_address_nv (op0
, mode1
, 0);
4296 op0
= copy_rtx (op0
);
4297 if (op0
== orig_op0
)
4298 op0
= shallow_copy_rtx (op0
);
4299 set_mem_attributes (op0
, exp
, 0);
4302 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4308 if (GET_MODE (op0
) == BLKmode
)
4311 if ((bitpos
% BITS_PER_UNIT
) == 0
4312 && bitsize
== GET_MODE_BITSIZE (mode1
))
4314 machine_mode opmode
= GET_MODE (op0
);
4316 if (opmode
== VOIDmode
)
4317 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4319 /* This condition may hold if we're expanding the address
4320 right past the end of an array that turned out not to
4321 be addressable (i.e., the address was only computed in
4322 debug stmts). The gen_subreg below would rightfully
4323 crash, and the address doesn't really exist, so just
4325 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4328 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4329 return simplify_gen_subreg (mode
, op0
, opmode
,
4330 bitpos
/ BITS_PER_UNIT
);
4333 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4334 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4336 : ZERO_EXTRACT
, mode
,
4337 GET_MODE (op0
) != VOIDmode
4339 : TYPE_MODE (TREE_TYPE (tem
)),
4340 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4344 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4347 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4350 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4353 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4355 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4358 case FIX_TRUNC_EXPR
:
4359 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4362 case POINTER_PLUS_EXPR
:
4363 /* For the rare target where pointers are not the same size as
4364 size_t, we need to check for mis-matched modes and correct
4367 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4368 && GET_MODE (op0
) != GET_MODE (op1
))
4370 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4371 /* If OP0 is a partial mode, then we must truncate, even if it has
4372 the same bitsize as OP1 as GCC's representation of partial modes
4374 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4375 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4376 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4379 /* We always sign-extend, regardless of the signedness of
4380 the operand, because the operand is always unsigned
4381 here even if the original C expression is signed. */
4382 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4387 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4390 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4393 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4396 case TRUNC_DIV_EXPR
:
4397 case EXACT_DIV_EXPR
:
4399 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4401 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4403 case TRUNC_MOD_EXPR
:
4404 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4406 case FLOOR_DIV_EXPR
:
4408 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4411 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4412 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4413 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4414 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4417 case FLOOR_MOD_EXPR
:
4419 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4422 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4423 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4424 adj
= simplify_gen_unary (NEG
, mode
,
4425 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4427 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4433 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4434 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4435 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4436 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4440 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4441 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4442 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4443 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4449 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4450 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4451 adj
= simplify_gen_unary (NEG
, mode
,
4452 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4454 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4458 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4459 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4460 adj
= simplify_gen_unary (NEG
, mode
,
4461 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4463 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4466 case ROUND_DIV_EXPR
:
4469 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4470 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4471 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4472 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4476 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4477 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4478 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4479 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4482 case ROUND_MOD_EXPR
:
4485 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4486 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4487 adj
= simplify_gen_unary (NEG
, mode
,
4488 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4490 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4494 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4495 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4496 adj
= simplify_gen_unary (NEG
, mode
,
4497 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4499 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4503 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4507 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4509 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4512 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4515 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4518 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4521 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4524 case TRUTH_AND_EXPR
:
4525 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4529 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4532 case TRUTH_XOR_EXPR
:
4533 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4535 case TRUTH_ANDIF_EXPR
:
4536 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4538 case TRUTH_ORIF_EXPR
:
4539 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4541 case TRUTH_NOT_EXPR
:
4542 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4545 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4549 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4553 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4557 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4561 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4564 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4566 case UNORDERED_EXPR
:
4567 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4570 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4573 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4576 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4579 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4582 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4585 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4588 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4591 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4594 gcc_assert (COMPLEX_MODE_P (mode
));
4595 if (GET_MODE (op0
) == VOIDmode
)
4596 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4597 if (GET_MODE (op1
) == VOIDmode
)
4598 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4599 return gen_rtx_CONCAT (mode
, op0
, op1
);
4602 if (GET_CODE (op0
) == CONCAT
)
4603 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4604 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4606 GET_MODE_INNER (mode
)));
4609 machine_mode imode
= GET_MODE_INNER (mode
);
4614 re
= adjust_address_nv (op0
, imode
, 0);
4615 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4619 machine_mode ifmode
= int_mode_for_mode (mode
);
4620 machine_mode ihmode
= int_mode_for_mode (imode
);
4622 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4624 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4627 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4628 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4629 if (imode
!= ihmode
)
4630 re
= gen_rtx_SUBREG (imode
, re
, 0);
4631 im
= copy_rtx (op0
);
4633 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4634 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4635 if (imode
!= ihmode
)
4636 im
= gen_rtx_SUBREG (imode
, im
, 0);
4638 im
= gen_rtx_NEG (imode
, im
);
4639 return gen_rtx_CONCAT (mode
, re
, im
);
4643 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4644 if (!op0
|| !MEM_P (op0
))
4646 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4647 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4648 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4649 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4650 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4651 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4653 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4655 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4657 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
4658 &bitoffset
, &bitsize
, &maxsize
);
4659 if ((TREE_CODE (decl
) == VAR_DECL
4660 || TREE_CODE (decl
) == PARM_DECL
4661 || TREE_CODE (decl
) == RESULT_DECL
)
4662 && (!TREE_ADDRESSABLE (decl
)
4663 || target_for_debug_bind (decl
))
4664 && (bitoffset
% BITS_PER_UNIT
) == 0
4666 && bitsize
== maxsize
)
4668 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4669 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4673 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4674 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4677 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4680 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4681 || (GET_CODE (op0
) == PLUS
4682 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4683 && CONST_INT_P (XEXP (op0
, 1)))))
4685 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4687 if (!op1
|| !CONST_INT_P (op1
))
4690 return plus_constant (mode
, op0
, INTVAL (op1
));
4697 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
4698 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4706 op0
= gen_rtx_CONCATN
4707 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4709 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4711 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4714 XVECEXP (op0
, 0, i
) = op1
;
4721 if (TREE_CLOBBER_P (exp
))
4723 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4728 op0
= gen_rtx_CONCATN
4729 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4731 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4733 op1
= expand_debug_expr (val
);
4736 XVECEXP (op0
, 0, i
) = op1
;
4739 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4741 op1
= expand_debug_expr
4742 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4747 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4748 XVECEXP (op0
, 0, i
) = op1
;
4754 goto flag_unsupported
;
4757 /* ??? Maybe handle some builtins? */
4762 gimple g
= get_gimple_for_ssa_name (exp
);
4766 if (deep_ter_debug_map
)
4768 tree
*slot
= deep_ter_debug_map
->get (exp
);
4773 t
= gimple_assign_rhs_to_tree (g
);
4774 op0
= expand_debug_expr (t
);
4780 int part
= var_to_partition (SA
.map
, exp
);
4782 if (part
== NO_PARTITION
)
4784 /* If this is a reference to an incoming value of parameter
4785 that is never used in the code or where the incoming
4786 value is never used in the code, use PARM_DECL's
4788 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
4789 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
4791 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
4794 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
4801 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
4803 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
4811 /* Vector stuff. For most of the codes we don't have rtl codes. */
4812 case REALIGN_LOAD_EXPR
:
4813 case REDUC_MAX_EXPR
:
4814 case REDUC_MIN_EXPR
:
4815 case REDUC_PLUS_EXPR
:
4817 case VEC_PACK_FIX_TRUNC_EXPR
:
4818 case VEC_PACK_SAT_EXPR
:
4819 case VEC_PACK_TRUNC_EXPR
:
4820 case VEC_UNPACK_FLOAT_HI_EXPR
:
4821 case VEC_UNPACK_FLOAT_LO_EXPR
:
4822 case VEC_UNPACK_HI_EXPR
:
4823 case VEC_UNPACK_LO_EXPR
:
4824 case VEC_WIDEN_MULT_HI_EXPR
:
4825 case VEC_WIDEN_MULT_LO_EXPR
:
4826 case VEC_WIDEN_MULT_EVEN_EXPR
:
4827 case VEC_WIDEN_MULT_ODD_EXPR
:
4828 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4829 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4834 case ADDR_SPACE_CONVERT_EXPR
:
4835 case FIXED_CONVERT_EXPR
:
4837 case WITH_SIZE_EXPR
:
4841 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4842 && SCALAR_INT_MODE_P (mode
))
4845 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4847 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4850 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4852 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
4854 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4855 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4859 case WIDEN_MULT_EXPR
:
4860 case WIDEN_MULT_PLUS_EXPR
:
4861 case WIDEN_MULT_MINUS_EXPR
:
4862 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4863 && SCALAR_INT_MODE_P (mode
))
4865 inner_mode
= GET_MODE (op0
);
4866 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4867 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4869 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4870 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
4871 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
4873 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
4874 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4875 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
4877 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
4878 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4880 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
4884 case MULT_HIGHPART_EXPR
:
4885 /* ??? Similar to the above. */
4888 case WIDEN_SUM_EXPR
:
4889 case WIDEN_LSHIFT_EXPR
:
4890 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4891 && SCALAR_INT_MODE_P (mode
))
4894 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4896 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4898 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
4899 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
4904 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
4908 #ifdef ENABLE_CHECKING
4917 /* Return an RTX equivalent to the source bind value of the tree expression
4921 expand_debug_source_expr (tree exp
)
4924 machine_mode mode
= VOIDmode
, inner_mode
;
4926 switch (TREE_CODE (exp
))
4930 mode
= DECL_MODE (exp
);
4931 op0
= expand_debug_parm_decl (exp
);
4934 /* See if this isn't an argument that has been completely
4936 if (!DECL_RTL_SET_P (exp
)
4937 && !DECL_INCOMING_RTL (exp
)
4938 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
4940 tree aexp
= DECL_ORIGIN (exp
);
4941 if (DECL_CONTEXT (aexp
)
4942 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
4944 vec
<tree
, va_gc
> **debug_args
;
4947 debug_args
= decl_debug_args_lookup (current_function_decl
);
4948 if (debug_args
!= NULL
)
4950 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
4953 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
4963 if (op0
== NULL_RTX
)
4966 inner_mode
= GET_MODE (op0
);
4967 if (mode
== inner_mode
)
4970 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4972 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4973 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4974 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4975 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4977 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4979 else if (FLOAT_MODE_P (mode
))
4981 else if (FLOAT_MODE_P (inner_mode
))
4983 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4984 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4986 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4988 else if (CONSTANT_P (op0
)
4989 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
4990 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4991 subreg_lowpart_offset (mode
, inner_mode
));
4992 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4993 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4995 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5000 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5001 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5002 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5005 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5009 if (exp
== NULL_RTX
)
5012 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5017 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5018 rtx dval
= make_debug_expr_from_rtl (exp
);
5020 /* Emit a debug bind insn before INSN. */
5021 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5022 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5023 VAR_INIT_STATUS_INITIALIZED
);
5025 emit_debug_insn_before (bind
, insn
);
5030 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5032 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5033 switch (*format_ptr
++)
5036 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5041 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5042 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5050 /* Expand the _LOCs in debug insns. We run this after expanding all
5051 regular insns, so that any variables referenced in the function
5052 will have their DECL_RTLs set. */
5055 expand_debug_locations (void)
5058 rtx_insn
*last
= get_last_insn ();
5059 int save_strict_alias
= flag_strict_aliasing
;
5061 /* New alias sets while setting up memory attributes cause
5062 -fcompare-debug failures, even though it doesn't bring about any
5064 flag_strict_aliasing
= 0;
5066 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5067 if (DEBUG_INSN_P (insn
))
5069 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5071 rtx_insn
*prev_insn
, *insn2
;
5074 if (value
== NULL_TREE
)
5078 if (INSN_VAR_LOCATION_STATUS (insn
)
5079 == VAR_INIT_STATUS_UNINITIALIZED
)
5080 val
= expand_debug_source_expr (value
);
5081 /* The avoid_deep_ter_for_debug function inserts
5082 debug bind stmts after SSA_NAME definition, with the
5083 SSA_NAME as the whole bind location. Disable temporarily
5084 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5085 being defined in this DEBUG_INSN. */
5086 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5088 tree
*slot
= deep_ter_debug_map
->get (value
);
5091 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5096 val
= expand_debug_expr (value
);
5098 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5101 val
= expand_debug_expr (value
);
5102 gcc_assert (last
== get_last_insn ());
5106 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5109 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5111 gcc_assert (mode
== GET_MODE (val
)
5112 || (GET_MODE (val
) == VOIDmode
5113 && (CONST_SCALAR_INT_P (val
)
5114 || GET_CODE (val
) == CONST_FIXED
5115 || GET_CODE (val
) == LABEL_REF
)));
5118 INSN_VAR_LOCATION_LOC (insn
) = val
;
5119 prev_insn
= PREV_INSN (insn
);
5120 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5121 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5124 flag_strict_aliasing
= save_strict_alias
;
5127 /* Performs swapping operands of commutative operations to expand
5128 the expensive one first. */
5131 reorder_operands (basic_block bb
)
5133 unsigned int *lattice
; /* Hold cost of each statement. */
5134 unsigned int i
= 0, n
= 0;
5135 gimple_stmt_iterator gsi
;
5141 use_operand_p use_p
;
5144 /* Compute cost of each statement using estimate_num_insns. */
5145 stmts
= bb_seq (bb
);
5146 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5148 stmt
= gsi_stmt (gsi
);
5149 if (!is_gimple_debug (stmt
))
5150 gimple_set_uid (stmt
, n
++);
5152 lattice
= XNEWVEC (unsigned int, n
);
5153 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5156 stmt
= gsi_stmt (gsi
);
5157 if (is_gimple_debug (stmt
))
5159 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5161 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5163 tree use
= USE_FROM_PTR (use_p
);
5165 if (TREE_CODE (use
) != SSA_NAME
)
5167 def_stmt
= get_gimple_for_ssa_name (use
);
5170 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5173 if (!is_gimple_assign (stmt
)
5174 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5176 op0
= gimple_op (stmt
, 1);
5177 op1
= gimple_op (stmt
, 2);
5178 if (TREE_CODE (op0
) != SSA_NAME
5179 || TREE_CODE (op1
) != SSA_NAME
)
5181 /* Swap operands if the second one is more expensive. */
5182 def0
= get_gimple_for_ssa_name (op0
);
5183 def1
= get_gimple_for_ssa_name (op1
);
5187 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5191 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5193 fprintf (dump_file
, "Swap operands in stmt:\n");
5194 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5195 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5196 def0
? lattice
[gimple_uid (def0
)] : 0,
5197 lattice
[gimple_uid (def1
)]);
5199 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5200 gimple_assign_rhs2_ptr (stmt
));
5206 /* Expand basic block BB from GIMPLE trees to RTL. */
5209 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5211 gimple_stmt_iterator gsi
;
5220 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5223 /* Note that since we are now transitioning from GIMPLE to RTL, we
5224 cannot use the gsi_*_bb() routines because they expect the basic
5225 block to be in GIMPLE, instead of RTL. Therefore, we need to
5226 access the BB sequence directly. */
5228 reorder_operands (bb
);
5229 stmts
= bb_seq (bb
);
5230 bb
->il
.gimple
.seq
= NULL
;
5231 bb
->il
.gimple
.phi_nodes
= NULL
;
5232 rtl_profile_for_bb (bb
);
5233 init_rtl_bb_info (bb
);
5234 bb
->flags
|= BB_RTL
;
5236 /* Remove the RETURN_EXPR if we may fall though to the exit
5238 gsi
= gsi_last (stmts
);
5239 if (!gsi_end_p (gsi
)
5240 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5242 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5244 gcc_assert (single_succ_p (bb
));
5245 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5247 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5248 && !gimple_return_retval (ret_stmt
))
5250 gsi_remove (&gsi
, false);
5251 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5255 gsi
= gsi_start (stmts
);
5256 if (!gsi_end_p (gsi
))
5258 stmt
= gsi_stmt (gsi
);
5259 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5263 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5267 last
= get_last_insn ();
5271 expand_gimple_stmt (stmt
);
5278 /* Java emits line number notes in the top of labels.
5279 ??? Make this go away once line number notes are obsoleted. */
5280 BB_HEAD (bb
) = NEXT_INSN (last
);
5281 if (NOTE_P (BB_HEAD (bb
)))
5282 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5283 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5285 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5288 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5290 NOTE_BASIC_BLOCK (note
) = bb
;
5292 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5296 stmt
= gsi_stmt (gsi
);
5298 /* If this statement is a non-debug one, and we generate debug
5299 insns, then this one might be the last real use of a TERed
5300 SSA_NAME, but where there are still some debug uses further
5301 down. Expanding the current SSA name in such further debug
5302 uses by their RHS might lead to wrong debug info, as coalescing
5303 might make the operands of such RHS be placed into the same
5304 pseudo as something else. Like so:
5305 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5309 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5310 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5311 the write to a_2 would actually have clobbered the place which
5314 So, instead of that, we recognize the situation, and generate
5315 debug temporaries at the last real use of TERed SSA names:
5322 if (MAY_HAVE_DEBUG_INSNS
5324 && !is_gimple_debug (stmt
))
5330 location_t sloc
= curr_insn_location ();
5332 /* Look for SSA names that have their last use here (TERed
5333 names always have only one real use). */
5334 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5335 if ((def
= get_gimple_for_ssa_name (op
)))
5337 imm_use_iterator imm_iter
;
5338 use_operand_p use_p
;
5339 bool have_debug_uses
= false;
5341 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5343 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5345 have_debug_uses
= true;
5350 if (have_debug_uses
)
5352 /* OP is a TERed SSA name, with DEF its defining
5353 statement, and where OP is used in further debug
5354 instructions. Generate a debug temporary, and
5355 replace all uses of OP in debug insns with that
5358 tree value
= gimple_assign_rhs_to_tree (def
);
5359 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5363 set_curr_insn_location (gimple_location (def
));
5365 DECL_ARTIFICIAL (vexpr
) = 1;
5366 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5368 mode
= DECL_MODE (value
);
5370 mode
= TYPE_MODE (TREE_TYPE (value
));
5371 DECL_MODE (vexpr
) = mode
;
5373 val
= gen_rtx_VAR_LOCATION
5374 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5376 emit_debug_insn (val
);
5378 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5380 if (!gimple_debug_bind_p (debugstmt
))
5383 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5384 SET_USE (use_p
, vexpr
);
5386 update_stmt (debugstmt
);
5390 set_curr_insn_location (sloc
);
5393 currently_expanding_gimple_stmt
= stmt
;
5395 /* Expand this statement, then evaluate the resulting RTL and
5396 fixup the CFG accordingly. */
5397 if (gimple_code (stmt
) == GIMPLE_COND
)
5399 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5403 else if (gimple_debug_bind_p (stmt
))
5405 location_t sloc
= curr_insn_location ();
5406 gimple_stmt_iterator nsi
= gsi
;
5410 tree var
= gimple_debug_bind_get_var (stmt
);
5415 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5416 && TREE_CODE (var
) != LABEL_DECL
5417 && !target_for_debug_bind (var
))
5418 goto delink_debug_stmt
;
5420 if (gimple_debug_bind_has_value_p (stmt
))
5421 value
= gimple_debug_bind_get_value (stmt
);
5425 last
= get_last_insn ();
5427 set_curr_insn_location (gimple_location (stmt
));
5430 mode
= DECL_MODE (var
);
5432 mode
= TYPE_MODE (TREE_TYPE (var
));
5434 val
= gen_rtx_VAR_LOCATION
5435 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5437 emit_debug_insn (val
);
5439 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5441 /* We can't dump the insn with a TREE where an RTX
5443 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5444 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5445 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5449 /* In order not to generate too many debug temporaries,
5450 we delink all uses of debug statements we already expanded.
5451 Therefore debug statements between definition and real
5452 use of TERed SSA names will continue to use the SSA name,
5453 and not be replaced with debug temps. */
5454 delink_stmt_imm_use (stmt
);
5458 if (gsi_end_p (nsi
))
5460 stmt
= gsi_stmt (nsi
);
5461 if (!gimple_debug_bind_p (stmt
))
5465 set_curr_insn_location (sloc
);
5467 else if (gimple_debug_source_bind_p (stmt
))
5469 location_t sloc
= curr_insn_location ();
5470 tree var
= gimple_debug_source_bind_get_var (stmt
);
5471 tree value
= gimple_debug_source_bind_get_value (stmt
);
5475 last
= get_last_insn ();
5477 set_curr_insn_location (gimple_location (stmt
));
5479 mode
= DECL_MODE (var
);
5481 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5482 VAR_INIT_STATUS_UNINITIALIZED
);
5484 emit_debug_insn (val
);
5486 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5488 /* We can't dump the insn with a TREE where an RTX
5490 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5491 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5492 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5495 set_curr_insn_location (sloc
);
5499 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5501 && gimple_call_tail_p (call_stmt
)
5502 && disable_tail_calls
)
5503 gimple_call_set_tail (call_stmt
, false);
5505 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5508 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5519 def_operand_p def_p
;
5520 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5524 /* Ignore this stmt if it is in the list of
5525 replaceable expressions. */
5527 && bitmap_bit_p (SA
.values
,
5528 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5531 last
= expand_gimple_stmt (stmt
);
5532 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5537 currently_expanding_gimple_stmt
= NULL
;
5539 /* Expand implicit goto and convert goto_locus. */
5540 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5542 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5543 set_curr_insn_location (e
->goto_locus
);
5544 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5546 emit_jump (label_rtx_for_bb (e
->dest
));
5547 e
->flags
&= ~EDGE_FALLTHRU
;
5551 /* Expanded RTL can create a jump in the last instruction of block.
5552 This later might be assumed to be a jump to successor and break edge insertion.
5553 We need to insert dummy move to prevent this. PR41440. */
5554 if (single_succ_p (bb
)
5555 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5556 && (last
= get_last_insn ())
5559 rtx dummy
= gen_reg_rtx (SImode
);
5560 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5563 do_pending_stack_adjust ();
5565 /* Find the block tail. The last insn in the block is the insn
5566 before a barrier and/or table jump insn. */
5567 last
= get_last_insn ();
5568 if (BARRIER_P (last
))
5569 last
= PREV_INSN (last
);
5570 if (JUMP_TABLE_DATA_P (last
))
5571 last
= PREV_INSN (PREV_INSN (last
));
5574 update_bb_for_insn (bb
);
5580 /* Create a basic block for initialization code. */
5583 construct_init_block (void)
5585 basic_block init_block
, first_block
;
5589 /* Multiple entry points not supported yet. */
5590 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5591 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5592 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5593 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5594 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5596 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5598 /* When entry edge points to first basic block, we don't need jump,
5599 otherwise we have to jump into proper target. */
5600 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5602 tree label
= gimple_block_label (e
->dest
);
5604 emit_jump (label_rtx (label
));
5608 flags
= EDGE_FALLTHRU
;
5610 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5612 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5613 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5614 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5615 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5618 first_block
= e
->dest
;
5619 redirect_edge_succ (e
, init_block
);
5620 e
= make_edge (init_block
, first_block
, flags
);
5623 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5624 e
->probability
= REG_BR_PROB_BASE
;
5625 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5627 update_bb_for_insn (init_block
);
5631 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5632 found in the block tree. */
5635 set_block_levels (tree block
, int level
)
5639 BLOCK_NUMBER (block
) = level
;
5640 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5641 block
= BLOCK_CHAIN (block
);
5645 /* Create a block containing landing pads and similar stuff. */
5648 construct_exit_block (void)
5650 rtx_insn
*head
= get_last_insn ();
5652 basic_block exit_block
;
5656 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5657 rtx_insn
*orig_end
= BB_END (prev_bb
);
5659 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5661 /* Make sure the locus is set to the end of the function, so that
5662 epilogue line numbers and warnings are set properly. */
5663 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5664 input_location
= cfun
->function_end_locus
;
5666 /* Generate rtl for function exit. */
5667 expand_function_end ();
5669 end
= get_last_insn ();
5672 /* While emitting the function end we could move end of the last basic
5674 BB_END (prev_bb
) = orig_end
;
5675 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5676 head
= NEXT_INSN (head
);
5677 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5678 bb frequency counting will be confused. Any instructions before that
5679 label are emitted for the case where PREV_BB falls through into the
5680 exit block, so append those instructions to prev_bb in that case. */
5681 if (NEXT_INSN (head
) != return_label
)
5683 while (NEXT_INSN (head
) != return_label
)
5685 if (!NOTE_P (NEXT_INSN (head
)))
5686 BB_END (prev_bb
) = NEXT_INSN (head
);
5687 head
= NEXT_INSN (head
);
5690 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5691 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5692 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5693 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5696 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5698 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5699 if (!(e
->flags
& EDGE_ABNORMAL
))
5700 redirect_edge_succ (e
, exit_block
);
5705 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5706 e
->probability
= REG_BR_PROB_BASE
;
5707 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5708 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5711 e
->count
-= e2
->count
;
5712 exit_block
->count
-= e2
->count
;
5713 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5717 if (exit_block
->count
< 0)
5718 exit_block
->count
= 0;
5719 if (exit_block
->frequency
< 0)
5720 exit_block
->frequency
= 0;
5721 update_bb_for_insn (exit_block
);
5724 /* Helper function for discover_nonconstant_array_refs.
5725 Look for ARRAY_REF nodes with non-constant indexes and mark them
5729 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5730 void *data ATTRIBUTE_UNUSED
)
5734 if (IS_TYPE_OR_DECL_P (t
))
5736 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5738 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5739 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5740 && (!TREE_OPERAND (t
, 2)
5741 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5742 || (TREE_CODE (t
) == COMPONENT_REF
5743 && (!TREE_OPERAND (t
,2)
5744 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5745 || TREE_CODE (t
) == BIT_FIELD_REF
5746 || TREE_CODE (t
) == REALPART_EXPR
5747 || TREE_CODE (t
) == IMAGPART_EXPR
5748 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5749 || CONVERT_EXPR_P (t
))
5750 t
= TREE_OPERAND (t
, 0);
5752 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5754 t
= get_base_address (t
);
5756 && DECL_MODE (t
) != BLKmode
)
5757 TREE_ADDRESSABLE (t
) = 1;
5766 /* RTL expansion is not able to compile array references with variable
5767 offsets for arrays stored in single register. Discover such
5768 expressions and mark variables as addressable to avoid this
5772 discover_nonconstant_array_refs (void)
5775 gimple_stmt_iterator gsi
;
5777 FOR_EACH_BB_FN (bb
, cfun
)
5778 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5780 gimple stmt
= gsi_stmt (gsi
);
5781 if (!is_gimple_debug (stmt
))
5782 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
5786 /* This function sets crtl->args.internal_arg_pointer to a virtual
5787 register if DRAP is needed. Local register allocator will replace
5788 virtual_incoming_args_rtx with the virtual register. */
5791 expand_stack_alignment (void)
5794 unsigned int preferred_stack_boundary
;
5796 if (! SUPPORTS_STACK_ALIGNMENT
)
5799 if (cfun
->calls_alloca
5800 || cfun
->has_nonlocal_label
5801 || crtl
->has_nonlocal_goto
)
5802 crtl
->need_drap
= true;
5804 /* Call update_stack_boundary here again to update incoming stack
5805 boundary. It may set incoming stack alignment to a different
5806 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
5807 use the minimum incoming stack alignment to check if it is OK
5808 to perform sibcall optimization since sibcall optimization will
5809 only align the outgoing stack to incoming stack boundary. */
5810 if (targetm
.calls
.update_stack_boundary
)
5811 targetm
.calls
.update_stack_boundary ();
5813 /* The incoming stack frame has to be aligned at least at
5814 parm_stack_boundary. */
5815 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
5817 /* Update crtl->stack_alignment_estimated and use it later to align
5818 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
5819 exceptions since callgraph doesn't collect incoming stack alignment
5821 if (cfun
->can_throw_non_call_exceptions
5822 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
5823 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
5825 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
5826 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
5827 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
5828 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
5829 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
5831 gcc_assert (crtl
->stack_alignment_needed
5832 <= crtl
->stack_alignment_estimated
);
5834 crtl
->stack_realign_needed
5835 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
5836 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
5838 crtl
->stack_realign_processed
= true;
5840 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
5842 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
5843 drap_rtx
= targetm
.calls
.get_drap_rtx ();
5845 /* stack_realign_drap and drap_rtx must match. */
5846 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
5848 /* Do nothing if NULL is returned, which means DRAP is not needed. */
5849 if (NULL
!= drap_rtx
)
5851 crtl
->args
.internal_arg_pointer
= drap_rtx
;
5853 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
5855 fixup_tail_calls ();
5861 expand_main_function (void)
5863 #if (defined(INVOKE__main) \
5864 || (!defined(HAS_INIT_SECTION) \
5865 && !defined(INIT_SECTION_ASM_OP) \
5866 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
5867 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
5872 /* Expand code to initialize the stack_protect_guard. This is invoked at
5873 the beginning of a function to be protected. */
5875 #ifndef HAVE_stack_protect_set
5876 # define HAVE_stack_protect_set 0
5877 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
5881 stack_protect_prologue (void)
5883 tree guard_decl
= targetm
.stack_protect_guard ();
5886 x
= expand_normal (crtl
->stack_protect_guard
);
5887 y
= expand_normal (guard_decl
);
5889 /* Allow the target to copy from Y to X without leaking Y into a
5891 if (HAVE_stack_protect_set
)
5893 rtx insn
= gen_stack_protect_set (x
, y
);
5901 /* Otherwise do a straight move. */
5902 emit_move_insn (x
, y
);
5905 /* Translate the intermediate representation contained in the CFG
5906 from GIMPLE trees to RTL.
5908 We do conversion per basic block and preserve/update the tree CFG.
5909 This implies we have to do some magic as the CFG can simultaneously
5910 consist of basic blocks containing RTL and GIMPLE trees. This can
5911 confuse the CFG hooks, so be careful to not manipulate CFG during
5916 const pass_data pass_data_expand
=
5918 RTL_PASS
, /* type */
5919 "expand", /* name */
5920 OPTGROUP_NONE
, /* optinfo_flags */
5921 TV_EXPAND
, /* tv_id */
5922 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
5924 | PROP_gimple_lvec
), /* properties_required */
5925 PROP_rtl
, /* properties_provided */
5926 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
5927 0, /* todo_flags_start */
5928 0, /* todo_flags_finish */
5931 class pass_expand
: public rtl_opt_pass
5934 pass_expand (gcc::context
*ctxt
)
5935 : rtl_opt_pass (pass_data_expand
, ctxt
)
5938 /* opt_pass methods: */
5939 virtual unsigned int execute (function
*);
5941 }; // class pass_expand
5944 pass_expand::execute (function
*fun
)
5946 basic_block bb
, init_block
;
5950 rtx_insn
*var_seq
, *var_ret_seq
;
5953 timevar_push (TV_OUT_OF_SSA
);
5954 rewrite_out_of_ssa (&SA
);
5955 timevar_pop (TV_OUT_OF_SSA
);
5956 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
5958 if (MAY_HAVE_DEBUG_STMTS
&& flag_tree_ter
)
5960 gimple_stmt_iterator gsi
;
5961 FOR_EACH_BB_FN (bb
, cfun
)
5962 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5963 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
5964 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
5967 /* Make sure all values used by the optimization passes have sane
5971 /* Some backends want to know that we are expanding to RTL. */
5972 currently_expanding_to_rtl
= 1;
5973 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
5974 free_dominance_info (CDI_DOMINATORS
);
5976 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
5978 if (chkp_function_instrumented_p (current_function_decl
))
5979 chkp_reset_rtl_bounds ();
5981 insn_locations_init ();
5982 if (!DECL_IS_BUILTIN (current_function_decl
))
5984 /* Eventually, all FEs should explicitly set function_start_locus. */
5985 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
5986 set_curr_insn_location
5987 (DECL_SOURCE_LOCATION (current_function_decl
));
5989 set_curr_insn_location (fun
->function_start_locus
);
5992 set_curr_insn_location (UNKNOWN_LOCATION
);
5993 prologue_location
= curr_insn_location ();
5995 #ifdef INSN_SCHEDULING
5996 init_sched_attrs ();
5999 /* Make sure first insn is a note even if we don't want linenums.
6000 This makes sure the first insn will never be deleted.
6001 Also, final expects a note to appear there. */
6002 emit_note (NOTE_INSN_DELETED
);
6004 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6005 discover_nonconstant_array_refs ();
6007 targetm
.expand_to_rtl_hook ();
6008 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
6009 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
6010 crtl
->stack_alignment_estimated
= 0;
6011 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
6012 fun
->cfg
->max_jumptable_ents
= 0;
6014 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6015 of the function section at exapnsion time to predict distance of calls. */
6016 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6018 /* Expand the variables recorded during gimple lowering. */
6019 timevar_push (TV_VAR_EXPAND
);
6022 var_ret_seq
= expand_used_vars ();
6024 var_seq
= get_insns ();
6026 timevar_pop (TV_VAR_EXPAND
);
6028 /* Honor stack protection warnings. */
6029 if (warn_stack_protect
)
6031 if (fun
->calls_alloca
)
6032 warning (OPT_Wstack_protector
,
6033 "stack protector not protecting local variables: "
6034 "variable length buffer");
6035 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6036 warning (OPT_Wstack_protector
,
6037 "stack protector not protecting function: "
6038 "all local arrays are less than %d bytes long",
6039 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
6042 /* Set up parameters and prepare for return, for the function. */
6043 expand_function_start (current_function_decl
);
6045 /* If we emitted any instructions for setting up the variables,
6046 emit them before the FUNCTION_START note. */
6049 emit_insn_before (var_seq
, parm_birth_insn
);
6051 /* In expand_function_end we'll insert the alloca save/restore
6052 before parm_birth_insn. We've just insertted an alloca call.
6053 Adjust the pointer to match. */
6054 parm_birth_insn
= var_seq
;
6057 /* Now that we also have the parameter RTXs, copy them over to our
6059 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
6061 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
6063 if (TREE_CODE (var
) != VAR_DECL
6064 && !SA
.partition_to_pseudo
[i
])
6065 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
6066 gcc_assert (SA
.partition_to_pseudo
[i
]);
6068 /* If this decl was marked as living in multiple places, reset
6069 this now to NULL. */
6070 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
6071 SET_DECL_RTL (var
, NULL
);
6073 /* Some RTL parts really want to look at DECL_RTL(x) when x
6074 was a decl marked in REG_ATTR or MEM_ATTR. We could use
6075 SET_DECL_RTL here making this available, but that would mean
6076 to select one of the potentially many RTLs for one DECL. Instead
6077 of doing that we simply reset the MEM_EXPR of the RTL in question,
6078 then nobody can get at it and hence nobody can call DECL_RTL on it. */
6079 if (!DECL_RTL_SET_P (var
))
6081 if (MEM_P (SA
.partition_to_pseudo
[i
]))
6082 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
6086 /* If we have a class containing differently aligned pointers
6087 we need to merge those into the corresponding RTL pointer
6089 for (i
= 1; i
< num_ssa_names
; i
++)
6091 tree name
= ssa_name (i
);
6096 /* We might have generated new SSA names in
6097 update_alias_info_with_stack_vars. They will have a NULL
6098 defining statements, and won't be part of the partitioning,
6100 || !SSA_NAME_DEF_STMT (name
))
6102 part
= var_to_partition (SA
.map
, name
);
6103 if (part
== NO_PARTITION
)
6106 /* Adjust all partition members to get the underlying decl of
6107 the representative which we might have created in expand_one_var. */
6108 if (SSA_NAME_VAR (name
) == NULL_TREE
)
6110 tree leader
= partition_to_var (SA
.map
, part
);
6111 gcc_assert (SSA_NAME_VAR (leader
) != NULL_TREE
);
6112 replace_ssa_name_symbol (name
, SSA_NAME_VAR (leader
));
6114 if (!POINTER_TYPE_P (TREE_TYPE (name
)))
6117 r
= SA
.partition_to_pseudo
[part
];
6119 mark_reg_pointer (r
, get_pointer_alignment (name
));
6122 /* If this function is `main', emit a call to `__main'
6123 to run global initializers, etc. */
6124 if (DECL_NAME (current_function_decl
)
6125 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6126 && DECL_FILE_SCOPE_P (current_function_decl
))
6127 expand_main_function ();
6129 /* Initialize the stack_protect_guard field. This must happen after the
6130 call to __main (if any) so that the external decl is initialized. */
6131 if (crtl
->stack_protect_guard
)
6132 stack_protect_prologue ();
6134 expand_phi_nodes (&SA
);
6136 /* Register rtl specific functions for cfg. */
6137 rtl_register_cfg_hooks ();
6139 init_block
= construct_init_block ();
6141 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6142 remaining edges later. */
6143 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6144 e
->flags
&= ~EDGE_EXECUTABLE
;
6146 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6147 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6149 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6151 if (MAY_HAVE_DEBUG_INSNS
)
6152 expand_debug_locations ();
6154 if (deep_ter_debug_map
)
6156 delete deep_ter_debug_map
;
6157 deep_ter_debug_map
= NULL
;
6160 /* Free stuff we no longer need after GIMPLE optimizations. */
6161 free_dominance_info (CDI_DOMINATORS
);
6162 free_dominance_info (CDI_POST_DOMINATORS
);
6163 delete_tree_cfg_annotations ();
6165 timevar_push (TV_OUT_OF_SSA
);
6166 finish_out_of_ssa (&SA
);
6167 timevar_pop (TV_OUT_OF_SSA
);
6169 timevar_push (TV_POST_EXPAND
);
6170 /* We are no longer in SSA form. */
6171 fun
->gimple_df
->in_ssa_p
= false;
6172 loops_state_clear (LOOP_CLOSED_SSA
);
6174 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6175 conservatively to true until they are all profile aware. */
6176 delete lab_rtx_for_bb
;
6179 construct_exit_block ();
6180 insn_locations_finalize ();
6184 rtx_insn
*after
= return_label
;
6185 rtx_insn
*next
= NEXT_INSN (after
);
6186 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6188 emit_insn_after (var_ret_seq
, after
);
6191 /* Zap the tree EH table. */
6192 set_eh_throw_stmt_table (fun
, NULL
);
6194 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6195 split edges which edge insertions might do. */
6196 rebuild_jump_labels (get_insns ());
6198 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
6199 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6203 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6207 rebuild_jump_labels_chain (e
->insns
.r
);
6208 /* Put insns after parm birth, but before
6209 NOTE_INSNS_FUNCTION_BEG. */
6210 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
6211 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6213 rtx_insn
*insns
= e
->insns
.r
;
6215 if (NOTE_P (parm_birth_insn
)
6216 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6217 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6219 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6222 commit_one_edge_insertion (e
);
6229 /* We're done expanding trees to RTL. */
6230 currently_expanding_to_rtl
= 0;
6232 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6233 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6237 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6239 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6240 e
->flags
&= ~EDGE_EXECUTABLE
;
6242 /* At the moment not all abnormal edges match the RTL
6243 representation. It is safe to remove them here as
6244 find_many_sub_basic_blocks will rediscover them.
6245 In the future we should get this fixed properly. */
6246 if ((e
->flags
& EDGE_ABNORMAL
)
6247 && !(e
->flags
& EDGE_SIBCALL
))
6254 blocks
= sbitmap_alloc (last_basic_block_for_fn (fun
));
6255 bitmap_ones (blocks
);
6256 find_many_sub_basic_blocks (blocks
);
6257 sbitmap_free (blocks
);
6258 purge_all_dead_edges ();
6260 expand_stack_alignment ();
6262 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6264 if (crtl
->tail_call_emit
)
6265 fixup_tail_calls ();
6267 /* After initial rtl generation, call back to finish generating
6268 exception support code. We need to do this before cleaning up
6269 the CFG as the code does not expect dead landing pads. */
6270 if (fun
->eh
->region_tree
!= NULL
)
6271 finish_eh_generation ();
6273 /* Remove unreachable blocks, otherwise we cannot compute dominators
6274 which are needed for loop state verification. As a side-effect
6275 this also compacts blocks.
6276 ??? We cannot remove trivially dead insns here as for example
6277 the DRAP reg on i?86 is not magically live at this point.
6278 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6279 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6281 #ifdef ENABLE_CHECKING
6282 verify_flow_info ();
6285 /* Initialize pseudos allocated for hard registers. */
6286 emit_initial_value_sets ();
6288 /* And finally unshare all RTL. */
6291 /* There's no need to defer outputting this function any more; we
6292 know we want to output it. */
6293 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6295 /* Now that we're done expanding trees to RTL, we shouldn't have any
6296 more CONCATs anywhere. */
6297 generating_concat_p
= 0;
6302 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6303 /* And the pass manager will dump RTL for us. */
6306 /* If we're emitting a nested function, make sure its parent gets
6307 emitted as well. Doing otherwise confuses debug info. */
6310 for (parent
= DECL_CONTEXT (current_function_decl
);
6311 parent
!= NULL_TREE
;
6312 parent
= get_containing_scope (parent
))
6313 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6314 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6317 /* We are now committed to emitting code for this function. Do any
6318 preparation, such as emitting abstract debug info for the inline
6319 before it gets mangled by optimization. */
6320 if (cgraph_function_possibly_inlined_p (current_function_decl
))
6321 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
6323 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6325 /* After expanding, the return labels are no longer needed. */
6326 return_label
= NULL
;
6327 naked_return_label
= NULL
;
6329 /* After expanding, the tm_restart map is no longer needed. */
6330 if (fun
->gimple_df
->tm_restart
)
6331 fun
->gimple_df
->tm_restart
= NULL
;
6333 /* Tag the blocks with a depth number so that change_scope can find
6334 the common parent easily. */
6335 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6336 default_rtl_profile ();
6338 timevar_pop (TV_POST_EXPAND
);
6346 make_pass_expand (gcc::context
*ctxt
)
6348 return new pass_expand (ctxt
);