1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "basic-block.h"
31 #include "langhooks.h"
32 #include "tree-flow.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
38 #include "diagnostic.h"
39 #include "tree-pretty-print.h"
40 #include "gimple-pretty-print.h"
44 #include "tree-inline.h"
45 #include "value-prof.h"
47 #include "ssaexpand.h"
51 #include "regs.h" /* For reg_renumber. */
52 #include "integrate.h" /* For emit_initial_value_sets. */
53 #include "insn-attr.h" /* For INSN_SCHEDULING. */
55 /* This variable holds information helping the rewriting of SSA trees
59 /* This variable holds the currently expanded gimple statement for purposes
60 of comminucating the profile info to the builtin expanders. */
61 gimple currently_expanding_gimple_stmt
;
63 static rtx
expand_debug_expr (tree
);
65 /* Return an expression tree corresponding to the RHS of GIMPLE
69 gimple_assign_rhs_to_tree (gimple stmt
)
72 enum gimple_rhs_class grhs_class
;
74 grhs_class
= get_gimple_rhs_class (gimple_expr_code (stmt
));
76 if (grhs_class
== GIMPLE_TERNARY_RHS
)
77 t
= build3 (gimple_assign_rhs_code (stmt
),
78 TREE_TYPE (gimple_assign_lhs (stmt
)),
79 gimple_assign_rhs1 (stmt
),
80 gimple_assign_rhs2 (stmt
),
81 gimple_assign_rhs3 (stmt
));
82 else if (grhs_class
== GIMPLE_BINARY_RHS
)
83 t
= build2 (gimple_assign_rhs_code (stmt
),
84 TREE_TYPE (gimple_assign_lhs (stmt
)),
85 gimple_assign_rhs1 (stmt
),
86 gimple_assign_rhs2 (stmt
));
87 else if (grhs_class
== GIMPLE_UNARY_RHS
)
88 t
= build1 (gimple_assign_rhs_code (stmt
),
89 TREE_TYPE (gimple_assign_lhs (stmt
)),
90 gimple_assign_rhs1 (stmt
));
91 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
93 t
= gimple_assign_rhs1 (stmt
);
94 /* Avoid modifying this tree in place below. */
95 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
96 && gimple_location (stmt
) != EXPR_LOCATION (t
))
97 || (gimple_block (stmt
)
98 && currently_expanding_to_rtl
100 && gimple_block (stmt
) != TREE_BLOCK (t
)))
106 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
107 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
108 if (gimple_block (stmt
) && currently_expanding_to_rtl
&& EXPR_P (t
))
109 TREE_BLOCK (t
) = gimple_block (stmt
);
115 #ifndef STACK_ALIGNMENT_NEEDED
116 #define STACK_ALIGNMENT_NEEDED 1
119 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
121 /* Associate declaration T with storage space X. If T is no
122 SSA name this is exactly SET_DECL_RTL, otherwise make the
123 partition of T associated with X. */
125 set_rtl (tree t
, rtx x
)
127 if (TREE_CODE (t
) == SSA_NAME
)
129 SA
.partition_to_pseudo
[var_to_partition (SA
.map
, t
)] = x
;
131 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t
), x
);
132 /* For the benefit of debug information at -O0 (where vartracking
133 doesn't run) record the place also in the base DECL if it's
134 a normal variable (not a parameter). */
135 if (x
&& x
!= pc_rtx
&& TREE_CODE (SSA_NAME_VAR (t
)) == VAR_DECL
)
137 tree var
= SSA_NAME_VAR (t
);
138 /* If we don't yet have something recorded, just record it now. */
139 if (!DECL_RTL_SET_P (var
))
140 SET_DECL_RTL (var
, x
);
141 /* If we have it set already to "multiple places" don't
143 else if (DECL_RTL (var
) == pc_rtx
)
145 /* If we have something recorded and it's not the same place
146 as we want to record now, we have multiple partitions for the
147 same base variable, with different places. We can't just
148 randomly chose one, hence we have to say that we don't know.
149 This only happens with optimization, and there var-tracking
150 will figure out the right thing. */
151 else if (DECL_RTL (var
) != x
)
152 SET_DECL_RTL (var
, pc_rtx
);
159 /* This structure holds data relevant to one variable that will be
160 placed in a stack slot. */
166 /* Initially, the size of the variable. Later, the size of the partition,
167 if this variable becomes it's partition's representative. */
170 /* The *byte* alignment required for this variable. Or as, with the
171 size, the alignment for this partition. */
174 /* The partition representative. */
175 size_t representative
;
177 /* The next stack variable in the partition, or EOC. */
180 /* The numbers of conflicting stack variables. */
184 #define EOC ((size_t)-1)
186 /* We have an array of such objects while deciding allocation. */
187 static struct stack_var
*stack_vars
;
188 static size_t stack_vars_alloc
;
189 static size_t stack_vars_num
;
190 static struct pointer_map_t
*decl_to_stack_part
;
192 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
193 is non-decreasing. */
194 static size_t *stack_vars_sorted
;
196 /* The phase of the stack frame. This is the known misalignment of
197 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
198 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
199 static int frame_phase
;
201 /* Used during expand_used_vars to remember if we saw any decls for
202 which we'd like to enable stack smashing protection. */
203 static bool has_protected_decls
;
205 /* Used during expand_used_vars. Remember if we say a character buffer
206 smaller than our cutoff threshold. Used for -Wstack-protector. */
207 static bool has_short_buffer
;
209 /* Compute the byte alignment to use for DECL. Ignore alignment
210 we can't do with expected alignment of the stack boundary. */
213 align_local_variable (tree decl
)
215 unsigned int align
= LOCAL_DECL_ALIGNMENT (decl
);
216 DECL_ALIGN (decl
) = align
;
217 return align
/ BITS_PER_UNIT
;
220 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
221 Return the frame offset. */
224 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
226 HOST_WIDE_INT offset
, new_frame_offset
;
228 new_frame_offset
= frame_offset
;
229 if (FRAME_GROWS_DOWNWARD
)
231 new_frame_offset
-= size
+ frame_phase
;
232 new_frame_offset
&= -align
;
233 new_frame_offset
+= frame_phase
;
234 offset
= new_frame_offset
;
238 new_frame_offset
-= frame_phase
;
239 new_frame_offset
+= align
- 1;
240 new_frame_offset
&= -align
;
241 new_frame_offset
+= frame_phase
;
242 offset
= new_frame_offset
;
243 new_frame_offset
+= size
;
245 frame_offset
= new_frame_offset
;
247 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
248 frame_offset
= offset
= 0;
253 /* Accumulate DECL into STACK_VARS. */
256 add_stack_var (tree decl
)
260 if (stack_vars_num
>= stack_vars_alloc
)
262 if (stack_vars_alloc
)
263 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
265 stack_vars_alloc
= 32;
267 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
269 if (!decl_to_stack_part
)
270 decl_to_stack_part
= pointer_map_create ();
272 v
= &stack_vars
[stack_vars_num
];
273 * (size_t *)pointer_map_insert (decl_to_stack_part
, decl
) = stack_vars_num
;
276 v
->size
= tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl
)), 1);
277 /* Ensure that all variables have size, so that &a != &b for any two
278 variables that are simultaneously live. */
281 v
->alignb
= align_local_variable (SSAVAR (decl
));
282 /* An alignment of zero can mightily confuse us later. */
283 gcc_assert (v
->alignb
!= 0);
285 /* All variables are initially in their own partition. */
286 v
->representative
= stack_vars_num
;
289 /* All variables initially conflict with no other. */
292 /* Ensure that this decl doesn't get put onto the list twice. */
293 set_rtl (decl
, pc_rtx
);
298 /* Make the decls associated with luid's X and Y conflict. */
301 add_stack_var_conflict (size_t x
, size_t y
)
303 struct stack_var
*a
= &stack_vars
[x
];
304 struct stack_var
*b
= &stack_vars
[y
];
306 a
->conflicts
= BITMAP_ALLOC (NULL
);
308 b
->conflicts
= BITMAP_ALLOC (NULL
);
309 bitmap_set_bit (a
->conflicts
, y
);
310 bitmap_set_bit (b
->conflicts
, x
);
313 /* Check whether the decls associated with luid's X and Y conflict. */
316 stack_var_conflict_p (size_t x
, size_t y
)
318 struct stack_var
*a
= &stack_vars
[x
];
319 struct stack_var
*b
= &stack_vars
[y
];
322 /* Partitions containing an SSA name result from gimple registers
323 with things like unsupported modes. They are top-level and
324 hence conflict with everything else. */
325 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
328 if (!a
->conflicts
|| !b
->conflicts
)
330 return bitmap_bit_p (a
->conflicts
, y
);
333 /* Returns true if TYPE is or contains a union type. */
336 aggregate_contains_union_type (tree type
)
340 if (TREE_CODE (type
) == UNION_TYPE
341 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
343 if (TREE_CODE (type
) == ARRAY_TYPE
)
344 return aggregate_contains_union_type (TREE_TYPE (type
));
345 if (TREE_CODE (type
) != RECORD_TYPE
)
348 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
349 if (TREE_CODE (field
) == FIELD_DECL
)
350 if (aggregate_contains_union_type (TREE_TYPE (field
)))
356 /* A subroutine of expand_used_vars. If two variables X and Y have alias
357 sets that do not conflict, then do add a conflict for these variables
358 in the interference graph. We also need to make sure to add conflicts
359 for union containing structures. Else RTL alias analysis comes along
360 and due to type based aliasing rules decides that for two overlapping
361 union temporaries { short s; int i; } accesses to the same mem through
362 different types may not alias and happily reorders stores across
363 life-time boundaries of the temporaries (See PR25654). */
366 add_alias_set_conflicts (void)
368 size_t i
, j
, n
= stack_vars_num
;
370 for (i
= 0; i
< n
; ++i
)
372 tree type_i
= TREE_TYPE (stack_vars
[i
].decl
);
373 bool aggr_i
= AGGREGATE_TYPE_P (type_i
);
376 contains_union
= aggregate_contains_union_type (type_i
);
377 for (j
= 0; j
< i
; ++j
)
379 tree type_j
= TREE_TYPE (stack_vars
[j
].decl
);
380 bool aggr_j
= AGGREGATE_TYPE_P (type_j
);
382 /* Either the objects conflict by means of type based
383 aliasing rules, or we need to add a conflict. */
384 || !objects_must_conflict_p (type_i
, type_j
)
385 /* In case the types do not conflict ensure that access
386 to elements will conflict. In case of unions we have
387 to be careful as type based aliasing rules may say
388 access to the same memory does not conflict. So play
389 safe and add a conflict in this case when
390 -fstrict-aliasing is used. */
391 || (contains_union
&& flag_strict_aliasing
))
392 add_stack_var_conflict (i
, j
);
397 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
398 enter its partition number into bitmap DATA. */
401 visit_op (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
403 bitmap active
= (bitmap
)data
;
404 op
= get_base_address (op
);
407 && DECL_RTL_IF_SET (op
) == pc_rtx
)
409 size_t *v
= (size_t *) pointer_map_contains (decl_to_stack_part
, op
);
411 bitmap_set_bit (active
, *v
);
416 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
417 record conflicts between it and all currently active other partitions
421 visit_conflict (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
423 bitmap active
= (bitmap
)data
;
424 op
= get_base_address (op
);
427 && DECL_RTL_IF_SET (op
) == pc_rtx
)
430 (size_t *) pointer_map_contains (decl_to_stack_part
, 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 bool (*visit
)(gimple
, tree
, void *);
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
482 pointer_map_contains (decl_to_stack_part
, lhs
)))
483 bitmap_clear_bit (work
, *v
);
485 else if (!is_gimple_debug (stmt
))
488 && visit
== visit_op
)
490 /* If this is the first real instruction in this BB we need
491 to add conflicts for everything live at this point now.
492 Unlike classical liveness for named objects we can't
493 rely on seeing a def/use of the names we're interested in.
494 There might merely be indirect loads/stores. We'd not add any
495 conflicts for such partitions. */
498 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
502 EXECUTE_IF_SET_IN_BITMAP (work
, i
+ 1, j
, bj
)
503 add_stack_var_conflict (i
, j
);
505 visit
= visit_conflict
;
507 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
512 /* Generate stack partition conflicts between all partitions that are
513 simultaneously live. */
516 add_scope_conflicts (void)
520 bitmap work
= BITMAP_ALLOC (NULL
);
522 /* We approximate the live range of a stack variable by taking the first
523 mention of its name as starting point(s), and by the end-of-scope
524 death clobber added by gimplify as ending point(s) of the range.
525 This overapproximates in the case we for instance moved an address-taken
526 operation upward, without also moving a dereference to it upwards.
527 But it's conservatively correct as a variable never can hold values
528 before its name is mentioned at least once.
530 We then do a mostly classical bitmap liveness algorithm. */
533 bb
->aux
= BITMAP_ALLOC (NULL
);
541 bitmap active
= (bitmap
)bb
->aux
;
542 add_scope_conflicts_1 (bb
, work
, false);
543 if (bitmap_ior_into (active
, work
))
549 add_scope_conflicts_1 (bb
, work
, true);
553 BITMAP_FREE (bb
->aux
);
556 /* A subroutine of partition_stack_vars. A comparison function for qsort,
557 sorting an array of indices by the properties of the object. */
560 stack_var_cmp (const void *a
, const void *b
)
562 size_t ia
= *(const size_t *)a
;
563 size_t ib
= *(const size_t *)b
;
564 unsigned int aligna
= stack_vars
[ia
].alignb
;
565 unsigned int alignb
= stack_vars
[ib
].alignb
;
566 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
567 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
568 tree decla
= stack_vars
[ia
].decl
;
569 tree declb
= stack_vars
[ib
].decl
;
571 unsigned int uida
, uidb
;
573 /* Primary compare on "large" alignment. Large comes first. */
574 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
575 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
576 if (largea
!= largeb
)
577 return (int)largeb
- (int)largea
;
579 /* Secondary compare on size, decreasing */
585 /* Tertiary compare on true alignment, decreasing. */
591 /* Final compare on ID for sort stability, increasing.
592 Two SSA names are compared by their version, SSA names come before
593 non-SSA names, and two normal decls are compared by their DECL_UID. */
594 if (TREE_CODE (decla
) == SSA_NAME
)
596 if (TREE_CODE (declb
) == SSA_NAME
)
597 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
601 else if (TREE_CODE (declb
) == SSA_NAME
)
604 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
613 /* If the points-to solution *PI points to variables that are in a partition
614 together with other variables add all partition members to the pointed-to
618 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
619 struct pointer_map_t
*decls_to_partitions
,
620 struct pointer_set_t
*visited
, bitmap temp
)
628 /* The pointed-to vars bitmap is shared, it is enough to
630 || pointer_set_insert(visited
, pt
->vars
))
635 /* By using a temporary bitmap to store all members of the partitions
636 we have to add we make sure to visit each of the partitions only
638 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
640 || !bitmap_bit_p (temp
, i
))
641 && (part
= (bitmap
*) pointer_map_contains (decls_to_partitions
,
642 (void *)(size_t) i
)))
643 bitmap_ior_into (temp
, *part
);
644 if (!bitmap_empty_p (temp
))
645 bitmap_ior_into (pt
->vars
, temp
);
648 /* Update points-to sets based on partition info, so we can use them on RTL.
649 The bitmaps representing stack partitions will be saved until expand,
650 where partitioned decls used as bases in memory expressions will be
654 update_alias_info_with_stack_vars (void)
656 struct pointer_map_t
*decls_to_partitions
= NULL
;
658 tree var
= NULL_TREE
;
660 for (i
= 0; i
< stack_vars_num
; i
++)
664 struct ptr_info_def
*pi
;
666 /* Not interested in partitions with single variable. */
667 if (stack_vars
[i
].representative
!= i
668 || stack_vars
[i
].next
== EOC
)
671 if (!decls_to_partitions
)
673 decls_to_partitions
= pointer_map_create ();
674 cfun
->gimple_df
->decls_to_pointers
= pointer_map_create ();
677 /* Create an SSA_NAME that points to the partition for use
678 as base during alias-oracle queries on RTL for bases that
679 have been partitioned. */
680 if (var
== NULL_TREE
)
681 var
= create_tmp_var (ptr_type_node
, NULL
);
682 name
= make_ssa_name (var
, NULL
);
684 /* Create bitmaps representing partitions. They will be used for
685 points-to sets later, so use GGC alloc. */
686 part
= BITMAP_GGC_ALLOC ();
687 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
689 tree decl
= stack_vars
[j
].decl
;
690 unsigned int uid
= DECL_PT_UID (decl
);
691 /* We should never end up partitioning SSA names (though they
692 may end up on the stack). Neither should we allocate stack
693 space to something that is unused and thus unreferenced, except
694 for -O0 where we are preserving even unreferenced variables. */
695 gcc_assert (DECL_P (decl
)
697 || referenced_var_lookup (cfun
, DECL_UID (decl
))));
698 bitmap_set_bit (part
, uid
);
699 *((bitmap
*) pointer_map_insert (decls_to_partitions
,
700 (void *)(size_t) uid
)) = part
;
701 *((tree
*) pointer_map_insert (cfun
->gimple_df
->decls_to_pointers
,
705 /* Make the SSA name point to all partition members. */
706 pi
= get_ptr_info (name
);
707 pt_solution_set (&pi
->pt
, part
, false);
710 /* Make all points-to sets that contain one member of a partition
711 contain all members of the partition. */
712 if (decls_to_partitions
)
715 struct pointer_set_t
*visited
= pointer_set_create ();
716 bitmap temp
= BITMAP_ALLOC (NULL
);
718 for (i
= 1; i
< num_ssa_names
; i
++)
720 tree name
= ssa_name (i
);
721 struct ptr_info_def
*pi
;
724 && POINTER_TYPE_P (TREE_TYPE (name
))
725 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
726 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
730 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
731 decls_to_partitions
, visited
, temp
);
733 pointer_set_destroy (visited
);
734 pointer_map_destroy (decls_to_partitions
);
739 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
740 partitioning algorithm. Partitions A and B are known to be non-conflicting.
741 Merge them into a single partition A. */
744 union_stack_vars (size_t a
, size_t b
)
746 struct stack_var
*vb
= &stack_vars
[b
];
750 gcc_assert (stack_vars
[b
].next
== EOC
);
751 /* Add B to A's partition. */
752 stack_vars
[b
].next
= stack_vars
[a
].next
;
753 stack_vars
[b
].representative
= a
;
754 stack_vars
[a
].next
= b
;
756 /* Update the required alignment of partition A to account for B. */
757 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
758 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
760 /* Update the interference graph and merge the conflicts. */
763 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
764 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
765 BITMAP_FREE (vb
->conflicts
);
769 /* A subroutine of expand_used_vars. Binpack the variables into
770 partitions constrained by the interference graph. The overall
771 algorithm used is as follows:
773 Sort the objects by size in descending order.
778 Look for the largest non-conflicting object B with size <= S.
785 partition_stack_vars (void)
787 size_t si
, sj
, n
= stack_vars_num
;
789 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
790 for (si
= 0; si
< n
; ++si
)
791 stack_vars_sorted
[si
] = si
;
796 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
798 for (si
= 0; si
< n
; ++si
)
800 size_t i
= stack_vars_sorted
[si
];
801 unsigned int ialign
= stack_vars
[i
].alignb
;
803 /* Ignore objects that aren't partition representatives. If we
804 see a var that is not a partition representative, it must
805 have been merged earlier. */
806 if (stack_vars
[i
].representative
!= i
)
809 for (sj
= si
+ 1; sj
< n
; ++sj
)
811 size_t j
= stack_vars_sorted
[sj
];
812 unsigned int jalign
= stack_vars
[j
].alignb
;
814 /* Ignore objects that aren't partition representatives. */
815 if (stack_vars
[j
].representative
!= j
)
818 /* Ignore conflicting objects. */
819 if (stack_var_conflict_p (i
, j
))
822 /* Do not mix objects of "small" (supported) alignment
823 and "large" (unsupported) alignment. */
824 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
825 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
828 /* UNION the objects, placing J at OFFSET. */
829 union_stack_vars (i
, j
);
833 update_alias_info_with_stack_vars ();
836 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
839 dump_stack_var_partition (void)
841 size_t si
, i
, j
, n
= stack_vars_num
;
843 for (si
= 0; si
< n
; ++si
)
845 i
= stack_vars_sorted
[si
];
847 /* Skip variables that aren't partition representatives, for now. */
848 if (stack_vars
[i
].representative
!= i
)
851 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
852 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
853 stack_vars
[i
].alignb
);
855 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
857 fputc ('\t', dump_file
);
858 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
860 fputc ('\n', dump_file
);
864 /* Assign rtl to DECL at BASE + OFFSET. */
867 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
868 HOST_WIDE_INT offset
)
873 /* If this fails, we've overflowed the stack frame. Error nicely? */
874 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
876 x
= plus_constant (base
, offset
);
877 x
= gen_rtx_MEM (DECL_MODE (SSAVAR (decl
)), x
);
879 if (TREE_CODE (decl
) != SSA_NAME
)
881 /* Set alignment we actually gave this decl if it isn't an SSA name.
882 If it is we generate stack slots only accidentally so it isn't as
883 important, we'll simply use the alignment that is already set. */
884 if (base
== virtual_stack_vars_rtx
)
885 offset
-= frame_phase
;
886 align
= offset
& -offset
;
887 align
*= BITS_PER_UNIT
;
888 if (align
== 0 || align
> base_align
)
891 /* One would think that we could assert that we're not decreasing
892 alignment here, but (at least) the i386 port does exactly this
893 via the MINIMUM_ALIGNMENT hook. */
895 DECL_ALIGN (decl
) = align
;
896 DECL_USER_ALIGN (decl
) = 0;
899 set_mem_attributes (x
, SSAVAR (decl
), true);
903 /* A subroutine of expand_used_vars. Give each partition representative
904 a unique location within the stack frame. Update each partition member
905 with that location. */
908 expand_stack_vars (bool (*pred
) (tree
))
910 size_t si
, i
, j
, n
= stack_vars_num
;
911 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
912 rtx large_base
= NULL
;
913 unsigned large_align
= 0;
916 /* Determine if there are any variables requiring "large" alignment.
917 Since these are dynamically allocated, we only process these if
918 no predicate involved. */
919 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
920 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
922 /* Find the total size of these variables. */
923 for (si
= 0; si
< n
; ++si
)
927 i
= stack_vars_sorted
[si
];
928 alignb
= stack_vars
[i
].alignb
;
930 /* Stop when we get to the first decl with "small" alignment. */
931 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
934 /* Skip variables that aren't partition representatives. */
935 if (stack_vars
[i
].representative
!= i
)
938 /* Skip variables that have already had rtl assigned. See also
939 add_stack_var where we perpetrate this pc_rtx hack. */
940 decl
= stack_vars
[i
].decl
;
941 if ((TREE_CODE (decl
) == SSA_NAME
942 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
943 : DECL_RTL (decl
)) != pc_rtx
)
946 large_size
+= alignb
- 1;
947 large_size
&= -(HOST_WIDE_INT
)alignb
;
948 large_size
+= stack_vars
[i
].size
;
951 /* If there were any, allocate space. */
953 large_base
= allocate_dynamic_stack_space (GEN_INT (large_size
), 0,
957 for (si
= 0; si
< n
; ++si
)
960 unsigned base_align
, alignb
;
961 HOST_WIDE_INT offset
;
963 i
= stack_vars_sorted
[si
];
965 /* Skip variables that aren't partition representatives, for now. */
966 if (stack_vars
[i
].representative
!= i
)
969 /* Skip variables that have already had rtl assigned. See also
970 add_stack_var where we perpetrate this pc_rtx hack. */
971 decl
= stack_vars
[i
].decl
;
972 if ((TREE_CODE (decl
) == SSA_NAME
973 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
974 : DECL_RTL (decl
)) != pc_rtx
)
977 /* Check the predicate to see whether this variable should be
978 allocated in this pass. */
979 if (pred
&& !pred (decl
))
982 alignb
= stack_vars
[i
].alignb
;
983 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
985 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
986 base
= virtual_stack_vars_rtx
;
987 base_align
= crtl
->max_used_stack_slot_alignment
;
991 /* Large alignment is only processed in the last pass. */
994 gcc_assert (large_base
!= NULL
);
996 large_alloc
+= alignb
- 1;
997 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
998 offset
= large_alloc
;
999 large_alloc
+= stack_vars
[i
].size
;
1002 base_align
= large_align
;
1005 /* Create rtl for each variable based on their location within the
1007 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1009 expand_one_stack_var_at (stack_vars
[j
].decl
,
1015 gcc_assert (large_alloc
== large_size
);
1018 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1019 static HOST_WIDE_INT
1020 account_stack_vars (void)
1022 size_t si
, j
, i
, n
= stack_vars_num
;
1023 HOST_WIDE_INT size
= 0;
1025 for (si
= 0; si
< n
; ++si
)
1027 i
= stack_vars_sorted
[si
];
1029 /* Skip variables that aren't partition representatives, for now. */
1030 if (stack_vars
[i
].representative
!= i
)
1033 size
+= stack_vars
[i
].size
;
1034 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1035 set_rtl (stack_vars
[j
].decl
, NULL
);
1040 /* A subroutine of expand_one_var. Called to immediately assign rtl
1041 to a variable to be allocated in the stack frame. */
1044 expand_one_stack_var (tree var
)
1046 HOST_WIDE_INT size
, offset
;
1047 unsigned byte_align
;
1049 size
= tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var
)), 1);
1050 byte_align
= align_local_variable (SSAVAR (var
));
1052 /* We handle highly aligned variables in expand_stack_vars. */
1053 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1055 offset
= alloc_stack_frame_space (size
, byte_align
);
1057 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1058 crtl
->max_used_stack_slot_alignment
, offset
);
1061 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1062 that will reside in a hard register. */
1065 expand_one_hard_reg_var (tree var
)
1067 rest_of_decl_compilation (var
, 0, 0);
1070 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1071 that will reside in a pseudo register. */
1074 expand_one_register_var (tree var
)
1076 tree decl
= SSAVAR (var
);
1077 tree type
= TREE_TYPE (decl
);
1078 enum machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1079 rtx x
= gen_reg_rtx (reg_mode
);
1083 /* Note if the object is a user variable. */
1084 if (!DECL_ARTIFICIAL (decl
))
1087 if (POINTER_TYPE_P (type
))
1088 mark_reg_pointer (x
, get_pointer_alignment (var
));
1091 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1092 has some associated error, e.g. its type is error-mark. We just need
1093 to pick something that won't crash the rest of the compiler. */
1096 expand_one_error_var (tree var
)
1098 enum machine_mode mode
= DECL_MODE (var
);
1101 if (mode
== BLKmode
)
1102 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1103 else if (mode
== VOIDmode
)
1106 x
= gen_reg_rtx (mode
);
1108 SET_DECL_RTL (var
, x
);
1111 /* A subroutine of expand_one_var. VAR is a variable that will be
1112 allocated to the local stack frame. Return true if we wish to
1113 add VAR to STACK_VARS so that it will be coalesced with other
1114 variables. Return false to allocate VAR immediately.
1116 This function is used to reduce the number of variables considered
1117 for coalescing, which reduces the size of the quadratic problem. */
1120 defer_stack_allocation (tree var
, bool toplevel
)
1122 /* If stack protection is enabled, *all* stack variables must be deferred,
1123 so that we can re-order the strings to the top of the frame. */
1124 if (flag_stack_protect
)
1127 /* We handle "large" alignment via dynamic allocation. We want to handle
1128 this extra complication in only one place, so defer them. */
1129 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
1132 /* Variables in the outermost scope automatically conflict with
1133 every other variable. The only reason to want to defer them
1134 at all is that, after sorting, we can more efficiently pack
1135 small variables in the stack frame. Continue to defer at -O2. */
1136 if (toplevel
&& optimize
< 2)
1139 /* Without optimization, *most* variables are allocated from the
1140 stack, which makes the quadratic problem large exactly when we
1141 want compilation to proceed as quickly as possible. On the
1142 other hand, we don't want the function's stack frame size to
1143 get completely out of hand. So we avoid adding scalars and
1144 "small" aggregates to the list at all. */
1145 if (optimize
== 0 && tree_low_cst (DECL_SIZE_UNIT (var
), 1) < 32)
1151 /* A subroutine of expand_used_vars. Expand one variable according to
1152 its flavor. Variables to be placed on the stack are not actually
1153 expanded yet, merely recorded.
1154 When REALLY_EXPAND is false, only add stack values to be allocated.
1155 Return stack usage this variable is supposed to take.
1158 static HOST_WIDE_INT
1159 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1161 unsigned int align
= BITS_PER_UNIT
;
1166 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1168 /* Because we don't know if VAR will be in register or on stack,
1169 we conservatively assume it will be on stack even if VAR is
1170 eventually put into register after RA pass. For non-automatic
1171 variables, which won't be on stack, we collect alignment of
1172 type and ignore user specified alignment. */
1173 if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1174 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1175 TYPE_MODE (TREE_TYPE (var
)),
1176 TYPE_ALIGN (TREE_TYPE (var
)));
1177 else if (DECL_HAS_VALUE_EXPR_P (var
)
1178 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1179 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1180 or variables which were assigned a stack slot already by
1181 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1182 changed from the offset chosen to it. */
1183 align
= crtl
->stack_alignment_estimated
;
1185 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1187 /* If the variable alignment is very large we'll dynamicaly allocate
1188 it, which means that in-frame portion is just a pointer. */
1189 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1190 align
= POINTER_SIZE
;
1193 if (SUPPORTS_STACK_ALIGNMENT
1194 && crtl
->stack_alignment_estimated
< align
)
1196 /* stack_alignment_estimated shouldn't change after stack
1197 realign decision made */
1198 gcc_assert(!crtl
->stack_realign_processed
);
1199 crtl
->stack_alignment_estimated
= align
;
1202 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1203 So here we only make sure stack_alignment_needed >= align. */
1204 if (crtl
->stack_alignment_needed
< align
)
1205 crtl
->stack_alignment_needed
= align
;
1206 if (crtl
->max_used_stack_slot_alignment
< align
)
1207 crtl
->max_used_stack_slot_alignment
= align
;
1209 if (TREE_CODE (origvar
) == SSA_NAME
)
1211 gcc_assert (TREE_CODE (var
) != VAR_DECL
1212 || (!DECL_EXTERNAL (var
)
1213 && !DECL_HAS_VALUE_EXPR_P (var
)
1214 && !TREE_STATIC (var
)
1215 && TREE_TYPE (var
) != error_mark_node
1216 && !DECL_HARD_REGISTER (var
)
1219 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1221 else if (DECL_EXTERNAL (var
))
1223 else if (DECL_HAS_VALUE_EXPR_P (var
))
1225 else if (TREE_STATIC (var
))
1227 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1229 else if (TREE_TYPE (var
) == error_mark_node
)
1232 expand_one_error_var (var
);
1234 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1237 expand_one_hard_reg_var (var
);
1239 else if (use_register_for_decl (var
))
1242 expand_one_register_var (origvar
);
1244 else if (!host_integerp (DECL_SIZE_UNIT (var
), 1))
1248 error ("size of variable %q+D is too large", var
);
1249 expand_one_error_var (var
);
1252 else if (defer_stack_allocation (var
, toplevel
))
1253 add_stack_var (origvar
);
1257 expand_one_stack_var (origvar
);
1258 return tree_low_cst (DECL_SIZE_UNIT (var
), 1);
1263 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1264 expanding variables. Those variables that can be put into registers
1265 are allocated pseudos; those that can't are put on the stack.
1267 TOPLEVEL is true if this is the outermost BLOCK. */
1270 expand_used_vars_for_block (tree block
, bool toplevel
)
1274 /* Expand all variables at this level. */
1275 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1277 && ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1278 || !DECL_NONSHAREABLE (t
)))
1279 expand_one_var (t
, toplevel
, true);
1281 /* Expand all variables at containing levels. */
1282 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1283 expand_used_vars_for_block (t
, false);
1286 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1287 and clear TREE_USED on all local variables. */
1290 clear_tree_used (tree block
)
1294 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1295 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1296 if ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1297 || !DECL_NONSHAREABLE (t
))
1300 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1301 clear_tree_used (t
);
1304 /* Examine TYPE and determine a bit mask of the following features. */
1306 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1307 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1308 #define SPCT_HAS_ARRAY 4
1309 #define SPCT_HAS_AGGREGATE 8
1312 stack_protect_classify_type (tree type
)
1314 unsigned int ret
= 0;
1317 switch (TREE_CODE (type
))
1320 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1321 if (t
== char_type_node
1322 || t
== signed_char_type_node
1323 || t
== unsigned_char_type_node
)
1325 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1326 unsigned HOST_WIDE_INT len
;
1328 if (!TYPE_SIZE_UNIT (type
)
1329 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
1332 len
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
1335 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1337 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1340 ret
= SPCT_HAS_ARRAY
;
1344 case QUAL_UNION_TYPE
:
1346 ret
= SPCT_HAS_AGGREGATE
;
1347 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1348 if (TREE_CODE (t
) == FIELD_DECL
)
1349 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1359 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1360 part of the local stack frame. Remember if we ever return nonzero for
1361 any variable in this function. The return value is the phase number in
1362 which the variable should be allocated. */
1365 stack_protect_decl_phase (tree decl
)
1367 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1370 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1371 has_short_buffer
= true;
1373 if (flag_stack_protect
== 2)
1375 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1376 && !(bits
& SPCT_HAS_AGGREGATE
))
1378 else if (bits
& SPCT_HAS_ARRAY
)
1382 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1385 has_protected_decls
= true;
1390 /* Two helper routines that check for phase 1 and phase 2. These are used
1391 as callbacks for expand_stack_vars. */
1394 stack_protect_decl_phase_1 (tree decl
)
1396 return stack_protect_decl_phase (decl
) == 1;
1400 stack_protect_decl_phase_2 (tree decl
)
1402 return stack_protect_decl_phase (decl
) == 2;
1405 /* Ensure that variables in different stack protection phases conflict
1406 so that they are not merged and share the same stack slot. */
1409 add_stack_protection_conflicts (void)
1411 size_t i
, j
, n
= stack_vars_num
;
1412 unsigned char *phase
;
1414 phase
= XNEWVEC (unsigned char, n
);
1415 for (i
= 0; i
< n
; ++i
)
1416 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1418 for (i
= 0; i
< n
; ++i
)
1420 unsigned char ph_i
= phase
[i
];
1421 for (j
= 0; j
< i
; ++j
)
1422 if (ph_i
!= phase
[j
])
1423 add_stack_var_conflict (i
, j
);
1429 /* Create a decl for the guard at the top of the stack frame. */
1432 create_stack_guard (void)
1434 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1435 VAR_DECL
, NULL
, ptr_type_node
);
1436 TREE_THIS_VOLATILE (guard
) = 1;
1437 TREE_USED (guard
) = 1;
1438 expand_one_stack_var (guard
);
1439 crtl
->stack_protect_guard
= guard
;
1442 /* Prepare for expanding variables. */
1444 init_vars_expansion (void)
1448 /* Set TREE_USED on all variables in the local_decls. */
1449 FOR_EACH_LOCAL_DECL (cfun
, ix
, t
)
1452 /* Clear TREE_USED on all variables associated with a block scope. */
1453 clear_tree_used (DECL_INITIAL (current_function_decl
));
1455 /* Initialize local stack smashing state. */
1456 has_protected_decls
= false;
1457 has_short_buffer
= false;
1460 /* Free up stack variable graph data. */
1462 fini_vars_expansion (void)
1464 size_t i
, n
= stack_vars_num
;
1465 for (i
= 0; i
< n
; i
++)
1466 BITMAP_FREE (stack_vars
[i
].conflicts
);
1467 XDELETEVEC (stack_vars
);
1468 XDELETEVEC (stack_vars_sorted
);
1470 stack_vars_alloc
= stack_vars_num
= 0;
1471 pointer_map_destroy (decl_to_stack_part
);
1472 decl_to_stack_part
= NULL
;
1475 /* Make a fair guess for the size of the stack frame of the function
1476 in NODE. This doesn't have to be exact, the result is only used in
1477 the inline heuristics. So we don't want to run the full stack var
1478 packing algorithm (which is quadratic in the number of stack vars).
1479 Instead, we calculate the total size of all stack vars. This turns
1480 out to be a pretty fair estimate -- packing of stack vars doesn't
1481 happen very often. */
1484 estimated_stack_frame_size (struct cgraph_node
*node
)
1486 HOST_WIDE_INT size
= 0;
1489 tree old_cur_fun_decl
= current_function_decl
;
1490 referenced_var_iterator rvi
;
1491 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1493 current_function_decl
= node
->decl
;
1496 gcc_checking_assert (gimple_referenced_vars (fn
));
1497 FOR_EACH_REFERENCED_VAR (fn
, var
, rvi
)
1498 size
+= expand_one_var (var
, true, false);
1500 if (stack_vars_num
> 0)
1502 /* Fake sorting the stack vars for account_stack_vars (). */
1503 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1504 for (i
= 0; i
< stack_vars_num
; ++i
)
1505 stack_vars_sorted
[i
] = i
;
1506 size
+= account_stack_vars ();
1507 fini_vars_expansion ();
1510 current_function_decl
= old_cur_fun_decl
;
1514 /* Expand all variables used in the function. */
1517 expand_used_vars (void)
1519 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1520 VEC(tree
,heap
) *maybe_local_decls
= NULL
;
1524 /* Compute the phase of the stack frame for this function. */
1526 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1527 int off
= STARTING_FRAME_OFFSET
% align
;
1528 frame_phase
= off
? align
- off
: 0;
1531 init_vars_expansion ();
1533 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1535 tree var
= partition_to_var (SA
.map
, i
);
1537 gcc_assert (is_gimple_reg (var
));
1538 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1539 expand_one_var (var
, true, true);
1542 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1543 contain the default def (representing the parm or result itself)
1544 we don't do anything here. But those which don't contain the
1545 default def (representing a temporary based on the parm/result)
1546 we need to allocate space just like for normal VAR_DECLs. */
1547 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1549 expand_one_var (var
, true, true);
1550 gcc_assert (SA
.partition_to_pseudo
[i
]);
1555 /* At this point all variables on the local_decls with TREE_USED
1556 set are not associated with any block scope. Lay them out. */
1558 len
= VEC_length (tree
, cfun
->local_decls
);
1559 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1561 bool expand_now
= false;
1563 /* Expanded above already. */
1564 if (is_gimple_reg (var
))
1566 TREE_USED (var
) = 0;
1569 /* We didn't set a block for static or extern because it's hard
1570 to tell the difference between a global variable (re)declared
1571 in a local scope, and one that's really declared there to
1572 begin with. And it doesn't really matter much, since we're
1573 not giving them stack space. Expand them now. */
1574 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1577 /* If the variable is not associated with any block, then it
1578 was created by the optimizers, and could be live anywhere
1580 else if (TREE_USED (var
))
1583 /* Finally, mark all variables on the list as used. We'll use
1584 this in a moment when we expand those associated with scopes. */
1585 TREE_USED (var
) = 1;
1588 expand_one_var (var
, true, true);
1591 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1593 rtx rtl
= DECL_RTL_IF_SET (var
);
1595 /* Keep artificial non-ignored vars in cfun->local_decls
1596 chain until instantiate_decls. */
1597 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1598 add_local_decl (cfun
, var
);
1599 else if (rtl
== NULL_RTX
)
1600 /* If rtl isn't set yet, which can happen e.g. with
1601 -fstack-protector, retry before returning from this
1603 VEC_safe_push (tree
, heap
, maybe_local_decls
, var
);
1607 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1609 +-----------------+-----------------+
1610 | ...processed... | ...duplicates...|
1611 +-----------------+-----------------+
1613 +-- LEN points here.
1615 We just want the duplicates, as those are the artificial
1616 non-ignored vars that we want to keep until instantiate_decls.
1617 Move them down and truncate the array. */
1618 if (!VEC_empty (tree
, cfun
->local_decls
))
1619 VEC_block_remove (tree
, cfun
->local_decls
, 0, len
);
1621 /* At this point, all variables within the block tree with TREE_USED
1622 set are actually used by the optimized function. Lay them out. */
1623 expand_used_vars_for_block (outer_block
, true);
1625 if (stack_vars_num
> 0)
1627 add_scope_conflicts ();
1628 /* Due to the way alias sets work, no variables with non-conflicting
1629 alias sets may be assigned the same address. Add conflicts to
1631 add_alias_set_conflicts ();
1633 /* If stack protection is enabled, we don't share space between
1634 vulnerable data and non-vulnerable data. */
1635 if (flag_stack_protect
)
1636 add_stack_protection_conflicts ();
1638 /* Now that we have collected all stack variables, and have computed a
1639 minimal interference graph, attempt to save some stack space. */
1640 partition_stack_vars ();
1642 dump_stack_var_partition ();
1645 /* There are several conditions under which we should create a
1646 stack guard: protect-all, alloca used, protected decls present. */
1647 if (flag_stack_protect
== 2
1648 || (flag_stack_protect
1649 && (cfun
->calls_alloca
|| has_protected_decls
)))
1650 create_stack_guard ();
1652 /* Assign rtl to each variable based on these partitions. */
1653 if (stack_vars_num
> 0)
1655 /* Reorder decls to be protected by iterating over the variables
1656 array multiple times, and allocating out of each phase in turn. */
1657 /* ??? We could probably integrate this into the qsort we did
1658 earlier, such that we naturally see these variables first,
1659 and thus naturally allocate things in the right order. */
1660 if (has_protected_decls
)
1662 /* Phase 1 contains only character arrays. */
1663 expand_stack_vars (stack_protect_decl_phase_1
);
1665 /* Phase 2 contains other kinds of arrays. */
1666 if (flag_stack_protect
== 2)
1667 expand_stack_vars (stack_protect_decl_phase_2
);
1670 expand_stack_vars (NULL
);
1672 fini_vars_expansion ();
1675 /* If there were any artificial non-ignored vars without rtl
1676 found earlier, see if deferred stack allocation hasn't assigned
1678 FOR_EACH_VEC_ELT_REVERSE (tree
, maybe_local_decls
, i
, var
)
1680 rtx rtl
= DECL_RTL_IF_SET (var
);
1682 /* Keep artificial non-ignored vars in cfun->local_decls
1683 chain until instantiate_decls. */
1684 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1685 add_local_decl (cfun
, var
);
1687 VEC_free (tree
, heap
, maybe_local_decls
);
1689 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1690 if (STACK_ALIGNMENT_NEEDED
)
1692 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1693 if (!FRAME_GROWS_DOWNWARD
)
1694 frame_offset
+= align
- 1;
1695 frame_offset
&= -align
;
1700 /* If we need to produce a detailed dump, print the tree representation
1701 for STMT to the dump file. SINCE is the last RTX after which the RTL
1702 generated for STMT should have been appended. */
1705 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx since
)
1707 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1709 fprintf (dump_file
, "\n;; ");
1710 print_gimple_stmt (dump_file
, stmt
, 0,
1711 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
1712 fprintf (dump_file
, "\n");
1714 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1718 /* Maps the blocks that do not contain tree labels to rtx labels. */
1720 static struct pointer_map_t
*lab_rtx_for_bb
;
1722 /* Returns the label_rtx expression for a label starting basic block BB. */
1725 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
1727 gimple_stmt_iterator gsi
;
1732 if (bb
->flags
& BB_RTL
)
1733 return block_label (bb
);
1735 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
1739 /* Find the tree label if it is present. */
1741 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1743 lab_stmt
= gsi_stmt (gsi
);
1744 if (gimple_code (lab_stmt
) != GIMPLE_LABEL
)
1747 lab
= gimple_label_label (lab_stmt
);
1748 if (DECL_NONLOCAL (lab
))
1751 return label_rtx (lab
);
1754 elt
= pointer_map_insert (lab_rtx_for_bb
, bb
);
1755 *elt
= gen_label_rtx ();
1760 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1761 of a basic block where we just expanded the conditional at the end,
1762 possibly clean up the CFG and instruction sequence. LAST is the
1763 last instruction before the just emitted jump sequence. */
1766 maybe_cleanup_end_of_block (edge e
, rtx last
)
1768 /* Special case: when jumpif decides that the condition is
1769 trivial it emits an unconditional jump (and the necessary
1770 barrier). But we still have two edges, the fallthru one is
1771 wrong. purge_dead_edges would clean this up later. Unfortunately
1772 we have to insert insns (and split edges) before
1773 find_many_sub_basic_blocks and hence before purge_dead_edges.
1774 But splitting edges might create new blocks which depend on the
1775 fact that if there are two edges there's no barrier. So the
1776 barrier would get lost and verify_flow_info would ICE. Instead
1777 of auditing all edge splitters to care for the barrier (which
1778 normally isn't there in a cleaned CFG), fix it here. */
1779 if (BARRIER_P (get_last_insn ()))
1783 /* Now, we have a single successor block, if we have insns to
1784 insert on the remaining edge we potentially will insert
1785 it at the end of this block (if the dest block isn't feasible)
1786 in order to avoid splitting the edge. This insertion will take
1787 place in front of the last jump. But we might have emitted
1788 multiple jumps (conditional and one unconditional) to the
1789 same destination. Inserting in front of the last one then
1790 is a problem. See PR 40021. We fix this by deleting all
1791 jumps except the last unconditional one. */
1792 insn
= PREV_INSN (get_last_insn ());
1793 /* Make sure we have an unconditional jump. Otherwise we're
1795 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
1796 for (insn
= PREV_INSN (insn
); insn
!= last
;)
1798 insn
= PREV_INSN (insn
);
1799 if (JUMP_P (NEXT_INSN (insn
)))
1801 if (!any_condjump_p (NEXT_INSN (insn
)))
1803 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
1804 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
1806 delete_insn (NEXT_INSN (insn
));
1812 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
1813 Returns a new basic block if we've terminated the current basic
1814 block and created a new one. */
1817 expand_gimple_cond (basic_block bb
, gimple stmt
)
1819 basic_block new_bb
, dest
;
1824 enum tree_code code
;
1827 code
= gimple_cond_code (stmt
);
1828 op0
= gimple_cond_lhs (stmt
);
1829 op1
= gimple_cond_rhs (stmt
);
1830 /* We're sometimes presented with such code:
1834 This would expand to two comparisons which then later might
1835 be cleaned up by combine. But some pattern matchers like if-conversion
1836 work better when there's only one compare, so make up for this
1837 here as special exception if TER would have made the same change. */
1838 if (gimple_cond_single_var_p (stmt
)
1840 && TREE_CODE (op0
) == SSA_NAME
1841 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
1843 gimple second
= SSA_NAME_DEF_STMT (op0
);
1844 if (gimple_code (second
) == GIMPLE_ASSIGN
)
1846 enum tree_code code2
= gimple_assign_rhs_code (second
);
1847 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
1850 op0
= gimple_assign_rhs1 (second
);
1851 op1
= gimple_assign_rhs2 (second
);
1853 /* If jumps are cheap turn some more codes into
1855 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
1857 if ((code2
== BIT_AND_EXPR
1858 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
1859 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
1860 || code2
== TRUTH_AND_EXPR
)
1862 code
= TRUTH_ANDIF_EXPR
;
1863 op0
= gimple_assign_rhs1 (second
);
1864 op1
= gimple_assign_rhs2 (second
);
1866 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
1868 code
= TRUTH_ORIF_EXPR
;
1869 op0
= gimple_assign_rhs1 (second
);
1870 op1
= gimple_assign_rhs2 (second
);
1876 last2
= last
= get_last_insn ();
1878 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1879 set_curr_insn_source_location (gimple_location (stmt
));
1880 set_curr_insn_block (gimple_block (stmt
));
1882 /* These flags have no purpose in RTL land. */
1883 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
1884 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
1886 /* We can either have a pure conditional jump with one fallthru edge or
1887 two-way jump that needs to be decomposed into two basic blocks. */
1888 if (false_edge
->dest
== bb
->next_bb
)
1890 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
1891 true_edge
->probability
);
1892 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
1893 if (true_edge
->goto_locus
)
1895 set_curr_insn_source_location (true_edge
->goto_locus
);
1896 set_curr_insn_block (true_edge
->goto_block
);
1897 true_edge
->goto_locus
= curr_insn_locator ();
1899 true_edge
->goto_block
= NULL
;
1900 false_edge
->flags
|= EDGE_FALLTHRU
;
1901 maybe_cleanup_end_of_block (false_edge
, last
);
1904 if (true_edge
->dest
== bb
->next_bb
)
1906 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
1907 false_edge
->probability
);
1908 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
1909 if (false_edge
->goto_locus
)
1911 set_curr_insn_source_location (false_edge
->goto_locus
);
1912 set_curr_insn_block (false_edge
->goto_block
);
1913 false_edge
->goto_locus
= curr_insn_locator ();
1915 false_edge
->goto_block
= NULL
;
1916 true_edge
->flags
|= EDGE_FALLTHRU
;
1917 maybe_cleanup_end_of_block (true_edge
, last
);
1921 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
1922 true_edge
->probability
);
1923 last
= get_last_insn ();
1924 if (false_edge
->goto_locus
)
1926 set_curr_insn_source_location (false_edge
->goto_locus
);
1927 set_curr_insn_block (false_edge
->goto_block
);
1928 false_edge
->goto_locus
= curr_insn_locator ();
1930 false_edge
->goto_block
= NULL
;
1931 emit_jump (label_rtx_for_bb (false_edge
->dest
));
1934 if (BARRIER_P (BB_END (bb
)))
1935 BB_END (bb
) = PREV_INSN (BB_END (bb
));
1936 update_bb_for_insn (bb
);
1938 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
1939 dest
= false_edge
->dest
;
1940 redirect_edge_succ (false_edge
, new_bb
);
1941 false_edge
->flags
|= EDGE_FALLTHRU
;
1942 new_bb
->count
= false_edge
->count
;
1943 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
1944 if (current_loops
&& bb
->loop_father
)
1945 add_bb_to_loop (new_bb
, bb
->loop_father
);
1946 new_edge
= make_edge (new_bb
, dest
, 0);
1947 new_edge
->probability
= REG_BR_PROB_BASE
;
1948 new_edge
->count
= new_bb
->count
;
1949 if (BARRIER_P (BB_END (new_bb
)))
1950 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
1951 update_bb_for_insn (new_bb
);
1953 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
1955 if (true_edge
->goto_locus
)
1957 set_curr_insn_source_location (true_edge
->goto_locus
);
1958 set_curr_insn_block (true_edge
->goto_block
);
1959 true_edge
->goto_locus
= curr_insn_locator ();
1961 true_edge
->goto_block
= NULL
;
1966 /* Mark all calls that can have a transaction restart. */
1969 mark_transaction_restart_calls (gimple stmt
)
1971 struct tm_restart_node dummy
;
1974 if (!cfun
->gimple_df
->tm_restart
)
1978 slot
= htab_find_slot (cfun
->gimple_df
->tm_restart
, &dummy
, NO_INSERT
);
1981 struct tm_restart_node
*n
= (struct tm_restart_node
*) *slot
;
1982 tree list
= n
->label_or_list
;
1985 for (insn
= next_real_insn (get_last_insn ());
1987 insn
= next_real_insn (insn
))
1990 if (TREE_CODE (list
) == LABEL_DECL
)
1991 add_reg_note (insn
, REG_TM
, label_rtx (list
));
1993 for (; list
; list
= TREE_CHAIN (list
))
1994 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
1998 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2002 expand_call_stmt (gimple stmt
)
2004 tree exp
, decl
, lhs
;
2008 if (gimple_call_internal_p (stmt
))
2010 expand_internal_call (stmt
);
2014 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2016 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2017 decl
= gimple_call_fndecl (stmt
);
2018 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2020 /* If this is not a builtin function, the function type through which the
2021 call is made may be different from the type of the function. */
2024 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2025 CALL_EXPR_FN (exp
));
2027 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2028 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2030 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2032 tree arg
= gimple_call_arg (stmt
, i
);
2034 /* TER addresses into arguments of builtin functions so we have a
2035 chance to infer more correct alignment information. See PR39954. */
2037 && TREE_CODE (arg
) == SSA_NAME
2038 && (def
= get_gimple_for_ssa_name (arg
))
2039 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2040 arg
= gimple_assign_rhs1 (def
);
2041 CALL_EXPR_ARG (exp
, i
) = arg
;
2044 if (gimple_has_side_effects (stmt
))
2045 TREE_SIDE_EFFECTS (exp
) = 1;
2047 if (gimple_call_nothrow_p (stmt
))
2048 TREE_NOTHROW (exp
) = 1;
2050 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2051 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2053 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2054 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2055 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2056 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2058 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2059 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2060 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2061 TREE_BLOCK (exp
) = gimple_block (stmt
);
2063 /* Ensure RTL is created for debug args. */
2064 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2066 VEC(tree
, gc
) **debug_args
= decl_debug_args_lookup (decl
);
2071 for (ix
= 1; VEC_iterate (tree
, *debug_args
, ix
, dtemp
); ix
+= 2)
2073 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2074 expand_debug_expr (dtemp
);
2078 lhs
= gimple_call_lhs (stmt
);
2080 expand_assignment (lhs
, exp
, false);
2082 expand_expr_real_1 (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
, NULL
);
2084 mark_transaction_restart_calls (stmt
);
2087 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
2088 STMT that doesn't require special handling for outgoing edges. That
2089 is no tailcalls and no GIMPLE_COND. */
2092 expand_gimple_stmt_1 (gimple stmt
)
2096 set_curr_insn_source_location (gimple_location (stmt
));
2097 set_curr_insn_block (gimple_block (stmt
));
2099 switch (gimple_code (stmt
))
2102 op0
= gimple_goto_dest (stmt
);
2103 if (TREE_CODE (op0
) == LABEL_DECL
)
2106 expand_computed_goto (op0
);
2109 expand_label (gimple_label_label (stmt
));
2112 case GIMPLE_PREDICT
:
2118 expand_asm_stmt (stmt
);
2121 expand_call_stmt (stmt
);
2125 op0
= gimple_return_retval (stmt
);
2127 if (op0
&& op0
!= error_mark_node
)
2129 tree result
= DECL_RESULT (current_function_decl
);
2131 /* If we are not returning the current function's RESULT_DECL,
2132 build an assignment to it. */
2135 /* I believe that a function's RESULT_DECL is unique. */
2136 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
2138 /* ??? We'd like to use simply expand_assignment here,
2139 but this fails if the value is of BLKmode but the return
2140 decl is a register. expand_return has special handling
2141 for this combination, which eventually should move
2142 to common code. See comments there. Until then, let's
2143 build a modify expression :-/ */
2144 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
2149 expand_null_return ();
2151 expand_return (op0
);
2156 tree lhs
= gimple_assign_lhs (stmt
);
2158 /* Tree expand used to fiddle with |= and &= of two bitfield
2159 COMPONENT_REFs here. This can't happen with gimple, the LHS
2160 of binary assigns must be a gimple reg. */
2162 if (TREE_CODE (lhs
) != SSA_NAME
2163 || get_gimple_rhs_class (gimple_expr_code (stmt
))
2164 == GIMPLE_SINGLE_RHS
)
2166 tree rhs
= gimple_assign_rhs1 (stmt
);
2167 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
2168 == GIMPLE_SINGLE_RHS
);
2169 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
2170 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
2171 if (TREE_CLOBBER_P (rhs
))
2172 /* This is a clobber to mark the going out of scope for
2176 expand_assignment (lhs
, rhs
,
2177 gimple_assign_nontemporal_move_p (stmt
));
2182 bool nontemporal
= gimple_assign_nontemporal_move_p (stmt
);
2183 struct separate_ops ops
;
2184 bool promoted
= false;
2186 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
2187 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
2190 ops
.code
= gimple_assign_rhs_code (stmt
);
2191 ops
.type
= TREE_TYPE (lhs
);
2192 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
2194 case GIMPLE_TERNARY_RHS
:
2195 ops
.op2
= gimple_assign_rhs3 (stmt
);
2197 case GIMPLE_BINARY_RHS
:
2198 ops
.op1
= gimple_assign_rhs2 (stmt
);
2200 case GIMPLE_UNARY_RHS
:
2201 ops
.op0
= gimple_assign_rhs1 (stmt
);
2206 ops
.location
= gimple_location (stmt
);
2208 /* If we want to use a nontemporal store, force the value to
2209 register first. If we store into a promoted register,
2210 don't directly expand to target. */
2211 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
2212 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
2219 int unsignedp
= SUBREG_PROMOTED_UNSIGNED_P (target
);
2220 /* If TEMP is a VOIDmode constant, use convert_modes to make
2221 sure that we properly convert it. */
2222 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
2224 temp
= convert_modes (GET_MODE (target
),
2225 TYPE_MODE (ops
.type
),
2227 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
2228 GET_MODE (target
), temp
, unsignedp
);
2231 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
2233 else if (nontemporal
&& emit_storent_insn (target
, temp
))
2237 temp
= force_operand (temp
, target
);
2239 emit_move_insn (target
, temp
);
2250 /* Expand one gimple statement STMT and return the last RTL instruction
2251 before any of the newly generated ones.
2253 In addition to generating the necessary RTL instructions this also
2254 sets REG_EH_REGION notes if necessary and sets the current source
2255 location for diagnostics. */
2258 expand_gimple_stmt (gimple stmt
)
2260 location_t saved_location
= input_location
;
2261 rtx last
= get_last_insn ();
2266 /* We need to save and restore the current source location so that errors
2267 discovered during expansion are emitted with the right location. But
2268 it would be better if the diagnostic routines used the source location
2269 embedded in the tree nodes rather than globals. */
2270 if (gimple_has_location (stmt
))
2271 input_location
= gimple_location (stmt
);
2273 expand_gimple_stmt_1 (stmt
);
2275 /* Free any temporaries used to evaluate this statement. */
2278 input_location
= saved_location
;
2280 /* Mark all insns that may trap. */
2281 lp_nr
= lookup_stmt_eh_lp (stmt
);
2285 for (insn
= next_real_insn (last
); insn
;
2286 insn
= next_real_insn (insn
))
2288 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
2289 /* If we want exceptions for non-call insns, any
2290 may_trap_p instruction may throw. */
2291 && GET_CODE (PATTERN (insn
)) != CLOBBER
2292 && GET_CODE (PATTERN (insn
)) != USE
2293 && insn_could_throw_p (insn
))
2294 make_reg_eh_region_note (insn
, 0, lp_nr
);
2301 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
2302 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
2303 generated a tail call (something that might be denied by the ABI
2304 rules governing the call; see calls.c).
2306 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
2307 can still reach the rest of BB. The case here is __builtin_sqrt,
2308 where the NaN result goes through the external function (with a
2309 tailcall) and the normal result happens via a sqrt instruction. */
2312 expand_gimple_tailcall (basic_block bb
, gimple stmt
, bool *can_fallthru
)
2320 last2
= last
= expand_gimple_stmt (stmt
);
2322 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
2323 if (CALL_P (last
) && SIBLING_CALL_P (last
))
2326 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2328 *can_fallthru
= true;
2332 /* ??? Wouldn't it be better to just reset any pending stack adjust?
2333 Any instructions emitted here are about to be deleted. */
2334 do_pending_stack_adjust ();
2336 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
2337 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
2338 EH or abnormal edges, we shouldn't have created a tail call in
2339 the first place. So it seems to me we should just be removing
2340 all edges here, or redirecting the existing fallthru edge to
2346 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
2348 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
2350 if (e
->dest
!= EXIT_BLOCK_PTR
)
2352 e
->dest
->count
-= e
->count
;
2353 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
2354 if (e
->dest
->count
< 0)
2356 if (e
->dest
->frequency
< 0)
2357 e
->dest
->frequency
= 0;
2360 probability
+= e
->probability
;
2367 /* This is somewhat ugly: the call_expr expander often emits instructions
2368 after the sibcall (to perform the function return). These confuse the
2369 find_many_sub_basic_blocks code, so we need to get rid of these. */
2370 last
= NEXT_INSN (last
);
2371 gcc_assert (BARRIER_P (last
));
2373 *can_fallthru
= false;
2374 while (NEXT_INSN (last
))
2376 /* For instance an sqrt builtin expander expands if with
2377 sibcall in the then and label for `else`. */
2378 if (LABEL_P (NEXT_INSN (last
)))
2380 *can_fallthru
= true;
2383 delete_insn (NEXT_INSN (last
));
2386 e
= make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_ABNORMAL
| EDGE_SIBCALL
);
2387 e
->probability
+= probability
;
2390 update_bb_for_insn (bb
);
2392 if (NEXT_INSN (last
))
2394 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2397 if (BARRIER_P (last
))
2398 BB_END (bb
) = PREV_INSN (last
);
2401 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2406 /* Return the difference between the floor and the truncated result of
2407 a signed division by OP1 with remainder MOD. */
2409 floor_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2411 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
2412 return gen_rtx_IF_THEN_ELSE
2413 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2414 gen_rtx_IF_THEN_ELSE
2415 (mode
, gen_rtx_LT (BImode
,
2416 gen_rtx_DIV (mode
, op1
, mod
),
2418 constm1_rtx
, const0_rtx
),
2422 /* Return the difference between the ceil and the truncated result of
2423 a signed division by OP1 with remainder MOD. */
2425 ceil_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2427 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
2428 return gen_rtx_IF_THEN_ELSE
2429 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2430 gen_rtx_IF_THEN_ELSE
2431 (mode
, gen_rtx_GT (BImode
,
2432 gen_rtx_DIV (mode
, op1
, mod
),
2434 const1_rtx
, const0_rtx
),
2438 /* Return the difference between the ceil and the truncated result of
2439 an unsigned division by OP1 with remainder MOD. */
2441 ceil_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
2443 /* (mod != 0 ? 1 : 0) */
2444 return gen_rtx_IF_THEN_ELSE
2445 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2446 const1_rtx
, const0_rtx
);
2449 /* Return the difference between the rounded and the truncated result
2450 of a signed division by OP1 with remainder MOD. Halfway cases are
2451 rounded away from zero, rather than to the nearest even number. */
2453 round_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2455 /* (abs (mod) >= abs (op1) - abs (mod)
2456 ? (op1 / mod > 0 ? 1 : -1)
2458 return gen_rtx_IF_THEN_ELSE
2459 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
2460 gen_rtx_MINUS (mode
,
2461 gen_rtx_ABS (mode
, op1
),
2462 gen_rtx_ABS (mode
, mod
))),
2463 gen_rtx_IF_THEN_ELSE
2464 (mode
, gen_rtx_GT (BImode
,
2465 gen_rtx_DIV (mode
, op1
, mod
),
2467 const1_rtx
, constm1_rtx
),
2471 /* Return the difference between the rounded and the truncated result
2472 of a unsigned division by OP1 with remainder MOD. Halfway cases
2473 are rounded away from zero, rather than to the nearest even
2476 round_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2478 /* (mod >= op1 - mod ? 1 : 0) */
2479 return gen_rtx_IF_THEN_ELSE
2480 (mode
, gen_rtx_GE (BImode
, mod
,
2481 gen_rtx_MINUS (mode
, op1
, mod
)),
2482 const1_rtx
, const0_rtx
);
2485 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
2489 convert_debug_memory_address (enum machine_mode mode
, rtx x
,
2492 enum machine_mode xmode
= GET_MODE (x
);
2494 #ifndef POINTERS_EXTEND_UNSIGNED
2495 gcc_assert (mode
== Pmode
2496 || mode
== targetm
.addr_space
.address_mode (as
));
2497 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
2501 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
2503 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
2506 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
2507 x
= simplify_gen_subreg (mode
, x
, xmode
,
2508 subreg_lowpart_offset
2510 else if (POINTERS_EXTEND_UNSIGNED
> 0)
2511 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
2512 else if (!POINTERS_EXTEND_UNSIGNED
)
2513 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
2516 switch (GET_CODE (x
))
2519 if ((SUBREG_PROMOTED_VAR_P (x
)
2520 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
2521 || (GET_CODE (SUBREG_REG (x
)) == PLUS
2522 && REG_P (XEXP (SUBREG_REG (x
), 0))
2523 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
2524 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
2525 && GET_MODE (SUBREG_REG (x
)) == mode
)
2526 return SUBREG_REG (x
);
2529 temp
= gen_rtx_LABEL_REF (mode
, XEXP (x
, 0));
2530 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
2533 temp
= shallow_copy_rtx (x
);
2534 PUT_MODE (temp
, mode
);
2537 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
2539 temp
= gen_rtx_CONST (mode
, temp
);
2543 if (CONST_INT_P (XEXP (x
, 1)))
2545 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
2547 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
2553 /* Don't know how to express ptr_extend as operation in debug info. */
2556 #endif /* POINTERS_EXTEND_UNSIGNED */
2561 /* Return an RTX equivalent to the value of the parameter DECL. */
2564 expand_debug_parm_decl (tree decl
)
2566 rtx incoming
= DECL_INCOMING_RTL (decl
);
2569 && GET_MODE (incoming
) != BLKmode
2570 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
2571 || (MEM_P (incoming
)
2572 && REG_P (XEXP (incoming
, 0))
2573 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
2575 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
2577 #ifdef HAVE_window_save
2578 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
2579 If the target machine has an explicit window save instruction, the
2580 actual entry value is the corresponding OUTGOING_REGNO instead. */
2581 if (REG_P (incoming
)
2582 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
2584 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
2585 OUTGOING_REGNO (REGNO (incoming
)), 0);
2586 else if (MEM_P (incoming
))
2588 rtx reg
= XEXP (incoming
, 0);
2589 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
2591 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
2592 incoming
= replace_equiv_address_nv (incoming
, reg
);
2597 ENTRY_VALUE_EXP (rtl
) = incoming
;
2602 && GET_MODE (incoming
) != BLKmode
2603 && !TREE_ADDRESSABLE (decl
)
2605 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
2606 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
2607 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
2608 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
2614 /* Return an RTX equivalent to the value of the tree expression EXP. */
2617 expand_debug_expr (tree exp
)
2619 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
2620 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2621 enum machine_mode inner_mode
= VOIDmode
;
2622 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
2625 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
2627 case tcc_expression
:
2628 switch (TREE_CODE (exp
))
2632 case WIDEN_MULT_PLUS_EXPR
:
2633 case WIDEN_MULT_MINUS_EXPR
:
2637 case TRUTH_ANDIF_EXPR
:
2638 case TRUTH_ORIF_EXPR
:
2639 case TRUTH_AND_EXPR
:
2641 case TRUTH_XOR_EXPR
:
2644 case TRUTH_NOT_EXPR
:
2653 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
2660 case tcc_comparison
:
2661 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
2668 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2669 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
2679 case tcc_exceptional
:
2680 case tcc_declaration
:
2686 switch (TREE_CODE (exp
))
2689 if (!lookup_constant_def (exp
))
2691 if (strlen (TREE_STRING_POINTER (exp
)) + 1
2692 != (size_t) TREE_STRING_LENGTH (exp
))
2694 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
2695 op0
= gen_rtx_MEM (BLKmode
, op0
);
2696 set_mem_attributes (op0
, exp
, 0);
2699 /* Fall through... */
2704 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
2708 gcc_assert (COMPLEX_MODE_P (mode
));
2709 op0
= expand_debug_expr (TREE_REALPART (exp
));
2710 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
2711 return gen_rtx_CONCAT (mode
, op0
, op1
);
2713 case DEBUG_EXPR_DECL
:
2714 op0
= DECL_RTL_IF_SET (exp
);
2719 op0
= gen_rtx_DEBUG_EXPR (mode
);
2720 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
2721 SET_DECL_RTL (exp
, op0
);
2731 op0
= DECL_RTL_IF_SET (exp
);
2733 /* This decl was probably optimized away. */
2736 if (TREE_CODE (exp
) != VAR_DECL
2737 || DECL_EXTERNAL (exp
)
2738 || !TREE_STATIC (exp
)
2740 || DECL_HARD_REGISTER (exp
)
2741 || DECL_IN_CONSTANT_POOL (exp
)
2742 || mode
== VOIDmode
)
2745 op0
= make_decl_rtl_for_debug (exp
);
2747 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
2748 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
2752 op0
= copy_rtx (op0
);
2754 if (GET_MODE (op0
) == BLKmode
2755 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
2756 below would ICE. While it is likely a FE bug,
2757 try to be robust here. See PR43166. */
2759 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
2761 gcc_assert (MEM_P (op0
));
2762 op0
= adjust_address_nv (op0
, mode
, 0);
2773 inner_mode
= GET_MODE (op0
);
2775 if (mode
== inner_mode
)
2778 if (inner_mode
== VOIDmode
)
2780 if (TREE_CODE (exp
) == SSA_NAME
)
2781 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
2783 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2784 if (mode
== inner_mode
)
2788 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
2790 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
2791 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
2792 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
2793 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
2795 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
2797 else if (FLOAT_MODE_P (mode
))
2799 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
2800 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
2801 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
2803 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
2805 else if (FLOAT_MODE_P (inner_mode
))
2808 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
2810 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
2812 else if (CONSTANT_P (op0
)
2813 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
2814 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
2815 subreg_lowpart_offset (mode
,
2817 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
2818 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
2820 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
2822 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
2828 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
2830 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
2831 TREE_OPERAND (exp
, 0),
2832 TREE_OPERAND (exp
, 1));
2834 return expand_debug_expr (newexp
);
2838 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
2842 if (TREE_CODE (exp
) == MEM_REF
)
2844 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
2845 || (GET_CODE (op0
) == PLUS
2846 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
2847 /* (mem (debug_implicit_ptr)) might confuse aliasing.
2848 Instead just use get_inner_reference. */
2851 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
2852 if (!op1
|| !CONST_INT_P (op1
))
2855 op0
= plus_constant (op0
, INTVAL (op1
));
2858 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
2859 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
2861 as
= ADDR_SPACE_GENERIC
;
2863 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
2865 if (op0
== NULL_RTX
)
2868 op0
= gen_rtx_MEM (mode
, op0
);
2869 set_mem_attributes (op0
, exp
, 0);
2870 if (TREE_CODE (exp
) == MEM_REF
2871 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
2872 set_mem_expr (op0
, NULL_TREE
);
2873 set_mem_addr_space (op0
, as
);
2877 case TARGET_MEM_REF
:
2878 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
2879 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
2882 op0
= expand_debug_expr
2883 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
2887 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
2888 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
2890 as
= ADDR_SPACE_GENERIC
;
2892 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
2894 if (op0
== NULL_RTX
)
2897 op0
= gen_rtx_MEM (mode
, op0
);
2899 set_mem_attributes (op0
, exp
, 0);
2900 set_mem_addr_space (op0
, as
);
2906 case ARRAY_RANGE_REF
:
2911 case VIEW_CONVERT_EXPR
:
2913 enum machine_mode mode1
;
2914 HOST_WIDE_INT bitsize
, bitpos
;
2917 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
2918 &mode1
, &unsignedp
, &volatilep
, false);
2924 orig_op0
= op0
= expand_debug_expr (tem
);
2931 enum machine_mode addrmode
, offmode
;
2936 op0
= XEXP (op0
, 0);
2937 addrmode
= GET_MODE (op0
);
2938 if (addrmode
== VOIDmode
)
2941 op1
= expand_debug_expr (offset
);
2945 offmode
= GET_MODE (op1
);
2946 if (offmode
== VOIDmode
)
2947 offmode
= TYPE_MODE (TREE_TYPE (offset
));
2949 if (addrmode
!= offmode
)
2950 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
2951 subreg_lowpart_offset (addrmode
,
2954 /* Don't use offset_address here, we don't need a
2955 recognizable address, and we don't want to generate
2957 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
2963 if (mode1
== VOIDmode
)
2965 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
2966 if (bitpos
>= BITS_PER_UNIT
)
2968 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
2969 bitpos
%= BITS_PER_UNIT
;
2971 else if (bitpos
< 0)
2974 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
2975 op0
= adjust_address_nv (op0
, mode1
, units
);
2976 bitpos
+= units
* BITS_PER_UNIT
;
2978 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
2979 op0
= adjust_address_nv (op0
, mode
, 0);
2980 else if (GET_MODE (op0
) != mode1
)
2981 op0
= adjust_address_nv (op0
, mode1
, 0);
2983 op0
= copy_rtx (op0
);
2984 if (op0
== orig_op0
)
2985 op0
= shallow_copy_rtx (op0
);
2986 set_mem_attributes (op0
, exp
, 0);
2989 if (bitpos
== 0 && mode
== GET_MODE (op0
))
2995 if (GET_MODE (op0
) == BLKmode
)
2998 if ((bitpos
% BITS_PER_UNIT
) == 0
2999 && bitsize
== GET_MODE_BITSIZE (mode1
))
3001 enum machine_mode opmode
= GET_MODE (op0
);
3003 if (opmode
== VOIDmode
)
3004 opmode
= TYPE_MODE (TREE_TYPE (tem
));
3006 /* This condition may hold if we're expanding the address
3007 right past the end of an array that turned out not to
3008 be addressable (i.e., the address was only computed in
3009 debug stmts). The gen_subreg below would rightfully
3010 crash, and the address doesn't really exist, so just
3012 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
3015 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
3016 return simplify_gen_subreg (mode
, op0
, opmode
,
3017 bitpos
/ BITS_PER_UNIT
);
3020 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
3021 && TYPE_UNSIGNED (TREE_TYPE (exp
))
3023 : ZERO_EXTRACT
, mode
,
3024 GET_MODE (op0
) != VOIDmode
3026 : TYPE_MODE (TREE_TYPE (tem
)),
3027 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
3031 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
3034 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
3037 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
3040 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3042 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
3045 case FIX_TRUNC_EXPR
:
3046 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
3049 case POINTER_PLUS_EXPR
:
3050 /* For the rare target where pointers are not the same size as
3051 size_t, we need to check for mis-matched modes and correct
3054 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
3055 && GET_MODE (op0
) != GET_MODE (op1
))
3057 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
)))
3058 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
3061 /* We always sign-extend, regardless of the signedness of
3062 the operand, because the operand is always unsigned
3063 here even if the original C expression is signed. */
3064 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
3069 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
3072 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
3075 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
3078 case TRUNC_DIV_EXPR
:
3079 case EXACT_DIV_EXPR
:
3081 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3083 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
3085 case TRUNC_MOD_EXPR
:
3086 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
3088 case FLOOR_DIV_EXPR
:
3090 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3093 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
3094 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3095 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
3096 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3099 case FLOOR_MOD_EXPR
:
3101 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3104 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3105 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
3106 adj
= simplify_gen_unary (NEG
, mode
,
3107 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3109 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3115 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3116 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3117 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
3118 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3122 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
3123 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3124 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
3125 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3131 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3132 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
3133 adj
= simplify_gen_unary (NEG
, mode
,
3134 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3136 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3140 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3141 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
3142 adj
= simplify_gen_unary (NEG
, mode
,
3143 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3145 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3148 case ROUND_DIV_EXPR
:
3151 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3152 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3153 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
3154 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3158 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
3159 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3160 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
3161 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3164 case ROUND_MOD_EXPR
:
3167 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3168 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
3169 adj
= simplify_gen_unary (NEG
, mode
,
3170 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3172 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3176 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3177 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
3178 adj
= simplify_gen_unary (NEG
, mode
,
3179 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3181 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3185 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
3189 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
3191 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
3194 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
3197 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
3200 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
3203 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
3206 case TRUTH_AND_EXPR
:
3207 return simplify_gen_binary (AND
, mode
, op0
, op1
);
3211 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
3214 case TRUTH_XOR_EXPR
:
3215 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
3217 case TRUTH_ANDIF_EXPR
:
3218 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
3220 case TRUTH_ORIF_EXPR
:
3221 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
3223 case TRUTH_NOT_EXPR
:
3224 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
3227 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
3231 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
3235 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
3239 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
3243 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
3246 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
3248 case UNORDERED_EXPR
:
3249 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
3252 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
3255 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
3258 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
3261 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
3264 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
3267 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
3270 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
3273 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
3276 gcc_assert (COMPLEX_MODE_P (mode
));
3277 if (GET_MODE (op0
) == VOIDmode
)
3278 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
3279 if (GET_MODE (op1
) == VOIDmode
)
3280 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
3281 return gen_rtx_CONCAT (mode
, op0
, op1
);
3284 if (GET_CODE (op0
) == CONCAT
)
3285 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
3286 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
3288 GET_MODE_INNER (mode
)));
3291 enum machine_mode imode
= GET_MODE_INNER (mode
);
3296 re
= adjust_address_nv (op0
, imode
, 0);
3297 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
3301 enum machine_mode ifmode
= int_mode_for_mode (mode
);
3302 enum machine_mode ihmode
= int_mode_for_mode (imode
);
3304 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
3306 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
3309 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
3310 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
3311 if (imode
!= ihmode
)
3312 re
= gen_rtx_SUBREG (imode
, re
, 0);
3313 im
= copy_rtx (op0
);
3315 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
3316 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
3317 if (imode
!= ihmode
)
3318 im
= gen_rtx_SUBREG (imode
, im
, 0);
3320 im
= gen_rtx_NEG (imode
, im
);
3321 return gen_rtx_CONCAT (mode
, re
, im
);
3325 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3326 if (!op0
|| !MEM_P (op0
))
3328 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
3329 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
3330 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
3331 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
3332 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
3333 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
3335 if (handled_component_p (TREE_OPERAND (exp
, 0)))
3337 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
3339 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
3340 &bitoffset
, &bitsize
, &maxsize
);
3341 if ((TREE_CODE (decl
) == VAR_DECL
3342 || TREE_CODE (decl
) == PARM_DECL
3343 || TREE_CODE (decl
) == RESULT_DECL
)
3344 && (!TREE_ADDRESSABLE (decl
)
3345 || target_for_debug_bind (decl
))
3346 && (bitoffset
% BITS_PER_UNIT
) == 0
3348 && bitsize
== maxsize
)
3349 return plus_constant (gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
),
3350 bitoffset
/ BITS_PER_UNIT
);
3356 as
= TYPE_ADDR_SPACE (TREE_TYPE (exp
));
3357 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
3365 op0
= gen_rtx_CONCATN
3366 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
3368 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
3370 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
3373 XVECEXP (op0
, 0, i
) = op1
;
3380 if (TREE_CLOBBER_P (exp
))
3382 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
3387 op0
= gen_rtx_CONCATN
3388 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
3390 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
3392 op1
= expand_debug_expr (val
);
3395 XVECEXP (op0
, 0, i
) = op1
;
3398 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
3400 op1
= expand_debug_expr
3401 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
3406 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
3407 XVECEXP (op0
, 0, i
) = op1
;
3413 goto flag_unsupported
;
3416 /* ??? Maybe handle some builtins? */
3421 gimple g
= get_gimple_for_ssa_name (exp
);
3424 op0
= expand_debug_expr (gimple_assign_rhs_to_tree (g
));
3430 int part
= var_to_partition (SA
.map
, exp
);
3432 if (part
== NO_PARTITION
)
3434 /* If this is a reference to an incoming value of parameter
3435 that is never used in the code or where the incoming
3436 value is never used in the code, use PARM_DECL's
3438 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
3439 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
3441 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
3444 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
3451 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
3453 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
3461 /* Vector stuff. For most of the codes we don't have rtl codes. */
3462 case REALIGN_LOAD_EXPR
:
3463 case REDUC_MAX_EXPR
:
3464 case REDUC_MIN_EXPR
:
3465 case REDUC_PLUS_EXPR
:
3467 case VEC_LSHIFT_EXPR
:
3468 case VEC_PACK_FIX_TRUNC_EXPR
:
3469 case VEC_PACK_SAT_EXPR
:
3470 case VEC_PACK_TRUNC_EXPR
:
3471 case VEC_RSHIFT_EXPR
:
3472 case VEC_UNPACK_FLOAT_HI_EXPR
:
3473 case VEC_UNPACK_FLOAT_LO_EXPR
:
3474 case VEC_UNPACK_HI_EXPR
:
3475 case VEC_UNPACK_LO_EXPR
:
3476 case VEC_WIDEN_MULT_HI_EXPR
:
3477 case VEC_WIDEN_MULT_LO_EXPR
:
3478 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3479 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3484 case ADDR_SPACE_CONVERT_EXPR
:
3485 case FIXED_CONVERT_EXPR
:
3487 case WITH_SIZE_EXPR
:
3491 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3492 && SCALAR_INT_MODE_P (mode
))
3495 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3497 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
3500 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3502 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
3504 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
3505 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
3509 case WIDEN_MULT_EXPR
:
3510 case WIDEN_MULT_PLUS_EXPR
:
3511 case WIDEN_MULT_MINUS_EXPR
:
3512 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3513 && SCALAR_INT_MODE_P (mode
))
3515 inner_mode
= GET_MODE (op0
);
3516 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3517 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3519 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3520 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
3521 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
3523 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
3524 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
3525 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
3527 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
3528 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
3530 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
3534 case WIDEN_SUM_EXPR
:
3535 case WIDEN_LSHIFT_EXPR
:
3536 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3537 && SCALAR_INT_MODE_P (mode
))
3540 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3542 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
3544 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
3545 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
3550 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
3554 #ifdef ENABLE_CHECKING
3563 /* Return an RTX equivalent to the source bind value of the tree expression
3567 expand_debug_source_expr (tree exp
)
3570 enum machine_mode mode
= VOIDmode
, inner_mode
;
3572 switch (TREE_CODE (exp
))
3576 mode
= DECL_MODE (exp
);
3577 op0
= expand_debug_parm_decl (exp
);
3580 /* See if this isn't an argument that has been completely
3582 if (!DECL_RTL_SET_P (exp
)
3583 && !DECL_INCOMING_RTL (exp
)
3584 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
3587 if (DECL_ABSTRACT_ORIGIN (exp
))
3588 aexp
= DECL_ABSTRACT_ORIGIN (exp
);
3589 if (DECL_CONTEXT (aexp
)
3590 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
3592 VEC(tree
, gc
) **debug_args
;
3595 #ifdef ENABLE_CHECKING
3597 for (parm
= DECL_ARGUMENTS (current_function_decl
);
3598 parm
; parm
= DECL_CHAIN (parm
))
3599 gcc_assert (parm
!= exp
3600 && DECL_ABSTRACT_ORIGIN (parm
) != aexp
);
3602 debug_args
= decl_debug_args_lookup (current_function_decl
);
3603 if (debug_args
!= NULL
)
3605 for (ix
= 0; VEC_iterate (tree
, *debug_args
, ix
, ddecl
);
3608 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
3618 if (op0
== NULL_RTX
)
3621 inner_mode
= GET_MODE (op0
);
3622 if (mode
== inner_mode
)
3625 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
3627 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
3628 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
3629 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
3630 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
3632 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
3634 else if (FLOAT_MODE_P (mode
))
3636 else if (FLOAT_MODE_P (inner_mode
))
3638 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
3639 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
3641 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
3643 else if (CONSTANT_P (op0
)
3644 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
3645 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
3646 subreg_lowpart_offset (mode
, inner_mode
));
3647 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
3648 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3650 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3655 /* Expand the _LOCs in debug insns. We run this after expanding all
3656 regular insns, so that any variables referenced in the function
3657 will have their DECL_RTLs set. */
3660 expand_debug_locations (void)
3663 rtx last
= get_last_insn ();
3664 int save_strict_alias
= flag_strict_aliasing
;
3666 /* New alias sets while setting up memory attributes cause
3667 -fcompare-debug failures, even though it doesn't bring about any
3669 flag_strict_aliasing
= 0;
3671 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3672 if (DEBUG_INSN_P (insn
))
3674 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
3676 enum machine_mode mode
;
3678 if (value
== NULL_TREE
)
3682 if (INSN_VAR_LOCATION_STATUS (insn
)
3683 == VAR_INIT_STATUS_UNINITIALIZED
)
3684 val
= expand_debug_source_expr (value
);
3686 val
= expand_debug_expr (value
);
3687 gcc_assert (last
== get_last_insn ());
3691 val
= gen_rtx_UNKNOWN_VAR_LOC ();
3694 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
3696 gcc_assert (mode
== GET_MODE (val
)
3697 || (GET_MODE (val
) == VOIDmode
3698 && (CONST_INT_P (val
)
3699 || GET_CODE (val
) == CONST_FIXED
3700 || GET_CODE (val
) == CONST_DOUBLE
3701 || GET_CODE (val
) == LABEL_REF
)));
3704 INSN_VAR_LOCATION_LOC (insn
) = val
;
3707 flag_strict_aliasing
= save_strict_alias
;
3710 /* Expand basic block BB from GIMPLE trees to RTL. */
3713 expand_gimple_basic_block (basic_block bb
)
3715 gimple_stmt_iterator gsi
;
3724 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
3727 /* Note that since we are now transitioning from GIMPLE to RTL, we
3728 cannot use the gsi_*_bb() routines because they expect the basic
3729 block to be in GIMPLE, instead of RTL. Therefore, we need to
3730 access the BB sequence directly. */
3731 stmts
= bb_seq (bb
);
3732 bb
->il
.gimple
= NULL
;
3733 rtl_profile_for_bb (bb
);
3734 init_rtl_bb_info (bb
);
3735 bb
->flags
|= BB_RTL
;
3737 /* Remove the RETURN_EXPR if we may fall though to the exit
3739 gsi
= gsi_last (stmts
);
3740 if (!gsi_end_p (gsi
)
3741 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
3743 gimple ret_stmt
= gsi_stmt (gsi
);
3745 gcc_assert (single_succ_p (bb
));
3746 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR
);
3748 if (bb
->next_bb
== EXIT_BLOCK_PTR
3749 && !gimple_return_retval (ret_stmt
))
3751 gsi_remove (&gsi
, false);
3752 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
3756 gsi
= gsi_start (stmts
);
3757 if (!gsi_end_p (gsi
))
3759 stmt
= gsi_stmt (gsi
);
3760 if (gimple_code (stmt
) != GIMPLE_LABEL
)
3764 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
3768 last
= get_last_insn ();
3772 expand_gimple_stmt (stmt
);
3777 emit_label ((rtx
) *elt
);
3779 /* Java emits line number notes in the top of labels.
3780 ??? Make this go away once line number notes are obsoleted. */
3781 BB_HEAD (bb
) = NEXT_INSN (last
);
3782 if (NOTE_P (BB_HEAD (bb
)))
3783 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
3784 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
3786 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
3789 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
3791 NOTE_BASIC_BLOCK (note
) = bb
;
3793 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
3797 stmt
= gsi_stmt (gsi
);
3799 /* If this statement is a non-debug one, and we generate debug
3800 insns, then this one might be the last real use of a TERed
3801 SSA_NAME, but where there are still some debug uses further
3802 down. Expanding the current SSA name in such further debug
3803 uses by their RHS might lead to wrong debug info, as coalescing
3804 might make the operands of such RHS be placed into the same
3805 pseudo as something else. Like so:
3806 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
3810 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
3811 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
3812 the write to a_2 would actually have clobbered the place which
3815 So, instead of that, we recognize the situation, and generate
3816 debug temporaries at the last real use of TERed SSA names:
3823 if (MAY_HAVE_DEBUG_INSNS
3825 && !is_gimple_debug (stmt
))
3831 location_t sloc
= get_curr_insn_source_location ();
3832 tree sblock
= get_curr_insn_block ();
3834 /* Look for SSA names that have their last use here (TERed
3835 names always have only one real use). */
3836 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
3837 if ((def
= get_gimple_for_ssa_name (op
)))
3839 imm_use_iterator imm_iter
;
3840 use_operand_p use_p
;
3841 bool have_debug_uses
= false;
3843 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
3845 if (gimple_debug_bind_p (USE_STMT (use_p
)))
3847 have_debug_uses
= true;
3852 if (have_debug_uses
)
3854 /* OP is a TERed SSA name, with DEF it's defining
3855 statement, and where OP is used in further debug
3856 instructions. Generate a debug temporary, and
3857 replace all uses of OP in debug insns with that
3860 tree value
= gimple_assign_rhs_to_tree (def
);
3861 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
3863 enum machine_mode mode
;
3865 set_curr_insn_source_location (gimple_location (def
));
3866 set_curr_insn_block (gimple_block (def
));
3868 DECL_ARTIFICIAL (vexpr
) = 1;
3869 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
3871 mode
= DECL_MODE (value
);
3873 mode
= TYPE_MODE (TREE_TYPE (value
));
3874 DECL_MODE (vexpr
) = mode
;
3876 val
= gen_rtx_VAR_LOCATION
3877 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
3879 emit_debug_insn (val
);
3881 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
3883 if (!gimple_debug_bind_p (debugstmt
))
3886 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
3887 SET_USE (use_p
, vexpr
);
3889 update_stmt (debugstmt
);
3893 set_curr_insn_source_location (sloc
);
3894 set_curr_insn_block (sblock
);
3897 currently_expanding_gimple_stmt
= stmt
;
3899 /* Expand this statement, then evaluate the resulting RTL and
3900 fixup the CFG accordingly. */
3901 if (gimple_code (stmt
) == GIMPLE_COND
)
3903 new_bb
= expand_gimple_cond (bb
, stmt
);
3907 else if (gimple_debug_bind_p (stmt
))
3909 location_t sloc
= get_curr_insn_source_location ();
3910 tree sblock
= get_curr_insn_block ();
3911 gimple_stmt_iterator nsi
= gsi
;
3915 tree var
= gimple_debug_bind_get_var (stmt
);
3918 enum machine_mode mode
;
3920 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
3921 && TREE_CODE (var
) != LABEL_DECL
3922 && !target_for_debug_bind (var
))
3923 goto delink_debug_stmt
;
3925 if (gimple_debug_bind_has_value_p (stmt
))
3926 value
= gimple_debug_bind_get_value (stmt
);
3930 last
= get_last_insn ();
3932 set_curr_insn_source_location (gimple_location (stmt
));
3933 set_curr_insn_block (gimple_block (stmt
));
3936 mode
= DECL_MODE (var
);
3938 mode
= TYPE_MODE (TREE_TYPE (var
));
3940 val
= gen_rtx_VAR_LOCATION
3941 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
3943 emit_debug_insn (val
);
3945 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3947 /* We can't dump the insn with a TREE where an RTX
3949 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
3950 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
3951 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
3955 /* In order not to generate too many debug temporaries,
3956 we delink all uses of debug statements we already expanded.
3957 Therefore debug statements between definition and real
3958 use of TERed SSA names will continue to use the SSA name,
3959 and not be replaced with debug temps. */
3960 delink_stmt_imm_use (stmt
);
3964 if (gsi_end_p (nsi
))
3966 stmt
= gsi_stmt (nsi
);
3967 if (!gimple_debug_bind_p (stmt
))
3971 set_curr_insn_source_location (sloc
);
3972 set_curr_insn_block (sblock
);
3974 else if (gimple_debug_source_bind_p (stmt
))
3976 location_t sloc
= get_curr_insn_source_location ();
3977 tree sblock
= get_curr_insn_block ();
3978 tree var
= gimple_debug_source_bind_get_var (stmt
);
3979 tree value
= gimple_debug_source_bind_get_value (stmt
);
3981 enum machine_mode mode
;
3983 last
= get_last_insn ();
3985 set_curr_insn_source_location (gimple_location (stmt
));
3986 set_curr_insn_block (gimple_block (stmt
));
3988 mode
= DECL_MODE (var
);
3990 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
3991 VAR_INIT_STATUS_UNINITIALIZED
);
3993 emit_debug_insn (val
);
3995 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3997 /* We can't dump the insn with a TREE where an RTX
3999 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
4000 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4001 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
4004 set_curr_insn_source_location (sloc
);
4005 set_curr_insn_block (sblock
);
4009 if (is_gimple_call (stmt
) && gimple_call_tail_p (stmt
))
4012 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
4023 def_operand_p def_p
;
4024 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
4028 /* Ignore this stmt if it is in the list of
4029 replaceable expressions. */
4031 && bitmap_bit_p (SA
.values
,
4032 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
4035 last
= expand_gimple_stmt (stmt
);
4036 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4041 currently_expanding_gimple_stmt
= NULL
;
4043 /* Expand implicit goto and convert goto_locus. */
4044 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4046 if (e
->goto_locus
&& e
->goto_block
)
4048 set_curr_insn_source_location (e
->goto_locus
);
4049 set_curr_insn_block (e
->goto_block
);
4050 e
->goto_locus
= curr_insn_locator ();
4052 e
->goto_block
= NULL
;
4053 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
4055 emit_jump (label_rtx_for_bb (e
->dest
));
4056 e
->flags
&= ~EDGE_FALLTHRU
;
4060 /* Expanded RTL can create a jump in the last instruction of block.
4061 This later might be assumed to be a jump to successor and break edge insertion.
4062 We need to insert dummy move to prevent this. PR41440. */
4063 if (single_succ_p (bb
)
4064 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
4065 && (last
= get_last_insn ())
4068 rtx dummy
= gen_reg_rtx (SImode
);
4069 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
4072 do_pending_stack_adjust ();
4074 /* Find the block tail. The last insn in the block is the insn
4075 before a barrier and/or table jump insn. */
4076 last
= get_last_insn ();
4077 if (BARRIER_P (last
))
4078 last
= PREV_INSN (last
);
4079 if (JUMP_TABLE_DATA_P (last
))
4080 last
= PREV_INSN (PREV_INSN (last
));
4083 update_bb_for_insn (bb
);
4089 /* Create a basic block for initialization code. */
4092 construct_init_block (void)
4094 basic_block init_block
, first_block
;
4098 /* Multiple entry points not supported yet. */
4099 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR
->succs
) == 1);
4100 init_rtl_bb_info (ENTRY_BLOCK_PTR
);
4101 init_rtl_bb_info (EXIT_BLOCK_PTR
);
4102 ENTRY_BLOCK_PTR
->flags
|= BB_RTL
;
4103 EXIT_BLOCK_PTR
->flags
|= BB_RTL
;
4105 e
= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0);
4107 /* When entry edge points to first basic block, we don't need jump,
4108 otherwise we have to jump into proper target. */
4109 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR
->next_bb
)
4111 tree label
= gimple_block_label (e
->dest
);
4113 emit_jump (label_rtx (label
));
4117 flags
= EDGE_FALLTHRU
;
4119 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
4122 init_block
->frequency
= ENTRY_BLOCK_PTR
->frequency
;
4123 init_block
->count
= ENTRY_BLOCK_PTR
->count
;
4124 if (current_loops
&& ENTRY_BLOCK_PTR
->loop_father
)
4125 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR
->loop_father
);
4128 first_block
= e
->dest
;
4129 redirect_edge_succ (e
, init_block
);
4130 e
= make_edge (init_block
, first_block
, flags
);
4133 e
= make_edge (init_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
4134 e
->probability
= REG_BR_PROB_BASE
;
4135 e
->count
= ENTRY_BLOCK_PTR
->count
;
4137 update_bb_for_insn (init_block
);
4141 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
4142 found in the block tree. */
4145 set_block_levels (tree block
, int level
)
4149 BLOCK_NUMBER (block
) = level
;
4150 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
4151 block
= BLOCK_CHAIN (block
);
4155 /* Create a block containing landing pads and similar stuff. */
4158 construct_exit_block (void)
4160 rtx head
= get_last_insn ();
4162 basic_block exit_block
;
4166 rtx orig_end
= BB_END (EXIT_BLOCK_PTR
->prev_bb
);
4168 rtl_profile_for_bb (EXIT_BLOCK_PTR
);
4170 /* Make sure the locus is set to the end of the function, so that
4171 epilogue line numbers and warnings are set properly. */
4172 if (cfun
->function_end_locus
!= UNKNOWN_LOCATION
)
4173 input_location
= cfun
->function_end_locus
;
4175 /* The following insns belong to the top scope. */
4176 set_curr_insn_block (DECL_INITIAL (current_function_decl
));
4178 /* Generate rtl for function exit. */
4179 expand_function_end ();
4181 end
= get_last_insn ();
4184 /* While emitting the function end we could move end of the last basic block.
4186 BB_END (EXIT_BLOCK_PTR
->prev_bb
) = orig_end
;
4187 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
4188 head
= NEXT_INSN (head
);
4189 exit_block
= create_basic_block (NEXT_INSN (head
), end
,
4190 EXIT_BLOCK_PTR
->prev_bb
);
4191 exit_block
->frequency
= EXIT_BLOCK_PTR
->frequency
;
4192 exit_block
->count
= EXIT_BLOCK_PTR
->count
;
4193 if (current_loops
&& EXIT_BLOCK_PTR
->loop_father
)
4194 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR
->loop_father
);
4197 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR
->preds
))
4199 e
= EDGE_PRED (EXIT_BLOCK_PTR
, ix
);
4200 if (!(e
->flags
& EDGE_ABNORMAL
))
4201 redirect_edge_succ (e
, exit_block
);
4206 e
= make_edge (exit_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
4207 e
->probability
= REG_BR_PROB_BASE
;
4208 e
->count
= EXIT_BLOCK_PTR
->count
;
4209 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR
->preds
)
4212 e
->count
-= e2
->count
;
4213 exit_block
->count
-= e2
->count
;
4214 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
4218 if (exit_block
->count
< 0)
4219 exit_block
->count
= 0;
4220 if (exit_block
->frequency
< 0)
4221 exit_block
->frequency
= 0;
4222 update_bb_for_insn (exit_block
);
4225 /* Helper function for discover_nonconstant_array_refs.
4226 Look for ARRAY_REF nodes with non-constant indexes and mark them
4230 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
4231 void *data ATTRIBUTE_UNUSED
)
4235 if (IS_TYPE_OR_DECL_P (t
))
4237 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
4239 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
4240 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
4241 && (!TREE_OPERAND (t
, 2)
4242 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
4243 || (TREE_CODE (t
) == COMPONENT_REF
4244 && (!TREE_OPERAND (t
,2)
4245 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
4246 || TREE_CODE (t
) == BIT_FIELD_REF
4247 || TREE_CODE (t
) == REALPART_EXPR
4248 || TREE_CODE (t
) == IMAGPART_EXPR
4249 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4250 || CONVERT_EXPR_P (t
))
4251 t
= TREE_OPERAND (t
, 0);
4253 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
4255 t
= get_base_address (t
);
4257 && DECL_MODE (t
) != BLKmode
)
4258 TREE_ADDRESSABLE (t
) = 1;
4267 /* RTL expansion is not able to compile array references with variable
4268 offsets for arrays stored in single register. Discover such
4269 expressions and mark variables as addressable to avoid this
4273 discover_nonconstant_array_refs (void)
4276 gimple_stmt_iterator gsi
;
4279 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4281 gimple stmt
= gsi_stmt (gsi
);
4282 if (!is_gimple_debug (stmt
))
4283 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
4287 /* This function sets crtl->args.internal_arg_pointer to a virtual
4288 register if DRAP is needed. Local register allocator will replace
4289 virtual_incoming_args_rtx with the virtual register. */
4292 expand_stack_alignment (void)
4295 unsigned int preferred_stack_boundary
;
4297 if (! SUPPORTS_STACK_ALIGNMENT
)
4300 if (cfun
->calls_alloca
4301 || cfun
->has_nonlocal_label
4302 || crtl
->has_nonlocal_goto
)
4303 crtl
->need_drap
= true;
4305 /* Call update_stack_boundary here again to update incoming stack
4306 boundary. It may set incoming stack alignment to a different
4307 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
4308 use the minimum incoming stack alignment to check if it is OK
4309 to perform sibcall optimization since sibcall optimization will
4310 only align the outgoing stack to incoming stack boundary. */
4311 if (targetm
.calls
.update_stack_boundary
)
4312 targetm
.calls
.update_stack_boundary ();
4314 /* The incoming stack frame has to be aligned at least at
4315 parm_stack_boundary. */
4316 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
4318 /* Update crtl->stack_alignment_estimated and use it later to align
4319 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
4320 exceptions since callgraph doesn't collect incoming stack alignment
4322 if (cfun
->can_throw_non_call_exceptions
4323 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
4324 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
4326 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
4327 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
4328 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
4329 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
4330 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
4332 gcc_assert (crtl
->stack_alignment_needed
4333 <= crtl
->stack_alignment_estimated
);
4335 crtl
->stack_realign_needed
4336 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
4337 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
4339 crtl
->stack_realign_processed
= true;
4341 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
4343 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
4344 drap_rtx
= targetm
.calls
.get_drap_rtx ();
4346 /* stack_realign_drap and drap_rtx must match. */
4347 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
4349 /* Do nothing if NULL is returned, which means DRAP is not needed. */
4350 if (NULL
!= drap_rtx
)
4352 crtl
->args
.internal_arg_pointer
= drap_rtx
;
4354 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
4356 fixup_tail_calls ();
4360 /* Translate the intermediate representation contained in the CFG
4361 from GIMPLE trees to RTL.
4363 We do conversion per basic block and preserve/update the tree CFG.
4364 This implies we have to do some magic as the CFG can simultaneously
4365 consist of basic blocks containing RTL and GIMPLE trees. This can
4366 confuse the CFG hooks, so be careful to not manipulate CFG during
4370 gimple_expand_cfg (void)
4372 basic_block bb
, init_block
;
4379 timevar_push (TV_OUT_OF_SSA
);
4380 rewrite_out_of_ssa (&SA
);
4381 timevar_pop (TV_OUT_OF_SSA
);
4382 SA
.partition_to_pseudo
= (rtx
*)xcalloc (SA
.map
->num_partitions
,
4385 /* Make sure all values used by the optimization passes have sane
4389 /* Some backends want to know that we are expanding to RTL. */
4390 currently_expanding_to_rtl
= 1;
4391 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
4392 free_dominance_info (CDI_DOMINATORS
);
4394 rtl_profile_for_bb (ENTRY_BLOCK_PTR
);
4396 insn_locators_alloc ();
4397 if (!DECL_IS_BUILTIN (current_function_decl
))
4399 /* Eventually, all FEs should explicitly set function_start_locus. */
4400 if (cfun
->function_start_locus
== UNKNOWN_LOCATION
)
4401 set_curr_insn_source_location
4402 (DECL_SOURCE_LOCATION (current_function_decl
));
4404 set_curr_insn_source_location (cfun
->function_start_locus
);
4407 set_curr_insn_source_location (UNKNOWN_LOCATION
);
4408 set_curr_insn_block (DECL_INITIAL (current_function_decl
));
4409 prologue_locator
= curr_insn_locator ();
4411 #ifdef INSN_SCHEDULING
4412 init_sched_attrs ();
4415 /* Make sure first insn is a note even if we don't want linenums.
4416 This makes sure the first insn will never be deleted.
4417 Also, final expects a note to appear there. */
4418 emit_note (NOTE_INSN_DELETED
);
4420 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
4421 discover_nonconstant_array_refs ();
4423 targetm
.expand_to_rtl_hook ();
4424 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
4425 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
4426 crtl
->stack_alignment_estimated
= 0;
4427 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
4428 cfun
->cfg
->max_jumptable_ents
= 0;
4430 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
4431 of the function section at exapnsion time to predict distance of calls. */
4432 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
4434 /* Expand the variables recorded during gimple lowering. */
4435 timevar_push (TV_VAR_EXPAND
);
4438 expand_used_vars ();
4440 var_seq
= get_insns ();
4442 timevar_pop (TV_VAR_EXPAND
);
4444 /* Honor stack protection warnings. */
4445 if (warn_stack_protect
)
4447 if (cfun
->calls_alloca
)
4448 warning (OPT_Wstack_protector
,
4449 "stack protector not protecting local variables: "
4450 "variable length buffer");
4451 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
4452 warning (OPT_Wstack_protector
,
4453 "stack protector not protecting function: "
4454 "all local arrays are less than %d bytes long",
4455 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
4458 /* Set up parameters and prepare for return, for the function. */
4459 expand_function_start (current_function_decl
);
4461 /* If we emitted any instructions for setting up the variables,
4462 emit them before the FUNCTION_START note. */
4465 emit_insn_before (var_seq
, parm_birth_insn
);
4467 /* In expand_function_end we'll insert the alloca save/restore
4468 before parm_birth_insn. We've just insertted an alloca call.
4469 Adjust the pointer to match. */
4470 parm_birth_insn
= var_seq
;
4473 /* Now that we also have the parameter RTXs, copy them over to our
4475 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
4477 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
4479 if (TREE_CODE (var
) != VAR_DECL
4480 && !SA
.partition_to_pseudo
[i
])
4481 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
4482 gcc_assert (SA
.partition_to_pseudo
[i
]);
4484 /* If this decl was marked as living in multiple places, reset
4485 this now to NULL. */
4486 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
4487 SET_DECL_RTL (var
, NULL
);
4489 /* Some RTL parts really want to look at DECL_RTL(x) when x
4490 was a decl marked in REG_ATTR or MEM_ATTR. We could use
4491 SET_DECL_RTL here making this available, but that would mean
4492 to select one of the potentially many RTLs for one DECL. Instead
4493 of doing that we simply reset the MEM_EXPR of the RTL in question,
4494 then nobody can get at it and hence nobody can call DECL_RTL on it. */
4495 if (!DECL_RTL_SET_P (var
))
4497 if (MEM_P (SA
.partition_to_pseudo
[i
]))
4498 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
4502 /* If we have a class containing differently aligned pointers
4503 we need to merge those into the corresponding RTL pointer
4505 for (i
= 1; i
< num_ssa_names
; i
++)
4507 tree name
= ssa_name (i
);
4512 || !POINTER_TYPE_P (TREE_TYPE (name
))
4513 /* We might have generated new SSA names in
4514 update_alias_info_with_stack_vars. They will have a NULL
4515 defining statements, and won't be part of the partitioning,
4517 || !SSA_NAME_DEF_STMT (name
))
4519 part
= var_to_partition (SA
.map
, name
);
4520 if (part
== NO_PARTITION
)
4522 r
= SA
.partition_to_pseudo
[part
];
4524 mark_reg_pointer (r
, get_pointer_alignment (name
));
4527 /* If this function is `main', emit a call to `__main'
4528 to run global initializers, etc. */
4529 if (DECL_NAME (current_function_decl
)
4530 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
4531 && DECL_FILE_SCOPE_P (current_function_decl
))
4532 expand_main_function ();
4534 /* Initialize the stack_protect_guard field. This must happen after the
4535 call to __main (if any) so that the external decl is initialized. */
4536 if (crtl
->stack_protect_guard
)
4537 stack_protect_prologue ();
4539 expand_phi_nodes (&SA
);
4541 /* Register rtl specific functions for cfg. */
4542 rtl_register_cfg_hooks ();
4544 init_block
= construct_init_block ();
4546 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
4547 remaining edges later. */
4548 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
4549 e
->flags
&= ~EDGE_EXECUTABLE
;
4551 lab_rtx_for_bb
= pointer_map_create ();
4552 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
4553 bb
= expand_gimple_basic_block (bb
);
4555 if (MAY_HAVE_DEBUG_INSNS
)
4556 expand_debug_locations ();
4558 execute_free_datastructures ();
4559 timevar_push (TV_OUT_OF_SSA
);
4560 finish_out_of_ssa (&SA
);
4561 timevar_pop (TV_OUT_OF_SSA
);
4563 timevar_push (TV_POST_EXPAND
);
4564 /* We are no longer in SSA form. */
4565 cfun
->gimple_df
->in_ssa_p
= false;
4567 loops_state_clear (LOOP_CLOSED_SSA
);
4569 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
4570 conservatively to true until they are all profile aware. */
4571 pointer_map_destroy (lab_rtx_for_bb
);
4574 construct_exit_block ();
4575 set_curr_insn_block (DECL_INITIAL (current_function_decl
));
4576 insn_locators_finalize ();
4578 /* Zap the tree EH table. */
4579 set_eh_throw_stmt_table (cfun
, NULL
);
4581 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
4582 split edges which edge insertions might do. */
4583 rebuild_jump_labels (get_insns ());
4585 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
4589 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4593 rebuild_jump_labels_chain (e
->insns
.r
);
4594 /* Avoid putting insns before parm_birth_insn. */
4595 if (e
->src
== ENTRY_BLOCK_PTR
4596 && single_succ_p (ENTRY_BLOCK_PTR
)
4599 rtx insns
= e
->insns
.r
;
4600 e
->insns
.r
= NULL_RTX
;
4601 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
4604 commit_one_edge_insertion (e
);
4611 /* We're done expanding trees to RTL. */
4612 currently_expanding_to_rtl
= 0;
4614 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
4618 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4620 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
4621 e
->flags
&= ~EDGE_EXECUTABLE
;
4623 /* At the moment not all abnormal edges match the RTL
4624 representation. It is safe to remove them here as
4625 find_many_sub_basic_blocks will rediscover them.
4626 In the future we should get this fixed properly. */
4627 if ((e
->flags
& EDGE_ABNORMAL
)
4628 && !(e
->flags
& EDGE_SIBCALL
))
4635 blocks
= sbitmap_alloc (last_basic_block
);
4636 sbitmap_ones (blocks
);
4637 find_many_sub_basic_blocks (blocks
);
4638 sbitmap_free (blocks
);
4639 purge_all_dead_edges ();
4641 expand_stack_alignment ();
4643 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
4645 if (crtl
->tail_call_emit
)
4646 fixup_tail_calls ();
4648 /* After initial rtl generation, call back to finish generating
4649 exception support code. We need to do this before cleaning up
4650 the CFG as the code does not expect dead landing pads. */
4651 if (cfun
->eh
->region_tree
!= NULL
)
4652 finish_eh_generation ();
4654 /* Remove unreachable blocks, otherwise we cannot compute dominators
4655 which are needed for loop state verification. As a side-effect
4656 this also compacts blocks.
4657 ??? We cannot remove trivially dead insns here as for example
4658 the DRAP reg on i?86 is not magically live at this point.
4659 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
4660 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
4662 #ifdef ENABLE_CHECKING
4663 verify_flow_info ();
4666 /* Initialize pseudos allocated for hard registers. */
4667 emit_initial_value_sets ();
4669 /* And finally unshare all RTL. */
4672 /* There's no need to defer outputting this function any more; we
4673 know we want to output it. */
4674 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
4676 /* Now that we're done expanding trees to RTL, we shouldn't have any
4677 more CONCATs anywhere. */
4678 generating_concat_p
= 0;
4683 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
4684 /* And the pass manager will dump RTL for us. */
4687 /* If we're emitting a nested function, make sure its parent gets
4688 emitted as well. Doing otherwise confuses debug info. */
4691 for (parent
= DECL_CONTEXT (current_function_decl
);
4692 parent
!= NULL_TREE
;
4693 parent
= get_containing_scope (parent
))
4694 if (TREE_CODE (parent
) == FUNCTION_DECL
)
4695 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
4698 /* We are now committed to emitting code for this function. Do any
4699 preparation, such as emitting abstract debug info for the inline
4700 before it gets mangled by optimization. */
4701 if (cgraph_function_possibly_inlined_p (current_function_decl
))
4702 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
4704 TREE_ASM_WRITTEN (current_function_decl
) = 1;
4706 /* After expanding, the return labels are no longer needed. */
4707 return_label
= NULL
;
4708 naked_return_label
= NULL
;
4710 /* After expanding, the tm_restart map is no longer needed. */
4711 if (cfun
->gimple_df
->tm_restart
)
4713 htab_delete (cfun
->gimple_df
->tm_restart
);
4714 cfun
->gimple_df
->tm_restart
= NULL
;
4717 /* Tag the blocks with a depth number so that change_scope can find
4718 the common parent easily. */
4719 set_block_levels (DECL_INITIAL (cfun
->decl
), 0);
4720 default_rtl_profile ();
4722 timevar_pop (TV_POST_EXPAND
);
4727 struct rtl_opt_pass pass_expand
=
4731 "expand", /* name */
4733 gimple_expand_cfg
, /* execute */
4736 0, /* static_pass_number */
4737 TV_EXPAND
, /* tv_id */
4738 PROP_ssa
| PROP_gimple_leh
| PROP_cfg
4739 | PROP_gimple_lcx
, /* properties_required */
4740 PROP_rtl
, /* properties_provided */
4741 PROP_ssa
| PROP_trees
, /* properties_destroyed */
4742 TODO_verify_ssa
| TODO_verify_flow
4743 | TODO_verify_stmts
, /* todo_flags_start */
4744 TODO_ggc_collect
/* todo_flags_finish */