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 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
286 Return the frame offset. */
289 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
291 HOST_WIDE_INT offset
, new_frame_offset
;
293 new_frame_offset
= frame_offset
;
294 if (FRAME_GROWS_DOWNWARD
)
296 new_frame_offset
-= size
+ frame_phase
;
297 new_frame_offset
&= -align
;
298 new_frame_offset
+= frame_phase
;
299 offset
= new_frame_offset
;
303 new_frame_offset
-= frame_phase
;
304 new_frame_offset
+= align
- 1;
305 new_frame_offset
&= -align
;
306 new_frame_offset
+= frame_phase
;
307 offset
= new_frame_offset
;
308 new_frame_offset
+= size
;
310 frame_offset
= new_frame_offset
;
312 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
313 frame_offset
= offset
= 0;
318 /* Accumulate DECL into STACK_VARS. */
321 add_stack_var (tree decl
)
325 if (stack_vars_num
>= stack_vars_alloc
)
327 if (stack_vars_alloc
)
328 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
330 stack_vars_alloc
= 32;
332 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
334 if (!decl_to_stack_part
)
335 decl_to_stack_part
= new hash_map
<tree
, size_t>;
337 v
= &stack_vars
[stack_vars_num
];
338 decl_to_stack_part
->put (decl
, stack_vars_num
);
341 v
->size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (decl
)));
342 /* Ensure that all variables have size, so that &a != &b for any two
343 variables that are simultaneously live. */
346 v
->alignb
= align_local_variable (SSAVAR (decl
));
347 /* An alignment of zero can mightily confuse us later. */
348 gcc_assert (v
->alignb
!= 0);
350 /* All variables are initially in their own partition. */
351 v
->representative
= stack_vars_num
;
354 /* All variables initially conflict with no other. */
357 /* Ensure that this decl doesn't get put onto the list twice. */
358 set_rtl (decl
, pc_rtx
);
363 /* Make the decls associated with luid's X and Y conflict. */
366 add_stack_var_conflict (size_t x
, size_t y
)
368 struct stack_var
*a
= &stack_vars
[x
];
369 struct stack_var
*b
= &stack_vars
[y
];
371 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
373 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
374 bitmap_set_bit (a
->conflicts
, y
);
375 bitmap_set_bit (b
->conflicts
, x
);
378 /* Check whether the decls associated with luid's X and Y conflict. */
381 stack_var_conflict_p (size_t x
, size_t y
)
383 struct stack_var
*a
= &stack_vars
[x
];
384 struct stack_var
*b
= &stack_vars
[y
];
387 /* Partitions containing an SSA name result from gimple registers
388 with things like unsupported modes. They are top-level and
389 hence conflict with everything else. */
390 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
393 if (!a
->conflicts
|| !b
->conflicts
)
395 return bitmap_bit_p (a
->conflicts
, y
);
398 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
399 enter its partition number into bitmap DATA. */
402 visit_op (gimple
, tree op
, tree
, void *data
)
404 bitmap active
= (bitmap
)data
;
405 op
= get_base_address (op
);
408 && DECL_RTL_IF_SET (op
) == pc_rtx
)
410 size_t *v
= decl_to_stack_part
->get (op
);
412 bitmap_set_bit (active
, *v
);
417 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
418 record conflicts between it and all currently active other partitions
422 visit_conflict (gimple
, tree op
, tree
, void *data
)
424 bitmap active
= (bitmap
)data
;
425 op
= get_base_address (op
);
428 && DECL_RTL_IF_SET (op
) == pc_rtx
)
430 size_t *v
= decl_to_stack_part
->get (op
);
431 if (v
&& bitmap_set_bit (active
, *v
))
436 gcc_assert (num
< stack_vars_num
);
437 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
438 add_stack_var_conflict (num
, i
);
444 /* Helper routine for add_scope_conflicts, calculating the active partitions
445 at the end of BB, leaving the result in WORK. We're called to generate
446 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
450 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
454 gimple_stmt_iterator gsi
;
455 walk_stmt_load_store_addr_fn visit
;
458 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
459 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
463 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
465 gimple stmt
= gsi_stmt (gsi
);
466 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
468 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
470 gimple stmt
= gsi_stmt (gsi
);
472 if (gimple_clobber_p (stmt
))
474 tree lhs
= gimple_assign_lhs (stmt
);
476 /* Nested function lowering might introduce LHSs
477 that are COMPONENT_REFs. */
478 if (TREE_CODE (lhs
) != VAR_DECL
)
480 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
481 && (v
= decl_to_stack_part
->get (lhs
)))
482 bitmap_clear_bit (work
, *v
);
484 else if (!is_gimple_debug (stmt
))
487 && visit
== visit_op
)
489 /* If this is the first real instruction in this BB we need
490 to add conflicts for everything live at this point now.
491 Unlike classical liveness for named objects we can't
492 rely on seeing a def/use of the names we're interested in.
493 There might merely be indirect loads/stores. We'd not add any
494 conflicts for such partitions. */
497 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
499 struct stack_var
*a
= &stack_vars
[i
];
501 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
502 bitmap_ior_into (a
->conflicts
, work
);
504 visit
= visit_conflict
;
506 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
511 /* Generate stack partition conflicts between all partitions that are
512 simultaneously live. */
515 add_scope_conflicts (void)
519 bitmap work
= BITMAP_ALLOC (NULL
);
523 /* We approximate the live range of a stack variable by taking the first
524 mention of its name as starting point(s), and by the end-of-scope
525 death clobber added by gimplify as ending point(s) of the range.
526 This overapproximates in the case we for instance moved an address-taken
527 operation upward, without also moving a dereference to it upwards.
528 But it's conservatively correct as a variable never can hold values
529 before its name is mentioned at least once.
531 We then do a mostly classical bitmap liveness algorithm. */
533 FOR_ALL_BB_FN (bb
, cfun
)
534 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
536 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
537 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
544 for (i
= 0; i
< n_bbs
; i
++)
547 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
548 active
= (bitmap
)bb
->aux
;
549 add_scope_conflicts_1 (bb
, work
, false);
550 if (bitmap_ior_into (active
, work
))
555 FOR_EACH_BB_FN (bb
, cfun
)
556 add_scope_conflicts_1 (bb
, work
, true);
560 FOR_ALL_BB_FN (bb
, cfun
)
561 BITMAP_FREE (bb
->aux
);
564 /* A subroutine of partition_stack_vars. A comparison function for qsort,
565 sorting an array of indices by the properties of the object. */
568 stack_var_cmp (const void *a
, const void *b
)
570 size_t ia
= *(const size_t *)a
;
571 size_t ib
= *(const size_t *)b
;
572 unsigned int aligna
= stack_vars
[ia
].alignb
;
573 unsigned int alignb
= stack_vars
[ib
].alignb
;
574 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
575 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
576 tree decla
= stack_vars
[ia
].decl
;
577 tree declb
= stack_vars
[ib
].decl
;
579 unsigned int uida
, uidb
;
581 /* Primary compare on "large" alignment. Large comes first. */
582 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
583 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
584 if (largea
!= largeb
)
585 return (int)largeb
- (int)largea
;
587 /* Secondary compare on size, decreasing */
593 /* Tertiary compare on true alignment, decreasing. */
599 /* Final compare on ID for sort stability, increasing.
600 Two SSA names are compared by their version, SSA names come before
601 non-SSA names, and two normal decls are compared by their DECL_UID. */
602 if (TREE_CODE (decla
) == SSA_NAME
)
604 if (TREE_CODE (declb
) == SSA_NAME
)
605 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
609 else if (TREE_CODE (declb
) == SSA_NAME
)
612 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
620 struct part_traits
: default_hashmap_traits
625 { return e
.m_value
== reinterpret_cast<void *> (1); }
627 template<typename T
> static bool is_empty (T
&e
) { return e
.m_value
== NULL
; }
631 { e
.m_value
= reinterpret_cast<T
> (1); }
636 { e
.m_value
= NULL
; }
639 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
641 /* If the points-to solution *PI points to variables that are in a partition
642 together with other variables add all partition members to the pointed-to
646 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
647 part_hashmap
*decls_to_partitions
,
648 hash_set
<bitmap
> *visited
, bitmap temp
)
656 /* The pointed-to vars bitmap is shared, it is enough to
658 || visited
->add (pt
->vars
))
663 /* By using a temporary bitmap to store all members of the partitions
664 we have to add we make sure to visit each of the partitions only
666 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
668 || !bitmap_bit_p (temp
, i
))
669 && (part
= decls_to_partitions
->get (i
)))
670 bitmap_ior_into (temp
, *part
);
671 if (!bitmap_empty_p (temp
))
672 bitmap_ior_into (pt
->vars
, temp
);
675 /* Update points-to sets based on partition info, so we can use them on RTL.
676 The bitmaps representing stack partitions will be saved until expand,
677 where partitioned decls used as bases in memory expressions will be
681 update_alias_info_with_stack_vars (void)
683 part_hashmap
*decls_to_partitions
= NULL
;
685 tree var
= NULL_TREE
;
687 for (i
= 0; i
< stack_vars_num
; i
++)
691 struct ptr_info_def
*pi
;
693 /* Not interested in partitions with single variable. */
694 if (stack_vars
[i
].representative
!= i
695 || stack_vars
[i
].next
== EOC
)
698 if (!decls_to_partitions
)
700 decls_to_partitions
= new part_hashmap
;
701 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
704 /* Create an SSA_NAME that points to the partition for use
705 as base during alias-oracle queries on RTL for bases that
706 have been partitioned. */
707 if (var
== NULL_TREE
)
708 var
= create_tmp_var (ptr_type_node
);
709 name
= make_ssa_name (var
);
711 /* Create bitmaps representing partitions. They will be used for
712 points-to sets later, so use GGC alloc. */
713 part
= BITMAP_GGC_ALLOC ();
714 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
716 tree decl
= stack_vars
[j
].decl
;
717 unsigned int uid
= DECL_PT_UID (decl
);
718 bitmap_set_bit (part
, uid
);
719 decls_to_partitions
->put (uid
, part
);
720 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
721 if (TREE_ADDRESSABLE (decl
))
722 TREE_ADDRESSABLE (name
) = 1;
725 /* Make the SSA name point to all partition members. */
726 pi
= get_ptr_info (name
);
727 pt_solution_set (&pi
->pt
, part
, false);
730 /* Make all points-to sets that contain one member of a partition
731 contain all members of the partition. */
732 if (decls_to_partitions
)
735 hash_set
<bitmap
> visited
;
736 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
738 for (i
= 1; i
< num_ssa_names
; i
++)
740 tree name
= ssa_name (i
);
741 struct ptr_info_def
*pi
;
744 && POINTER_TYPE_P (TREE_TYPE (name
))
745 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
746 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
750 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
751 decls_to_partitions
, &visited
, temp
);
753 delete decls_to_partitions
;
758 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
759 partitioning algorithm. Partitions A and B are known to be non-conflicting.
760 Merge them into a single partition A. */
763 union_stack_vars (size_t a
, size_t b
)
765 struct stack_var
*vb
= &stack_vars
[b
];
769 gcc_assert (stack_vars
[b
].next
== EOC
);
770 /* Add B to A's partition. */
771 stack_vars
[b
].next
= stack_vars
[a
].next
;
772 stack_vars
[b
].representative
= a
;
773 stack_vars
[a
].next
= b
;
775 /* Update the required alignment of partition A to account for B. */
776 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
777 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
779 /* Update the interference graph and merge the conflicts. */
782 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
783 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
784 BITMAP_FREE (vb
->conflicts
);
788 /* A subroutine of expand_used_vars. Binpack the variables into
789 partitions constrained by the interference graph. The overall
790 algorithm used is as follows:
792 Sort the objects by size in descending order.
797 Look for the largest non-conflicting object B with size <= S.
804 partition_stack_vars (void)
806 size_t si
, sj
, n
= stack_vars_num
;
808 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
809 for (si
= 0; si
< n
; ++si
)
810 stack_vars_sorted
[si
] = si
;
815 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
817 for (si
= 0; si
< n
; ++si
)
819 size_t i
= stack_vars_sorted
[si
];
820 unsigned int ialign
= stack_vars
[i
].alignb
;
821 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
823 /* Ignore objects that aren't partition representatives. If we
824 see a var that is not a partition representative, it must
825 have been merged earlier. */
826 if (stack_vars
[i
].representative
!= i
)
829 for (sj
= si
+ 1; sj
< n
; ++sj
)
831 size_t j
= stack_vars_sorted
[sj
];
832 unsigned int jalign
= stack_vars
[j
].alignb
;
833 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
835 /* Ignore objects that aren't partition representatives. */
836 if (stack_vars
[j
].representative
!= j
)
839 /* Do not mix objects of "small" (supported) alignment
840 and "large" (unsupported) alignment. */
841 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
842 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
845 /* For Address Sanitizer do not mix objects with different
846 sizes, as the shorter vars wouldn't be adequately protected.
847 Don't do that for "large" (unsupported) alignment objects,
848 those aren't protected anyway. */
849 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
&& isize
!= jsize
850 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
853 /* Ignore conflicting objects. */
854 if (stack_var_conflict_p (i
, j
))
857 /* UNION the objects, placing J at OFFSET. */
858 union_stack_vars (i
, j
);
862 update_alias_info_with_stack_vars ();
865 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
868 dump_stack_var_partition (void)
870 size_t si
, i
, j
, n
= stack_vars_num
;
872 for (si
= 0; si
< n
; ++si
)
874 i
= stack_vars_sorted
[si
];
876 /* Skip variables that aren't partition representatives, for now. */
877 if (stack_vars
[i
].representative
!= i
)
880 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
881 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
882 stack_vars
[i
].alignb
);
884 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
886 fputc ('\t', dump_file
);
887 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
889 fputc ('\n', dump_file
);
893 /* Assign rtl to DECL at BASE + OFFSET. */
896 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
897 HOST_WIDE_INT offset
)
902 /* If this fails, we've overflowed the stack frame. Error nicely? */
903 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
905 x
= plus_constant (Pmode
, base
, offset
);
906 x
= gen_rtx_MEM (DECL_MODE (SSAVAR (decl
)), x
);
908 if (TREE_CODE (decl
) != SSA_NAME
)
910 /* Set alignment we actually gave this decl if it isn't an SSA name.
911 If it is we generate stack slots only accidentally so it isn't as
912 important, we'll simply use the alignment that is already set. */
913 if (base
== virtual_stack_vars_rtx
)
914 offset
-= frame_phase
;
915 align
= offset
& -offset
;
916 align
*= BITS_PER_UNIT
;
917 if (align
== 0 || align
> base_align
)
920 /* One would think that we could assert that we're not decreasing
921 alignment here, but (at least) the i386 port does exactly this
922 via the MINIMUM_ALIGNMENT hook. */
924 DECL_ALIGN (decl
) = align
;
925 DECL_USER_ALIGN (decl
) = 0;
928 set_mem_attributes (x
, SSAVAR (decl
), true);
932 struct stack_vars_data
934 /* Vector of offset pairs, always end of some padding followed
935 by start of the padding that needs Address Sanitizer protection.
936 The vector is in reversed, highest offset pairs come first. */
937 vec
<HOST_WIDE_INT
> asan_vec
;
939 /* Vector of partition representative decls in between the paddings. */
940 vec
<tree
> asan_decl_vec
;
942 /* Base pseudo register for Address Sanitizer protected automatic vars. */
945 /* Alignment needed for the Address Sanitizer protected automatic vars. */
946 unsigned int asan_alignb
;
949 /* A subroutine of expand_used_vars. Give each partition representative
950 a unique location within the stack frame. Update each partition member
951 with that location. */
954 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
956 size_t si
, i
, j
, n
= stack_vars_num
;
957 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
958 rtx large_base
= NULL
;
959 unsigned large_align
= 0;
962 /* Determine if there are any variables requiring "large" alignment.
963 Since these are dynamically allocated, we only process these if
964 no predicate involved. */
965 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
966 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
968 /* Find the total size of these variables. */
969 for (si
= 0; si
< n
; ++si
)
973 i
= stack_vars_sorted
[si
];
974 alignb
= stack_vars
[i
].alignb
;
976 /* Stop when we get to the first decl with "small" alignment. */
977 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
980 /* Skip variables that aren't partition representatives. */
981 if (stack_vars
[i
].representative
!= i
)
984 /* Skip variables that have already had rtl assigned. See also
985 add_stack_var where we perpetrate this pc_rtx hack. */
986 decl
= stack_vars
[i
].decl
;
987 if ((TREE_CODE (decl
) == SSA_NAME
988 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
989 : DECL_RTL (decl
)) != pc_rtx
)
992 large_size
+= alignb
- 1;
993 large_size
&= -(HOST_WIDE_INT
)alignb
;
994 large_size
+= stack_vars
[i
].size
;
997 /* If there were any, allocate space. */
999 large_base
= allocate_dynamic_stack_space (GEN_INT (large_size
), 0,
1003 for (si
= 0; si
< n
; ++si
)
1006 unsigned base_align
, alignb
;
1007 HOST_WIDE_INT offset
;
1009 i
= stack_vars_sorted
[si
];
1011 /* Skip variables that aren't partition representatives, for now. */
1012 if (stack_vars
[i
].representative
!= i
)
1015 /* Skip variables that have already had rtl assigned. See also
1016 add_stack_var where we perpetrate this pc_rtx hack. */
1017 decl
= stack_vars
[i
].decl
;
1018 if ((TREE_CODE (decl
) == SSA_NAME
1019 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
1020 : DECL_RTL (decl
)) != pc_rtx
)
1023 /* Check the predicate to see whether this variable should be
1024 allocated in this pass. */
1025 if (pred
&& !pred (i
))
1028 alignb
= stack_vars
[i
].alignb
;
1029 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1031 base
= virtual_stack_vars_rtx
;
1032 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
&& pred
)
1034 HOST_WIDE_INT prev_offset
= frame_offset
;
1035 tree repr_decl
= NULL_TREE
;
1038 = alloc_stack_frame_space (stack_vars
[i
].size
1039 + ASAN_RED_ZONE_SIZE
,
1040 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
1041 data
->asan_vec
.safe_push (prev_offset
);
1042 data
->asan_vec
.safe_push (offset
+ stack_vars
[i
].size
);
1043 /* Find best representative of the partition.
1044 Prefer those with DECL_NAME, even better
1045 satisfying asan_protect_stack_decl predicate. */
1046 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1047 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1048 && DECL_NAME (stack_vars
[j
].decl
))
1050 repr_decl
= stack_vars
[j
].decl
;
1053 else if (repr_decl
== NULL_TREE
1054 && DECL_P (stack_vars
[j
].decl
)
1055 && DECL_NAME (stack_vars
[j
].decl
))
1056 repr_decl
= stack_vars
[j
].decl
;
1057 if (repr_decl
== NULL_TREE
)
1058 repr_decl
= stack_vars
[i
].decl
;
1059 data
->asan_decl_vec
.safe_push (repr_decl
);
1060 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1061 if (data
->asan_base
== NULL
)
1062 data
->asan_base
= gen_reg_rtx (Pmode
);
1063 base
= data
->asan_base
;
1065 if (!STRICT_ALIGNMENT
)
1066 base_align
= crtl
->max_used_stack_slot_alignment
;
1068 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1069 GET_MODE_ALIGNMENT (SImode
)
1070 << ASAN_SHADOW_SHIFT
);
1074 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1075 base_align
= crtl
->max_used_stack_slot_alignment
;
1080 /* Large alignment is only processed in the last pass. */
1083 gcc_assert (large_base
!= NULL
);
1085 large_alloc
+= alignb
- 1;
1086 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
1087 offset
= large_alloc
;
1088 large_alloc
+= stack_vars
[i
].size
;
1091 base_align
= large_align
;
1094 /* Create rtl for each variable based on their location within the
1096 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1098 expand_one_stack_var_at (stack_vars
[j
].decl
,
1104 gcc_assert (large_alloc
== large_size
);
1107 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1108 static HOST_WIDE_INT
1109 account_stack_vars (void)
1111 size_t si
, j
, i
, n
= stack_vars_num
;
1112 HOST_WIDE_INT size
= 0;
1114 for (si
= 0; si
< n
; ++si
)
1116 i
= stack_vars_sorted
[si
];
1118 /* Skip variables that aren't partition representatives, for now. */
1119 if (stack_vars
[i
].representative
!= i
)
1122 size
+= stack_vars
[i
].size
;
1123 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1124 set_rtl (stack_vars
[j
].decl
, NULL
);
1129 /* A subroutine of expand_one_var. Called to immediately assign rtl
1130 to a variable to be allocated in the stack frame. */
1133 expand_one_stack_var (tree var
)
1135 HOST_WIDE_INT size
, offset
;
1136 unsigned byte_align
;
1138 size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (var
)));
1139 byte_align
= align_local_variable (SSAVAR (var
));
1141 /* We handle highly aligned variables in expand_stack_vars. */
1142 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1144 offset
= alloc_stack_frame_space (size
, byte_align
);
1146 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1147 crtl
->max_used_stack_slot_alignment
, offset
);
1150 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1151 that will reside in a hard register. */
1154 expand_one_hard_reg_var (tree var
)
1156 rest_of_decl_compilation (var
, 0, 0);
1159 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1160 that will reside in a pseudo register. */
1163 expand_one_register_var (tree var
)
1165 tree decl
= SSAVAR (var
);
1166 tree type
= TREE_TYPE (decl
);
1167 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1168 rtx x
= gen_reg_rtx (reg_mode
);
1172 /* Note if the object is a user variable. */
1173 if (!DECL_ARTIFICIAL (decl
))
1176 if (POINTER_TYPE_P (type
))
1177 mark_reg_pointer (x
, get_pointer_alignment (var
));
1180 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1181 has some associated error, e.g. its type is error-mark. We just need
1182 to pick something that won't crash the rest of the compiler. */
1185 expand_one_error_var (tree var
)
1187 machine_mode mode
= DECL_MODE (var
);
1190 if (mode
== BLKmode
)
1191 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1192 else if (mode
== VOIDmode
)
1195 x
= gen_reg_rtx (mode
);
1197 SET_DECL_RTL (var
, x
);
1200 /* A subroutine of expand_one_var. VAR is a variable that will be
1201 allocated to the local stack frame. Return true if we wish to
1202 add VAR to STACK_VARS so that it will be coalesced with other
1203 variables. Return false to allocate VAR immediately.
1205 This function is used to reduce the number of variables considered
1206 for coalescing, which reduces the size of the quadratic problem. */
1209 defer_stack_allocation (tree var
, bool toplevel
)
1211 /* Whether the variable is small enough for immediate allocation not to be
1212 a problem with regard to the frame size. */
1214 = ((HOST_WIDE_INT
) tree_to_uhwi (DECL_SIZE_UNIT (var
))
1215 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
));
1217 /* If stack protection is enabled, *all* stack variables must be deferred,
1218 so that we can re-order the strings to the top of the frame.
1219 Similarly for Address Sanitizer. */
1220 if (flag_stack_protect
|| ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
))
1223 /* We handle "large" alignment via dynamic allocation. We want to handle
1224 this extra complication in only one place, so defer them. */
1225 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
1228 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1229 might be detached from their block and appear at toplevel when we reach
1230 here. We want to coalesce them with variables from other blocks when
1231 the immediate contribution to the frame size would be noticeable. */
1232 if (toplevel
&& optimize
> 0 && DECL_IGNORED_P (var
) && !smallish
)
1235 /* Variables declared in the outermost scope automatically conflict
1236 with every other variable. The only reason to want to defer them
1237 at all is that, after sorting, we can more efficiently pack
1238 small variables in the stack frame. Continue to defer at -O2. */
1239 if (toplevel
&& optimize
< 2)
1242 /* Without optimization, *most* variables are allocated from the
1243 stack, which makes the quadratic problem large exactly when we
1244 want compilation to proceed as quickly as possible. On the
1245 other hand, we don't want the function's stack frame size to
1246 get completely out of hand. So we avoid adding scalars and
1247 "small" aggregates to the list at all. */
1248 if (optimize
== 0 && smallish
)
1254 /* A subroutine of expand_used_vars. Expand one variable according to
1255 its flavor. Variables to be placed on the stack are not actually
1256 expanded yet, merely recorded.
1257 When REALLY_EXPAND is false, only add stack values to be allocated.
1258 Return stack usage this variable is supposed to take.
1261 static HOST_WIDE_INT
1262 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1264 unsigned int align
= BITS_PER_UNIT
;
1269 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1271 /* Because we don't know if VAR will be in register or on stack,
1272 we conservatively assume it will be on stack even if VAR is
1273 eventually put into register after RA pass. For non-automatic
1274 variables, which won't be on stack, we collect alignment of
1275 type and ignore user specified alignment. Similarly for
1276 SSA_NAMEs for which use_register_for_decl returns true. */
1277 if (TREE_STATIC (var
)
1278 || DECL_EXTERNAL (var
)
1279 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1280 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1281 TYPE_MODE (TREE_TYPE (var
)),
1282 TYPE_ALIGN (TREE_TYPE (var
)));
1283 else if (DECL_HAS_VALUE_EXPR_P (var
)
1284 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1285 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1286 or variables which were assigned a stack slot already by
1287 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1288 changed from the offset chosen to it. */
1289 align
= crtl
->stack_alignment_estimated
;
1291 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1293 /* If the variable alignment is very large we'll dynamicaly allocate
1294 it, which means that in-frame portion is just a pointer. */
1295 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1296 align
= POINTER_SIZE
;
1299 if (SUPPORTS_STACK_ALIGNMENT
1300 && crtl
->stack_alignment_estimated
< align
)
1302 /* stack_alignment_estimated shouldn't change after stack
1303 realign decision made */
1304 gcc_assert (!crtl
->stack_realign_processed
);
1305 crtl
->stack_alignment_estimated
= align
;
1308 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1309 So here we only make sure stack_alignment_needed >= align. */
1310 if (crtl
->stack_alignment_needed
< align
)
1311 crtl
->stack_alignment_needed
= align
;
1312 if (crtl
->max_used_stack_slot_alignment
< align
)
1313 crtl
->max_used_stack_slot_alignment
= align
;
1315 if (TREE_CODE (origvar
) == SSA_NAME
)
1317 gcc_assert (TREE_CODE (var
) != VAR_DECL
1318 || (!DECL_EXTERNAL (var
)
1319 && !DECL_HAS_VALUE_EXPR_P (var
)
1320 && !TREE_STATIC (var
)
1321 && TREE_TYPE (var
) != error_mark_node
1322 && !DECL_HARD_REGISTER (var
)
1325 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1327 else if (DECL_EXTERNAL (var
))
1329 else if (DECL_HAS_VALUE_EXPR_P (var
))
1331 else if (TREE_STATIC (var
))
1333 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1335 else if (TREE_TYPE (var
) == error_mark_node
)
1338 expand_one_error_var (var
);
1340 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1344 expand_one_hard_reg_var (var
);
1345 if (!DECL_HARD_REGISTER (var
))
1346 /* Invalid register specification. */
1347 expand_one_error_var (var
);
1350 else if (use_register_for_decl (var
))
1353 expand_one_register_var (origvar
);
1355 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1357 /* Reject variables which cover more than half of the address-space. */
1360 error ("size of variable %q+D is too large", var
);
1361 expand_one_error_var (var
);
1364 else if (defer_stack_allocation (var
, toplevel
))
1365 add_stack_var (origvar
);
1369 expand_one_stack_var (origvar
);
1370 return tree_to_uhwi (DECL_SIZE_UNIT (var
));
1375 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1376 expanding variables. Those variables that can be put into registers
1377 are allocated pseudos; those that can't are put on the stack.
1379 TOPLEVEL is true if this is the outermost BLOCK. */
1382 expand_used_vars_for_block (tree block
, bool toplevel
)
1386 /* Expand all variables at this level. */
1387 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1389 && ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1390 || !DECL_NONSHAREABLE (t
)))
1391 expand_one_var (t
, toplevel
, true);
1393 /* Expand all variables at containing levels. */
1394 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1395 expand_used_vars_for_block (t
, false);
1398 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1399 and clear TREE_USED on all local variables. */
1402 clear_tree_used (tree block
)
1406 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1407 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1408 if ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1409 || !DECL_NONSHAREABLE (t
))
1412 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1413 clear_tree_used (t
);
1417 SPCT_FLAG_DEFAULT
= 1,
1419 SPCT_FLAG_STRONG
= 3,
1420 SPCT_FLAG_EXPLICIT
= 4
1423 /* Examine TYPE and determine a bit mask of the following features. */
1425 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1426 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1427 #define SPCT_HAS_ARRAY 4
1428 #define SPCT_HAS_AGGREGATE 8
1431 stack_protect_classify_type (tree type
)
1433 unsigned int ret
= 0;
1436 switch (TREE_CODE (type
))
1439 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1440 if (t
== char_type_node
1441 || t
== signed_char_type_node
1442 || t
== unsigned_char_type_node
)
1444 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1445 unsigned HOST_WIDE_INT len
;
1447 if (!TYPE_SIZE_UNIT (type
)
1448 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1451 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1454 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1456 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1459 ret
= SPCT_HAS_ARRAY
;
1463 case QUAL_UNION_TYPE
:
1465 ret
= SPCT_HAS_AGGREGATE
;
1466 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1467 if (TREE_CODE (t
) == FIELD_DECL
)
1468 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1478 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1479 part of the local stack frame. Remember if we ever return nonzero for
1480 any variable in this function. The return value is the phase number in
1481 which the variable should be allocated. */
1484 stack_protect_decl_phase (tree decl
)
1486 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1489 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1490 has_short_buffer
= true;
1492 if (flag_stack_protect
== SPCT_FLAG_ALL
1493 || flag_stack_protect
== SPCT_FLAG_STRONG
1494 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1495 && lookup_attribute ("stack_protect",
1496 DECL_ATTRIBUTES (current_function_decl
))))
1498 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1499 && !(bits
& SPCT_HAS_AGGREGATE
))
1501 else if (bits
& SPCT_HAS_ARRAY
)
1505 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1508 has_protected_decls
= true;
1513 /* Two helper routines that check for phase 1 and phase 2. These are used
1514 as callbacks for expand_stack_vars. */
1517 stack_protect_decl_phase_1 (size_t i
)
1519 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1523 stack_protect_decl_phase_2 (size_t i
)
1525 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1528 /* And helper function that checks for asan phase (with stack protector
1529 it is phase 3). This is used as callback for expand_stack_vars.
1530 Returns true if any of the vars in the partition need to be protected. */
1533 asan_decl_phase_3 (size_t i
)
1537 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1539 i
= stack_vars
[i
].next
;
1544 /* Ensure that variables in different stack protection phases conflict
1545 so that they are not merged and share the same stack slot. */
1548 add_stack_protection_conflicts (void)
1550 size_t i
, j
, n
= stack_vars_num
;
1551 unsigned char *phase
;
1553 phase
= XNEWVEC (unsigned char, n
);
1554 for (i
= 0; i
< n
; ++i
)
1555 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1557 for (i
= 0; i
< n
; ++i
)
1559 unsigned char ph_i
= phase
[i
];
1560 for (j
= i
+ 1; j
< n
; ++j
)
1561 if (ph_i
!= phase
[j
])
1562 add_stack_var_conflict (i
, j
);
1568 /* Create a decl for the guard at the top of the stack frame. */
1571 create_stack_guard (void)
1573 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1574 VAR_DECL
, NULL
, ptr_type_node
);
1575 TREE_THIS_VOLATILE (guard
) = 1;
1576 TREE_USED (guard
) = 1;
1577 expand_one_stack_var (guard
);
1578 crtl
->stack_protect_guard
= guard
;
1581 /* Prepare for expanding variables. */
1583 init_vars_expansion (void)
1585 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1586 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1588 /* A map from decl to stack partition. */
1589 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1591 /* Initialize local stack smashing state. */
1592 has_protected_decls
= false;
1593 has_short_buffer
= false;
1596 /* Free up stack variable graph data. */
1598 fini_vars_expansion (void)
1600 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1602 XDELETEVEC (stack_vars
);
1603 if (stack_vars_sorted
)
1604 XDELETEVEC (stack_vars_sorted
);
1606 stack_vars_sorted
= NULL
;
1607 stack_vars_alloc
= stack_vars_num
= 0;
1608 delete decl_to_stack_part
;
1609 decl_to_stack_part
= NULL
;
1612 /* Make a fair guess for the size of the stack frame of the function
1613 in NODE. This doesn't have to be exact, the result is only used in
1614 the inline heuristics. So we don't want to run the full stack var
1615 packing algorithm (which is quadratic in the number of stack vars).
1616 Instead, we calculate the total size of all stack vars. This turns
1617 out to be a pretty fair estimate -- packing of stack vars doesn't
1618 happen very often. */
1621 estimated_stack_frame_size (struct cgraph_node
*node
)
1623 HOST_WIDE_INT size
= 0;
1626 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1630 init_vars_expansion ();
1632 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1633 if (auto_var_in_fn_p (var
, fn
->decl
))
1634 size
+= expand_one_var (var
, true, false);
1636 if (stack_vars_num
> 0)
1638 /* Fake sorting the stack vars for account_stack_vars (). */
1639 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1640 for (i
= 0; i
< stack_vars_num
; ++i
)
1641 stack_vars_sorted
[i
] = i
;
1642 size
+= account_stack_vars ();
1645 fini_vars_expansion ();
1650 /* Helper routine to check if a record or union contains an array field. */
1653 record_or_union_type_has_array_p (const_tree tree_type
)
1655 tree fields
= TYPE_FIELDS (tree_type
);
1658 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1659 if (TREE_CODE (f
) == FIELD_DECL
)
1661 tree field_type
= TREE_TYPE (f
);
1662 if (RECORD_OR_UNION_TYPE_P (field_type
)
1663 && record_or_union_type_has_array_p (field_type
))
1665 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1671 /* Check if the current function has local referenced variables that
1672 have their addresses taken, contain an array, or are arrays. */
1675 stack_protect_decl_p ()
1680 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1681 if (!is_global_var (var
))
1683 tree var_type
= TREE_TYPE (var
);
1684 if (TREE_CODE (var
) == VAR_DECL
1685 && (TREE_CODE (var_type
) == ARRAY_TYPE
1686 || TREE_ADDRESSABLE (var
)
1687 || (RECORD_OR_UNION_TYPE_P (var_type
)
1688 && record_or_union_type_has_array_p (var_type
))))
1694 /* Check if the current function has calls that use a return slot. */
1697 stack_protect_return_slot_p ()
1701 FOR_ALL_BB_FN (bb
, cfun
)
1702 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
1703 !gsi_end_p (gsi
); gsi_next (&gsi
))
1705 gimple stmt
= gsi_stmt (gsi
);
1706 /* This assumes that calls to internal-only functions never
1707 use a return slot. */
1708 if (is_gimple_call (stmt
)
1709 && !gimple_call_internal_p (stmt
)
1710 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
1711 gimple_call_fndecl (stmt
)))
1717 /* Expand all variables used in the function. */
1720 expand_used_vars (void)
1722 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1723 vec
<tree
> maybe_local_decls
= vNULL
;
1724 rtx_insn
*var_end_seq
= NULL
;
1727 bool gen_stack_protect_signal
= false;
1729 /* Compute the phase of the stack frame for this function. */
1731 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1732 int off
= STARTING_FRAME_OFFSET
% align
;
1733 frame_phase
= off
? align
- off
: 0;
1736 /* Set TREE_USED on all variables in the local_decls. */
1737 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1738 TREE_USED (var
) = 1;
1739 /* Clear TREE_USED on all variables associated with a block scope. */
1740 clear_tree_used (DECL_INITIAL (current_function_decl
));
1742 init_vars_expansion ();
1744 if (targetm
.use_pseudo_pic_reg ())
1745 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
1747 hash_map
<tree
, tree
> ssa_name_decls
;
1748 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1750 tree var
= partition_to_var (SA
.map
, i
);
1752 gcc_assert (!virtual_operand_p (var
));
1754 /* Assign decls to each SSA name partition, share decls for partitions
1755 we could have coalesced (those with the same type). */
1756 if (SSA_NAME_VAR (var
) == NULL_TREE
)
1758 tree
*slot
= &ssa_name_decls
.get_or_insert (TREE_TYPE (var
));
1760 *slot
= create_tmp_reg (TREE_TYPE (var
));
1761 replace_ssa_name_symbol (var
, *slot
);
1764 /* Always allocate space for partitions based on VAR_DECLs. But for
1765 those based on PARM_DECLs or RESULT_DECLs and which matter for the
1766 debug info, there is no need to do so if optimization is disabled
1767 because all the SSA_NAMEs based on these DECLs have been coalesced
1768 into a single partition, which is thus assigned the canonical RTL
1769 location of the DECLs. If in_lto_p, we can't rely on optimize,
1770 a function could be compiled with -O1 -flto first and only the
1771 link performed at -O0. */
1772 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1773 expand_one_var (var
, true, true);
1774 else if (DECL_IGNORED_P (SSA_NAME_VAR (var
)) || optimize
|| in_lto_p
)
1776 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1777 contain the default def (representing the parm or result itself)
1778 we don't do anything here. But those which don't contain the
1779 default def (representing a temporary based on the parm/result)
1780 we need to allocate space just like for normal VAR_DECLs. */
1781 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1783 expand_one_var (var
, true, true);
1784 gcc_assert (SA
.partition_to_pseudo
[i
]);
1789 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1790 gen_stack_protect_signal
1791 = stack_protect_decl_p () || stack_protect_return_slot_p ();
1793 /* At this point all variables on the local_decls with TREE_USED
1794 set are not associated with any block scope. Lay them out. */
1796 len
= vec_safe_length (cfun
->local_decls
);
1797 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1799 bool expand_now
= false;
1801 /* Expanded above already. */
1802 if (is_gimple_reg (var
))
1804 TREE_USED (var
) = 0;
1807 /* We didn't set a block for static or extern because it's hard
1808 to tell the difference between a global variable (re)declared
1809 in a local scope, and one that's really declared there to
1810 begin with. And it doesn't really matter much, since we're
1811 not giving them stack space. Expand them now. */
1812 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1815 /* Expand variables not associated with any block now. Those created by
1816 the optimizers could be live anywhere in the function. Those that
1817 could possibly have been scoped originally and detached from their
1818 block will have their allocation deferred so we coalesce them with
1819 others when optimization is enabled. */
1820 else if (TREE_USED (var
))
1823 /* Finally, mark all variables on the list as used. We'll use
1824 this in a moment when we expand those associated with scopes. */
1825 TREE_USED (var
) = 1;
1828 expand_one_var (var
, true, true);
1831 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1833 rtx rtl
= DECL_RTL_IF_SET (var
);
1835 /* Keep artificial non-ignored vars in cfun->local_decls
1836 chain until instantiate_decls. */
1837 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1838 add_local_decl (cfun
, var
);
1839 else if (rtl
== NULL_RTX
)
1840 /* If rtl isn't set yet, which can happen e.g. with
1841 -fstack-protector, retry before returning from this
1843 maybe_local_decls
.safe_push (var
);
1847 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1849 +-----------------+-----------------+
1850 | ...processed... | ...duplicates...|
1851 +-----------------+-----------------+
1853 +-- LEN points here.
1855 We just want the duplicates, as those are the artificial
1856 non-ignored vars that we want to keep until instantiate_decls.
1857 Move them down and truncate the array. */
1858 if (!vec_safe_is_empty (cfun
->local_decls
))
1859 cfun
->local_decls
->block_remove (0, len
);
1861 /* At this point, all variables within the block tree with TREE_USED
1862 set are actually used by the optimized function. Lay them out. */
1863 expand_used_vars_for_block (outer_block
, true);
1865 if (stack_vars_num
> 0)
1867 add_scope_conflicts ();
1869 /* If stack protection is enabled, we don't share space between
1870 vulnerable data and non-vulnerable data. */
1871 if (flag_stack_protect
!= 0
1872 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
1873 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1874 && lookup_attribute ("stack_protect",
1875 DECL_ATTRIBUTES (current_function_decl
)))))
1876 add_stack_protection_conflicts ();
1878 /* Now that we have collected all stack variables, and have computed a
1879 minimal interference graph, attempt to save some stack space. */
1880 partition_stack_vars ();
1882 dump_stack_var_partition ();
1885 switch (flag_stack_protect
)
1888 create_stack_guard ();
1891 case SPCT_FLAG_STRONG
:
1892 if (gen_stack_protect_signal
1893 || cfun
->calls_alloca
|| has_protected_decls
1894 || lookup_attribute ("stack_protect",
1895 DECL_ATTRIBUTES (current_function_decl
)))
1896 create_stack_guard ();
1899 case SPCT_FLAG_DEFAULT
:
1900 if (cfun
->calls_alloca
|| has_protected_decls
1901 || lookup_attribute ("stack_protect",
1902 DECL_ATTRIBUTES (current_function_decl
)))
1903 create_stack_guard ();
1906 case SPCT_FLAG_EXPLICIT
:
1907 if (lookup_attribute ("stack_protect",
1908 DECL_ATTRIBUTES (current_function_decl
)))
1909 create_stack_guard ();
1915 /* Assign rtl to each variable based on these partitions. */
1916 if (stack_vars_num
> 0)
1918 struct stack_vars_data data
;
1920 data
.asan_vec
= vNULL
;
1921 data
.asan_decl_vec
= vNULL
;
1922 data
.asan_base
= NULL_RTX
;
1923 data
.asan_alignb
= 0;
1925 /* Reorder decls to be protected by iterating over the variables
1926 array multiple times, and allocating out of each phase in turn. */
1927 /* ??? We could probably integrate this into the qsort we did
1928 earlier, such that we naturally see these variables first,
1929 and thus naturally allocate things in the right order. */
1930 if (has_protected_decls
)
1932 /* Phase 1 contains only character arrays. */
1933 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
1935 /* Phase 2 contains other kinds of arrays. */
1936 if (flag_stack_protect
== SPCT_FLAG_ALL
1937 || flag_stack_protect
== SPCT_FLAG_STRONG
1938 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1939 && lookup_attribute ("stack_protect",
1940 DECL_ATTRIBUTES (current_function_decl
))))
1941 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
1944 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
)
1945 /* Phase 3, any partitions that need asan protection
1946 in addition to phase 1 and 2. */
1947 expand_stack_vars (asan_decl_phase_3
, &data
);
1949 if (!data
.asan_vec
.is_empty ())
1951 HOST_WIDE_INT prev_offset
= frame_offset
;
1952 HOST_WIDE_INT offset
, sz
, redzonesz
;
1953 redzonesz
= ASAN_RED_ZONE_SIZE
;
1954 sz
= data
.asan_vec
[0] - prev_offset
;
1955 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
1956 && data
.asan_alignb
<= 4096
1957 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
1958 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
1959 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
1961 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
1962 data
.asan_vec
.safe_push (prev_offset
);
1963 data
.asan_vec
.safe_push (offset
);
1964 /* Leave space for alignment if STRICT_ALIGNMENT. */
1965 if (STRICT_ALIGNMENT
)
1966 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
1967 << ASAN_SHADOW_SHIFT
)
1968 / BITS_PER_UNIT
, 1);
1971 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
1974 data
.asan_vec
.address (),
1975 data
.asan_decl_vec
.address (),
1976 data
.asan_vec
.length ());
1979 expand_stack_vars (NULL
, &data
);
1981 data
.asan_vec
.release ();
1982 data
.asan_decl_vec
.release ();
1985 fini_vars_expansion ();
1987 /* If there were any artificial non-ignored vars without rtl
1988 found earlier, see if deferred stack allocation hasn't assigned
1990 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
1992 rtx rtl
= DECL_RTL_IF_SET (var
);
1994 /* Keep artificial non-ignored vars in cfun->local_decls
1995 chain until instantiate_decls. */
1996 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1997 add_local_decl (cfun
, var
);
1999 maybe_local_decls
.release ();
2001 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2002 if (STACK_ALIGNMENT_NEEDED
)
2004 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2005 if (!FRAME_GROWS_DOWNWARD
)
2006 frame_offset
+= align
- 1;
2007 frame_offset
&= -align
;
2014 /* If we need to produce a detailed dump, print the tree representation
2015 for STMT to the dump file. SINCE is the last RTX after which the RTL
2016 generated for STMT should have been appended. */
2019 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx_insn
*since
)
2021 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2023 fprintf (dump_file
, "\n;; ");
2024 print_gimple_stmt (dump_file
, stmt
, 0,
2025 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2026 fprintf (dump_file
, "\n");
2028 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2032 /* Maps the blocks that do not contain tree labels to rtx labels. */
2034 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2036 /* Returns the label_rtx expression for a label starting basic block BB. */
2039 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2041 gimple_stmt_iterator gsi
;
2044 if (bb
->flags
& BB_RTL
)
2045 return block_label (bb
);
2047 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2051 /* Find the tree label if it is present. */
2053 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2057 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2061 lab
= gimple_label_label (lab_stmt
);
2062 if (DECL_NONLOCAL (lab
))
2065 return label_rtx (lab
);
2068 rtx_code_label
*l
= gen_label_rtx ();
2069 lab_rtx_for_bb
->put (bb
, l
);
2074 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2075 of a basic block where we just expanded the conditional at the end,
2076 possibly clean up the CFG and instruction sequence. LAST is the
2077 last instruction before the just emitted jump sequence. */
2080 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2082 /* Special case: when jumpif decides that the condition is
2083 trivial it emits an unconditional jump (and the necessary
2084 barrier). But we still have two edges, the fallthru one is
2085 wrong. purge_dead_edges would clean this up later. Unfortunately
2086 we have to insert insns (and split edges) before
2087 find_many_sub_basic_blocks and hence before purge_dead_edges.
2088 But splitting edges might create new blocks which depend on the
2089 fact that if there are two edges there's no barrier. So the
2090 barrier would get lost and verify_flow_info would ICE. Instead
2091 of auditing all edge splitters to care for the barrier (which
2092 normally isn't there in a cleaned CFG), fix it here. */
2093 if (BARRIER_P (get_last_insn ()))
2097 /* Now, we have a single successor block, if we have insns to
2098 insert on the remaining edge we potentially will insert
2099 it at the end of this block (if the dest block isn't feasible)
2100 in order to avoid splitting the edge. This insertion will take
2101 place in front of the last jump. But we might have emitted
2102 multiple jumps (conditional and one unconditional) to the
2103 same destination. Inserting in front of the last one then
2104 is a problem. See PR 40021. We fix this by deleting all
2105 jumps except the last unconditional one. */
2106 insn
= PREV_INSN (get_last_insn ());
2107 /* Make sure we have an unconditional jump. Otherwise we're
2109 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2110 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2112 insn
= PREV_INSN (insn
);
2113 if (JUMP_P (NEXT_INSN (insn
)))
2115 if (!any_condjump_p (NEXT_INSN (insn
)))
2117 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2118 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2120 delete_insn (NEXT_INSN (insn
));
2126 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2127 Returns a new basic block if we've terminated the current basic
2128 block and created a new one. */
2131 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2133 basic_block new_bb
, dest
;
2137 rtx_insn
*last2
, *last
;
2138 enum tree_code code
;
2141 code
= gimple_cond_code (stmt
);
2142 op0
= gimple_cond_lhs (stmt
);
2143 op1
= gimple_cond_rhs (stmt
);
2144 /* We're sometimes presented with such code:
2148 This would expand to two comparisons which then later might
2149 be cleaned up by combine. But some pattern matchers like if-conversion
2150 work better when there's only one compare, so make up for this
2151 here as special exception if TER would have made the same change. */
2153 && TREE_CODE (op0
) == SSA_NAME
2154 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2155 && TREE_CODE (op1
) == INTEGER_CST
2156 && ((gimple_cond_code (stmt
) == NE_EXPR
2157 && integer_zerop (op1
))
2158 || (gimple_cond_code (stmt
) == EQ_EXPR
2159 && integer_onep (op1
)))
2160 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2162 gimple second
= SSA_NAME_DEF_STMT (op0
);
2163 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2165 enum tree_code code2
= gimple_assign_rhs_code (second
);
2166 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2169 op0
= gimple_assign_rhs1 (second
);
2170 op1
= gimple_assign_rhs2 (second
);
2172 /* If jumps are cheap and the target does not support conditional
2173 compare, turn some more codes into jumpy sequences. */
2174 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2175 && targetm
.gen_ccmp_first
== NULL
)
2177 if ((code2
== BIT_AND_EXPR
2178 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2179 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2180 || code2
== TRUTH_AND_EXPR
)
2182 code
= TRUTH_ANDIF_EXPR
;
2183 op0
= gimple_assign_rhs1 (second
);
2184 op1
= gimple_assign_rhs2 (second
);
2186 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2188 code
= TRUTH_ORIF_EXPR
;
2189 op0
= gimple_assign_rhs1 (second
);
2190 op1
= gimple_assign_rhs2 (second
);
2196 last2
= last
= get_last_insn ();
2198 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2199 set_curr_insn_location (gimple_location (stmt
));
2201 /* These flags have no purpose in RTL land. */
2202 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2203 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2205 /* We can either have a pure conditional jump with one fallthru edge or
2206 two-way jump that needs to be decomposed into two basic blocks. */
2207 if (false_edge
->dest
== bb
->next_bb
)
2209 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2210 true_edge
->probability
);
2211 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2212 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2213 set_curr_insn_location (true_edge
->goto_locus
);
2214 false_edge
->flags
|= EDGE_FALLTHRU
;
2215 maybe_cleanup_end_of_block (false_edge
, last
);
2218 if (true_edge
->dest
== bb
->next_bb
)
2220 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2221 false_edge
->probability
);
2222 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2223 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2224 set_curr_insn_location (false_edge
->goto_locus
);
2225 true_edge
->flags
|= EDGE_FALLTHRU
;
2226 maybe_cleanup_end_of_block (true_edge
, last
);
2230 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2231 true_edge
->probability
);
2232 last
= get_last_insn ();
2233 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2234 set_curr_insn_location (false_edge
->goto_locus
);
2235 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2238 if (BARRIER_P (BB_END (bb
)))
2239 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2240 update_bb_for_insn (bb
);
2242 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2243 dest
= false_edge
->dest
;
2244 redirect_edge_succ (false_edge
, new_bb
);
2245 false_edge
->flags
|= EDGE_FALLTHRU
;
2246 new_bb
->count
= false_edge
->count
;
2247 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2248 add_bb_to_loop (new_bb
, bb
->loop_father
);
2249 new_edge
= make_edge (new_bb
, dest
, 0);
2250 new_edge
->probability
= REG_BR_PROB_BASE
;
2251 new_edge
->count
= new_bb
->count
;
2252 if (BARRIER_P (BB_END (new_bb
)))
2253 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2254 update_bb_for_insn (new_bb
);
2256 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2258 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2260 set_curr_insn_location (true_edge
->goto_locus
);
2261 true_edge
->goto_locus
= curr_insn_location ();
2267 /* Mark all calls that can have a transaction restart. */
2270 mark_transaction_restart_calls (gimple stmt
)
2272 struct tm_restart_node dummy
;
2273 tm_restart_node
**slot
;
2275 if (!cfun
->gimple_df
->tm_restart
)
2279 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2282 struct tm_restart_node
*n
= *slot
;
2283 tree list
= n
->label_or_list
;
2286 for (insn
= next_real_insn (get_last_insn ());
2288 insn
= next_real_insn (insn
))
2291 if (TREE_CODE (list
) == LABEL_DECL
)
2292 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2294 for (; list
; list
= TREE_CHAIN (list
))
2295 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2299 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2303 expand_call_stmt (gcall
*stmt
)
2305 tree exp
, decl
, lhs
;
2309 if (gimple_call_internal_p (stmt
))
2311 expand_internal_call (stmt
);
2315 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2317 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2318 decl
= gimple_call_fndecl (stmt
);
2319 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2321 /* If this is not a builtin function, the function type through which the
2322 call is made may be different from the type of the function. */
2325 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2326 CALL_EXPR_FN (exp
));
2328 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2329 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2331 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2333 tree arg
= gimple_call_arg (stmt
, i
);
2335 /* TER addresses into arguments of builtin functions so we have a
2336 chance to infer more correct alignment information. See PR39954. */
2338 && TREE_CODE (arg
) == SSA_NAME
2339 && (def
= get_gimple_for_ssa_name (arg
))
2340 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2341 arg
= gimple_assign_rhs1 (def
);
2342 CALL_EXPR_ARG (exp
, i
) = arg
;
2345 if (gimple_has_side_effects (stmt
))
2346 TREE_SIDE_EFFECTS (exp
) = 1;
2348 if (gimple_call_nothrow_p (stmt
))
2349 TREE_NOTHROW (exp
) = 1;
2351 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2352 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2354 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2355 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2356 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2357 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2359 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2360 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2361 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2362 CALL_WITH_BOUNDS_P (exp
) = gimple_call_with_bounds_p (stmt
);
2364 /* Ensure RTL is created for debug args. */
2365 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2367 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2372 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2374 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2375 expand_debug_expr (dtemp
);
2379 lhs
= gimple_call_lhs (stmt
);
2381 expand_assignment (lhs
, exp
, false);
2383 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2385 mark_transaction_restart_calls (stmt
);
2389 /* Generate RTL for an asm statement (explicit assembler code).
2390 STRING is a STRING_CST node containing the assembler code text,
2391 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2392 insn is volatile; don't optimize it. */
2395 expand_asm_loc (tree string
, int vol
, location_t locus
)
2399 if (TREE_CODE (string
) == ADDR_EXPR
)
2400 string
= TREE_OPERAND (string
, 0);
2402 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2403 ggc_strdup (TREE_STRING_POINTER (string
)),
2406 MEM_VOLATILE_P (body
) = vol
;
2411 /* Return the number of times character C occurs in string S. */
2413 n_occurrences (int c
, const char *s
)
2421 /* A subroutine of expand_asm_operands. Check that all operands have
2422 the same number of alternatives. Return true if so. */
2425 check_operand_nalternatives (tree outputs
, tree inputs
)
2427 if (outputs
|| inputs
)
2429 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
2431 = n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp
)));
2434 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2436 error ("too many alternatives in %<asm%>");
2443 const char *constraint
2444 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp
)));
2446 if (n_occurrences (',', constraint
) != nalternatives
)
2448 error ("operand constraints for %<asm%> differ "
2449 "in number of alternatives");
2453 if (TREE_CHAIN (tmp
))
2454 tmp
= TREE_CHAIN (tmp
);
2456 tmp
= next
, next
= 0;
2463 /* Check for overlap between registers marked in CLOBBERED_REGS and
2464 anything inappropriate in T. Emit error and return the register
2465 variable definition for error, NULL_TREE for ok. */
2468 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2470 /* Conflicts between asm-declared register variables and the clobber
2471 list are not allowed. */
2472 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2476 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2477 DECL_NAME (overlap
));
2479 /* Reset registerness to stop multiple errors emitted for a single
2481 DECL_REGISTER (overlap
) = 0;
2488 /* Generate RTL for an asm statement with arguments.
2489 STRING is the instruction template.
2490 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2491 Each output or input has an expression in the TREE_VALUE and
2492 a tree list in TREE_PURPOSE which in turn contains a constraint
2493 name in TREE_VALUE (or NULL_TREE) and a constraint string
2495 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2496 that is clobbered by this insn.
2498 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2499 should be the fallthru basic block of the asm goto.
2501 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2502 Some elements of OUTPUTS may be replaced with trees representing temporary
2503 values. The caller should copy those temporary values to the originally
2506 VOL nonzero means the insn is volatile; don't optimize it. */
2509 expand_asm_operands (tree string
, tree outputs
, tree inputs
,
2510 tree clobbers
, tree labels
, basic_block fallthru_bb
,
2511 int vol
, location_t locus
)
2513 rtvec argvec
, constraintvec
, labelvec
;
2515 int ninputs
= list_length (inputs
);
2516 int noutputs
= list_length (outputs
);
2517 int nlabels
= list_length (labels
);
2520 HARD_REG_SET clobbered_regs
;
2521 int clobber_conflict_found
= 0;
2525 /* Vector of RTX's of evaluated output operands. */
2526 rtx
*output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2527 int *inout_opnum
= XALLOCAVEC (int, noutputs
);
2528 rtx
*real_output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2529 machine_mode
*inout_mode
= XALLOCAVEC (machine_mode
, noutputs
);
2530 const char **constraints
= XALLOCAVEC (const char *, noutputs
+ ninputs
);
2531 int old_generating_concat_p
= generating_concat_p
;
2532 rtx_code_label
*fallthru_label
= NULL
;
2534 /* An ASM with no outputs needs to be treated as volatile, for now. */
2538 if (! check_operand_nalternatives (outputs
, inputs
))
2541 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
2543 /* Collect constraints. */
2545 for (t
= outputs
; t
; t
= TREE_CHAIN (t
), i
++)
2546 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2547 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), i
++)
2548 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2550 /* Sometimes we wish to automatically clobber registers across an asm.
2551 Case in point is when the i386 backend moved from cc0 to a hard reg --
2552 maintaining source-level compatibility means automatically clobbering
2553 the flags register. */
2554 clobbers
= targetm
.md_asm_clobbers (outputs
, inputs
, clobbers
);
2556 /* Count the number of meaningful clobbered registers, ignoring what
2557 we would ignore later. */
2559 CLEAR_HARD_REG_SET (clobbered_regs
);
2560 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2562 const char *regname
;
2565 if (TREE_VALUE (tail
) == error_mark_node
)
2567 regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2569 i
= decode_reg_name_and_count (regname
, &nregs
);
2573 error ("unknown register name %qs in %<asm%>", regname
);
2575 /* Mark clobbered registers. */
2580 for (reg
= i
; reg
< i
+ nregs
; reg
++)
2584 /* Clobbering the PIC register is an error. */
2585 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2587 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2591 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2596 /* First pass over inputs and outputs checks validity and sets
2597 mark_addressable if needed. */
2600 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2602 tree val
= TREE_VALUE (tail
);
2603 tree type
= TREE_TYPE (val
);
2604 const char *constraint
;
2609 /* If there's an erroneous arg, emit no insn. */
2610 if (type
== error_mark_node
)
2613 /* Try to parse the output constraint. If that fails, there's
2614 no point in going further. */
2615 constraint
= constraints
[i
];
2616 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2617 &allows_mem
, &allows_reg
, &is_inout
))
2624 && REG_P (DECL_RTL (val
))
2625 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2626 mark_addressable (val
);
2633 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2635 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2639 for (i
= 0, tail
= inputs
; tail
; i
++, tail
= TREE_CHAIN (tail
))
2641 bool allows_reg
, allows_mem
;
2642 const char *constraint
;
2644 /* If there's an erroneous arg, emit no insn, because the ASM_INPUT
2645 would get VOIDmode and that could cause a crash in reload. */
2646 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
2649 constraint
= constraints
[i
+ noutputs
];
2650 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2651 constraints
, &allows_mem
, &allows_reg
))
2654 if (! allows_reg
&& allows_mem
)
2655 mark_addressable (TREE_VALUE (tail
));
2658 /* Second pass evaluates arguments. */
2660 /* Make sure stack is consistent for asm goto. */
2662 do_pending_stack_adjust ();
2665 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2667 tree val
= TREE_VALUE (tail
);
2668 tree type
= TREE_TYPE (val
);
2675 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2676 noutputs
, &allows_mem
, &allows_reg
,
2680 /* If an output operand is not a decl or indirect ref and our constraint
2681 allows a register, make a temporary to act as an intermediate.
2682 Make the asm insn write into that, then our caller will copy it to
2683 the real output operand. Likewise for promoted variables. */
2685 generating_concat_p
= 0;
2687 real_output_rtx
[i
] = NULL_RTX
;
2688 if ((TREE_CODE (val
) == INDIRECT_REF
2691 && (allows_mem
|| REG_P (DECL_RTL (val
)))
2692 && ! (REG_P (DECL_RTL (val
))
2693 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
2697 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2698 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
2700 op
= validize_mem (op
);
2702 if (! allows_reg
&& !MEM_P (op
))
2703 error ("output number %d not directly addressable", i
);
2704 if ((! allows_mem
&& MEM_P (op
))
2705 || GET_CODE (op
) == CONCAT
)
2707 real_output_rtx
[i
] = op
;
2708 op
= gen_reg_rtx (GET_MODE (op
));
2710 emit_move_insn (op
, real_output_rtx
[i
]);
2715 op
= assign_temp (type
, 0, 1);
2716 op
= validize_mem (op
);
2717 if (!MEM_P (op
) && TREE_CODE (TREE_VALUE (tail
)) == SSA_NAME
)
2718 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (TREE_VALUE (tail
)), op
);
2719 TREE_VALUE (tail
) = make_tree (type
, op
);
2723 generating_concat_p
= old_generating_concat_p
;
2727 inout_mode
[ninout
] = TYPE_MODE (type
);
2728 inout_opnum
[ninout
++] = i
;
2731 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2732 clobber_conflict_found
= 1;
2735 /* Make vectors for the expression-rtx, constraint strings,
2736 and named operands. */
2738 argvec
= rtvec_alloc (ninputs
);
2739 constraintvec
= rtvec_alloc (ninputs
);
2740 labelvec
= rtvec_alloc (nlabels
);
2742 body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
2743 : GET_MODE (output_rtx
[0])),
2744 ggc_strdup (TREE_STRING_POINTER (string
)),
2745 empty_string
, 0, argvec
, constraintvec
,
2748 MEM_VOLATILE_P (body
) = vol
;
2750 /* Eval the inputs and put them into ARGVEC.
2751 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
2753 for (i
= 0, tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
), ++i
)
2755 bool allows_reg
, allows_mem
;
2756 const char *constraint
;
2761 constraint
= constraints
[i
+ noutputs
];
2762 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2763 constraints
, &allows_mem
, &allows_reg
);
2766 generating_concat_p
= 0;
2768 val
= TREE_VALUE (tail
);
2769 type
= TREE_TYPE (val
);
2770 /* EXPAND_INITIALIZER will not generate code for valid initializer
2771 constants, but will still generate code for other types of operand.
2772 This is the behavior we want for constant constraints. */
2773 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2774 allows_reg
? EXPAND_NORMAL
2775 : allows_mem
? EXPAND_MEMORY
2776 : EXPAND_INITIALIZER
);
2778 /* Never pass a CONCAT to an ASM. */
2779 if (GET_CODE (op
) == CONCAT
)
2780 op
= force_reg (GET_MODE (op
), op
);
2781 else if (MEM_P (op
))
2782 op
= validize_mem (op
);
2784 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
2786 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
2787 op
= force_reg (TYPE_MODE (type
), op
);
2788 else if (!allows_mem
)
2789 warning (0, "asm operand %d probably doesn%'t match constraints",
2791 else if (MEM_P (op
))
2793 /* We won't recognize either volatile memory or memory
2794 with a queued address as available a memory_operand
2795 at this point. Ignore it: clearly this *is* a memory. */
2801 generating_concat_p
= old_generating_concat_p
;
2802 ASM_OPERANDS_INPUT (body
, i
) = op
;
2804 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
2805 = gen_rtx_ASM_INPUT_loc (TYPE_MODE (type
),
2806 ggc_strdup (constraints
[i
+ noutputs
]),
2809 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2810 clobber_conflict_found
= 1;
2813 /* Protect all the operands from the queue now that they have all been
2816 generating_concat_p
= 0;
2818 /* For in-out operands, copy output rtx to input rtx. */
2819 for (i
= 0; i
< ninout
; i
++)
2821 int j
= inout_opnum
[i
];
2824 ASM_OPERANDS_INPUT (body
, ninputs
- ninout
+ i
)
2827 sprintf (buffer
, "%d", j
);
2828 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, ninputs
- ninout
+ i
)
2829 = gen_rtx_ASM_INPUT_loc (inout_mode
[i
], ggc_strdup (buffer
), locus
);
2832 /* Copy labels to the vector. */
2833 for (i
= 0, tail
= labels
; i
< nlabels
; ++i
, tail
= TREE_CHAIN (tail
))
2836 /* If asm goto has any labels in the fallthru basic block, use
2837 a label that we emit immediately after the asm goto. Expansion
2838 may insert further instructions into the same basic block after
2839 asm goto and if we don't do this, insertion of instructions on
2840 the fallthru edge might misbehave. See PR58670. */
2842 && label_to_block_fn (cfun
, TREE_VALUE (tail
)) == fallthru_bb
)
2844 if (fallthru_label
== NULL_RTX
)
2845 fallthru_label
= gen_label_rtx ();
2849 r
= label_rtx (TREE_VALUE (tail
));
2850 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
2853 generating_concat_p
= old_generating_concat_p
;
2855 /* Now, for each output, construct an rtx
2856 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
2857 ARGVEC CONSTRAINTS OPNAMES))
2858 If there is more than one, put them inside a PARALLEL. */
2860 if (nlabels
> 0 && nclobbers
== 0)
2862 gcc_assert (noutputs
== 0);
2863 emit_jump_insn (body
);
2865 else if (noutputs
== 0 && nclobbers
== 0)
2867 /* No output operands: put in a raw ASM_OPERANDS rtx. */
2870 else if (noutputs
== 1 && nclobbers
== 0)
2872 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = ggc_strdup (constraints
[0]);
2873 emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
2883 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
2885 /* For each output operand, store a SET. */
2886 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2888 XVECEXP (body
, 0, i
)
2889 = gen_rtx_SET (VOIDmode
,
2891 gen_rtx_ASM_OPERANDS
2892 (GET_MODE (output_rtx
[i
]),
2893 ggc_strdup (TREE_STRING_POINTER (string
)),
2894 ggc_strdup (constraints
[i
]),
2895 i
, argvec
, constraintvec
, labelvec
, locus
));
2897 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
2900 /* If there are no outputs (but there are some clobbers)
2901 store the bare ASM_OPERANDS into the PARALLEL. */
2904 XVECEXP (body
, 0, i
++) = obody
;
2906 /* Store (clobber REG) for each clobbered register specified. */
2908 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2910 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2912 int j
= decode_reg_name_and_count (regname
, &nregs
);
2917 if (j
== -3) /* `cc', which is not a register */
2920 if (j
== -4) /* `memory', don't cache memory across asm */
2922 XVECEXP (body
, 0, i
++)
2923 = gen_rtx_CLOBBER (VOIDmode
,
2926 gen_rtx_SCRATCH (VOIDmode
)));
2930 /* Ignore unknown register, error already signaled. */
2934 for (reg
= j
; reg
< j
+ nregs
; reg
++)
2936 /* Use QImode since that's guaranteed to clobber just
2938 clobbered_reg
= gen_rtx_REG (QImode
, reg
);
2940 /* Do sanity check for overlap between clobbers and
2941 respectively input and outputs that hasn't been
2942 handled. Such overlap should have been detected and
2944 if (!clobber_conflict_found
)
2948 /* We test the old body (obody) contents to avoid
2949 tripping over the under-construction body. */
2950 for (opno
= 0; opno
< noutputs
; opno
++)
2951 if (reg_overlap_mentioned_p (clobbered_reg
,
2954 ("asm clobber conflict with output operand");
2956 for (opno
= 0; opno
< ninputs
- ninout
; opno
++)
2957 if (reg_overlap_mentioned_p (clobbered_reg
,
2958 ASM_OPERANDS_INPUT (obody
,
2961 ("asm clobber conflict with input operand");
2964 XVECEXP (body
, 0, i
++)
2965 = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
2970 emit_jump_insn (body
);
2976 emit_label (fallthru_label
);
2978 /* For any outputs that needed reloading into registers, spill them
2979 back to where they belong. */
2980 for (i
= 0; i
< noutputs
; ++i
)
2981 if (real_output_rtx
[i
])
2982 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
2984 crtl
->has_asm_statement
= 1;
2990 expand_asm_stmt (gasm
*stmt
)
2993 tree outputs
, tail
, t
;
2997 tree str
, out
, in
, cl
, labels
;
2998 location_t locus
= gimple_location (stmt
);
2999 basic_block fallthru_bb
= NULL
;
3001 /* Meh... convert the gimple asm operands into real tree lists.
3002 Eventually we should make all routines work on the vectors instead
3003 of relying on TREE_CHAIN. */
3005 n
= gimple_asm_noutputs (stmt
);
3008 t
= out
= gimple_asm_output_op (stmt
, 0);
3009 for (i
= 1; i
< n
; i
++)
3010 t
= TREE_CHAIN (t
) = gimple_asm_output_op (stmt
, i
);
3014 n
= gimple_asm_ninputs (stmt
);
3017 t
= in
= gimple_asm_input_op (stmt
, 0);
3018 for (i
= 1; i
< n
; i
++)
3019 t
= TREE_CHAIN (t
) = gimple_asm_input_op (stmt
, i
);
3023 n
= gimple_asm_nclobbers (stmt
);
3026 t
= cl
= gimple_asm_clobber_op (stmt
, 0);
3027 for (i
= 1; i
< n
; i
++)
3028 t
= TREE_CHAIN (t
) = gimple_asm_clobber_op (stmt
, i
);
3032 n
= gimple_asm_nlabels (stmt
);
3035 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3037 fallthru_bb
= fallthru
->dest
;
3038 t
= labels
= gimple_asm_label_op (stmt
, 0);
3039 for (i
= 1; i
< n
; i
++)
3040 t
= TREE_CHAIN (t
) = gimple_asm_label_op (stmt
, i
);
3043 s
= gimple_asm_string (stmt
);
3044 str
= build_string (strlen (s
), s
);
3046 if (gimple_asm_input_p (stmt
))
3048 expand_asm_loc (str
, gimple_asm_volatile_p (stmt
), locus
);
3053 noutputs
= gimple_asm_noutputs (stmt
);
3054 /* o[I] is the place that output number I should be written. */
3055 o
= (tree
*) alloca (noutputs
* sizeof (tree
));
3057 /* Record the contents of OUTPUTS before it is modified. */
3058 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
3059 o
[i
] = TREE_VALUE (tail
);
3061 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
3062 OUTPUTS some trees for where the values were actually stored. */
3063 expand_asm_operands (str
, outputs
, in
, cl
, labels
, fallthru_bb
,
3064 gimple_asm_volatile_p (stmt
), locus
);
3066 /* Copy all the intermediate outputs into the specified outputs. */
3067 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
3069 if (o
[i
] != TREE_VALUE (tail
))
3071 expand_assignment (o
[i
], TREE_VALUE (tail
), false);
3074 /* Restore the original value so that it's correct the next
3075 time we expand this function. */
3076 TREE_VALUE (tail
) = o
[i
];
3081 /* Emit code to jump to the address
3082 specified by the pointer expression EXP. */
3085 expand_computed_goto (tree exp
)
3087 rtx x
= expand_normal (exp
);
3089 do_pending_stack_adjust ();
3090 emit_indirect_jump (x
);
3093 /* Generate RTL code for a `goto' statement with target label LABEL.
3094 LABEL should be a LABEL_DECL tree node that was or will later be
3095 defined with `expand_label'. */
3098 expand_goto (tree label
)
3100 #ifdef ENABLE_CHECKING
3101 /* Check for a nonlocal goto to a containing function. Should have
3102 gotten translated to __builtin_nonlocal_goto. */
3103 tree context
= decl_function_context (label
);
3104 gcc_assert (!context
|| context
== current_function_decl
);
3107 emit_jump (label_rtx (label
));
3110 /* Output a return with no value. */
3113 expand_null_return_1 (void)
3115 clear_pending_stack_adjust ();
3116 do_pending_stack_adjust ();
3117 emit_jump (return_label
);
3120 /* Generate RTL to return from the current function, with no value.
3121 (That is, we do not do anything about returning any value.) */
3124 expand_null_return (void)
3126 /* If this function was declared to return a value, but we
3127 didn't, clobber the return registers so that they are not
3128 propagated live to the rest of the function. */
3129 clobber_return_register ();
3131 expand_null_return_1 ();
3134 /* Generate RTL to return from the current function, with value VAL. */
3137 expand_value_return (rtx val
)
3139 /* Copy the value to the return location unless it's already there. */
3141 tree decl
= DECL_RESULT (current_function_decl
);
3142 rtx return_reg
= DECL_RTL (decl
);
3143 if (return_reg
!= val
)
3145 tree funtype
= TREE_TYPE (current_function_decl
);
3146 tree type
= TREE_TYPE (decl
);
3147 int unsignedp
= TYPE_UNSIGNED (type
);
3148 machine_mode old_mode
= DECL_MODE (decl
);
3150 if (DECL_BY_REFERENCE (decl
))
3151 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3153 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3155 if (mode
!= old_mode
)
3156 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3158 if (GET_CODE (return_reg
) == PARALLEL
)
3159 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3161 emit_move_insn (return_reg
, val
);
3164 expand_null_return_1 ();
3167 /* Generate RTL to evaluate the expression RETVAL and return it
3168 from the current function. */
3171 expand_return (tree retval
, tree bounds
)
3178 /* If function wants no value, give it none. */
3179 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3181 expand_normal (retval
);
3182 expand_null_return ();
3186 if (retval
== error_mark_node
)
3188 /* Treat this like a return of no value from a function that
3190 expand_null_return ();
3193 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3194 || TREE_CODE (retval
) == INIT_EXPR
)
3195 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3196 retval_rhs
= TREE_OPERAND (retval
, 1);
3198 retval_rhs
= retval
;
3200 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3202 /* Put returned bounds to the right place. */
3203 bounds_rtl
= DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl
));
3210 bnd
= expand_normal (bounds
);
3211 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3213 else if (REG_P (bounds_rtl
))
3215 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3216 addr
= gen_rtx_MEM (Pmode
, addr
);
3217 bnd
= targetm
.calls
.load_bounds_for_arg (addr
, NULL
, NULL
);
3218 targetm
.calls
.store_returned_bounds (bounds_rtl
, bnd
);
3224 gcc_assert (GET_CODE (bounds_rtl
) == PARALLEL
);
3226 addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3227 addr
= gen_rtx_MEM (Pmode
, addr
);
3229 for (n
= 0; n
< XVECLEN (bounds_rtl
, 0); n
++)
3231 rtx offs
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 1);
3232 rtx slot
= XEXP (XVECEXP (bounds_rtl
, 0, n
), 0);
3233 rtx from
= adjust_address (addr
, Pmode
, INTVAL (offs
));
3234 rtx bnd
= targetm
.calls
.load_bounds_for_arg (from
, NULL
, NULL
);
3235 targetm
.calls
.store_returned_bounds (slot
, bnd
);
3239 else if (chkp_function_instrumented_p (current_function_decl
)
3240 && !BOUNDED_P (retval_rhs
)
3241 && chkp_type_has_pointer (TREE_TYPE (retval_rhs
))
3242 && TREE_CODE (retval_rhs
) != RESULT_DECL
)
3244 rtx addr
= expand_normal (build_fold_addr_expr (retval_rhs
));
3245 addr
= gen_rtx_MEM (Pmode
, addr
);
3247 gcc_assert (MEM_P (result_rtl
));
3249 chkp_copy_bounds_for_stack_parm (result_rtl
, addr
, TREE_TYPE (retval_rhs
));
3252 /* If we are returning the RESULT_DECL, then the value has already
3253 been stored into it, so we don't have to do anything special. */
3254 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3255 expand_value_return (result_rtl
);
3257 /* If the result is an aggregate that is being returned in one (or more)
3258 registers, load the registers here. */
3260 else if (retval_rhs
!= 0
3261 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3262 && REG_P (result_rtl
))
3264 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3267 /* Use the mode of the result value on the return register. */
3268 PUT_MODE (result_rtl
, GET_MODE (val
));
3269 expand_value_return (val
);
3272 expand_null_return ();
3274 else if (retval_rhs
!= 0
3275 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3276 && (REG_P (result_rtl
)
3277 || (GET_CODE (result_rtl
) == PARALLEL
)))
3279 /* Compute the return value into a temporary (usually a pseudo reg). */
3281 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3282 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3283 val
= force_not_mem (val
);
3284 expand_value_return (val
);
3288 /* No hard reg used; calculate value into hard return reg. */
3289 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3290 expand_value_return (result_rtl
);
3294 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3295 STMT that doesn't require special handling for outgoing edges. That
3296 is no tailcalls and no GIMPLE_COND. */
3299 expand_gimple_stmt_1 (gimple stmt
)
3303 set_curr_insn_location (gimple_location (stmt
));
3305 switch (gimple_code (stmt
))
3308 op0
= gimple_goto_dest (stmt
);
3309 if (TREE_CODE (op0
) == LABEL_DECL
)
3312 expand_computed_goto (op0
);
3315 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3318 case GIMPLE_PREDICT
:
3321 expand_case (as_a
<gswitch
*> (stmt
));
3324 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3327 expand_call_stmt (as_a
<gcall
*> (stmt
));
3331 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3333 if (op0
&& op0
!= error_mark_node
)
3335 tree result
= DECL_RESULT (current_function_decl
);
3337 /* If we are not returning the current function's RESULT_DECL,
3338 build an assignment to it. */
3341 /* I believe that a function's RESULT_DECL is unique. */
3342 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3344 /* ??? We'd like to use simply expand_assignment here,
3345 but this fails if the value is of BLKmode but the return
3346 decl is a register. expand_return has special handling
3347 for this combination, which eventually should move
3348 to common code. See comments there. Until then, let's
3349 build a modify expression :-/ */
3350 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3355 expand_null_return ();
3357 expand_return (op0
, gimple_return_retbnd (stmt
));
3362 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3363 tree lhs
= gimple_assign_lhs (assign_stmt
);
3365 /* Tree expand used to fiddle with |= and &= of two bitfield
3366 COMPONENT_REFs here. This can't happen with gimple, the LHS
3367 of binary assigns must be a gimple reg. */
3369 if (TREE_CODE (lhs
) != SSA_NAME
3370 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3371 == GIMPLE_SINGLE_RHS
)
3373 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3374 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3375 == GIMPLE_SINGLE_RHS
);
3376 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
3377 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3378 if (TREE_CLOBBER_P (rhs
))
3379 /* This is a clobber to mark the going out of scope for
3383 expand_assignment (lhs
, rhs
,
3384 gimple_assign_nontemporal_move_p (
3390 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3391 struct separate_ops ops
;
3392 bool promoted
= false;
3394 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3395 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3398 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3399 ops
.type
= TREE_TYPE (lhs
);
3400 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
3402 case GIMPLE_TERNARY_RHS
:
3403 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3405 case GIMPLE_BINARY_RHS
:
3406 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3408 case GIMPLE_UNARY_RHS
:
3409 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3414 ops
.location
= gimple_location (stmt
);
3416 /* If we want to use a nontemporal store, force the value to
3417 register first. If we store into a promoted register,
3418 don't directly expand to target. */
3419 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3420 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3427 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3428 /* If TEMP is a VOIDmode constant, use convert_modes to make
3429 sure that we properly convert it. */
3430 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3432 temp
= convert_modes (GET_MODE (target
),
3433 TYPE_MODE (ops
.type
),
3435 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3436 GET_MODE (target
), temp
, unsignedp
);
3439 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3441 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3445 temp
= force_operand (temp
, target
);
3447 emit_move_insn (target
, temp
);
3458 /* Expand one gimple statement STMT and return the last RTL instruction
3459 before any of the newly generated ones.
3461 In addition to generating the necessary RTL instructions this also
3462 sets REG_EH_REGION notes if necessary and sets the current source
3463 location for diagnostics. */
3466 expand_gimple_stmt (gimple stmt
)
3468 location_t saved_location
= input_location
;
3469 rtx_insn
*last
= get_last_insn ();
3474 /* We need to save and restore the current source location so that errors
3475 discovered during expansion are emitted with the right location. But
3476 it would be better if the diagnostic routines used the source location
3477 embedded in the tree nodes rather than globals. */
3478 if (gimple_has_location (stmt
))
3479 input_location
= gimple_location (stmt
);
3481 expand_gimple_stmt_1 (stmt
);
3483 /* Free any temporaries used to evaluate this statement. */
3486 input_location
= saved_location
;
3488 /* Mark all insns that may trap. */
3489 lp_nr
= lookup_stmt_eh_lp (stmt
);
3493 for (insn
= next_real_insn (last
); insn
;
3494 insn
= next_real_insn (insn
))
3496 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3497 /* If we want exceptions for non-call insns, any
3498 may_trap_p instruction may throw. */
3499 && GET_CODE (PATTERN (insn
)) != CLOBBER
3500 && GET_CODE (PATTERN (insn
)) != USE
3501 && insn_could_throw_p (insn
))
3502 make_reg_eh_region_note (insn
, 0, lp_nr
);
3509 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3510 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3511 generated a tail call (something that might be denied by the ABI
3512 rules governing the call; see calls.c).
3514 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3515 can still reach the rest of BB. The case here is __builtin_sqrt,
3516 where the NaN result goes through the external function (with a
3517 tailcall) and the normal result happens via a sqrt instruction. */
3520 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3522 rtx_insn
*last2
, *last
;
3528 last2
= last
= expand_gimple_stmt (stmt
);
3530 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3531 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3534 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3536 *can_fallthru
= true;
3540 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3541 Any instructions emitted here are about to be deleted. */
3542 do_pending_stack_adjust ();
3544 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3545 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3546 EH or abnormal edges, we shouldn't have created a tail call in
3547 the first place. So it seems to me we should just be removing
3548 all edges here, or redirecting the existing fallthru edge to
3554 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3556 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3558 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3560 e
->dest
->count
-= e
->count
;
3561 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3562 if (e
->dest
->count
< 0)
3564 if (e
->dest
->frequency
< 0)
3565 e
->dest
->frequency
= 0;
3568 probability
+= e
->probability
;
3575 /* This is somewhat ugly: the call_expr expander often emits instructions
3576 after the sibcall (to perform the function return). These confuse the
3577 find_many_sub_basic_blocks code, so we need to get rid of these. */
3578 last
= NEXT_INSN (last
);
3579 gcc_assert (BARRIER_P (last
));
3581 *can_fallthru
= false;
3582 while (NEXT_INSN (last
))
3584 /* For instance an sqrt builtin expander expands if with
3585 sibcall in the then and label for `else`. */
3586 if (LABEL_P (NEXT_INSN (last
)))
3588 *can_fallthru
= true;
3591 delete_insn (NEXT_INSN (last
));
3594 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3596 e
->probability
+= probability
;
3599 update_bb_for_insn (bb
);
3601 if (NEXT_INSN (last
))
3603 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3606 if (BARRIER_P (last
))
3607 BB_END (bb
) = PREV_INSN (last
);
3610 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3615 /* Return the difference between the floor and the truncated result of
3616 a signed division by OP1 with remainder MOD. */
3618 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3620 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3621 return gen_rtx_IF_THEN_ELSE
3622 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3623 gen_rtx_IF_THEN_ELSE
3624 (mode
, gen_rtx_LT (BImode
,
3625 gen_rtx_DIV (mode
, op1
, mod
),
3627 constm1_rtx
, const0_rtx
),
3631 /* Return the difference between the ceil and the truncated result of
3632 a signed division by OP1 with remainder MOD. */
3634 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3636 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3637 return gen_rtx_IF_THEN_ELSE
3638 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3639 gen_rtx_IF_THEN_ELSE
3640 (mode
, gen_rtx_GT (BImode
,
3641 gen_rtx_DIV (mode
, op1
, mod
),
3643 const1_rtx
, const0_rtx
),
3647 /* Return the difference between the ceil and the truncated result of
3648 an unsigned division by OP1 with remainder MOD. */
3650 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3652 /* (mod != 0 ? 1 : 0) */
3653 return gen_rtx_IF_THEN_ELSE
3654 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3655 const1_rtx
, const0_rtx
);
3658 /* Return the difference between the rounded and the truncated result
3659 of a signed division by OP1 with remainder MOD. Halfway cases are
3660 rounded away from zero, rather than to the nearest even number. */
3662 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3664 /* (abs (mod) >= abs (op1) - abs (mod)
3665 ? (op1 / mod > 0 ? 1 : -1)
3667 return gen_rtx_IF_THEN_ELSE
3668 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3669 gen_rtx_MINUS (mode
,
3670 gen_rtx_ABS (mode
, op1
),
3671 gen_rtx_ABS (mode
, mod
))),
3672 gen_rtx_IF_THEN_ELSE
3673 (mode
, gen_rtx_GT (BImode
,
3674 gen_rtx_DIV (mode
, op1
, mod
),
3676 const1_rtx
, constm1_rtx
),
3680 /* Return the difference between the rounded and the truncated result
3681 of a unsigned division by OP1 with remainder MOD. Halfway cases
3682 are rounded away from zero, rather than to the nearest even
3685 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3687 /* (mod >= op1 - mod ? 1 : 0) */
3688 return gen_rtx_IF_THEN_ELSE
3689 (mode
, gen_rtx_GE (BImode
, mod
,
3690 gen_rtx_MINUS (mode
, op1
, mod
)),
3691 const1_rtx
, const0_rtx
);
3694 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3698 convert_debug_memory_address (machine_mode mode
, rtx x
,
3701 machine_mode xmode
= GET_MODE (x
);
3703 #ifndef POINTERS_EXTEND_UNSIGNED
3704 gcc_assert (mode
== Pmode
3705 || mode
== targetm
.addr_space
.address_mode (as
));
3706 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3710 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3712 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3715 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3716 x
= simplify_gen_subreg (mode
, x
, xmode
,
3717 subreg_lowpart_offset
3719 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3720 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3721 else if (!POINTERS_EXTEND_UNSIGNED
)
3722 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3725 switch (GET_CODE (x
))
3728 if ((SUBREG_PROMOTED_VAR_P (x
)
3729 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3730 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3731 && REG_P (XEXP (SUBREG_REG (x
), 0))
3732 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3733 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3734 && GET_MODE (SUBREG_REG (x
)) == mode
)
3735 return SUBREG_REG (x
);
3738 temp
= gen_rtx_LABEL_REF (mode
, LABEL_REF_LABEL (x
));
3739 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
3742 temp
= shallow_copy_rtx (x
);
3743 PUT_MODE (temp
, mode
);
3746 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3748 temp
= gen_rtx_CONST (mode
, temp
);
3752 if (CONST_INT_P (XEXP (x
, 1)))
3754 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3756 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
3762 /* Don't know how to express ptr_extend as operation in debug info. */
3765 #endif /* POINTERS_EXTEND_UNSIGNED */
3770 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
3771 by avoid_deep_ter_for_debug. */
3773 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
3775 /* Split too deep TER chains for debug stmts using debug temporaries. */
3778 avoid_deep_ter_for_debug (gimple stmt
, int depth
)
3780 use_operand_p use_p
;
3782 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
3784 tree use
= USE_FROM_PTR (use_p
);
3785 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
3787 gimple g
= get_gimple_for_ssa_name (use
);
3790 if (depth
> 6 && !stmt_ends_bb_p (g
))
3792 if (deep_ter_debug_map
== NULL
)
3793 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
3795 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
3798 vexpr
= make_node (DEBUG_EXPR_DECL
);
3799 gimple def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
3800 DECL_ARTIFICIAL (vexpr
) = 1;
3801 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
3802 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (use
));
3803 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
3804 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
3805 avoid_deep_ter_for_debug (def_temp
, 0);
3808 avoid_deep_ter_for_debug (g
, depth
+ 1);
3812 /* Return an RTX equivalent to the value of the parameter DECL. */
3815 expand_debug_parm_decl (tree decl
)
3817 rtx incoming
= DECL_INCOMING_RTL (decl
);
3820 && GET_MODE (incoming
) != BLKmode
3821 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
3822 || (MEM_P (incoming
)
3823 && REG_P (XEXP (incoming
, 0))
3824 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
3826 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
3828 #ifdef HAVE_window_save
3829 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
3830 If the target machine has an explicit window save instruction, the
3831 actual entry value is the corresponding OUTGOING_REGNO instead. */
3832 if (REG_P (incoming
)
3833 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
3835 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
3836 OUTGOING_REGNO (REGNO (incoming
)), 0);
3837 else if (MEM_P (incoming
))
3839 rtx reg
= XEXP (incoming
, 0);
3840 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
3842 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
3843 incoming
= replace_equiv_address_nv (incoming
, reg
);
3846 incoming
= copy_rtx (incoming
);
3850 ENTRY_VALUE_EXP (rtl
) = incoming
;
3855 && GET_MODE (incoming
) != BLKmode
3856 && !TREE_ADDRESSABLE (decl
)
3858 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
3859 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
3860 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
3861 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
3862 return copy_rtx (incoming
);
3867 /* Return an RTX equivalent to the value of the tree expression EXP. */
3870 expand_debug_expr (tree exp
)
3872 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
3873 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
3874 machine_mode inner_mode
= VOIDmode
;
3875 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
3878 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
3880 case tcc_expression
:
3881 switch (TREE_CODE (exp
))
3886 case WIDEN_MULT_PLUS_EXPR
:
3887 case WIDEN_MULT_MINUS_EXPR
:
3891 case TRUTH_ANDIF_EXPR
:
3892 case TRUTH_ORIF_EXPR
:
3893 case TRUTH_AND_EXPR
:
3895 case TRUTH_XOR_EXPR
:
3898 case TRUTH_NOT_EXPR
:
3907 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
3914 case tcc_comparison
:
3915 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3922 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3923 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3933 case tcc_exceptional
:
3934 case tcc_declaration
:
3940 switch (TREE_CODE (exp
))
3943 if (!lookup_constant_def (exp
))
3945 if (strlen (TREE_STRING_POINTER (exp
)) + 1
3946 != (size_t) TREE_STRING_LENGTH (exp
))
3948 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
3949 op0
= gen_rtx_MEM (BLKmode
, op0
);
3950 set_mem_attributes (op0
, exp
, 0);
3953 /* Fall through... */
3958 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
3962 gcc_assert (COMPLEX_MODE_P (mode
));
3963 op0
= expand_debug_expr (TREE_REALPART (exp
));
3964 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
3965 return gen_rtx_CONCAT (mode
, op0
, op1
);
3967 case DEBUG_EXPR_DECL
:
3968 op0
= DECL_RTL_IF_SET (exp
);
3973 op0
= gen_rtx_DEBUG_EXPR (mode
);
3974 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
3975 SET_DECL_RTL (exp
, op0
);
3985 op0
= DECL_RTL_IF_SET (exp
);
3987 /* This decl was probably optimized away. */
3990 if (TREE_CODE (exp
) != VAR_DECL
3991 || DECL_EXTERNAL (exp
)
3992 || !TREE_STATIC (exp
)
3994 || DECL_HARD_REGISTER (exp
)
3995 || DECL_IN_CONSTANT_POOL (exp
)
3996 || mode
== VOIDmode
)
3999 op0
= make_decl_rtl_for_debug (exp
);
4001 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4002 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4006 op0
= copy_rtx (op0
);
4008 if (GET_MODE (op0
) == BLKmode
4009 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
4010 below would ICE. While it is likely a FE bug,
4011 try to be robust here. See PR43166. */
4013 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4015 gcc_assert (MEM_P (op0
));
4016 op0
= adjust_address_nv (op0
, mode
, 0);
4026 inner_mode
= GET_MODE (op0
);
4028 if (mode
== inner_mode
)
4031 if (inner_mode
== VOIDmode
)
4033 if (TREE_CODE (exp
) == SSA_NAME
)
4034 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4036 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4037 if (mode
== inner_mode
)
4041 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4043 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4044 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4045 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4046 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4048 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4050 else if (FLOAT_MODE_P (mode
))
4052 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4053 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4054 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4056 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4058 else if (FLOAT_MODE_P (inner_mode
))
4061 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4063 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4065 else if (CONSTANT_P (op0
)
4066 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
4067 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4068 subreg_lowpart_offset (mode
,
4070 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
4071 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4073 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4075 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4081 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4083 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4084 TREE_OPERAND (exp
, 0),
4085 TREE_OPERAND (exp
, 1));
4087 return expand_debug_expr (newexp
);
4091 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4092 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4096 if (TREE_CODE (exp
) == MEM_REF
)
4098 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4099 || (GET_CODE (op0
) == PLUS
4100 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4101 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4102 Instead just use get_inner_reference. */
4105 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4106 if (!op1
|| !CONST_INT_P (op1
))
4109 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
4112 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4114 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4116 if (op0
== NULL_RTX
)
4119 op0
= gen_rtx_MEM (mode
, op0
);
4120 set_mem_attributes (op0
, exp
, 0);
4121 if (TREE_CODE (exp
) == MEM_REF
4122 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4123 set_mem_expr (op0
, NULL_TREE
);
4124 set_mem_addr_space (op0
, as
);
4128 case TARGET_MEM_REF
:
4129 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4130 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4133 op0
= expand_debug_expr
4134 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4138 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4139 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4141 if (op0
== NULL_RTX
)
4144 op0
= gen_rtx_MEM (mode
, op0
);
4146 set_mem_attributes (op0
, exp
, 0);
4147 set_mem_addr_space (op0
, as
);
4153 case ARRAY_RANGE_REF
:
4158 case VIEW_CONVERT_EXPR
:
4161 HOST_WIDE_INT bitsize
, bitpos
;
4164 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
4165 &mode1
, &unsignedp
, &volatilep
, false);
4171 orig_op0
= op0
= expand_debug_expr (tem
);
4178 machine_mode addrmode
, offmode
;
4183 op0
= XEXP (op0
, 0);
4184 addrmode
= GET_MODE (op0
);
4185 if (addrmode
== VOIDmode
)
4188 op1
= expand_debug_expr (offset
);
4192 offmode
= GET_MODE (op1
);
4193 if (offmode
== VOIDmode
)
4194 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4196 if (addrmode
!= offmode
)
4197 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
4198 subreg_lowpart_offset (addrmode
,
4201 /* Don't use offset_address here, we don't need a
4202 recognizable address, and we don't want to generate
4204 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4210 if (mode1
== VOIDmode
)
4212 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4213 if (bitpos
>= BITS_PER_UNIT
)
4215 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4216 bitpos
%= BITS_PER_UNIT
;
4218 else if (bitpos
< 0)
4221 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4222 op0
= adjust_address_nv (op0
, mode1
, units
);
4223 bitpos
+= units
* BITS_PER_UNIT
;
4225 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4226 op0
= adjust_address_nv (op0
, mode
, 0);
4227 else if (GET_MODE (op0
) != mode1
)
4228 op0
= adjust_address_nv (op0
, mode1
, 0);
4230 op0
= copy_rtx (op0
);
4231 if (op0
== orig_op0
)
4232 op0
= shallow_copy_rtx (op0
);
4233 set_mem_attributes (op0
, exp
, 0);
4236 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4242 if (GET_MODE (op0
) == BLKmode
)
4245 if ((bitpos
% BITS_PER_UNIT
) == 0
4246 && bitsize
== GET_MODE_BITSIZE (mode1
))
4248 machine_mode opmode
= GET_MODE (op0
);
4250 if (opmode
== VOIDmode
)
4251 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4253 /* This condition may hold if we're expanding the address
4254 right past the end of an array that turned out not to
4255 be addressable (i.e., the address was only computed in
4256 debug stmts). The gen_subreg below would rightfully
4257 crash, and the address doesn't really exist, so just
4259 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4262 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4263 return simplify_gen_subreg (mode
, op0
, opmode
,
4264 bitpos
/ BITS_PER_UNIT
);
4267 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4268 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4270 : ZERO_EXTRACT
, mode
,
4271 GET_MODE (op0
) != VOIDmode
4273 : TYPE_MODE (TREE_TYPE (tem
)),
4274 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4278 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4281 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4284 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4287 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4289 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4292 case FIX_TRUNC_EXPR
:
4293 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4296 case POINTER_PLUS_EXPR
:
4297 /* For the rare target where pointers are not the same size as
4298 size_t, we need to check for mis-matched modes and correct
4301 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4302 && GET_MODE (op0
) != GET_MODE (op1
))
4304 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4305 /* If OP0 is a partial mode, then we must truncate, even if it has
4306 the same bitsize as OP1 as GCC's representation of partial modes
4308 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4309 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4310 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4313 /* We always sign-extend, regardless of the signedness of
4314 the operand, because the operand is always unsigned
4315 here even if the original C expression is signed. */
4316 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4321 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4324 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4327 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4330 case TRUNC_DIV_EXPR
:
4331 case EXACT_DIV_EXPR
:
4333 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4335 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4337 case TRUNC_MOD_EXPR
:
4338 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4340 case FLOOR_DIV_EXPR
:
4342 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4345 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4346 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4347 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4348 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4351 case FLOOR_MOD_EXPR
:
4353 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4356 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4357 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4358 adj
= simplify_gen_unary (NEG
, mode
,
4359 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4361 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4367 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4368 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4369 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4370 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4374 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4375 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4376 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4377 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4383 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4384 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4385 adj
= simplify_gen_unary (NEG
, mode
,
4386 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4388 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4392 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4393 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4394 adj
= simplify_gen_unary (NEG
, mode
,
4395 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4397 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4400 case ROUND_DIV_EXPR
:
4403 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4404 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4405 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4406 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4410 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4411 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4412 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4413 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4416 case ROUND_MOD_EXPR
:
4419 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4420 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4421 adj
= simplify_gen_unary (NEG
, mode
,
4422 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4424 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4428 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4429 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4430 adj
= simplify_gen_unary (NEG
, mode
,
4431 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4433 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4437 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4441 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4443 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4446 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4449 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4452 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4455 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4458 case TRUTH_AND_EXPR
:
4459 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4463 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4466 case TRUTH_XOR_EXPR
:
4467 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4469 case TRUTH_ANDIF_EXPR
:
4470 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4472 case TRUTH_ORIF_EXPR
:
4473 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4475 case TRUTH_NOT_EXPR
:
4476 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4479 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4483 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4487 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4491 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4495 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4498 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4500 case UNORDERED_EXPR
:
4501 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4504 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4507 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4510 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4513 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4516 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4519 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4522 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4525 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4528 gcc_assert (COMPLEX_MODE_P (mode
));
4529 if (GET_MODE (op0
) == VOIDmode
)
4530 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4531 if (GET_MODE (op1
) == VOIDmode
)
4532 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4533 return gen_rtx_CONCAT (mode
, op0
, op1
);
4536 if (GET_CODE (op0
) == CONCAT
)
4537 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4538 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4540 GET_MODE_INNER (mode
)));
4543 machine_mode imode
= GET_MODE_INNER (mode
);
4548 re
= adjust_address_nv (op0
, imode
, 0);
4549 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4553 machine_mode ifmode
= int_mode_for_mode (mode
);
4554 machine_mode ihmode
= int_mode_for_mode (imode
);
4556 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4558 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4561 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4562 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4563 if (imode
!= ihmode
)
4564 re
= gen_rtx_SUBREG (imode
, re
, 0);
4565 im
= copy_rtx (op0
);
4567 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4568 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4569 if (imode
!= ihmode
)
4570 im
= gen_rtx_SUBREG (imode
, im
, 0);
4572 im
= gen_rtx_NEG (imode
, im
);
4573 return gen_rtx_CONCAT (mode
, re
, im
);
4577 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4578 if (!op0
|| !MEM_P (op0
))
4580 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4581 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4582 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4583 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4584 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4585 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4587 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4589 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4591 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
4592 &bitoffset
, &bitsize
, &maxsize
);
4593 if ((TREE_CODE (decl
) == VAR_DECL
4594 || TREE_CODE (decl
) == PARM_DECL
4595 || TREE_CODE (decl
) == RESULT_DECL
)
4596 && (!TREE_ADDRESSABLE (decl
)
4597 || target_for_debug_bind (decl
))
4598 && (bitoffset
% BITS_PER_UNIT
) == 0
4600 && bitsize
== maxsize
)
4602 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4603 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4607 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4608 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4611 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4614 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4615 || (GET_CODE (op0
) == PLUS
4616 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4617 && CONST_INT_P (XEXP (op0
, 1)))))
4619 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4621 if (!op1
|| !CONST_INT_P (op1
))
4624 return plus_constant (mode
, op0
, INTVAL (op1
));
4631 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
4632 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4640 op0
= gen_rtx_CONCATN
4641 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4643 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4645 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4648 XVECEXP (op0
, 0, i
) = op1
;
4655 if (TREE_CLOBBER_P (exp
))
4657 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4662 op0
= gen_rtx_CONCATN
4663 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4665 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4667 op1
= expand_debug_expr (val
);
4670 XVECEXP (op0
, 0, i
) = op1
;
4673 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4675 op1
= expand_debug_expr
4676 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4681 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4682 XVECEXP (op0
, 0, i
) = op1
;
4688 goto flag_unsupported
;
4691 /* ??? Maybe handle some builtins? */
4696 gimple g
= get_gimple_for_ssa_name (exp
);
4700 if (deep_ter_debug_map
)
4702 tree
*slot
= deep_ter_debug_map
->get (exp
);
4707 t
= gimple_assign_rhs_to_tree (g
);
4708 op0
= expand_debug_expr (t
);
4714 int part
= var_to_partition (SA
.map
, exp
);
4716 if (part
== NO_PARTITION
)
4718 /* If this is a reference to an incoming value of parameter
4719 that is never used in the code or where the incoming
4720 value is never used in the code, use PARM_DECL's
4722 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
4723 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
4725 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
4728 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
4735 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
4737 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
4745 /* Vector stuff. For most of the codes we don't have rtl codes. */
4746 case REALIGN_LOAD_EXPR
:
4747 case REDUC_MAX_EXPR
:
4748 case REDUC_MIN_EXPR
:
4749 case REDUC_PLUS_EXPR
:
4751 case VEC_PACK_FIX_TRUNC_EXPR
:
4752 case VEC_PACK_SAT_EXPR
:
4753 case VEC_PACK_TRUNC_EXPR
:
4754 case VEC_UNPACK_FLOAT_HI_EXPR
:
4755 case VEC_UNPACK_FLOAT_LO_EXPR
:
4756 case VEC_UNPACK_HI_EXPR
:
4757 case VEC_UNPACK_LO_EXPR
:
4758 case VEC_WIDEN_MULT_HI_EXPR
:
4759 case VEC_WIDEN_MULT_LO_EXPR
:
4760 case VEC_WIDEN_MULT_EVEN_EXPR
:
4761 case VEC_WIDEN_MULT_ODD_EXPR
:
4762 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4763 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4768 case ADDR_SPACE_CONVERT_EXPR
:
4769 case FIXED_CONVERT_EXPR
:
4771 case WITH_SIZE_EXPR
:
4775 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4776 && SCALAR_INT_MODE_P (mode
))
4779 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4781 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4784 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4786 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
4788 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4789 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4793 case WIDEN_MULT_EXPR
:
4794 case WIDEN_MULT_PLUS_EXPR
:
4795 case WIDEN_MULT_MINUS_EXPR
:
4796 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4797 && SCALAR_INT_MODE_P (mode
))
4799 inner_mode
= GET_MODE (op0
);
4800 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4801 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4803 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4804 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
4805 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
4807 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
4808 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4809 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
4811 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
4812 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4814 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
4818 case MULT_HIGHPART_EXPR
:
4819 /* ??? Similar to the above. */
4822 case WIDEN_SUM_EXPR
:
4823 case WIDEN_LSHIFT_EXPR
:
4824 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4825 && SCALAR_INT_MODE_P (mode
))
4828 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4830 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4832 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
4833 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
4838 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
4842 #ifdef ENABLE_CHECKING
4851 /* Return an RTX equivalent to the source bind value of the tree expression
4855 expand_debug_source_expr (tree exp
)
4858 machine_mode mode
= VOIDmode
, inner_mode
;
4860 switch (TREE_CODE (exp
))
4864 mode
= DECL_MODE (exp
);
4865 op0
= expand_debug_parm_decl (exp
);
4868 /* See if this isn't an argument that has been completely
4870 if (!DECL_RTL_SET_P (exp
)
4871 && !DECL_INCOMING_RTL (exp
)
4872 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
4874 tree aexp
= DECL_ORIGIN (exp
);
4875 if (DECL_CONTEXT (aexp
)
4876 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
4878 vec
<tree
, va_gc
> **debug_args
;
4881 debug_args
= decl_debug_args_lookup (current_function_decl
);
4882 if (debug_args
!= NULL
)
4884 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
4887 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
4897 if (op0
== NULL_RTX
)
4900 inner_mode
= GET_MODE (op0
);
4901 if (mode
== inner_mode
)
4904 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4906 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4907 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4908 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4909 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4911 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4913 else if (FLOAT_MODE_P (mode
))
4915 else if (FLOAT_MODE_P (inner_mode
))
4917 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4918 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4920 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4922 else if (CONSTANT_P (op0
)
4923 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
4924 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4925 subreg_lowpart_offset (mode
, inner_mode
));
4926 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4927 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4929 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4934 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
4935 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
4936 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
4939 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
4943 if (exp
== NULL_RTX
)
4946 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
4951 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
4952 rtx dval
= make_debug_expr_from_rtl (exp
);
4954 /* Emit a debug bind insn before INSN. */
4955 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
4956 DEBUG_EXPR_TREE_DECL (dval
), exp
,
4957 VAR_INIT_STATUS_INITIALIZED
);
4959 emit_debug_insn_before (bind
, insn
);
4964 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
4966 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4967 switch (*format_ptr
++)
4970 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
4975 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4976 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
4984 /* Expand the _LOCs in debug insns. We run this after expanding all
4985 regular insns, so that any variables referenced in the function
4986 will have their DECL_RTLs set. */
4989 expand_debug_locations (void)
4992 rtx_insn
*last
= get_last_insn ();
4993 int save_strict_alias
= flag_strict_aliasing
;
4995 /* New alias sets while setting up memory attributes cause
4996 -fcompare-debug failures, even though it doesn't bring about any
4998 flag_strict_aliasing
= 0;
5000 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5001 if (DEBUG_INSN_P (insn
))
5003 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5005 rtx_insn
*prev_insn
, *insn2
;
5008 if (value
== NULL_TREE
)
5012 if (INSN_VAR_LOCATION_STATUS (insn
)
5013 == VAR_INIT_STATUS_UNINITIALIZED
)
5014 val
= expand_debug_source_expr (value
);
5015 /* The avoid_deep_ter_for_debug function inserts
5016 debug bind stmts after SSA_NAME definition, with the
5017 SSA_NAME as the whole bind location. Disable temporarily
5018 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5019 being defined in this DEBUG_INSN. */
5020 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5022 tree
*slot
= deep_ter_debug_map
->get (value
);
5025 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5030 val
= expand_debug_expr (value
);
5032 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5035 val
= expand_debug_expr (value
);
5036 gcc_assert (last
== get_last_insn ());
5040 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5043 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5045 gcc_assert (mode
== GET_MODE (val
)
5046 || (GET_MODE (val
) == VOIDmode
5047 && (CONST_SCALAR_INT_P (val
)
5048 || GET_CODE (val
) == CONST_FIXED
5049 || GET_CODE (val
) == LABEL_REF
)));
5052 INSN_VAR_LOCATION_LOC (insn
) = val
;
5053 prev_insn
= PREV_INSN (insn
);
5054 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5055 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5058 flag_strict_aliasing
= save_strict_alias
;
5061 /* Performs swapping operands of commutative operations to expand
5062 the expensive one first. */
5065 reorder_operands (basic_block bb
)
5067 unsigned int *lattice
; /* Hold cost of each statement. */
5068 unsigned int i
= 0, n
= 0;
5069 gimple_stmt_iterator gsi
;
5075 use_operand_p use_p
;
5078 /* Compute cost of each statement using estimate_num_insns. */
5079 stmts
= bb_seq (bb
);
5080 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5082 stmt
= gsi_stmt (gsi
);
5083 if (!is_gimple_debug (stmt
))
5084 gimple_set_uid (stmt
, n
++);
5086 lattice
= XNEWVEC (unsigned int, n
);
5087 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5090 stmt
= gsi_stmt (gsi
);
5091 if (is_gimple_debug (stmt
))
5093 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5095 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5097 tree use
= USE_FROM_PTR (use_p
);
5099 if (TREE_CODE (use
) != SSA_NAME
)
5101 def_stmt
= get_gimple_for_ssa_name (use
);
5104 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5107 if (!is_gimple_assign (stmt
)
5108 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5110 op0
= gimple_op (stmt
, 1);
5111 op1
= gimple_op (stmt
, 2);
5112 if (TREE_CODE (op0
) != SSA_NAME
5113 || TREE_CODE (op1
) != SSA_NAME
)
5115 /* Swap operands if the second one is more expensive. */
5116 def0
= get_gimple_for_ssa_name (op0
);
5119 def1
= get_gimple_for_ssa_name (op1
);
5123 if (lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5127 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5129 fprintf (dump_file
, "Swap operands in stmt:\n");
5130 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5131 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5132 lattice
[gimple_uid (def0
)],
5133 lattice
[gimple_uid (def1
)]);
5135 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5136 gimple_assign_rhs2_ptr (stmt
));
5142 /* Expand basic block BB from GIMPLE trees to RTL. */
5145 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5147 gimple_stmt_iterator gsi
;
5156 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5159 /* Note that since we are now transitioning from GIMPLE to RTL, we
5160 cannot use the gsi_*_bb() routines because they expect the basic
5161 block to be in GIMPLE, instead of RTL. Therefore, we need to
5162 access the BB sequence directly. */
5164 reorder_operands (bb
);
5165 stmts
= bb_seq (bb
);
5166 bb
->il
.gimple
.seq
= NULL
;
5167 bb
->il
.gimple
.phi_nodes
= NULL
;
5168 rtl_profile_for_bb (bb
);
5169 init_rtl_bb_info (bb
);
5170 bb
->flags
|= BB_RTL
;
5172 /* Remove the RETURN_EXPR if we may fall though to the exit
5174 gsi
= gsi_last (stmts
);
5175 if (!gsi_end_p (gsi
)
5176 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5178 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5180 gcc_assert (single_succ_p (bb
));
5181 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5183 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5184 && !gimple_return_retval (ret_stmt
))
5186 gsi_remove (&gsi
, false);
5187 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5191 gsi
= gsi_start (stmts
);
5192 if (!gsi_end_p (gsi
))
5194 stmt
= gsi_stmt (gsi
);
5195 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5199 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5203 last
= get_last_insn ();
5207 expand_gimple_stmt (stmt
);
5214 /* Java emits line number notes in the top of labels.
5215 ??? Make this go away once line number notes are obsoleted. */
5216 BB_HEAD (bb
) = NEXT_INSN (last
);
5217 if (NOTE_P (BB_HEAD (bb
)))
5218 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5219 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5221 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5224 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5226 NOTE_BASIC_BLOCK (note
) = bb
;
5228 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5232 stmt
= gsi_stmt (gsi
);
5234 /* If this statement is a non-debug one, and we generate debug
5235 insns, then this one might be the last real use of a TERed
5236 SSA_NAME, but where there are still some debug uses further
5237 down. Expanding the current SSA name in such further debug
5238 uses by their RHS might lead to wrong debug info, as coalescing
5239 might make the operands of such RHS be placed into the same
5240 pseudo as something else. Like so:
5241 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5245 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5246 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5247 the write to a_2 would actually have clobbered the place which
5250 So, instead of that, we recognize the situation, and generate
5251 debug temporaries at the last real use of TERed SSA names:
5258 if (MAY_HAVE_DEBUG_INSNS
5260 && !is_gimple_debug (stmt
))
5266 location_t sloc
= curr_insn_location ();
5268 /* Look for SSA names that have their last use here (TERed
5269 names always have only one real use). */
5270 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5271 if ((def
= get_gimple_for_ssa_name (op
)))
5273 imm_use_iterator imm_iter
;
5274 use_operand_p use_p
;
5275 bool have_debug_uses
= false;
5277 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5279 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5281 have_debug_uses
= true;
5286 if (have_debug_uses
)
5288 /* OP is a TERed SSA name, with DEF it's defining
5289 statement, and where OP is used in further debug
5290 instructions. Generate a debug temporary, and
5291 replace all uses of OP in debug insns with that
5294 tree value
= gimple_assign_rhs_to_tree (def
);
5295 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5299 set_curr_insn_location (gimple_location (def
));
5301 DECL_ARTIFICIAL (vexpr
) = 1;
5302 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5304 mode
= DECL_MODE (value
);
5306 mode
= TYPE_MODE (TREE_TYPE (value
));
5307 DECL_MODE (vexpr
) = mode
;
5309 val
= gen_rtx_VAR_LOCATION
5310 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5312 emit_debug_insn (val
);
5314 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5316 if (!gimple_debug_bind_p (debugstmt
))
5319 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5320 SET_USE (use_p
, vexpr
);
5322 update_stmt (debugstmt
);
5326 set_curr_insn_location (sloc
);
5329 currently_expanding_gimple_stmt
= stmt
;
5331 /* Expand this statement, then evaluate the resulting RTL and
5332 fixup the CFG accordingly. */
5333 if (gimple_code (stmt
) == GIMPLE_COND
)
5335 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5339 else if (gimple_debug_bind_p (stmt
))
5341 location_t sloc
= curr_insn_location ();
5342 gimple_stmt_iterator nsi
= gsi
;
5346 tree var
= gimple_debug_bind_get_var (stmt
);
5351 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5352 && TREE_CODE (var
) != LABEL_DECL
5353 && !target_for_debug_bind (var
))
5354 goto delink_debug_stmt
;
5356 if (gimple_debug_bind_has_value_p (stmt
))
5357 value
= gimple_debug_bind_get_value (stmt
);
5361 last
= get_last_insn ();
5363 set_curr_insn_location (gimple_location (stmt
));
5366 mode
= DECL_MODE (var
);
5368 mode
= TYPE_MODE (TREE_TYPE (var
));
5370 val
= gen_rtx_VAR_LOCATION
5371 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5373 emit_debug_insn (val
);
5375 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5377 /* We can't dump the insn with a TREE where an RTX
5379 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5380 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5381 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5385 /* In order not to generate too many debug temporaries,
5386 we delink all uses of debug statements we already expanded.
5387 Therefore debug statements between definition and real
5388 use of TERed SSA names will continue to use the SSA name,
5389 and not be replaced with debug temps. */
5390 delink_stmt_imm_use (stmt
);
5394 if (gsi_end_p (nsi
))
5396 stmt
= gsi_stmt (nsi
);
5397 if (!gimple_debug_bind_p (stmt
))
5401 set_curr_insn_location (sloc
);
5403 else if (gimple_debug_source_bind_p (stmt
))
5405 location_t sloc
= curr_insn_location ();
5406 tree var
= gimple_debug_source_bind_get_var (stmt
);
5407 tree value
= gimple_debug_source_bind_get_value (stmt
);
5411 last
= get_last_insn ();
5413 set_curr_insn_location (gimple_location (stmt
));
5415 mode
= DECL_MODE (var
);
5417 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5418 VAR_INIT_STATUS_UNINITIALIZED
);
5420 emit_debug_insn (val
);
5422 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5424 /* We can't dump the insn with a TREE where an RTX
5426 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5427 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5428 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5431 set_curr_insn_location (sloc
);
5435 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5437 && gimple_call_tail_p (call_stmt
)
5438 && disable_tail_calls
)
5439 gimple_call_set_tail (call_stmt
, false);
5441 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5444 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5455 def_operand_p def_p
;
5456 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5460 /* Ignore this stmt if it is in the list of
5461 replaceable expressions. */
5463 && bitmap_bit_p (SA
.values
,
5464 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5467 last
= expand_gimple_stmt (stmt
);
5468 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5473 currently_expanding_gimple_stmt
= NULL
;
5475 /* Expand implicit goto and convert goto_locus. */
5476 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5478 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5479 set_curr_insn_location (e
->goto_locus
);
5480 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5482 emit_jump (label_rtx_for_bb (e
->dest
));
5483 e
->flags
&= ~EDGE_FALLTHRU
;
5487 /* Expanded RTL can create a jump in the last instruction of block.
5488 This later might be assumed to be a jump to successor and break edge insertion.
5489 We need to insert dummy move to prevent this. PR41440. */
5490 if (single_succ_p (bb
)
5491 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5492 && (last
= get_last_insn ())
5495 rtx dummy
= gen_reg_rtx (SImode
);
5496 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5499 do_pending_stack_adjust ();
5501 /* Find the block tail. The last insn in the block is the insn
5502 before a barrier and/or table jump insn. */
5503 last
= get_last_insn ();
5504 if (BARRIER_P (last
))
5505 last
= PREV_INSN (last
);
5506 if (JUMP_TABLE_DATA_P (last
))
5507 last
= PREV_INSN (PREV_INSN (last
));
5510 update_bb_for_insn (bb
);
5516 /* Create a basic block for initialization code. */
5519 construct_init_block (void)
5521 basic_block init_block
, first_block
;
5525 /* Multiple entry points not supported yet. */
5526 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5527 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5528 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5529 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5530 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5532 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5534 /* When entry edge points to first basic block, we don't need jump,
5535 otherwise we have to jump into proper target. */
5536 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5538 tree label
= gimple_block_label (e
->dest
);
5540 emit_jump (label_rtx (label
));
5544 flags
= EDGE_FALLTHRU
;
5546 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5548 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5549 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5550 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5551 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5554 first_block
= e
->dest
;
5555 redirect_edge_succ (e
, init_block
);
5556 e
= make_edge (init_block
, first_block
, flags
);
5559 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5560 e
->probability
= REG_BR_PROB_BASE
;
5561 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5563 update_bb_for_insn (init_block
);
5567 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5568 found in the block tree. */
5571 set_block_levels (tree block
, int level
)
5575 BLOCK_NUMBER (block
) = level
;
5576 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5577 block
= BLOCK_CHAIN (block
);
5581 /* Create a block containing landing pads and similar stuff. */
5584 construct_exit_block (void)
5586 rtx_insn
*head
= get_last_insn ();
5588 basic_block exit_block
;
5592 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5593 rtx_insn
*orig_end
= BB_END (prev_bb
);
5595 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5597 /* Make sure the locus is set to the end of the function, so that
5598 epilogue line numbers and warnings are set properly. */
5599 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5600 input_location
= cfun
->function_end_locus
;
5602 /* Generate rtl for function exit. */
5603 expand_function_end ();
5605 end
= get_last_insn ();
5608 /* While emitting the function end we could move end of the last basic
5610 BB_END (prev_bb
) = orig_end
;
5611 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5612 head
= NEXT_INSN (head
);
5613 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5614 bb frequency counting will be confused. Any instructions before that
5615 label are emitted for the case where PREV_BB falls through into the
5616 exit block, so append those instructions to prev_bb in that case. */
5617 if (NEXT_INSN (head
) != return_label
)
5619 while (NEXT_INSN (head
) != return_label
)
5621 if (!NOTE_P (NEXT_INSN (head
)))
5622 BB_END (prev_bb
) = NEXT_INSN (head
);
5623 head
= NEXT_INSN (head
);
5626 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5627 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5628 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5629 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5632 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5634 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5635 if (!(e
->flags
& EDGE_ABNORMAL
))
5636 redirect_edge_succ (e
, exit_block
);
5641 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5642 e
->probability
= REG_BR_PROB_BASE
;
5643 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5644 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5647 e
->count
-= e2
->count
;
5648 exit_block
->count
-= e2
->count
;
5649 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5653 if (exit_block
->count
< 0)
5654 exit_block
->count
= 0;
5655 if (exit_block
->frequency
< 0)
5656 exit_block
->frequency
= 0;
5657 update_bb_for_insn (exit_block
);
5660 /* Helper function for discover_nonconstant_array_refs.
5661 Look for ARRAY_REF nodes with non-constant indexes and mark them
5665 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5666 void *data ATTRIBUTE_UNUSED
)
5670 if (IS_TYPE_OR_DECL_P (t
))
5672 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5674 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5675 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5676 && (!TREE_OPERAND (t
, 2)
5677 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5678 || (TREE_CODE (t
) == COMPONENT_REF
5679 && (!TREE_OPERAND (t
,2)
5680 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5681 || TREE_CODE (t
) == BIT_FIELD_REF
5682 || TREE_CODE (t
) == REALPART_EXPR
5683 || TREE_CODE (t
) == IMAGPART_EXPR
5684 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5685 || CONVERT_EXPR_P (t
))
5686 t
= TREE_OPERAND (t
, 0);
5688 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5690 t
= get_base_address (t
);
5692 && DECL_MODE (t
) != BLKmode
)
5693 TREE_ADDRESSABLE (t
) = 1;
5702 /* RTL expansion is not able to compile array references with variable
5703 offsets for arrays stored in single register. Discover such
5704 expressions and mark variables as addressable to avoid this
5708 discover_nonconstant_array_refs (void)
5711 gimple_stmt_iterator gsi
;
5713 FOR_EACH_BB_FN (bb
, cfun
)
5714 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5716 gimple stmt
= gsi_stmt (gsi
);
5717 if (!is_gimple_debug (stmt
))
5718 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
5722 /* This function sets crtl->args.internal_arg_pointer to a virtual
5723 register if DRAP is needed. Local register allocator will replace
5724 virtual_incoming_args_rtx with the virtual register. */
5727 expand_stack_alignment (void)
5730 unsigned int preferred_stack_boundary
;
5732 if (! SUPPORTS_STACK_ALIGNMENT
)
5735 if (cfun
->calls_alloca
5736 || cfun
->has_nonlocal_label
5737 || crtl
->has_nonlocal_goto
)
5738 crtl
->need_drap
= true;
5740 /* Call update_stack_boundary here again to update incoming stack
5741 boundary. It may set incoming stack alignment to a different
5742 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
5743 use the minimum incoming stack alignment to check if it is OK
5744 to perform sibcall optimization since sibcall optimization will
5745 only align the outgoing stack to incoming stack boundary. */
5746 if (targetm
.calls
.update_stack_boundary
)
5747 targetm
.calls
.update_stack_boundary ();
5749 /* The incoming stack frame has to be aligned at least at
5750 parm_stack_boundary. */
5751 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
5753 /* Update crtl->stack_alignment_estimated and use it later to align
5754 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
5755 exceptions since callgraph doesn't collect incoming stack alignment
5757 if (cfun
->can_throw_non_call_exceptions
5758 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
5759 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
5761 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
5762 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
5763 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
5764 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
5765 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
5767 gcc_assert (crtl
->stack_alignment_needed
5768 <= crtl
->stack_alignment_estimated
);
5770 crtl
->stack_realign_needed
5771 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
5772 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
5774 crtl
->stack_realign_processed
= true;
5776 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
5778 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
5779 drap_rtx
= targetm
.calls
.get_drap_rtx ();
5781 /* stack_realign_drap and drap_rtx must match. */
5782 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
5784 /* Do nothing if NULL is returned, which means DRAP is not needed. */
5785 if (NULL
!= drap_rtx
)
5787 crtl
->args
.internal_arg_pointer
= drap_rtx
;
5789 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
5791 fixup_tail_calls ();
5797 expand_main_function (void)
5799 #if (defined(INVOKE__main) \
5800 || (!defined(HAS_INIT_SECTION) \
5801 && !defined(INIT_SECTION_ASM_OP) \
5802 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
5803 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
5808 /* Expand code to initialize the stack_protect_guard. This is invoked at
5809 the beginning of a function to be protected. */
5811 #ifndef HAVE_stack_protect_set
5812 # define HAVE_stack_protect_set 0
5813 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
5817 stack_protect_prologue (void)
5819 tree guard_decl
= targetm
.stack_protect_guard ();
5822 x
= expand_normal (crtl
->stack_protect_guard
);
5823 y
= expand_normal (guard_decl
);
5825 /* Allow the target to copy from Y to X without leaking Y into a
5827 if (HAVE_stack_protect_set
)
5829 rtx insn
= gen_stack_protect_set (x
, y
);
5837 /* Otherwise do a straight move. */
5838 emit_move_insn (x
, y
);
5841 /* Translate the intermediate representation contained in the CFG
5842 from GIMPLE trees to RTL.
5844 We do conversion per basic block and preserve/update the tree CFG.
5845 This implies we have to do some magic as the CFG can simultaneously
5846 consist of basic blocks containing RTL and GIMPLE trees. This can
5847 confuse the CFG hooks, so be careful to not manipulate CFG during
5852 const pass_data pass_data_expand
=
5854 RTL_PASS
, /* type */
5855 "expand", /* name */
5856 OPTGROUP_NONE
, /* optinfo_flags */
5857 TV_EXPAND
, /* tv_id */
5858 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
5860 | PROP_gimple_lvec
), /* properties_required */
5861 PROP_rtl
, /* properties_provided */
5862 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
5863 0, /* todo_flags_start */
5864 0, /* todo_flags_finish */
5867 class pass_expand
: public rtl_opt_pass
5870 pass_expand (gcc::context
*ctxt
)
5871 : rtl_opt_pass (pass_data_expand
, ctxt
)
5874 /* opt_pass methods: */
5875 virtual unsigned int execute (function
*);
5877 }; // class pass_expand
5880 pass_expand::execute (function
*fun
)
5882 basic_block bb
, init_block
;
5886 rtx_insn
*var_seq
, *var_ret_seq
;
5889 timevar_push (TV_OUT_OF_SSA
);
5890 rewrite_out_of_ssa (&SA
);
5891 timevar_pop (TV_OUT_OF_SSA
);
5892 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
5894 if (MAY_HAVE_DEBUG_STMTS
&& flag_tree_ter
)
5896 gimple_stmt_iterator gsi
;
5897 FOR_EACH_BB_FN (bb
, cfun
)
5898 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5899 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
5900 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
5903 /* Make sure all values used by the optimization passes have sane
5907 /* Some backends want to know that we are expanding to RTL. */
5908 currently_expanding_to_rtl
= 1;
5909 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
5910 free_dominance_info (CDI_DOMINATORS
);
5912 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
5914 if (chkp_function_instrumented_p (current_function_decl
))
5915 chkp_reset_rtl_bounds ();
5917 insn_locations_init ();
5918 if (!DECL_IS_BUILTIN (current_function_decl
))
5920 /* Eventually, all FEs should explicitly set function_start_locus. */
5921 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
5922 set_curr_insn_location
5923 (DECL_SOURCE_LOCATION (current_function_decl
));
5925 set_curr_insn_location (fun
->function_start_locus
);
5928 set_curr_insn_location (UNKNOWN_LOCATION
);
5929 prologue_location
= curr_insn_location ();
5931 #ifdef INSN_SCHEDULING
5932 init_sched_attrs ();
5935 /* Make sure first insn is a note even if we don't want linenums.
5936 This makes sure the first insn will never be deleted.
5937 Also, final expects a note to appear there. */
5938 emit_note (NOTE_INSN_DELETED
);
5940 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
5941 discover_nonconstant_array_refs ();
5943 targetm
.expand_to_rtl_hook ();
5944 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
5945 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
5946 crtl
->stack_alignment_estimated
= 0;
5947 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
5948 fun
->cfg
->max_jumptable_ents
= 0;
5950 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
5951 of the function section at exapnsion time to predict distance of calls. */
5952 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
5954 /* Expand the variables recorded during gimple lowering. */
5955 timevar_push (TV_VAR_EXPAND
);
5958 var_ret_seq
= expand_used_vars ();
5960 var_seq
= get_insns ();
5962 timevar_pop (TV_VAR_EXPAND
);
5964 /* Honor stack protection warnings. */
5965 if (warn_stack_protect
)
5967 if (fun
->calls_alloca
)
5968 warning (OPT_Wstack_protector
,
5969 "stack protector not protecting local variables: "
5970 "variable length buffer");
5971 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
5972 warning (OPT_Wstack_protector
,
5973 "stack protector not protecting function: "
5974 "all local arrays are less than %d bytes long",
5975 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
5978 /* Set up parameters and prepare for return, for the function. */
5979 expand_function_start (current_function_decl
);
5981 /* If we emitted any instructions for setting up the variables,
5982 emit them before the FUNCTION_START note. */
5985 emit_insn_before (var_seq
, parm_birth_insn
);
5987 /* In expand_function_end we'll insert the alloca save/restore
5988 before parm_birth_insn. We've just insertted an alloca call.
5989 Adjust the pointer to match. */
5990 parm_birth_insn
= var_seq
;
5993 /* Now that we also have the parameter RTXs, copy them over to our
5995 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
5997 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
5999 if (TREE_CODE (var
) != VAR_DECL
6000 && !SA
.partition_to_pseudo
[i
])
6001 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
6002 gcc_assert (SA
.partition_to_pseudo
[i
]);
6004 /* If this decl was marked as living in multiple places, reset
6005 this now to NULL. */
6006 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
6007 SET_DECL_RTL (var
, NULL
);
6009 /* Some RTL parts really want to look at DECL_RTL(x) when x
6010 was a decl marked in REG_ATTR or MEM_ATTR. We could use
6011 SET_DECL_RTL here making this available, but that would mean
6012 to select one of the potentially many RTLs for one DECL. Instead
6013 of doing that we simply reset the MEM_EXPR of the RTL in question,
6014 then nobody can get at it and hence nobody can call DECL_RTL on it. */
6015 if (!DECL_RTL_SET_P (var
))
6017 if (MEM_P (SA
.partition_to_pseudo
[i
]))
6018 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
6022 /* If we have a class containing differently aligned pointers
6023 we need to merge those into the corresponding RTL pointer
6025 for (i
= 1; i
< num_ssa_names
; i
++)
6027 tree name
= ssa_name (i
);
6032 /* We might have generated new SSA names in
6033 update_alias_info_with_stack_vars. They will have a NULL
6034 defining statements, and won't be part of the partitioning,
6036 || !SSA_NAME_DEF_STMT (name
))
6038 part
= var_to_partition (SA
.map
, name
);
6039 if (part
== NO_PARTITION
)
6042 /* Adjust all partition members to get the underlying decl of
6043 the representative which we might have created in expand_one_var. */
6044 if (SSA_NAME_VAR (name
) == NULL_TREE
)
6046 tree leader
= partition_to_var (SA
.map
, part
);
6047 gcc_assert (SSA_NAME_VAR (leader
) != NULL_TREE
);
6048 replace_ssa_name_symbol (name
, SSA_NAME_VAR (leader
));
6050 if (!POINTER_TYPE_P (TREE_TYPE (name
)))
6053 r
= SA
.partition_to_pseudo
[part
];
6055 mark_reg_pointer (r
, get_pointer_alignment (name
));
6058 /* If this function is `main', emit a call to `__main'
6059 to run global initializers, etc. */
6060 if (DECL_NAME (current_function_decl
)
6061 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6062 && DECL_FILE_SCOPE_P (current_function_decl
))
6063 expand_main_function ();
6065 /* Initialize the stack_protect_guard field. This must happen after the
6066 call to __main (if any) so that the external decl is initialized. */
6067 if (crtl
->stack_protect_guard
)
6068 stack_protect_prologue ();
6070 expand_phi_nodes (&SA
);
6072 /* Register rtl specific functions for cfg. */
6073 rtl_register_cfg_hooks ();
6075 init_block
= construct_init_block ();
6077 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6078 remaining edges later. */
6079 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6080 e
->flags
&= ~EDGE_EXECUTABLE
;
6082 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6083 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6085 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6087 if (MAY_HAVE_DEBUG_INSNS
)
6088 expand_debug_locations ();
6090 if (deep_ter_debug_map
)
6092 delete deep_ter_debug_map
;
6093 deep_ter_debug_map
= NULL
;
6096 /* Free stuff we no longer need after GIMPLE optimizations. */
6097 free_dominance_info (CDI_DOMINATORS
);
6098 free_dominance_info (CDI_POST_DOMINATORS
);
6099 delete_tree_cfg_annotations ();
6101 timevar_push (TV_OUT_OF_SSA
);
6102 finish_out_of_ssa (&SA
);
6103 timevar_pop (TV_OUT_OF_SSA
);
6105 timevar_push (TV_POST_EXPAND
);
6106 /* We are no longer in SSA form. */
6107 fun
->gimple_df
->in_ssa_p
= false;
6108 loops_state_clear (LOOP_CLOSED_SSA
);
6110 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6111 conservatively to true until they are all profile aware. */
6112 delete lab_rtx_for_bb
;
6115 construct_exit_block ();
6116 insn_locations_finalize ();
6120 rtx_insn
*after
= return_label
;
6121 rtx_insn
*next
= NEXT_INSN (after
);
6122 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6124 emit_insn_after (var_ret_seq
, after
);
6127 /* Zap the tree EH table. */
6128 set_eh_throw_stmt_table (fun
, NULL
);
6130 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6131 split edges which edge insertions might do. */
6132 rebuild_jump_labels (get_insns ());
6134 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
6135 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6139 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6143 rebuild_jump_labels_chain (e
->insns
.r
);
6144 /* Put insns after parm birth, but before
6145 NOTE_INSNS_FUNCTION_BEG. */
6146 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
6147 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6149 rtx_insn
*insns
= e
->insns
.r
;
6151 if (NOTE_P (parm_birth_insn
)
6152 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6153 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6155 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6158 commit_one_edge_insertion (e
);
6165 /* We're done expanding trees to RTL. */
6166 currently_expanding_to_rtl
= 0;
6168 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6169 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6173 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6175 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6176 e
->flags
&= ~EDGE_EXECUTABLE
;
6178 /* At the moment not all abnormal edges match the RTL
6179 representation. It is safe to remove them here as
6180 find_many_sub_basic_blocks will rediscover them.
6181 In the future we should get this fixed properly. */
6182 if ((e
->flags
& EDGE_ABNORMAL
)
6183 && !(e
->flags
& EDGE_SIBCALL
))
6190 blocks
= sbitmap_alloc (last_basic_block_for_fn (fun
));
6191 bitmap_ones (blocks
);
6192 find_many_sub_basic_blocks (blocks
);
6193 sbitmap_free (blocks
);
6194 purge_all_dead_edges ();
6196 expand_stack_alignment ();
6198 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6200 if (crtl
->tail_call_emit
)
6201 fixup_tail_calls ();
6203 /* After initial rtl generation, call back to finish generating
6204 exception support code. We need to do this before cleaning up
6205 the CFG as the code does not expect dead landing pads. */
6206 if (fun
->eh
->region_tree
!= NULL
)
6207 finish_eh_generation ();
6209 /* Remove unreachable blocks, otherwise we cannot compute dominators
6210 which are needed for loop state verification. As a side-effect
6211 this also compacts blocks.
6212 ??? We cannot remove trivially dead insns here as for example
6213 the DRAP reg on i?86 is not magically live at this point.
6214 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6215 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6217 #ifdef ENABLE_CHECKING
6218 verify_flow_info ();
6221 /* Initialize pseudos allocated for hard registers. */
6222 emit_initial_value_sets ();
6224 /* And finally unshare all RTL. */
6227 /* There's no need to defer outputting this function any more; we
6228 know we want to output it. */
6229 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6231 /* Now that we're done expanding trees to RTL, we shouldn't have any
6232 more CONCATs anywhere. */
6233 generating_concat_p
= 0;
6238 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6239 /* And the pass manager will dump RTL for us. */
6242 /* If we're emitting a nested function, make sure its parent gets
6243 emitted as well. Doing otherwise confuses debug info. */
6246 for (parent
= DECL_CONTEXT (current_function_decl
);
6247 parent
!= NULL_TREE
;
6248 parent
= get_containing_scope (parent
))
6249 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6250 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6253 /* We are now committed to emitting code for this function. Do any
6254 preparation, such as emitting abstract debug info for the inline
6255 before it gets mangled by optimization. */
6256 if (cgraph_function_possibly_inlined_p (current_function_decl
))
6257 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
6259 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6261 /* After expanding, the return labels are no longer needed. */
6262 return_label
= NULL
;
6263 naked_return_label
= NULL
;
6265 /* After expanding, the tm_restart map is no longer needed. */
6266 if (fun
->gimple_df
->tm_restart
)
6267 fun
->gimple_df
->tm_restart
= NULL
;
6269 /* Tag the blocks with a depth number so that change_scope can find
6270 the common parent easily. */
6271 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6272 default_rtl_profile ();
6274 timevar_pop (TV_POST_EXPAND
);
6282 make_pass_expand (gcc::context
*ctxt
)
6284 return new pass_expand (ctxt
);