2017-10-16 Tamar Christina <tamar.christina@arm.com>
[official-gcc.git] / gcc / cfgexpand.c
blobbe93c5843e50c6157edd61437240c9f578152540
1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "backend.h"
24 #include "target.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "gimple.h"
28 #include "cfghooks.h"
29 #include "tree-pass.h"
30 #include "memmodel.h"
31 #include "tm_p.h"
32 #include "ssa.h"
33 #include "optabs.h"
34 #include "regs.h" /* For reg_renumber. */
35 #include "emit-rtl.h"
36 #include "recog.h"
37 #include "cgraph.h"
38 #include "diagnostic.h"
39 #include "fold-const.h"
40 #include "varasm.h"
41 #include "stor-layout.h"
42 #include "stmt.h"
43 #include "print-tree.h"
44 #include "cfgrtl.h"
45 #include "cfganal.h"
46 #include "cfgbuild.h"
47 #include "cfgcleanup.h"
48 #include "dojump.h"
49 #include "explow.h"
50 #include "calls.h"
51 #include "expr.h"
52 #include "internal-fn.h"
53 #include "tree-eh.h"
54 #include "gimple-iterator.h"
55 #include "gimple-expr.h"
56 #include "gimple-walk.h"
57 #include "tree-cfg.h"
58 #include "tree-dfa.h"
59 #include "tree-ssa.h"
60 #include "except.h"
61 #include "gimple-pretty-print.h"
62 #include "toplev.h"
63 #include "debug.h"
64 #include "params.h"
65 #include "tree-inline.h"
66 #include "value-prof.h"
67 #include "tree-ssa-live.h"
68 #include "tree-outof-ssa.h"
69 #include "cfgloop.h"
70 #include "insn-attr.h" /* For INSN_SCHEDULING. */
71 #include "stringpool.h"
72 #include "attribs.h"
73 #include "asan.h"
74 #include "tree-ssa-address.h"
75 #include "output.h"
76 #include "builtins.h"
77 #include "tree-chkp.h"
78 #include "rtl-chkp.h"
80 /* Some systems use __main in a way incompatible with its use in gcc, in these
81 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
82 give the same symbol without quotes for an alternative entry point. You
83 must define both, or neither. */
84 #ifndef NAME__MAIN
85 #define NAME__MAIN "__main"
86 #endif
88 /* This variable holds information helping the rewriting of SSA trees
89 into RTL. */
90 struct ssaexpand SA;
92 /* This variable holds the currently expanded gimple statement for purposes
93 of comminucating the profile info to the builtin expanders. */
94 gimple *currently_expanding_gimple_stmt;
96 static rtx expand_debug_expr (tree);
98 static bool defer_stack_allocation (tree, bool);
100 static void record_alignment_for_reg_var (unsigned int);
102 /* Return an expression tree corresponding to the RHS of GIMPLE
103 statement STMT. */
105 tree
106 gimple_assign_rhs_to_tree (gimple *stmt)
108 tree t;
109 enum gimple_rhs_class grhs_class;
111 grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
113 if (grhs_class == GIMPLE_TERNARY_RHS)
114 t = build3 (gimple_assign_rhs_code (stmt),
115 TREE_TYPE (gimple_assign_lhs (stmt)),
116 gimple_assign_rhs1 (stmt),
117 gimple_assign_rhs2 (stmt),
118 gimple_assign_rhs3 (stmt));
119 else if (grhs_class == GIMPLE_BINARY_RHS)
120 t = build2 (gimple_assign_rhs_code (stmt),
121 TREE_TYPE (gimple_assign_lhs (stmt)),
122 gimple_assign_rhs1 (stmt),
123 gimple_assign_rhs2 (stmt));
124 else if (grhs_class == GIMPLE_UNARY_RHS)
125 t = build1 (gimple_assign_rhs_code (stmt),
126 TREE_TYPE (gimple_assign_lhs (stmt)),
127 gimple_assign_rhs1 (stmt));
128 else if (grhs_class == GIMPLE_SINGLE_RHS)
130 t = gimple_assign_rhs1 (stmt);
131 /* Avoid modifying this tree in place below. */
132 if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
133 && gimple_location (stmt) != EXPR_LOCATION (t))
134 || (gimple_block (stmt)
135 && currently_expanding_to_rtl
136 && EXPR_P (t)))
137 t = copy_node (t);
139 else
140 gcc_unreachable ();
142 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
143 SET_EXPR_LOCATION (t, gimple_location (stmt));
145 return t;
149 #ifndef STACK_ALIGNMENT_NEEDED
150 #define STACK_ALIGNMENT_NEEDED 1
151 #endif
153 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
155 /* Choose either CUR or NEXT as the leader DECL for a partition.
156 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
157 out of the same user variable being in multiple partitions (this is
158 less likely for compiler-introduced temps). */
160 static tree
161 leader_merge (tree cur, tree next)
163 if (cur == NULL || cur == next)
164 return next;
166 if (DECL_P (cur) && DECL_IGNORED_P (cur))
167 return cur;
169 if (DECL_P (next) && DECL_IGNORED_P (next))
170 return next;
172 return cur;
175 /* Associate declaration T with storage space X. If T is no
176 SSA name this is exactly SET_DECL_RTL, otherwise make the
177 partition of T associated with X. */
178 static inline void
179 set_rtl (tree t, rtx x)
181 gcc_checking_assert (!x
182 || !(TREE_CODE (t) == SSA_NAME || is_gimple_reg (t))
183 || (use_register_for_decl (t)
184 ? (REG_P (x)
185 || (GET_CODE (x) == CONCAT
186 && (REG_P (XEXP (x, 0))
187 || SUBREG_P (XEXP (x, 0)))
188 && (REG_P (XEXP (x, 1))
189 || SUBREG_P (XEXP (x, 1))))
190 /* We need to accept PARALLELs for RESUT_DECLs
191 because of vector types with BLKmode returned
192 in multiple registers, but they are supposed
193 to be uncoalesced. */
194 || (GET_CODE (x) == PARALLEL
195 && SSAVAR (t)
196 && TREE_CODE (SSAVAR (t)) == RESULT_DECL
197 && (GET_MODE (x) == BLKmode
198 || !flag_tree_coalesce_vars)))
199 : (MEM_P (x) || x == pc_rtx
200 || (GET_CODE (x) == CONCAT
201 && MEM_P (XEXP (x, 0))
202 && MEM_P (XEXP (x, 1))))));
203 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
204 RESULT_DECLs has the expected mode. For memory, we accept
205 unpromoted modes, since that's what we're likely to get. For
206 PARM_DECLs and RESULT_DECLs, we'll have been called by
207 set_parm_rtl, which will give us the default def, so we don't
208 have to compute it ourselves. For RESULT_DECLs, we accept mode
209 mismatches too, as long as we have BLKmode or are not coalescing
210 across variables, so that we don't reject BLKmode PARALLELs or
211 unpromoted REGs. */
212 gcc_checking_assert (!x || x == pc_rtx || TREE_CODE (t) != SSA_NAME
213 || (SSAVAR (t)
214 && TREE_CODE (SSAVAR (t)) == RESULT_DECL
215 && (promote_ssa_mode (t, NULL) == BLKmode
216 || !flag_tree_coalesce_vars))
217 || !use_register_for_decl (t)
218 || GET_MODE (x) == promote_ssa_mode (t, NULL));
220 if (x)
222 bool skip = false;
223 tree cur = NULL_TREE;
224 rtx xm = x;
226 retry:
227 if (MEM_P (xm))
228 cur = MEM_EXPR (xm);
229 else if (REG_P (xm))
230 cur = REG_EXPR (xm);
231 else if (SUBREG_P (xm))
233 gcc_assert (subreg_lowpart_p (xm));
234 xm = SUBREG_REG (xm);
235 goto retry;
237 else if (GET_CODE (xm) == CONCAT)
239 xm = XEXP (xm, 0);
240 goto retry;
242 else if (GET_CODE (xm) == PARALLEL)
244 xm = XVECEXP (xm, 0, 0);
245 gcc_assert (GET_CODE (xm) == EXPR_LIST);
246 xm = XEXP (xm, 0);
247 goto retry;
249 else if (xm == pc_rtx)
250 skip = true;
251 else
252 gcc_unreachable ();
254 tree next = skip ? cur : leader_merge (cur, SSAVAR (t) ? SSAVAR (t) : t);
256 if (cur != next)
258 if (MEM_P (x))
259 set_mem_attributes (x,
260 next && TREE_CODE (next) == SSA_NAME
261 ? TREE_TYPE (next)
262 : next, true);
263 else
264 set_reg_attrs_for_decl_rtl (next, x);
268 if (TREE_CODE (t) == SSA_NAME)
270 int part = var_to_partition (SA.map, t);
271 if (part != NO_PARTITION)
273 if (SA.partition_to_pseudo[part])
274 gcc_assert (SA.partition_to_pseudo[part] == x);
275 else if (x != pc_rtx)
276 SA.partition_to_pseudo[part] = x;
278 /* For the benefit of debug information at -O0 (where
279 vartracking doesn't run) record the place also in the base
280 DECL. For PARMs and RESULTs, do so only when setting the
281 default def. */
282 if (x && x != pc_rtx && SSA_NAME_VAR (t)
283 && (VAR_P (SSA_NAME_VAR (t))
284 || SSA_NAME_IS_DEFAULT_DEF (t)))
286 tree var = SSA_NAME_VAR (t);
287 /* If we don't yet have something recorded, just record it now. */
288 if (!DECL_RTL_SET_P (var))
289 SET_DECL_RTL (var, x);
290 /* If we have it set already to "multiple places" don't
291 change this. */
292 else if (DECL_RTL (var) == pc_rtx)
294 /* If we have something recorded and it's not the same place
295 as we want to record now, we have multiple partitions for the
296 same base variable, with different places. We can't just
297 randomly chose one, hence we have to say that we don't know.
298 This only happens with optimization, and there var-tracking
299 will figure out the right thing. */
300 else if (DECL_RTL (var) != x)
301 SET_DECL_RTL (var, pc_rtx);
304 else
305 SET_DECL_RTL (t, x);
308 /* This structure holds data relevant to one variable that will be
309 placed in a stack slot. */
310 struct stack_var
312 /* The Variable. */
313 tree decl;
315 /* Initially, the size of the variable. Later, the size of the partition,
316 if this variable becomes it's partition's representative. */
317 HOST_WIDE_INT size;
319 /* The *byte* alignment required for this variable. Or as, with the
320 size, the alignment for this partition. */
321 unsigned int alignb;
323 /* The partition representative. */
324 size_t representative;
326 /* The next stack variable in the partition, or EOC. */
327 size_t next;
329 /* The numbers of conflicting stack variables. */
330 bitmap conflicts;
333 #define EOC ((size_t)-1)
335 /* We have an array of such objects while deciding allocation. */
336 static struct stack_var *stack_vars;
337 static size_t stack_vars_alloc;
338 static size_t stack_vars_num;
339 static hash_map<tree, size_t> *decl_to_stack_part;
341 /* Conflict bitmaps go on this obstack. This allows us to destroy
342 all of them in one big sweep. */
343 static bitmap_obstack stack_var_bitmap_obstack;
345 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
346 is non-decreasing. */
347 static size_t *stack_vars_sorted;
349 /* The phase of the stack frame. This is the known misalignment of
350 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
351 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
352 static int frame_phase;
354 /* Used during expand_used_vars to remember if we saw any decls for
355 which we'd like to enable stack smashing protection. */
356 static bool has_protected_decls;
358 /* Used during expand_used_vars. Remember if we say a character buffer
359 smaller than our cutoff threshold. Used for -Wstack-protector. */
360 static bool has_short_buffer;
362 /* Compute the byte alignment to use for DECL. Ignore alignment
363 we can't do with expected alignment of the stack boundary. */
365 static unsigned int
366 align_local_variable (tree decl)
368 unsigned int align;
370 if (TREE_CODE (decl) == SSA_NAME)
371 align = TYPE_ALIGN (TREE_TYPE (decl));
372 else
374 align = LOCAL_DECL_ALIGNMENT (decl);
375 SET_DECL_ALIGN (decl, align);
377 return align / BITS_PER_UNIT;
380 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
381 down otherwise. Return truncated BASE value. */
383 static inline unsigned HOST_WIDE_INT
384 align_base (HOST_WIDE_INT base, unsigned HOST_WIDE_INT align, bool align_up)
386 return align_up ? (base + align - 1) & -align : base & -align;
389 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
390 Return the frame offset. */
392 static HOST_WIDE_INT
393 alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
395 HOST_WIDE_INT offset, new_frame_offset;
397 if (FRAME_GROWS_DOWNWARD)
399 new_frame_offset
400 = align_base (frame_offset - frame_phase - size,
401 align, false) + frame_phase;
402 offset = new_frame_offset;
404 else
406 new_frame_offset
407 = align_base (frame_offset - frame_phase, align, true) + frame_phase;
408 offset = new_frame_offset;
409 new_frame_offset += size;
411 frame_offset = new_frame_offset;
413 if (frame_offset_overflow (frame_offset, cfun->decl))
414 frame_offset = offset = 0;
416 return offset;
419 /* Accumulate DECL into STACK_VARS. */
421 static void
422 add_stack_var (tree decl)
424 struct stack_var *v;
426 if (stack_vars_num >= stack_vars_alloc)
428 if (stack_vars_alloc)
429 stack_vars_alloc = stack_vars_alloc * 3 / 2;
430 else
431 stack_vars_alloc = 32;
432 stack_vars
433 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
435 if (!decl_to_stack_part)
436 decl_to_stack_part = new hash_map<tree, size_t>;
438 v = &stack_vars[stack_vars_num];
439 decl_to_stack_part->put (decl, stack_vars_num);
441 v->decl = decl;
442 tree size = TREE_CODE (decl) == SSA_NAME
443 ? TYPE_SIZE_UNIT (TREE_TYPE (decl))
444 : DECL_SIZE_UNIT (decl);
445 v->size = tree_to_uhwi (size);
446 /* Ensure that all variables have size, so that &a != &b for any two
447 variables that are simultaneously live. */
448 if (v->size == 0)
449 v->size = 1;
450 v->alignb = align_local_variable (decl);
451 /* An alignment of zero can mightily confuse us later. */
452 gcc_assert (v->alignb != 0);
454 /* All variables are initially in their own partition. */
455 v->representative = stack_vars_num;
456 v->next = EOC;
458 /* All variables initially conflict with no other. */
459 v->conflicts = NULL;
461 /* Ensure that this decl doesn't get put onto the list twice. */
462 set_rtl (decl, pc_rtx);
464 stack_vars_num++;
467 /* Make the decls associated with luid's X and Y conflict. */
469 static void
470 add_stack_var_conflict (size_t x, size_t y)
472 struct stack_var *a = &stack_vars[x];
473 struct stack_var *b = &stack_vars[y];
474 if (!a->conflicts)
475 a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
476 if (!b->conflicts)
477 b->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
478 bitmap_set_bit (a->conflicts, y);
479 bitmap_set_bit (b->conflicts, x);
482 /* Check whether the decls associated with luid's X and Y conflict. */
484 static bool
485 stack_var_conflict_p (size_t x, size_t y)
487 struct stack_var *a = &stack_vars[x];
488 struct stack_var *b = &stack_vars[y];
489 if (x == y)
490 return false;
491 /* Partitions containing an SSA name result from gimple registers
492 with things like unsupported modes. They are top-level and
493 hence conflict with everything else. */
494 if (TREE_CODE (a->decl) == SSA_NAME || TREE_CODE (b->decl) == SSA_NAME)
495 return true;
497 if (!a->conflicts || !b->conflicts)
498 return false;
499 return bitmap_bit_p (a->conflicts, y);
502 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
503 enter its partition number into bitmap DATA. */
505 static bool
506 visit_op (gimple *, tree op, tree, void *data)
508 bitmap active = (bitmap)data;
509 op = get_base_address (op);
510 if (op
511 && DECL_P (op)
512 && DECL_RTL_IF_SET (op) == pc_rtx)
514 size_t *v = decl_to_stack_part->get (op);
515 if (v)
516 bitmap_set_bit (active, *v);
518 return false;
521 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
522 record conflicts between it and all currently active other partitions
523 from bitmap DATA. */
525 static bool
526 visit_conflict (gimple *, tree op, tree, void *data)
528 bitmap active = (bitmap)data;
529 op = get_base_address (op);
530 if (op
531 && DECL_P (op)
532 && DECL_RTL_IF_SET (op) == pc_rtx)
534 size_t *v = decl_to_stack_part->get (op);
535 if (v && bitmap_set_bit (active, *v))
537 size_t num = *v;
538 bitmap_iterator bi;
539 unsigned i;
540 gcc_assert (num < stack_vars_num);
541 EXECUTE_IF_SET_IN_BITMAP (active, 0, i, bi)
542 add_stack_var_conflict (num, i);
545 return false;
548 /* Helper routine for add_scope_conflicts, calculating the active partitions
549 at the end of BB, leaving the result in WORK. We're called to generate
550 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
551 liveness. */
553 static void
554 add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
556 edge e;
557 edge_iterator ei;
558 gimple_stmt_iterator gsi;
559 walk_stmt_load_store_addr_fn visit;
561 bitmap_clear (work);
562 FOR_EACH_EDGE (e, ei, bb->preds)
563 bitmap_ior_into (work, (bitmap)e->src->aux);
565 visit = visit_op;
567 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
569 gimple *stmt = gsi_stmt (gsi);
570 walk_stmt_load_store_addr_ops (stmt, work, NULL, NULL, visit);
572 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
574 gimple *stmt = gsi_stmt (gsi);
576 if (gimple_clobber_p (stmt))
578 tree lhs = gimple_assign_lhs (stmt);
579 size_t *v;
580 /* Nested function lowering might introduce LHSs
581 that are COMPONENT_REFs. */
582 if (!VAR_P (lhs))
583 continue;
584 if (DECL_RTL_IF_SET (lhs) == pc_rtx
585 && (v = decl_to_stack_part->get (lhs)))
586 bitmap_clear_bit (work, *v);
588 else if (!is_gimple_debug (stmt))
590 if (for_conflict
591 && visit == visit_op)
593 /* If this is the first real instruction in this BB we need
594 to add conflicts for everything live at this point now.
595 Unlike classical liveness for named objects we can't
596 rely on seeing a def/use of the names we're interested in.
597 There might merely be indirect loads/stores. We'd not add any
598 conflicts for such partitions. */
599 bitmap_iterator bi;
600 unsigned i;
601 EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
603 struct stack_var *a = &stack_vars[i];
604 if (!a->conflicts)
605 a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
606 bitmap_ior_into (a->conflicts, work);
608 visit = visit_conflict;
610 walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
615 /* Generate stack partition conflicts between all partitions that are
616 simultaneously live. */
618 static void
619 add_scope_conflicts (void)
621 basic_block bb;
622 bool changed;
623 bitmap work = BITMAP_ALLOC (NULL);
624 int *rpo;
625 int n_bbs;
627 /* We approximate the live range of a stack variable by taking the first
628 mention of its name as starting point(s), and by the end-of-scope
629 death clobber added by gimplify as ending point(s) of the range.
630 This overapproximates in the case we for instance moved an address-taken
631 operation upward, without also moving a dereference to it upwards.
632 But it's conservatively correct as a variable never can hold values
633 before its name is mentioned at least once.
635 We then do a mostly classical bitmap liveness algorithm. */
637 FOR_ALL_BB_FN (bb, cfun)
638 bb->aux = BITMAP_ALLOC (&stack_var_bitmap_obstack);
640 rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
641 n_bbs = pre_and_rev_post_order_compute (NULL, rpo, false);
643 changed = true;
644 while (changed)
646 int i;
647 changed = false;
648 for (i = 0; i < n_bbs; i++)
650 bitmap active;
651 bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]);
652 active = (bitmap)bb->aux;
653 add_scope_conflicts_1 (bb, work, false);
654 if (bitmap_ior_into (active, work))
655 changed = true;
659 FOR_EACH_BB_FN (bb, cfun)
660 add_scope_conflicts_1 (bb, work, true);
662 free (rpo);
663 BITMAP_FREE (work);
664 FOR_ALL_BB_FN (bb, cfun)
665 BITMAP_FREE (bb->aux);
668 /* A subroutine of partition_stack_vars. A comparison function for qsort,
669 sorting an array of indices by the properties of the object. */
671 static int
672 stack_var_cmp (const void *a, const void *b)
674 size_t ia = *(const size_t *)a;
675 size_t ib = *(const size_t *)b;
676 unsigned int aligna = stack_vars[ia].alignb;
677 unsigned int alignb = stack_vars[ib].alignb;
678 HOST_WIDE_INT sizea = stack_vars[ia].size;
679 HOST_WIDE_INT sizeb = stack_vars[ib].size;
680 tree decla = stack_vars[ia].decl;
681 tree declb = stack_vars[ib].decl;
682 bool largea, largeb;
683 unsigned int uida, uidb;
685 /* Primary compare on "large" alignment. Large comes first. */
686 largea = (aligna * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
687 largeb = (alignb * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
688 if (largea != largeb)
689 return (int)largeb - (int)largea;
691 /* Secondary compare on size, decreasing */
692 if (sizea > sizeb)
693 return -1;
694 if (sizea < sizeb)
695 return 1;
697 /* Tertiary compare on true alignment, decreasing. */
698 if (aligna < alignb)
699 return -1;
700 if (aligna > alignb)
701 return 1;
703 /* Final compare on ID for sort stability, increasing.
704 Two SSA names are compared by their version, SSA names come before
705 non-SSA names, and two normal decls are compared by their DECL_UID. */
706 if (TREE_CODE (decla) == SSA_NAME)
708 if (TREE_CODE (declb) == SSA_NAME)
709 uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
710 else
711 return -1;
713 else if (TREE_CODE (declb) == SSA_NAME)
714 return 1;
715 else
716 uida = DECL_UID (decla), uidb = DECL_UID (declb);
717 if (uida < uidb)
718 return 1;
719 if (uida > uidb)
720 return -1;
721 return 0;
724 struct part_traits : unbounded_int_hashmap_traits <size_t, bitmap> {};
725 typedef hash_map<size_t, bitmap, part_traits> part_hashmap;
727 /* If the points-to solution *PI points to variables that are in a partition
728 together with other variables add all partition members to the pointed-to
729 variables bitmap. */
731 static void
732 add_partitioned_vars_to_ptset (struct pt_solution *pt,
733 part_hashmap *decls_to_partitions,
734 hash_set<bitmap> *visited, bitmap temp)
736 bitmap_iterator bi;
737 unsigned i;
738 bitmap *part;
740 if (pt->anything
741 || pt->vars == NULL
742 /* The pointed-to vars bitmap is shared, it is enough to
743 visit it once. */
744 || visited->add (pt->vars))
745 return;
747 bitmap_clear (temp);
749 /* By using a temporary bitmap to store all members of the partitions
750 we have to add we make sure to visit each of the partitions only
751 once. */
752 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
753 if ((!temp
754 || !bitmap_bit_p (temp, i))
755 && (part = decls_to_partitions->get (i)))
756 bitmap_ior_into (temp, *part);
757 if (!bitmap_empty_p (temp))
758 bitmap_ior_into (pt->vars, temp);
761 /* Update points-to sets based on partition info, so we can use them on RTL.
762 The bitmaps representing stack partitions will be saved until expand,
763 where partitioned decls used as bases in memory expressions will be
764 rewritten. */
766 static void
767 update_alias_info_with_stack_vars (void)
769 part_hashmap *decls_to_partitions = NULL;
770 size_t i, j;
771 tree var = NULL_TREE;
773 for (i = 0; i < stack_vars_num; i++)
775 bitmap part = NULL;
776 tree name;
777 struct ptr_info_def *pi;
779 /* Not interested in partitions with single variable. */
780 if (stack_vars[i].representative != i
781 || stack_vars[i].next == EOC)
782 continue;
784 if (!decls_to_partitions)
786 decls_to_partitions = new part_hashmap;
787 cfun->gimple_df->decls_to_pointers = new hash_map<tree, tree>;
790 /* Create an SSA_NAME that points to the partition for use
791 as base during alias-oracle queries on RTL for bases that
792 have been partitioned. */
793 if (var == NULL_TREE)
794 var = create_tmp_var (ptr_type_node);
795 name = make_ssa_name (var);
797 /* Create bitmaps representing partitions. They will be used for
798 points-to sets later, so use GGC alloc. */
799 part = BITMAP_GGC_ALLOC ();
800 for (j = i; j != EOC; j = stack_vars[j].next)
802 tree decl = stack_vars[j].decl;
803 unsigned int uid = DECL_PT_UID (decl);
804 bitmap_set_bit (part, uid);
805 decls_to_partitions->put (uid, part);
806 cfun->gimple_df->decls_to_pointers->put (decl, name);
807 if (TREE_ADDRESSABLE (decl))
808 TREE_ADDRESSABLE (name) = 1;
811 /* Make the SSA name point to all partition members. */
812 pi = get_ptr_info (name);
813 pt_solution_set (&pi->pt, part, false);
816 /* Make all points-to sets that contain one member of a partition
817 contain all members of the partition. */
818 if (decls_to_partitions)
820 unsigned i;
821 tree name;
822 hash_set<bitmap> visited;
823 bitmap temp = BITMAP_ALLOC (&stack_var_bitmap_obstack);
825 FOR_EACH_SSA_NAME (i, name, cfun)
827 struct ptr_info_def *pi;
829 if (POINTER_TYPE_P (TREE_TYPE (name))
830 && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
831 add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
832 &visited, temp);
835 add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
836 decls_to_partitions, &visited, temp);
838 delete decls_to_partitions;
839 BITMAP_FREE (temp);
843 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
844 partitioning algorithm. Partitions A and B are known to be non-conflicting.
845 Merge them into a single partition A. */
847 static void
848 union_stack_vars (size_t a, size_t b)
850 struct stack_var *vb = &stack_vars[b];
851 bitmap_iterator bi;
852 unsigned u;
854 gcc_assert (stack_vars[b].next == EOC);
855 /* Add B to A's partition. */
856 stack_vars[b].next = stack_vars[a].next;
857 stack_vars[b].representative = a;
858 stack_vars[a].next = b;
860 /* Update the required alignment of partition A to account for B. */
861 if (stack_vars[a].alignb < stack_vars[b].alignb)
862 stack_vars[a].alignb = stack_vars[b].alignb;
864 /* Update the interference graph and merge the conflicts. */
865 if (vb->conflicts)
867 EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)
868 add_stack_var_conflict (a, stack_vars[u].representative);
869 BITMAP_FREE (vb->conflicts);
873 /* A subroutine of expand_used_vars. Binpack the variables into
874 partitions constrained by the interference graph. The overall
875 algorithm used is as follows:
877 Sort the objects by size in descending order.
878 For each object A {
879 S = size(A)
880 O = 0
881 loop {
882 Look for the largest non-conflicting object B with size <= S.
883 UNION (A, B)
888 static void
889 partition_stack_vars (void)
891 size_t si, sj, n = stack_vars_num;
893 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
894 for (si = 0; si < n; ++si)
895 stack_vars_sorted[si] = si;
897 if (n == 1)
898 return;
900 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp);
902 for (si = 0; si < n; ++si)
904 size_t i = stack_vars_sorted[si];
905 unsigned int ialign = stack_vars[i].alignb;
906 HOST_WIDE_INT isize = stack_vars[i].size;
908 /* Ignore objects that aren't partition representatives. If we
909 see a var that is not a partition representative, it must
910 have been merged earlier. */
911 if (stack_vars[i].representative != i)
912 continue;
914 for (sj = si + 1; sj < n; ++sj)
916 size_t j = stack_vars_sorted[sj];
917 unsigned int jalign = stack_vars[j].alignb;
918 HOST_WIDE_INT jsize = stack_vars[j].size;
920 /* Ignore objects that aren't partition representatives. */
921 if (stack_vars[j].representative != j)
922 continue;
924 /* Do not mix objects of "small" (supported) alignment
925 and "large" (unsupported) alignment. */
926 if ((ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
927 != (jalign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT))
928 break;
930 /* For Address Sanitizer do not mix objects with different
931 sizes, as the shorter vars wouldn't be adequately protected.
932 Don't do that for "large" (unsupported) alignment objects,
933 those aren't protected anyway. */
934 if ((asan_sanitize_stack_p ())
935 && isize != jsize
936 && ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
937 break;
939 /* Ignore conflicting objects. */
940 if (stack_var_conflict_p (i, j))
941 continue;
943 /* UNION the objects, placing J at OFFSET. */
944 union_stack_vars (i, j);
948 update_alias_info_with_stack_vars ();
951 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
953 static void
954 dump_stack_var_partition (void)
956 size_t si, i, j, n = stack_vars_num;
958 for (si = 0; si < n; ++si)
960 i = stack_vars_sorted[si];
962 /* Skip variables that aren't partition representatives, for now. */
963 if (stack_vars[i].representative != i)
964 continue;
966 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
967 " align %u\n", (unsigned long) i, stack_vars[i].size,
968 stack_vars[i].alignb);
970 for (j = i; j != EOC; j = stack_vars[j].next)
972 fputc ('\t', dump_file);
973 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
975 fputc ('\n', dump_file);
979 /* Assign rtl to DECL at BASE + OFFSET. */
981 static void
982 expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
983 HOST_WIDE_INT offset)
985 unsigned align;
986 rtx x;
988 /* If this fails, we've overflowed the stack frame. Error nicely? */
989 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
991 x = plus_constant (Pmode, base, offset);
992 x = gen_rtx_MEM (TREE_CODE (decl) == SSA_NAME
993 ? TYPE_MODE (TREE_TYPE (decl))
994 : DECL_MODE (SSAVAR (decl)), x);
996 if (TREE_CODE (decl) != SSA_NAME)
998 /* Set alignment we actually gave this decl if it isn't an SSA name.
999 If it is we generate stack slots only accidentally so it isn't as
1000 important, we'll simply use the alignment that is already set. */
1001 if (base == virtual_stack_vars_rtx)
1002 offset -= frame_phase;
1003 align = least_bit_hwi (offset);
1004 align *= BITS_PER_UNIT;
1005 if (align == 0 || align > base_align)
1006 align = base_align;
1008 /* One would think that we could assert that we're not decreasing
1009 alignment here, but (at least) the i386 port does exactly this
1010 via the MINIMUM_ALIGNMENT hook. */
1012 SET_DECL_ALIGN (decl, align);
1013 DECL_USER_ALIGN (decl) = 0;
1016 set_rtl (decl, x);
1019 struct stack_vars_data
1021 /* Vector of offset pairs, always end of some padding followed
1022 by start of the padding that needs Address Sanitizer protection.
1023 The vector is in reversed, highest offset pairs come first. */
1024 auto_vec<HOST_WIDE_INT> asan_vec;
1026 /* Vector of partition representative decls in between the paddings. */
1027 auto_vec<tree> asan_decl_vec;
1029 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1030 rtx asan_base;
1032 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1033 unsigned int asan_alignb;
1036 /* A subroutine of expand_used_vars. Give each partition representative
1037 a unique location within the stack frame. Update each partition member
1038 with that location. */
1040 static void
1041 expand_stack_vars (bool (*pred) (size_t), struct stack_vars_data *data)
1043 size_t si, i, j, n = stack_vars_num;
1044 HOST_WIDE_INT large_size = 0, large_alloc = 0;
1045 rtx large_base = NULL;
1046 unsigned large_align = 0;
1047 bool large_allocation_done = false;
1048 tree decl;
1050 /* Determine if there are any variables requiring "large" alignment.
1051 Since these are dynamically allocated, we only process these if
1052 no predicate involved. */
1053 large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT;
1054 if (pred == NULL && large_align > MAX_SUPPORTED_STACK_ALIGNMENT)
1056 /* Find the total size of these variables. */
1057 for (si = 0; si < n; ++si)
1059 unsigned alignb;
1061 i = stack_vars_sorted[si];
1062 alignb = stack_vars[i].alignb;
1064 /* All "large" alignment decls come before all "small" alignment
1065 decls, but "large" alignment decls are not sorted based on
1066 their alignment. Increase large_align to track the largest
1067 required alignment. */
1068 if ((alignb * BITS_PER_UNIT) > large_align)
1069 large_align = alignb * BITS_PER_UNIT;
1071 /* Stop when we get to the first decl with "small" alignment. */
1072 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1073 break;
1075 /* Skip variables that aren't partition representatives. */
1076 if (stack_vars[i].representative != i)
1077 continue;
1079 /* Skip variables that have already had rtl assigned. See also
1080 add_stack_var where we perpetrate this pc_rtx hack. */
1081 decl = stack_vars[i].decl;
1082 if (TREE_CODE (decl) == SSA_NAME
1083 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
1084 : DECL_RTL (decl) != pc_rtx)
1085 continue;
1087 large_size += alignb - 1;
1088 large_size &= -(HOST_WIDE_INT)alignb;
1089 large_size += stack_vars[i].size;
1093 for (si = 0; si < n; ++si)
1095 rtx base;
1096 unsigned base_align, alignb;
1097 HOST_WIDE_INT offset;
1099 i = stack_vars_sorted[si];
1101 /* Skip variables that aren't partition representatives, for now. */
1102 if (stack_vars[i].representative != i)
1103 continue;
1105 /* Skip variables that have already had rtl assigned. See also
1106 add_stack_var where we perpetrate this pc_rtx hack. */
1107 decl = stack_vars[i].decl;
1108 if (TREE_CODE (decl) == SSA_NAME
1109 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
1110 : DECL_RTL (decl) != pc_rtx)
1111 continue;
1113 /* Check the predicate to see whether this variable should be
1114 allocated in this pass. */
1115 if (pred && !pred (i))
1116 continue;
1118 alignb = stack_vars[i].alignb;
1119 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1121 base = virtual_stack_vars_rtx;
1122 if ((asan_sanitize_stack_p ())
1123 && pred)
1125 HOST_WIDE_INT prev_offset
1126 = align_base (frame_offset,
1127 MAX (alignb, ASAN_RED_ZONE_SIZE),
1128 !FRAME_GROWS_DOWNWARD);
1129 tree repr_decl = NULL_TREE;
1130 offset
1131 = alloc_stack_frame_space (stack_vars[i].size
1132 + ASAN_RED_ZONE_SIZE,
1133 MAX (alignb, ASAN_RED_ZONE_SIZE));
1135 data->asan_vec.safe_push (prev_offset);
1136 data->asan_vec.safe_push (offset + stack_vars[i].size);
1137 /* Find best representative of the partition.
1138 Prefer those with DECL_NAME, even better
1139 satisfying asan_protect_stack_decl predicate. */
1140 for (j = i; j != EOC; j = stack_vars[j].next)
1141 if (asan_protect_stack_decl (stack_vars[j].decl)
1142 && DECL_NAME (stack_vars[j].decl))
1144 repr_decl = stack_vars[j].decl;
1145 break;
1147 else if (repr_decl == NULL_TREE
1148 && DECL_P (stack_vars[j].decl)
1149 && DECL_NAME (stack_vars[j].decl))
1150 repr_decl = stack_vars[j].decl;
1151 if (repr_decl == NULL_TREE)
1152 repr_decl = stack_vars[i].decl;
1153 data->asan_decl_vec.safe_push (repr_decl);
1154 data->asan_alignb = MAX (data->asan_alignb, alignb);
1155 if (data->asan_base == NULL)
1156 data->asan_base = gen_reg_rtx (Pmode);
1157 base = data->asan_base;
1159 if (!STRICT_ALIGNMENT)
1160 base_align = crtl->max_used_stack_slot_alignment;
1161 else
1162 base_align = MAX (crtl->max_used_stack_slot_alignment,
1163 GET_MODE_ALIGNMENT (SImode)
1164 << ASAN_SHADOW_SHIFT);
1166 else
1168 offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
1169 base_align = crtl->max_used_stack_slot_alignment;
1172 else
1174 /* Large alignment is only processed in the last pass. */
1175 if (pred)
1176 continue;
1178 /* If there were any variables requiring "large" alignment, allocate
1179 space. */
1180 if (large_size > 0 && ! large_allocation_done)
1182 HOST_WIDE_INT loffset;
1183 rtx large_allocsize;
1185 large_allocsize = GEN_INT (large_size);
1186 get_dynamic_stack_size (&large_allocsize, 0, large_align, NULL);
1187 loffset = alloc_stack_frame_space
1188 (INTVAL (large_allocsize),
1189 PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT);
1190 large_base = get_dynamic_stack_base (loffset, large_align);
1191 large_allocation_done = true;
1193 gcc_assert (large_base != NULL);
1195 large_alloc += alignb - 1;
1196 large_alloc &= -(HOST_WIDE_INT)alignb;
1197 offset = large_alloc;
1198 large_alloc += stack_vars[i].size;
1200 base = large_base;
1201 base_align = large_align;
1204 /* Create rtl for each variable based on their location within the
1205 partition. */
1206 for (j = i; j != EOC; j = stack_vars[j].next)
1208 expand_one_stack_var_at (stack_vars[j].decl,
1209 base, base_align,
1210 offset);
1214 gcc_assert (large_alloc == large_size);
1217 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1218 static HOST_WIDE_INT
1219 account_stack_vars (void)
1221 size_t si, j, i, n = stack_vars_num;
1222 HOST_WIDE_INT size = 0;
1224 for (si = 0; si < n; ++si)
1226 i = stack_vars_sorted[si];
1228 /* Skip variables that aren't partition representatives, for now. */
1229 if (stack_vars[i].representative != i)
1230 continue;
1232 size += stack_vars[i].size;
1233 for (j = i; j != EOC; j = stack_vars[j].next)
1234 set_rtl (stack_vars[j].decl, NULL);
1236 return size;
1239 /* Record the RTL assignment X for the default def of PARM. */
1241 extern void
1242 set_parm_rtl (tree parm, rtx x)
1244 gcc_assert (TREE_CODE (parm) == PARM_DECL
1245 || TREE_CODE (parm) == RESULT_DECL);
1247 if (x && !MEM_P (x))
1249 unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (parm),
1250 TYPE_MODE (TREE_TYPE (parm)),
1251 TYPE_ALIGN (TREE_TYPE (parm)));
1253 /* If the variable alignment is very large we'll dynamicaly
1254 allocate it, which means that in-frame portion is just a
1255 pointer. ??? We've got a pseudo for sure here, do we
1256 actually dynamically allocate its spilling area if needed?
1257 ??? Isn't it a problem when POINTER_SIZE also exceeds
1258 MAX_SUPPORTED_STACK_ALIGNMENT, as on cris and lm32? */
1259 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1260 align = POINTER_SIZE;
1262 record_alignment_for_reg_var (align);
1265 tree ssa = ssa_default_def (cfun, parm);
1266 if (!ssa)
1267 return set_rtl (parm, x);
1269 int part = var_to_partition (SA.map, ssa);
1270 gcc_assert (part != NO_PARTITION);
1272 bool changed = bitmap_bit_p (SA.partitions_for_parm_default_defs, part);
1273 gcc_assert (changed);
1275 set_rtl (ssa, x);
1276 gcc_assert (DECL_RTL (parm) == x);
1279 /* A subroutine of expand_one_var. Called to immediately assign rtl
1280 to a variable to be allocated in the stack frame. */
1282 static void
1283 expand_one_stack_var_1 (tree var)
1285 HOST_WIDE_INT size, offset;
1286 unsigned byte_align;
1288 if (TREE_CODE (var) == SSA_NAME)
1290 tree type = TREE_TYPE (var);
1291 size = tree_to_uhwi (TYPE_SIZE_UNIT (type));
1292 byte_align = TYPE_ALIGN_UNIT (type);
1294 else
1296 size = tree_to_uhwi (DECL_SIZE_UNIT (var));
1297 byte_align = align_local_variable (var);
1300 /* We handle highly aligned variables in expand_stack_vars. */
1301 gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
1303 offset = alloc_stack_frame_space (size, byte_align);
1305 expand_one_stack_var_at (var, virtual_stack_vars_rtx,
1306 crtl->max_used_stack_slot_alignment, offset);
1309 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1310 already assigned some MEM. */
1312 static void
1313 expand_one_stack_var (tree var)
1315 if (TREE_CODE (var) == SSA_NAME)
1317 int part = var_to_partition (SA.map, var);
1318 if (part != NO_PARTITION)
1320 rtx x = SA.partition_to_pseudo[part];
1321 gcc_assert (x);
1322 gcc_assert (MEM_P (x));
1323 return;
1327 return expand_one_stack_var_1 (var);
1330 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1331 that will reside in a hard register. */
1333 static void
1334 expand_one_hard_reg_var (tree var)
1336 rest_of_decl_compilation (var, 0, 0);
1339 /* Record the alignment requirements of some variable assigned to a
1340 pseudo. */
1342 static void
1343 record_alignment_for_reg_var (unsigned int align)
1345 if (SUPPORTS_STACK_ALIGNMENT
1346 && crtl->stack_alignment_estimated < align)
1348 /* stack_alignment_estimated shouldn't change after stack
1349 realign decision made */
1350 gcc_assert (!crtl->stack_realign_processed);
1351 crtl->stack_alignment_estimated = align;
1354 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1355 So here we only make sure stack_alignment_needed >= align. */
1356 if (crtl->stack_alignment_needed < align)
1357 crtl->stack_alignment_needed = align;
1358 if (crtl->max_used_stack_slot_alignment < align)
1359 crtl->max_used_stack_slot_alignment = align;
1362 /* Create RTL for an SSA partition. */
1364 static void
1365 expand_one_ssa_partition (tree var)
1367 int part = var_to_partition (SA.map, var);
1368 gcc_assert (part != NO_PARTITION);
1370 if (SA.partition_to_pseudo[part])
1371 return;
1373 unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1374 TYPE_MODE (TREE_TYPE (var)),
1375 TYPE_ALIGN (TREE_TYPE (var)));
1377 /* If the variable alignment is very large we'll dynamicaly allocate
1378 it, which means that in-frame portion is just a pointer. */
1379 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1380 align = POINTER_SIZE;
1382 record_alignment_for_reg_var (align);
1384 if (!use_register_for_decl (var))
1386 if (defer_stack_allocation (var, true))
1387 add_stack_var (var);
1388 else
1389 expand_one_stack_var_1 (var);
1390 return;
1393 machine_mode reg_mode = promote_ssa_mode (var, NULL);
1395 rtx x = gen_reg_rtx (reg_mode);
1397 set_rtl (var, x);
1400 /* Record the association between the RTL generated for partition PART
1401 and the underlying variable of the SSA_NAME VAR. */
1403 static void
1404 adjust_one_expanded_partition_var (tree var)
1406 if (!var)
1407 return;
1409 tree decl = SSA_NAME_VAR (var);
1411 int part = var_to_partition (SA.map, var);
1412 if (part == NO_PARTITION)
1413 return;
1415 rtx x = SA.partition_to_pseudo[part];
1417 gcc_assert (x);
1419 set_rtl (var, x);
1421 if (!REG_P (x))
1422 return;
1424 /* Note if the object is a user variable. */
1425 if (decl && !DECL_ARTIFICIAL (decl))
1426 mark_user_reg (x);
1428 if (POINTER_TYPE_P (decl ? TREE_TYPE (decl) : TREE_TYPE (var)))
1429 mark_reg_pointer (x, get_pointer_alignment (var));
1432 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1433 that will reside in a pseudo register. */
1435 static void
1436 expand_one_register_var (tree var)
1438 if (TREE_CODE (var) == SSA_NAME)
1440 int part = var_to_partition (SA.map, var);
1441 if (part != NO_PARTITION)
1443 rtx x = SA.partition_to_pseudo[part];
1444 gcc_assert (x);
1445 gcc_assert (REG_P (x));
1446 return;
1448 gcc_unreachable ();
1451 tree decl = var;
1452 tree type = TREE_TYPE (decl);
1453 machine_mode reg_mode = promote_decl_mode (decl, NULL);
1454 rtx x = gen_reg_rtx (reg_mode);
1456 set_rtl (var, x);
1458 /* Note if the object is a user variable. */
1459 if (!DECL_ARTIFICIAL (decl))
1460 mark_user_reg (x);
1462 if (POINTER_TYPE_P (type))
1463 mark_reg_pointer (x, get_pointer_alignment (var));
1466 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1467 has some associated error, e.g. its type is error-mark. We just need
1468 to pick something that won't crash the rest of the compiler. */
1470 static void
1471 expand_one_error_var (tree var)
1473 machine_mode mode = DECL_MODE (var);
1474 rtx x;
1476 if (mode == BLKmode)
1477 x = gen_rtx_MEM (BLKmode, const0_rtx);
1478 else if (mode == VOIDmode)
1479 x = const0_rtx;
1480 else
1481 x = gen_reg_rtx (mode);
1483 SET_DECL_RTL (var, x);
1486 /* A subroutine of expand_one_var. VAR is a variable that will be
1487 allocated to the local stack frame. Return true if we wish to
1488 add VAR to STACK_VARS so that it will be coalesced with other
1489 variables. Return false to allocate VAR immediately.
1491 This function is used to reduce the number of variables considered
1492 for coalescing, which reduces the size of the quadratic problem. */
1494 static bool
1495 defer_stack_allocation (tree var, bool toplevel)
1497 tree size_unit = TREE_CODE (var) == SSA_NAME
1498 ? TYPE_SIZE_UNIT (TREE_TYPE (var))
1499 : DECL_SIZE_UNIT (var);
1501 /* Whether the variable is small enough for immediate allocation not to be
1502 a problem with regard to the frame size. */
1503 bool smallish
1504 = ((HOST_WIDE_INT) tree_to_uhwi (size_unit)
1505 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING));
1507 /* If stack protection is enabled, *all* stack variables must be deferred,
1508 so that we can re-order the strings to the top of the frame.
1509 Similarly for Address Sanitizer. */
1510 if (flag_stack_protect || asan_sanitize_stack_p ())
1511 return true;
1513 unsigned int align = TREE_CODE (var) == SSA_NAME
1514 ? TYPE_ALIGN (TREE_TYPE (var))
1515 : DECL_ALIGN (var);
1517 /* We handle "large" alignment via dynamic allocation. We want to handle
1518 this extra complication in only one place, so defer them. */
1519 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1520 return true;
1522 bool ignored = TREE_CODE (var) == SSA_NAME
1523 ? !SSAVAR (var) || DECL_IGNORED_P (SSA_NAME_VAR (var))
1524 : DECL_IGNORED_P (var);
1526 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1527 might be detached from their block and appear at toplevel when we reach
1528 here. We want to coalesce them with variables from other blocks when
1529 the immediate contribution to the frame size would be noticeable. */
1530 if (toplevel && optimize > 0 && ignored && !smallish)
1531 return true;
1533 /* Variables declared in the outermost scope automatically conflict
1534 with every other variable. The only reason to want to defer them
1535 at all is that, after sorting, we can more efficiently pack
1536 small variables in the stack frame. Continue to defer at -O2. */
1537 if (toplevel && optimize < 2)
1538 return false;
1540 /* Without optimization, *most* variables are allocated from the
1541 stack, which makes the quadratic problem large exactly when we
1542 want compilation to proceed as quickly as possible. On the
1543 other hand, we don't want the function's stack frame size to
1544 get completely out of hand. So we avoid adding scalars and
1545 "small" aggregates to the list at all. */
1546 if (optimize == 0 && smallish)
1547 return false;
1549 return true;
1552 /* A subroutine of expand_used_vars. Expand one variable according to
1553 its flavor. Variables to be placed on the stack are not actually
1554 expanded yet, merely recorded.
1555 When REALLY_EXPAND is false, only add stack values to be allocated.
1556 Return stack usage this variable is supposed to take.
1559 static HOST_WIDE_INT
1560 expand_one_var (tree var, bool toplevel, bool really_expand)
1562 unsigned int align = BITS_PER_UNIT;
1563 tree origvar = var;
1565 var = SSAVAR (var);
1567 if (TREE_TYPE (var) != error_mark_node && VAR_P (var))
1569 if (is_global_var (var))
1570 return 0;
1572 /* Because we don't know if VAR will be in register or on stack,
1573 we conservatively assume it will be on stack even if VAR is
1574 eventually put into register after RA pass. For non-automatic
1575 variables, which won't be on stack, we collect alignment of
1576 type and ignore user specified alignment. Similarly for
1577 SSA_NAMEs for which use_register_for_decl returns true. */
1578 if (TREE_STATIC (var)
1579 || DECL_EXTERNAL (var)
1580 || (TREE_CODE (origvar) == SSA_NAME && use_register_for_decl (var)))
1581 align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1582 TYPE_MODE (TREE_TYPE (var)),
1583 TYPE_ALIGN (TREE_TYPE (var)));
1584 else if (DECL_HAS_VALUE_EXPR_P (var)
1585 || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
1586 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1587 or variables which were assigned a stack slot already by
1588 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1589 changed from the offset chosen to it. */
1590 align = crtl->stack_alignment_estimated;
1591 else
1592 align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
1594 /* If the variable alignment is very large we'll dynamicaly allocate
1595 it, which means that in-frame portion is just a pointer. */
1596 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1597 align = POINTER_SIZE;
1600 record_alignment_for_reg_var (align);
1602 if (TREE_CODE (origvar) == SSA_NAME)
1604 gcc_assert (!VAR_P (var)
1605 || (!DECL_EXTERNAL (var)
1606 && !DECL_HAS_VALUE_EXPR_P (var)
1607 && !TREE_STATIC (var)
1608 && TREE_TYPE (var) != error_mark_node
1609 && !DECL_HARD_REGISTER (var)
1610 && really_expand));
1612 if (!VAR_P (var) && TREE_CODE (origvar) != SSA_NAME)
1614 else if (DECL_EXTERNAL (var))
1616 else if (DECL_HAS_VALUE_EXPR_P (var))
1618 else if (TREE_STATIC (var))
1620 else if (TREE_CODE (origvar) != SSA_NAME && DECL_RTL_SET_P (var))
1622 else if (TREE_TYPE (var) == error_mark_node)
1624 if (really_expand)
1625 expand_one_error_var (var);
1627 else if (VAR_P (var) && DECL_HARD_REGISTER (var))
1629 if (really_expand)
1631 expand_one_hard_reg_var (var);
1632 if (!DECL_HARD_REGISTER (var))
1633 /* Invalid register specification. */
1634 expand_one_error_var (var);
1637 else if (use_register_for_decl (var))
1639 if (really_expand)
1640 expand_one_register_var (origvar);
1642 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var)))
1644 /* Reject variables which cover more than half of the address-space. */
1645 if (really_expand)
1647 error ("size of variable %q+D is too large", var);
1648 expand_one_error_var (var);
1651 else if (defer_stack_allocation (var, toplevel))
1652 add_stack_var (origvar);
1653 else
1655 if (really_expand)
1657 if (lookup_attribute ("naked",
1658 DECL_ATTRIBUTES (current_function_decl)))
1659 error ("cannot allocate stack for variable %q+D, naked function.",
1660 var);
1662 expand_one_stack_var (origvar);
1666 return tree_to_uhwi (DECL_SIZE_UNIT (var));
1668 return 0;
1671 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1672 expanding variables. Those variables that can be put into registers
1673 are allocated pseudos; those that can't are put on the stack.
1675 TOPLEVEL is true if this is the outermost BLOCK. */
1677 static void
1678 expand_used_vars_for_block (tree block, bool toplevel)
1680 tree t;
1682 /* Expand all variables at this level. */
1683 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1684 if (TREE_USED (t)
1685 && ((!VAR_P (t) && TREE_CODE (t) != RESULT_DECL)
1686 || !DECL_NONSHAREABLE (t)))
1687 expand_one_var (t, toplevel, true);
1689 /* Expand all variables at containing levels. */
1690 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1691 expand_used_vars_for_block (t, false);
1694 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1695 and clear TREE_USED on all local variables. */
1697 static void
1698 clear_tree_used (tree block)
1700 tree t;
1702 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1703 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1704 if ((!VAR_P (t) && TREE_CODE (t) != RESULT_DECL)
1705 || !DECL_NONSHAREABLE (t))
1706 TREE_USED (t) = 0;
1708 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1709 clear_tree_used (t);
1712 enum {
1713 SPCT_FLAG_DEFAULT = 1,
1714 SPCT_FLAG_ALL = 2,
1715 SPCT_FLAG_STRONG = 3,
1716 SPCT_FLAG_EXPLICIT = 4
1719 /* Examine TYPE and determine a bit mask of the following features. */
1721 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1722 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1723 #define SPCT_HAS_ARRAY 4
1724 #define SPCT_HAS_AGGREGATE 8
1726 static unsigned int
1727 stack_protect_classify_type (tree type)
1729 unsigned int ret = 0;
1730 tree t;
1732 switch (TREE_CODE (type))
1734 case ARRAY_TYPE:
1735 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1736 if (t == char_type_node
1737 || t == signed_char_type_node
1738 || t == unsigned_char_type_node)
1740 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
1741 unsigned HOST_WIDE_INT len;
1743 if (!TYPE_SIZE_UNIT (type)
1744 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type)))
1745 len = max;
1746 else
1747 len = tree_to_uhwi (TYPE_SIZE_UNIT (type));
1749 if (len < max)
1750 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
1751 else
1752 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
1754 else
1755 ret = SPCT_HAS_ARRAY;
1756 break;
1758 case UNION_TYPE:
1759 case QUAL_UNION_TYPE:
1760 case RECORD_TYPE:
1761 ret = SPCT_HAS_AGGREGATE;
1762 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
1763 if (TREE_CODE (t) == FIELD_DECL)
1764 ret |= stack_protect_classify_type (TREE_TYPE (t));
1765 break;
1767 default:
1768 break;
1771 return ret;
1774 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1775 part of the local stack frame. Remember if we ever return nonzero for
1776 any variable in this function. The return value is the phase number in
1777 which the variable should be allocated. */
1779 static int
1780 stack_protect_decl_phase (tree decl)
1782 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
1783 int ret = 0;
1785 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
1786 has_short_buffer = true;
1788 if (flag_stack_protect == SPCT_FLAG_ALL
1789 || flag_stack_protect == SPCT_FLAG_STRONG
1790 || (flag_stack_protect == SPCT_FLAG_EXPLICIT
1791 && lookup_attribute ("stack_protect",
1792 DECL_ATTRIBUTES (current_function_decl))))
1794 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
1795 && !(bits & SPCT_HAS_AGGREGATE))
1796 ret = 1;
1797 else if (bits & SPCT_HAS_ARRAY)
1798 ret = 2;
1800 else
1801 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
1803 if (ret)
1804 has_protected_decls = true;
1806 return ret;
1809 /* Two helper routines that check for phase 1 and phase 2. These are used
1810 as callbacks for expand_stack_vars. */
1812 static bool
1813 stack_protect_decl_phase_1 (size_t i)
1815 return stack_protect_decl_phase (stack_vars[i].decl) == 1;
1818 static bool
1819 stack_protect_decl_phase_2 (size_t i)
1821 return stack_protect_decl_phase (stack_vars[i].decl) == 2;
1824 /* And helper function that checks for asan phase (with stack protector
1825 it is phase 3). This is used as callback for expand_stack_vars.
1826 Returns true if any of the vars in the partition need to be protected. */
1828 static bool
1829 asan_decl_phase_3 (size_t i)
1831 while (i != EOC)
1833 if (asan_protect_stack_decl (stack_vars[i].decl))
1834 return true;
1835 i = stack_vars[i].next;
1837 return false;
1840 /* Ensure that variables in different stack protection phases conflict
1841 so that they are not merged and share the same stack slot. */
1843 static void
1844 add_stack_protection_conflicts (void)
1846 size_t i, j, n = stack_vars_num;
1847 unsigned char *phase;
1849 phase = XNEWVEC (unsigned char, n);
1850 for (i = 0; i < n; ++i)
1851 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
1853 for (i = 0; i < n; ++i)
1855 unsigned char ph_i = phase[i];
1856 for (j = i + 1; j < n; ++j)
1857 if (ph_i != phase[j])
1858 add_stack_var_conflict (i, j);
1861 XDELETEVEC (phase);
1864 /* Create a decl for the guard at the top of the stack frame. */
1866 static void
1867 create_stack_guard (void)
1869 tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
1870 VAR_DECL, NULL, ptr_type_node);
1871 TREE_THIS_VOLATILE (guard) = 1;
1872 TREE_USED (guard) = 1;
1873 expand_one_stack_var (guard);
1874 crtl->stack_protect_guard = guard;
1877 /* Prepare for expanding variables. */
1878 static void
1879 init_vars_expansion (void)
1881 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1882 bitmap_obstack_initialize (&stack_var_bitmap_obstack);
1884 /* A map from decl to stack partition. */
1885 decl_to_stack_part = new hash_map<tree, size_t>;
1887 /* Initialize local stack smashing state. */
1888 has_protected_decls = false;
1889 has_short_buffer = false;
1892 /* Free up stack variable graph data. */
1893 static void
1894 fini_vars_expansion (void)
1896 bitmap_obstack_release (&stack_var_bitmap_obstack);
1897 if (stack_vars)
1898 XDELETEVEC (stack_vars);
1899 if (stack_vars_sorted)
1900 XDELETEVEC (stack_vars_sorted);
1901 stack_vars = NULL;
1902 stack_vars_sorted = NULL;
1903 stack_vars_alloc = stack_vars_num = 0;
1904 delete decl_to_stack_part;
1905 decl_to_stack_part = NULL;
1908 /* Make a fair guess for the size of the stack frame of the function
1909 in NODE. This doesn't have to be exact, the result is only used in
1910 the inline heuristics. So we don't want to run the full stack var
1911 packing algorithm (which is quadratic in the number of stack vars).
1912 Instead, we calculate the total size of all stack vars. This turns
1913 out to be a pretty fair estimate -- packing of stack vars doesn't
1914 happen very often. */
1916 HOST_WIDE_INT
1917 estimated_stack_frame_size (struct cgraph_node *node)
1919 HOST_WIDE_INT size = 0;
1920 size_t i;
1921 tree var;
1922 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
1924 push_cfun (fn);
1926 init_vars_expansion ();
1928 FOR_EACH_LOCAL_DECL (fn, i, var)
1929 if (auto_var_in_fn_p (var, fn->decl))
1930 size += expand_one_var (var, true, false);
1932 if (stack_vars_num > 0)
1934 /* Fake sorting the stack vars for account_stack_vars (). */
1935 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
1936 for (i = 0; i < stack_vars_num; ++i)
1937 stack_vars_sorted[i] = i;
1938 size += account_stack_vars ();
1941 fini_vars_expansion ();
1942 pop_cfun ();
1943 return size;
1946 /* Helper routine to check if a record or union contains an array field. */
1948 static int
1949 record_or_union_type_has_array_p (const_tree tree_type)
1951 tree fields = TYPE_FIELDS (tree_type);
1952 tree f;
1954 for (f = fields; f; f = DECL_CHAIN (f))
1955 if (TREE_CODE (f) == FIELD_DECL)
1957 tree field_type = TREE_TYPE (f);
1958 if (RECORD_OR_UNION_TYPE_P (field_type)
1959 && record_or_union_type_has_array_p (field_type))
1960 return 1;
1961 if (TREE_CODE (field_type) == ARRAY_TYPE)
1962 return 1;
1964 return 0;
1967 /* Check if the current function has local referenced variables that
1968 have their addresses taken, contain an array, or are arrays. */
1970 static bool
1971 stack_protect_decl_p ()
1973 unsigned i;
1974 tree var;
1976 FOR_EACH_LOCAL_DECL (cfun, i, var)
1977 if (!is_global_var (var))
1979 tree var_type = TREE_TYPE (var);
1980 if (VAR_P (var)
1981 && (TREE_CODE (var_type) == ARRAY_TYPE
1982 || TREE_ADDRESSABLE (var)
1983 || (RECORD_OR_UNION_TYPE_P (var_type)
1984 && record_or_union_type_has_array_p (var_type))))
1985 return true;
1987 return false;
1990 /* Check if the current function has calls that use a return slot. */
1992 static bool
1993 stack_protect_return_slot_p ()
1995 basic_block bb;
1997 FOR_ALL_BB_FN (bb, cfun)
1998 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
1999 !gsi_end_p (gsi); gsi_next (&gsi))
2001 gimple *stmt = gsi_stmt (gsi);
2002 /* This assumes that calls to internal-only functions never
2003 use a return slot. */
2004 if (is_gimple_call (stmt)
2005 && !gimple_call_internal_p (stmt)
2006 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt)),
2007 gimple_call_fndecl (stmt)))
2008 return true;
2010 return false;
2013 /* Expand all variables used in the function. */
2015 static rtx_insn *
2016 expand_used_vars (void)
2018 tree var, outer_block = DECL_INITIAL (current_function_decl);
2019 auto_vec<tree> maybe_local_decls;
2020 rtx_insn *var_end_seq = NULL;
2021 unsigned i;
2022 unsigned len;
2023 bool gen_stack_protect_signal = false;
2025 /* Compute the phase of the stack frame for this function. */
2027 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
2028 int off = STARTING_FRAME_OFFSET % align;
2029 frame_phase = off ? align - off : 0;
2032 /* Set TREE_USED on all variables in the local_decls. */
2033 FOR_EACH_LOCAL_DECL (cfun, i, var)
2034 TREE_USED (var) = 1;
2035 /* Clear TREE_USED on all variables associated with a block scope. */
2036 clear_tree_used (DECL_INITIAL (current_function_decl));
2038 init_vars_expansion ();
2040 if (targetm.use_pseudo_pic_reg ())
2041 pic_offset_table_rtx = gen_reg_rtx (Pmode);
2043 for (i = 0; i < SA.map->num_partitions; i++)
2045 if (bitmap_bit_p (SA.partitions_for_parm_default_defs, i))
2046 continue;
2048 tree var = partition_to_var (SA.map, i);
2050 gcc_assert (!virtual_operand_p (var));
2052 expand_one_ssa_partition (var);
2055 if (flag_stack_protect == SPCT_FLAG_STRONG)
2056 gen_stack_protect_signal
2057 = stack_protect_decl_p () || stack_protect_return_slot_p ();
2059 /* At this point all variables on the local_decls with TREE_USED
2060 set are not associated with any block scope. Lay them out. */
2062 len = vec_safe_length (cfun->local_decls);
2063 FOR_EACH_LOCAL_DECL (cfun, i, var)
2065 bool expand_now = false;
2067 /* Expanded above already. */
2068 if (is_gimple_reg (var))
2070 TREE_USED (var) = 0;
2071 goto next;
2073 /* We didn't set a block for static or extern because it's hard
2074 to tell the difference between a global variable (re)declared
2075 in a local scope, and one that's really declared there to
2076 begin with. And it doesn't really matter much, since we're
2077 not giving them stack space. Expand them now. */
2078 else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
2079 expand_now = true;
2081 /* Expand variables not associated with any block now. Those created by
2082 the optimizers could be live anywhere in the function. Those that
2083 could possibly have been scoped originally and detached from their
2084 block will have their allocation deferred so we coalesce them with
2085 others when optimization is enabled. */
2086 else if (TREE_USED (var))
2087 expand_now = true;
2089 /* Finally, mark all variables on the list as used. We'll use
2090 this in a moment when we expand those associated with scopes. */
2091 TREE_USED (var) = 1;
2093 if (expand_now)
2094 expand_one_var (var, true, true);
2096 next:
2097 if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
2099 rtx rtl = DECL_RTL_IF_SET (var);
2101 /* Keep artificial non-ignored vars in cfun->local_decls
2102 chain until instantiate_decls. */
2103 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
2104 add_local_decl (cfun, var);
2105 else if (rtl == NULL_RTX)
2106 /* If rtl isn't set yet, which can happen e.g. with
2107 -fstack-protector, retry before returning from this
2108 function. */
2109 maybe_local_decls.safe_push (var);
2113 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2115 +-----------------+-----------------+
2116 | ...processed... | ...duplicates...|
2117 +-----------------+-----------------+
2119 +-- LEN points here.
2121 We just want the duplicates, as those are the artificial
2122 non-ignored vars that we want to keep until instantiate_decls.
2123 Move them down and truncate the array. */
2124 if (!vec_safe_is_empty (cfun->local_decls))
2125 cfun->local_decls->block_remove (0, len);
2127 /* At this point, all variables within the block tree with TREE_USED
2128 set are actually used by the optimized function. Lay them out. */
2129 expand_used_vars_for_block (outer_block, true);
2131 if (stack_vars_num > 0)
2133 add_scope_conflicts ();
2135 /* If stack protection is enabled, we don't share space between
2136 vulnerable data and non-vulnerable data. */
2137 if (flag_stack_protect != 0
2138 && (flag_stack_protect != SPCT_FLAG_EXPLICIT
2139 || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2140 && lookup_attribute ("stack_protect",
2141 DECL_ATTRIBUTES (current_function_decl)))))
2142 add_stack_protection_conflicts ();
2144 /* Now that we have collected all stack variables, and have computed a
2145 minimal interference graph, attempt to save some stack space. */
2146 partition_stack_vars ();
2147 if (dump_file)
2148 dump_stack_var_partition ();
2151 switch (flag_stack_protect)
2153 case SPCT_FLAG_ALL:
2154 create_stack_guard ();
2155 break;
2157 case SPCT_FLAG_STRONG:
2158 if (gen_stack_protect_signal
2159 || cfun->calls_alloca || has_protected_decls
2160 || lookup_attribute ("stack_protect",
2161 DECL_ATTRIBUTES (current_function_decl)))
2162 create_stack_guard ();
2163 break;
2165 case SPCT_FLAG_DEFAULT:
2166 if (cfun->calls_alloca || has_protected_decls
2167 || lookup_attribute ("stack_protect",
2168 DECL_ATTRIBUTES (current_function_decl)))
2169 create_stack_guard ();
2170 break;
2172 case SPCT_FLAG_EXPLICIT:
2173 if (lookup_attribute ("stack_protect",
2174 DECL_ATTRIBUTES (current_function_decl)))
2175 create_stack_guard ();
2176 break;
2177 default:
2181 /* Assign rtl to each variable based on these partitions. */
2182 if (stack_vars_num > 0)
2184 struct stack_vars_data data;
2186 data.asan_base = NULL_RTX;
2187 data.asan_alignb = 0;
2189 /* Reorder decls to be protected by iterating over the variables
2190 array multiple times, and allocating out of each phase in turn. */
2191 /* ??? We could probably integrate this into the qsort we did
2192 earlier, such that we naturally see these variables first,
2193 and thus naturally allocate things in the right order. */
2194 if (has_protected_decls)
2196 /* Phase 1 contains only character arrays. */
2197 expand_stack_vars (stack_protect_decl_phase_1, &data);
2199 /* Phase 2 contains other kinds of arrays. */
2200 if (flag_stack_protect == SPCT_FLAG_ALL
2201 || flag_stack_protect == SPCT_FLAG_STRONG
2202 || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2203 && lookup_attribute ("stack_protect",
2204 DECL_ATTRIBUTES (current_function_decl))))
2205 expand_stack_vars (stack_protect_decl_phase_2, &data);
2208 if (asan_sanitize_stack_p ())
2209 /* Phase 3, any partitions that need asan protection
2210 in addition to phase 1 and 2. */
2211 expand_stack_vars (asan_decl_phase_3, &data);
2213 if (!data.asan_vec.is_empty ())
2215 HOST_WIDE_INT prev_offset = frame_offset;
2216 HOST_WIDE_INT offset, sz, redzonesz;
2217 redzonesz = ASAN_RED_ZONE_SIZE;
2218 sz = data.asan_vec[0] - prev_offset;
2219 if (data.asan_alignb > ASAN_RED_ZONE_SIZE
2220 && data.asan_alignb <= 4096
2221 && sz + ASAN_RED_ZONE_SIZE >= (int) data.asan_alignb)
2222 redzonesz = ((sz + ASAN_RED_ZONE_SIZE + data.asan_alignb - 1)
2223 & ~(data.asan_alignb - HOST_WIDE_INT_1)) - sz;
2224 offset
2225 = alloc_stack_frame_space (redzonesz, ASAN_RED_ZONE_SIZE);
2226 data.asan_vec.safe_push (prev_offset);
2227 data.asan_vec.safe_push (offset);
2228 /* Leave space for alignment if STRICT_ALIGNMENT. */
2229 if (STRICT_ALIGNMENT)
2230 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode)
2231 << ASAN_SHADOW_SHIFT)
2232 / BITS_PER_UNIT, 1);
2234 var_end_seq
2235 = asan_emit_stack_protection (virtual_stack_vars_rtx,
2236 data.asan_base,
2237 data.asan_alignb,
2238 data.asan_vec.address (),
2239 data.asan_decl_vec.address (),
2240 data.asan_vec.length ());
2243 expand_stack_vars (NULL, &data);
2246 if (asan_sanitize_allocas_p () && cfun->calls_alloca)
2247 var_end_seq = asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx,
2248 virtual_stack_vars_rtx,
2249 var_end_seq);
2251 fini_vars_expansion ();
2253 /* If there were any artificial non-ignored vars without rtl
2254 found earlier, see if deferred stack allocation hasn't assigned
2255 rtl to them. */
2256 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls, i, var)
2258 rtx rtl = DECL_RTL_IF_SET (var);
2260 /* Keep artificial non-ignored vars in cfun->local_decls
2261 chain until instantiate_decls. */
2262 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
2263 add_local_decl (cfun, var);
2266 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2267 if (STACK_ALIGNMENT_NEEDED)
2269 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
2270 if (!FRAME_GROWS_DOWNWARD)
2271 frame_offset += align - 1;
2272 frame_offset &= -align;
2275 return var_end_seq;
2279 /* If we need to produce a detailed dump, print the tree representation
2280 for STMT to the dump file. SINCE is the last RTX after which the RTL
2281 generated for STMT should have been appended. */
2283 static void
2284 maybe_dump_rtl_for_gimple_stmt (gimple *stmt, rtx_insn *since)
2286 if (dump_file && (dump_flags & TDF_DETAILS))
2288 fprintf (dump_file, "\n;; ");
2289 print_gimple_stmt (dump_file, stmt, 0,
2290 TDF_SLIM | (dump_flags & TDF_LINENO));
2291 fprintf (dump_file, "\n");
2293 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
2297 /* Maps the blocks that do not contain tree labels to rtx labels. */
2299 static hash_map<basic_block, rtx_code_label *> *lab_rtx_for_bb;
2301 /* Returns the label_rtx expression for a label starting basic block BB. */
2303 static rtx_code_label *
2304 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
2306 gimple_stmt_iterator gsi;
2307 tree lab;
2309 if (bb->flags & BB_RTL)
2310 return block_label (bb);
2312 rtx_code_label **elt = lab_rtx_for_bb->get (bb);
2313 if (elt)
2314 return *elt;
2316 /* Find the tree label if it is present. */
2318 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2320 glabel *lab_stmt;
2322 lab_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
2323 if (!lab_stmt)
2324 break;
2326 lab = gimple_label_label (lab_stmt);
2327 if (DECL_NONLOCAL (lab))
2328 break;
2330 return jump_target_rtx (lab);
2333 rtx_code_label *l = gen_label_rtx ();
2334 lab_rtx_for_bb->put (bb, l);
2335 return l;
2339 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2340 of a basic block where we just expanded the conditional at the end,
2341 possibly clean up the CFG and instruction sequence. LAST is the
2342 last instruction before the just emitted jump sequence. */
2344 static void
2345 maybe_cleanup_end_of_block (edge e, rtx_insn *last)
2347 /* Special case: when jumpif decides that the condition is
2348 trivial it emits an unconditional jump (and the necessary
2349 barrier). But we still have two edges, the fallthru one is
2350 wrong. purge_dead_edges would clean this up later. Unfortunately
2351 we have to insert insns (and split edges) before
2352 find_many_sub_basic_blocks and hence before purge_dead_edges.
2353 But splitting edges might create new blocks which depend on the
2354 fact that if there are two edges there's no barrier. So the
2355 barrier would get lost and verify_flow_info would ICE. Instead
2356 of auditing all edge splitters to care for the barrier (which
2357 normally isn't there in a cleaned CFG), fix it here. */
2358 if (BARRIER_P (get_last_insn ()))
2360 rtx_insn *insn;
2361 remove_edge (e);
2362 /* Now, we have a single successor block, if we have insns to
2363 insert on the remaining edge we potentially will insert
2364 it at the end of this block (if the dest block isn't feasible)
2365 in order to avoid splitting the edge. This insertion will take
2366 place in front of the last jump. But we might have emitted
2367 multiple jumps (conditional and one unconditional) to the
2368 same destination. Inserting in front of the last one then
2369 is a problem. See PR 40021. We fix this by deleting all
2370 jumps except the last unconditional one. */
2371 insn = PREV_INSN (get_last_insn ());
2372 /* Make sure we have an unconditional jump. Otherwise we're
2373 confused. */
2374 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
2375 for (insn = PREV_INSN (insn); insn != last;)
2377 insn = PREV_INSN (insn);
2378 if (JUMP_P (NEXT_INSN (insn)))
2380 if (!any_condjump_p (NEXT_INSN (insn)))
2382 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))));
2383 delete_insn (NEXT_INSN (NEXT_INSN (insn)));
2385 delete_insn (NEXT_INSN (insn));
2391 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2392 Returns a new basic block if we've terminated the current basic
2393 block and created a new one. */
2395 static basic_block
2396 expand_gimple_cond (basic_block bb, gcond *stmt)
2398 basic_block new_bb, dest;
2399 edge true_edge;
2400 edge false_edge;
2401 rtx_insn *last2, *last;
2402 enum tree_code code;
2403 tree op0, op1;
2405 code = gimple_cond_code (stmt);
2406 op0 = gimple_cond_lhs (stmt);
2407 op1 = gimple_cond_rhs (stmt);
2408 /* We're sometimes presented with such code:
2409 D.123_1 = x < y;
2410 if (D.123_1 != 0)
2412 This would expand to two comparisons which then later might
2413 be cleaned up by combine. But some pattern matchers like if-conversion
2414 work better when there's only one compare, so make up for this
2415 here as special exception if TER would have made the same change. */
2416 if (SA.values
2417 && TREE_CODE (op0) == SSA_NAME
2418 && TREE_CODE (TREE_TYPE (op0)) == BOOLEAN_TYPE
2419 && TREE_CODE (op1) == INTEGER_CST
2420 && ((gimple_cond_code (stmt) == NE_EXPR
2421 && integer_zerop (op1))
2422 || (gimple_cond_code (stmt) == EQ_EXPR
2423 && integer_onep (op1)))
2424 && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
2426 gimple *second = SSA_NAME_DEF_STMT (op0);
2427 if (gimple_code (second) == GIMPLE_ASSIGN)
2429 enum tree_code code2 = gimple_assign_rhs_code (second);
2430 if (TREE_CODE_CLASS (code2) == tcc_comparison)
2432 code = code2;
2433 op0 = gimple_assign_rhs1 (second);
2434 op1 = gimple_assign_rhs2 (second);
2436 /* If jumps are cheap and the target does not support conditional
2437 compare, turn some more codes into jumpy sequences. */
2438 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2439 && targetm.gen_ccmp_first == NULL)
2441 if ((code2 == BIT_AND_EXPR
2442 && TYPE_PRECISION (TREE_TYPE (op0)) == 1
2443 && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
2444 || code2 == TRUTH_AND_EXPR)
2446 code = TRUTH_ANDIF_EXPR;
2447 op0 = gimple_assign_rhs1 (second);
2448 op1 = gimple_assign_rhs2 (second);
2450 else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
2452 code = TRUTH_ORIF_EXPR;
2453 op0 = gimple_assign_rhs1 (second);
2454 op1 = gimple_assign_rhs2 (second);
2460 last2 = last = get_last_insn ();
2462 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2463 set_curr_insn_location (gimple_location (stmt));
2465 /* These flags have no purpose in RTL land. */
2466 true_edge->flags &= ~EDGE_TRUE_VALUE;
2467 false_edge->flags &= ~EDGE_FALSE_VALUE;
2469 /* We can either have a pure conditional jump with one fallthru edge or
2470 two-way jump that needs to be decomposed into two basic blocks. */
2471 if (false_edge->dest == bb->next_bb)
2473 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2474 true_edge->probability);
2475 maybe_dump_rtl_for_gimple_stmt (stmt, last);
2476 if (true_edge->goto_locus != UNKNOWN_LOCATION)
2477 set_curr_insn_location (true_edge->goto_locus);
2478 false_edge->flags |= EDGE_FALLTHRU;
2479 maybe_cleanup_end_of_block (false_edge, last);
2480 return NULL;
2482 if (true_edge->dest == bb->next_bb)
2484 jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
2485 false_edge->probability);
2486 maybe_dump_rtl_for_gimple_stmt (stmt, last);
2487 if (false_edge->goto_locus != UNKNOWN_LOCATION)
2488 set_curr_insn_location (false_edge->goto_locus);
2489 true_edge->flags |= EDGE_FALLTHRU;
2490 maybe_cleanup_end_of_block (true_edge, last);
2491 return NULL;
2494 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2495 true_edge->probability);
2496 last = get_last_insn ();
2497 if (false_edge->goto_locus != UNKNOWN_LOCATION)
2498 set_curr_insn_location (false_edge->goto_locus);
2499 emit_jump (label_rtx_for_bb (false_edge->dest));
2501 BB_END (bb) = last;
2502 if (BARRIER_P (BB_END (bb)))
2503 BB_END (bb) = PREV_INSN (BB_END (bb));
2504 update_bb_for_insn (bb);
2506 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2507 dest = false_edge->dest;
2508 redirect_edge_succ (false_edge, new_bb);
2509 false_edge->flags |= EDGE_FALLTHRU;
2510 new_bb->count = false_edge->count;
2511 new_bb->frequency = EDGE_FREQUENCY (false_edge);
2512 loop_p loop = find_common_loop (bb->loop_father, dest->loop_father);
2513 add_bb_to_loop (new_bb, loop);
2514 if (loop->latch == bb
2515 && loop->header == dest)
2516 loop->latch = new_bb;
2517 make_single_succ_edge (new_bb, dest, 0);
2518 if (BARRIER_P (BB_END (new_bb)))
2519 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
2520 update_bb_for_insn (new_bb);
2522 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2524 if (true_edge->goto_locus != UNKNOWN_LOCATION)
2526 set_curr_insn_location (true_edge->goto_locus);
2527 true_edge->goto_locus = curr_insn_location ();
2530 return new_bb;
2533 /* Mark all calls that can have a transaction restart. */
2535 static void
2536 mark_transaction_restart_calls (gimple *stmt)
2538 struct tm_restart_node dummy;
2539 tm_restart_node **slot;
2541 if (!cfun->gimple_df->tm_restart)
2542 return;
2544 dummy.stmt = stmt;
2545 slot = cfun->gimple_df->tm_restart->find_slot (&dummy, NO_INSERT);
2546 if (slot)
2548 struct tm_restart_node *n = *slot;
2549 tree list = n->label_or_list;
2550 rtx_insn *insn;
2552 for (insn = next_real_insn (get_last_insn ());
2553 !CALL_P (insn);
2554 insn = next_real_insn (insn))
2555 continue;
2557 if (TREE_CODE (list) == LABEL_DECL)
2558 add_reg_note (insn, REG_TM, label_rtx (list));
2559 else
2560 for (; list ; list = TREE_CHAIN (list))
2561 add_reg_note (insn, REG_TM, label_rtx (TREE_VALUE (list)));
2565 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2566 statement STMT. */
2568 static void
2569 expand_call_stmt (gcall *stmt)
2571 tree exp, decl, lhs;
2572 bool builtin_p;
2573 size_t i;
2575 if (gimple_call_internal_p (stmt))
2577 expand_internal_call (stmt);
2578 return;
2581 /* If this is a call to a built-in function and it has no effect other
2582 than setting the lhs, try to implement it using an internal function
2583 instead. */
2584 decl = gimple_call_fndecl (stmt);
2585 if (gimple_call_lhs (stmt)
2586 && !gimple_has_side_effects (stmt)
2587 && (optimize || (decl && called_as_built_in (decl))))
2589 internal_fn ifn = replacement_internal_fn (stmt);
2590 if (ifn != IFN_LAST)
2592 expand_internal_call (ifn, stmt);
2593 return;
2597 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2599 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2600 builtin_p = decl && DECL_BUILT_IN (decl);
2602 /* If this is not a builtin function, the function type through which the
2603 call is made may be different from the type of the function. */
2604 if (!builtin_p)
2605 CALL_EXPR_FN (exp)
2606 = fold_convert (build_pointer_type (gimple_call_fntype (stmt)),
2607 CALL_EXPR_FN (exp));
2609 TREE_TYPE (exp) = gimple_call_return_type (stmt);
2610 CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2612 for (i = 0; i < gimple_call_num_args (stmt); i++)
2614 tree arg = gimple_call_arg (stmt, i);
2615 gimple *def;
2616 /* TER addresses into arguments of builtin functions so we have a
2617 chance to infer more correct alignment information. See PR39954. */
2618 if (builtin_p
2619 && TREE_CODE (arg) == SSA_NAME
2620 && (def = get_gimple_for_ssa_name (arg))
2621 && gimple_assign_rhs_code (def) == ADDR_EXPR)
2622 arg = gimple_assign_rhs1 (def);
2623 CALL_EXPR_ARG (exp, i) = arg;
2626 if (gimple_has_side_effects (stmt))
2627 TREE_SIDE_EFFECTS (exp) = 1;
2629 if (gimple_call_nothrow_p (stmt))
2630 TREE_NOTHROW (exp) = 1;
2632 CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
2633 CALL_EXPR_MUST_TAIL_CALL (exp) = gimple_call_must_tail_p (stmt);
2634 CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
2635 if (decl
2636 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2637 && (DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA
2638 || DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA_WITH_ALIGN))
2639 CALL_ALLOCA_FOR_VAR_P (exp) = gimple_call_alloca_for_var_p (stmt);
2640 else
2641 CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
2642 CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
2643 CALL_EXPR_BY_DESCRIPTOR (exp) = gimple_call_by_descriptor_p (stmt);
2644 SET_EXPR_LOCATION (exp, gimple_location (stmt));
2645 CALL_WITH_BOUNDS_P (exp) = gimple_call_with_bounds_p (stmt);
2647 /* Ensure RTL is created for debug args. */
2648 if (decl && DECL_HAS_DEBUG_ARGS_P (decl))
2650 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (decl);
2651 unsigned int ix;
2652 tree dtemp;
2654 if (debug_args)
2655 for (ix = 1; (*debug_args)->iterate (ix, &dtemp); ix += 2)
2657 gcc_assert (TREE_CODE (dtemp) == DEBUG_EXPR_DECL);
2658 expand_debug_expr (dtemp);
2662 lhs = gimple_call_lhs (stmt);
2663 if (lhs)
2664 expand_assignment (lhs, exp, false);
2665 else
2666 expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
2668 mark_transaction_restart_calls (stmt);
2672 /* Generate RTL for an asm statement (explicit assembler code).
2673 STRING is a STRING_CST node containing the assembler code text,
2674 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2675 insn is volatile; don't optimize it. */
2677 static void
2678 expand_asm_loc (tree string, int vol, location_t locus)
2680 rtx body;
2682 body = gen_rtx_ASM_INPUT_loc (VOIDmode,
2683 ggc_strdup (TREE_STRING_POINTER (string)),
2684 locus);
2686 MEM_VOLATILE_P (body) = vol;
2688 /* Non-empty basic ASM implicitly clobbers memory. */
2689 if (TREE_STRING_LENGTH (string) != 0)
2691 rtx asm_op, clob;
2692 unsigned i, nclobbers;
2693 auto_vec<rtx> input_rvec, output_rvec;
2694 auto_vec<const char *> constraints;
2695 auto_vec<rtx> clobber_rvec;
2696 HARD_REG_SET clobbered_regs;
2697 CLEAR_HARD_REG_SET (clobbered_regs);
2699 clob = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
2700 clobber_rvec.safe_push (clob);
2702 if (targetm.md_asm_adjust)
2703 targetm.md_asm_adjust (output_rvec, input_rvec,
2704 constraints, clobber_rvec,
2705 clobbered_regs);
2707 asm_op = body;
2708 nclobbers = clobber_rvec.length ();
2709 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (1 + nclobbers));
2711 XVECEXP (body, 0, 0) = asm_op;
2712 for (i = 0; i < nclobbers; i++)
2713 XVECEXP (body, 0, i + 1) = gen_rtx_CLOBBER (VOIDmode, clobber_rvec[i]);
2716 emit_insn (body);
2719 /* Return the number of times character C occurs in string S. */
2720 static int
2721 n_occurrences (int c, const char *s)
2723 int n = 0;
2724 while (*s)
2725 n += (*s++ == c);
2726 return n;
2729 /* A subroutine of expand_asm_operands. Check that all operands have
2730 the same number of alternatives. Return true if so. */
2732 static bool
2733 check_operand_nalternatives (const vec<const char *> &constraints)
2735 unsigned len = constraints.length();
2736 if (len > 0)
2738 int nalternatives = n_occurrences (',', constraints[0]);
2740 if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES)
2742 error ("too many alternatives in %<asm%>");
2743 return false;
2746 for (unsigned i = 1; i < len; ++i)
2747 if (n_occurrences (',', constraints[i]) != nalternatives)
2749 error ("operand constraints for %<asm%> differ "
2750 "in number of alternatives");
2751 return false;
2754 return true;
2757 /* Check for overlap between registers marked in CLOBBERED_REGS and
2758 anything inappropriate in T. Emit error and return the register
2759 variable definition for error, NULL_TREE for ok. */
2761 static bool
2762 tree_conflicts_with_clobbers_p (tree t, HARD_REG_SET *clobbered_regs)
2764 /* Conflicts between asm-declared register variables and the clobber
2765 list are not allowed. */
2766 tree overlap = tree_overlaps_hard_reg_set (t, clobbered_regs);
2768 if (overlap)
2770 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2771 DECL_NAME (overlap));
2773 /* Reset registerness to stop multiple errors emitted for a single
2774 variable. */
2775 DECL_REGISTER (overlap) = 0;
2776 return true;
2779 return false;
2782 /* Generate RTL for an asm statement with arguments.
2783 STRING is the instruction template.
2784 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2785 Each output or input has an expression in the TREE_VALUE and
2786 a tree list in TREE_PURPOSE which in turn contains a constraint
2787 name in TREE_VALUE (or NULL_TREE) and a constraint string
2788 in TREE_PURPOSE.
2789 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2790 that is clobbered by this insn.
2792 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2793 should be the fallthru basic block of the asm goto.
2795 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2796 Some elements of OUTPUTS may be replaced with trees representing temporary
2797 values. The caller should copy those temporary values to the originally
2798 specified lvalues.
2800 VOL nonzero means the insn is volatile; don't optimize it. */
2802 static void
2803 expand_asm_stmt (gasm *stmt)
2805 class save_input_location
2807 location_t old;
2809 public:
2810 explicit save_input_location(location_t where)
2812 old = input_location;
2813 input_location = where;
2816 ~save_input_location()
2818 input_location = old;
2822 location_t locus = gimple_location (stmt);
2824 if (gimple_asm_input_p (stmt))
2826 const char *s = gimple_asm_string (stmt);
2827 tree string = build_string (strlen (s), s);
2828 expand_asm_loc (string, gimple_asm_volatile_p (stmt), locus);
2829 return;
2832 /* There are some legacy diagnostics in here, and also avoids a
2833 sixth parameger to targetm.md_asm_adjust. */
2834 save_input_location s_i_l(locus);
2836 unsigned noutputs = gimple_asm_noutputs (stmt);
2837 unsigned ninputs = gimple_asm_ninputs (stmt);
2838 unsigned nlabels = gimple_asm_nlabels (stmt);
2839 unsigned i;
2841 /* ??? Diagnose during gimplification? */
2842 if (ninputs + noutputs + nlabels > MAX_RECOG_OPERANDS)
2844 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS);
2845 return;
2848 auto_vec<tree, MAX_RECOG_OPERANDS> output_tvec;
2849 auto_vec<tree, MAX_RECOG_OPERANDS> input_tvec;
2850 auto_vec<const char *, MAX_RECOG_OPERANDS> constraints;
2852 /* Copy the gimple vectors into new vectors that we can manipulate. */
2854 output_tvec.safe_grow (noutputs);
2855 input_tvec.safe_grow (ninputs);
2856 constraints.safe_grow (noutputs + ninputs);
2858 for (i = 0; i < noutputs; ++i)
2860 tree t = gimple_asm_output_op (stmt, i);
2861 output_tvec[i] = TREE_VALUE (t);
2862 constraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
2864 for (i = 0; i < ninputs; i++)
2866 tree t = gimple_asm_input_op (stmt, i);
2867 input_tvec[i] = TREE_VALUE (t);
2868 constraints[i + noutputs]
2869 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
2872 /* ??? Diagnose during gimplification? */
2873 if (! check_operand_nalternatives (constraints))
2874 return;
2876 /* Count the number of meaningful clobbered registers, ignoring what
2877 we would ignore later. */
2878 auto_vec<rtx> clobber_rvec;
2879 HARD_REG_SET clobbered_regs;
2880 CLEAR_HARD_REG_SET (clobbered_regs);
2882 if (unsigned n = gimple_asm_nclobbers (stmt))
2884 clobber_rvec.reserve (n);
2885 for (i = 0; i < n; i++)
2887 tree t = gimple_asm_clobber_op (stmt, i);
2888 const char *regname = TREE_STRING_POINTER (TREE_VALUE (t));
2889 int nregs, j;
2891 j = decode_reg_name_and_count (regname, &nregs);
2892 if (j < 0)
2894 if (j == -2)
2896 /* ??? Diagnose during gimplification? */
2897 error ("unknown register name %qs in %<asm%>", regname);
2899 else if (j == -4)
2901 rtx x = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
2902 clobber_rvec.safe_push (x);
2904 else
2906 /* Otherwise we should have -1 == empty string
2907 or -3 == cc, which is not a register. */
2908 gcc_assert (j == -1 || j == -3);
2911 else
2912 for (int reg = j; reg < j + nregs; reg++)
2914 /* Clobbering the PIC register is an error. */
2915 if (reg == (int) PIC_OFFSET_TABLE_REGNUM)
2917 /* ??? Diagnose during gimplification? */
2918 error ("PIC register clobbered by %qs in %<asm%>",
2919 regname);
2920 return;
2923 SET_HARD_REG_BIT (clobbered_regs, reg);
2924 rtx x = gen_rtx_REG (reg_raw_mode[reg], reg);
2925 clobber_rvec.safe_push (x);
2929 unsigned nclobbers = clobber_rvec.length();
2931 /* First pass over inputs and outputs checks validity and sets
2932 mark_addressable if needed. */
2933 /* ??? Diagnose during gimplification? */
2935 for (i = 0; i < noutputs; ++i)
2937 tree val = output_tvec[i];
2938 tree type = TREE_TYPE (val);
2939 const char *constraint;
2940 bool is_inout;
2941 bool allows_reg;
2942 bool allows_mem;
2944 /* Try to parse the output constraint. If that fails, there's
2945 no point in going further. */
2946 constraint = constraints[i];
2947 if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
2948 &allows_mem, &allows_reg, &is_inout))
2949 return;
2951 if (! allows_reg
2952 && (allows_mem
2953 || is_inout
2954 || (DECL_P (val)
2955 && REG_P (DECL_RTL (val))
2956 && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type))))
2957 mark_addressable (val);
2960 for (i = 0; i < ninputs; ++i)
2962 bool allows_reg, allows_mem;
2963 const char *constraint;
2965 constraint = constraints[i + noutputs];
2966 if (! parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
2967 constraints.address (),
2968 &allows_mem, &allows_reg))
2969 return;
2971 if (! allows_reg && allows_mem)
2972 mark_addressable (input_tvec[i]);
2975 /* Second pass evaluates arguments. */
2977 /* Make sure stack is consistent for asm goto. */
2978 if (nlabels > 0)
2979 do_pending_stack_adjust ();
2980 int old_generating_concat_p = generating_concat_p;
2982 /* Vector of RTX's of evaluated output operands. */
2983 auto_vec<rtx, MAX_RECOG_OPERANDS> output_rvec;
2984 auto_vec<int, MAX_RECOG_OPERANDS> inout_opnum;
2985 rtx_insn *after_rtl_seq = NULL, *after_rtl_end = NULL;
2987 output_rvec.safe_grow (noutputs);
2989 for (i = 0; i < noutputs; ++i)
2991 tree val = output_tvec[i];
2992 tree type = TREE_TYPE (val);
2993 bool is_inout, allows_reg, allows_mem, ok;
2994 rtx op;
2996 ok = parse_output_constraint (&constraints[i], i, ninputs,
2997 noutputs, &allows_mem, &allows_reg,
2998 &is_inout);
2999 gcc_assert (ok);
3001 /* If an output operand is not a decl or indirect ref and our constraint
3002 allows a register, make a temporary to act as an intermediate.
3003 Make the asm insn write into that, then we will copy it to
3004 the real output operand. Likewise for promoted variables. */
3006 generating_concat_p = 0;
3008 if ((TREE_CODE (val) == INDIRECT_REF
3009 && allows_mem)
3010 || (DECL_P (val)
3011 && (allows_mem || REG_P (DECL_RTL (val)))
3012 && ! (REG_P (DECL_RTL (val))
3013 && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))
3014 || ! allows_reg
3015 || is_inout)
3017 op = expand_expr (val, NULL_RTX, VOIDmode,
3018 !allows_reg ? EXPAND_MEMORY : EXPAND_WRITE);
3019 if (MEM_P (op))
3020 op = validize_mem (op);
3022 if (! allows_reg && !MEM_P (op))
3023 error ("output number %d not directly addressable", i);
3024 if ((! allows_mem && MEM_P (op))
3025 || GET_CODE (op) == CONCAT)
3027 rtx old_op = op;
3028 op = gen_reg_rtx (GET_MODE (op));
3030 generating_concat_p = old_generating_concat_p;
3032 if (is_inout)
3033 emit_move_insn (op, old_op);
3035 push_to_sequence2 (after_rtl_seq, after_rtl_end);
3036 emit_move_insn (old_op, op);
3037 after_rtl_seq = get_insns ();
3038 after_rtl_end = get_last_insn ();
3039 end_sequence ();
3042 else
3044 op = assign_temp (type, 0, 1);
3045 op = validize_mem (op);
3046 if (!MEM_P (op) && TREE_CODE (val) == SSA_NAME)
3047 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val), op);
3049 generating_concat_p = old_generating_concat_p;
3051 push_to_sequence2 (after_rtl_seq, after_rtl_end);
3052 expand_assignment (val, make_tree (type, op), false);
3053 after_rtl_seq = get_insns ();
3054 after_rtl_end = get_last_insn ();
3055 end_sequence ();
3057 output_rvec[i] = op;
3059 if (is_inout)
3060 inout_opnum.safe_push (i);
3063 auto_vec<rtx, MAX_RECOG_OPERANDS> input_rvec;
3064 auto_vec<machine_mode, MAX_RECOG_OPERANDS> input_mode;
3066 input_rvec.safe_grow (ninputs);
3067 input_mode.safe_grow (ninputs);
3069 generating_concat_p = 0;
3071 for (i = 0; i < ninputs; ++i)
3073 tree val = input_tvec[i];
3074 tree type = TREE_TYPE (val);
3075 bool allows_reg, allows_mem, ok;
3076 const char *constraint;
3077 rtx op;
3079 constraint = constraints[i + noutputs];
3080 ok = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
3081 constraints.address (),
3082 &allows_mem, &allows_reg);
3083 gcc_assert (ok);
3085 /* EXPAND_INITIALIZER will not generate code for valid initializer
3086 constants, but will still generate code for other types of operand.
3087 This is the behavior we want for constant constraints. */
3088 op = expand_expr (val, NULL_RTX, VOIDmode,
3089 allows_reg ? EXPAND_NORMAL
3090 : allows_mem ? EXPAND_MEMORY
3091 : EXPAND_INITIALIZER);
3093 /* Never pass a CONCAT to an ASM. */
3094 if (GET_CODE (op) == CONCAT)
3095 op = force_reg (GET_MODE (op), op);
3096 else if (MEM_P (op))
3097 op = validize_mem (op);
3099 if (asm_operand_ok (op, constraint, NULL) <= 0)
3101 if (allows_reg && TYPE_MODE (type) != BLKmode)
3102 op = force_reg (TYPE_MODE (type), op);
3103 else if (!allows_mem)
3104 warning (0, "asm operand %d probably doesn%'t match constraints",
3105 i + noutputs);
3106 else if (MEM_P (op))
3108 /* We won't recognize either volatile memory or memory
3109 with a queued address as available a memory_operand
3110 at this point. Ignore it: clearly this *is* a memory. */
3112 else
3113 gcc_unreachable ();
3115 input_rvec[i] = op;
3116 input_mode[i] = TYPE_MODE (type);
3119 /* For in-out operands, copy output rtx to input rtx. */
3120 unsigned ninout = inout_opnum.length();
3121 for (i = 0; i < ninout; i++)
3123 int j = inout_opnum[i];
3124 rtx o = output_rvec[j];
3126 input_rvec.safe_push (o);
3127 input_mode.safe_push (GET_MODE (o));
3129 char buffer[16];
3130 sprintf (buffer, "%d", j);
3131 constraints.safe_push (ggc_strdup (buffer));
3133 ninputs += ninout;
3135 /* Sometimes we wish to automatically clobber registers across an asm.
3136 Case in point is when the i386 backend moved from cc0 to a hard reg --
3137 maintaining source-level compatibility means automatically clobbering
3138 the flags register. */
3139 rtx_insn *after_md_seq = NULL;
3140 if (targetm.md_asm_adjust)
3141 after_md_seq = targetm.md_asm_adjust (output_rvec, input_rvec,
3142 constraints, clobber_rvec,
3143 clobbered_regs);
3145 /* Do not allow the hook to change the output and input count,
3146 lest it mess up the operand numbering. */
3147 gcc_assert (output_rvec.length() == noutputs);
3148 gcc_assert (input_rvec.length() == ninputs);
3149 gcc_assert (constraints.length() == noutputs + ninputs);
3151 /* But it certainly can adjust the clobbers. */
3152 nclobbers = clobber_rvec.length();
3154 /* Third pass checks for easy conflicts. */
3155 /* ??? Why are we doing this on trees instead of rtx. */
3157 bool clobber_conflict_found = 0;
3158 for (i = 0; i < noutputs; ++i)
3159 if (tree_conflicts_with_clobbers_p (output_tvec[i], &clobbered_regs))
3160 clobber_conflict_found = 1;
3161 for (i = 0; i < ninputs - ninout; ++i)
3162 if (tree_conflicts_with_clobbers_p (input_tvec[i], &clobbered_regs))
3163 clobber_conflict_found = 1;
3165 /* Make vectors for the expression-rtx, constraint strings,
3166 and named operands. */
3168 rtvec argvec = rtvec_alloc (ninputs);
3169 rtvec constraintvec = rtvec_alloc (ninputs);
3170 rtvec labelvec = rtvec_alloc (nlabels);
3172 rtx body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
3173 : GET_MODE (output_rvec[0])),
3174 ggc_strdup (gimple_asm_string (stmt)),
3175 "", 0, argvec, constraintvec,
3176 labelvec, locus);
3177 MEM_VOLATILE_P (body) = gimple_asm_volatile_p (stmt);
3179 for (i = 0; i < ninputs; ++i)
3181 ASM_OPERANDS_INPUT (body, i) = input_rvec[i];
3182 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)
3183 = gen_rtx_ASM_INPUT_loc (input_mode[i],
3184 constraints[i + noutputs],
3185 locus);
3188 /* Copy labels to the vector. */
3189 rtx_code_label *fallthru_label = NULL;
3190 if (nlabels > 0)
3192 basic_block fallthru_bb = NULL;
3193 edge fallthru = find_fallthru_edge (gimple_bb (stmt)->succs);
3194 if (fallthru)
3195 fallthru_bb = fallthru->dest;
3197 for (i = 0; i < nlabels; ++i)
3199 tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
3200 rtx_insn *r;
3201 /* If asm goto has any labels in the fallthru basic block, use
3202 a label that we emit immediately after the asm goto. Expansion
3203 may insert further instructions into the same basic block after
3204 asm goto and if we don't do this, insertion of instructions on
3205 the fallthru edge might misbehave. See PR58670. */
3206 if (fallthru_bb && label_to_block_fn (cfun, label) == fallthru_bb)
3208 if (fallthru_label == NULL_RTX)
3209 fallthru_label = gen_label_rtx ();
3210 r = fallthru_label;
3212 else
3213 r = label_rtx (label);
3214 ASM_OPERANDS_LABEL (body, i) = gen_rtx_LABEL_REF (Pmode, r);
3218 /* Now, for each output, construct an rtx
3219 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3220 ARGVEC CONSTRAINTS OPNAMES))
3221 If there is more than one, put them inside a PARALLEL. */
3223 if (nlabels > 0 && nclobbers == 0)
3225 gcc_assert (noutputs == 0);
3226 emit_jump_insn (body);
3228 else if (noutputs == 0 && nclobbers == 0)
3230 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3231 emit_insn (body);
3233 else if (noutputs == 1 && nclobbers == 0)
3235 ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = constraints[0];
3236 emit_insn (gen_rtx_SET (output_rvec[0], body));
3238 else
3240 rtx obody = body;
3241 int num = noutputs;
3243 if (num == 0)
3244 num = 1;
3246 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num + nclobbers));
3248 /* For each output operand, store a SET. */
3249 for (i = 0; i < noutputs; ++i)
3251 rtx src, o = output_rvec[i];
3252 if (i == 0)
3254 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody) = constraints[0];
3255 src = obody;
3257 else
3259 src = gen_rtx_ASM_OPERANDS (GET_MODE (o),
3260 ASM_OPERANDS_TEMPLATE (obody),
3261 constraints[i], i, argvec,
3262 constraintvec, labelvec, locus);
3263 MEM_VOLATILE_P (src) = gimple_asm_volatile_p (stmt);
3265 XVECEXP (body, 0, i) = gen_rtx_SET (o, src);
3268 /* If there are no outputs (but there are some clobbers)
3269 store the bare ASM_OPERANDS into the PARALLEL. */
3270 if (i == 0)
3271 XVECEXP (body, 0, i++) = obody;
3273 /* Store (clobber REG) for each clobbered register specified. */
3274 for (unsigned j = 0; j < nclobbers; ++j)
3276 rtx clobbered_reg = clobber_rvec[j];
3278 /* Do sanity check for overlap between clobbers and respectively
3279 input and outputs that hasn't been handled. Such overlap
3280 should have been detected and reported above. */
3281 if (!clobber_conflict_found && REG_P (clobbered_reg))
3283 /* We test the old body (obody) contents to avoid
3284 tripping over the under-construction body. */
3285 for (unsigned k = 0; k < noutputs; ++k)
3286 if (reg_overlap_mentioned_p (clobbered_reg, output_rvec[k]))
3287 internal_error ("asm clobber conflict with output operand");
3289 for (unsigned k = 0; k < ninputs - ninout; ++k)
3290 if (reg_overlap_mentioned_p (clobbered_reg, input_rvec[k]))
3291 internal_error ("asm clobber conflict with input operand");
3294 XVECEXP (body, 0, i++) = gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
3297 if (nlabels > 0)
3298 emit_jump_insn (body);
3299 else
3300 emit_insn (body);
3303 generating_concat_p = old_generating_concat_p;
3305 if (fallthru_label)
3306 emit_label (fallthru_label);
3308 if (after_md_seq)
3309 emit_insn (after_md_seq);
3310 if (after_rtl_seq)
3311 emit_insn (after_rtl_seq);
3313 free_temp_slots ();
3314 crtl->has_asm_statement = 1;
3317 /* Emit code to jump to the address
3318 specified by the pointer expression EXP. */
3320 static void
3321 expand_computed_goto (tree exp)
3323 rtx x = expand_normal (exp);
3325 do_pending_stack_adjust ();
3326 emit_indirect_jump (x);
3329 /* Generate RTL code for a `goto' statement with target label LABEL.
3330 LABEL should be a LABEL_DECL tree node that was or will later be
3331 defined with `expand_label'. */
3333 static void
3334 expand_goto (tree label)
3336 if (flag_checking)
3338 /* Check for a nonlocal goto to a containing function. Should have
3339 gotten translated to __builtin_nonlocal_goto. */
3340 tree context = decl_function_context (label);
3341 gcc_assert (!context || context == current_function_decl);
3344 emit_jump (jump_target_rtx (label));
3347 /* Output a return with no value. */
3349 static void
3350 expand_null_return_1 (void)
3352 clear_pending_stack_adjust ();
3353 do_pending_stack_adjust ();
3354 emit_jump (return_label);
3357 /* Generate RTL to return from the current function, with no value.
3358 (That is, we do not do anything about returning any value.) */
3360 void
3361 expand_null_return (void)
3363 /* If this function was declared to return a value, but we
3364 didn't, clobber the return registers so that they are not
3365 propagated live to the rest of the function. */
3366 clobber_return_register ();
3368 expand_null_return_1 ();
3371 /* Generate RTL to return from the current function, with value VAL. */
3373 static void
3374 expand_value_return (rtx val)
3376 /* Copy the value to the return location unless it's already there. */
3378 tree decl = DECL_RESULT (current_function_decl);
3379 rtx return_reg = DECL_RTL (decl);
3380 if (return_reg != val)
3382 tree funtype = TREE_TYPE (current_function_decl);
3383 tree type = TREE_TYPE (decl);
3384 int unsignedp = TYPE_UNSIGNED (type);
3385 machine_mode old_mode = DECL_MODE (decl);
3386 machine_mode mode;
3387 if (DECL_BY_REFERENCE (decl))
3388 mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 2);
3389 else
3390 mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 1);
3392 if (mode != old_mode)
3393 val = convert_modes (mode, old_mode, val, unsignedp);
3395 if (GET_CODE (return_reg) == PARALLEL)
3396 emit_group_load (return_reg, val, type, int_size_in_bytes (type));
3397 else
3398 emit_move_insn (return_reg, val);
3401 expand_null_return_1 ();
3404 /* Generate RTL to evaluate the expression RETVAL and return it
3405 from the current function. */
3407 static void
3408 expand_return (tree retval, tree bounds)
3410 rtx result_rtl;
3411 rtx val = 0;
3412 tree retval_rhs;
3413 rtx bounds_rtl;
3415 /* If function wants no value, give it none. */
3416 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
3418 expand_normal (retval);
3419 expand_null_return ();
3420 return;
3423 if (retval == error_mark_node)
3425 /* Treat this like a return of no value from a function that
3426 returns a value. */
3427 expand_null_return ();
3428 return;
3430 else if ((TREE_CODE (retval) == MODIFY_EXPR
3431 || TREE_CODE (retval) == INIT_EXPR)
3432 && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
3433 retval_rhs = TREE_OPERAND (retval, 1);
3434 else
3435 retval_rhs = retval;
3437 result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
3439 /* Put returned bounds to the right place. */
3440 bounds_rtl = DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl));
3441 if (bounds_rtl)
3443 rtx addr = NULL;
3444 rtx bnd = NULL;
3446 if (bounds && bounds != error_mark_node)
3448 bnd = expand_normal (bounds);
3449 targetm.calls.store_returned_bounds (bounds_rtl, bnd);
3451 else if (REG_P (bounds_rtl))
3453 if (bounds)
3454 bnd = chkp_expand_zero_bounds ();
3455 else
3457 addr = expand_normal (build_fold_addr_expr (retval_rhs));
3458 addr = gen_rtx_MEM (Pmode, addr);
3459 bnd = targetm.calls.load_bounds_for_arg (addr, NULL, NULL);
3462 targetm.calls.store_returned_bounds (bounds_rtl, bnd);
3464 else
3466 int n;
3468 gcc_assert (GET_CODE (bounds_rtl) == PARALLEL);
3470 if (bounds)
3471 bnd = chkp_expand_zero_bounds ();
3472 else
3474 addr = expand_normal (build_fold_addr_expr (retval_rhs));
3475 addr = gen_rtx_MEM (Pmode, addr);
3478 for (n = 0; n < XVECLEN (bounds_rtl, 0); n++)
3480 rtx slot = XEXP (XVECEXP (bounds_rtl, 0, n), 0);
3481 if (!bounds)
3483 rtx offs = XEXP (XVECEXP (bounds_rtl, 0, n), 1);
3484 rtx from = adjust_address (addr, Pmode, INTVAL (offs));
3485 bnd = targetm.calls.load_bounds_for_arg (from, NULL, NULL);
3487 targetm.calls.store_returned_bounds (slot, bnd);
3491 else if (chkp_function_instrumented_p (current_function_decl)
3492 && !BOUNDED_P (retval_rhs)
3493 && chkp_type_has_pointer (TREE_TYPE (retval_rhs))
3494 && TREE_CODE (retval_rhs) != RESULT_DECL)
3496 rtx addr = expand_normal (build_fold_addr_expr (retval_rhs));
3497 addr = gen_rtx_MEM (Pmode, addr);
3499 gcc_assert (MEM_P (result_rtl));
3501 chkp_copy_bounds_for_stack_parm (result_rtl, addr, TREE_TYPE (retval_rhs));
3504 /* If we are returning the RESULT_DECL, then the value has already
3505 been stored into it, so we don't have to do anything special. */
3506 if (TREE_CODE (retval_rhs) == RESULT_DECL)
3507 expand_value_return (result_rtl);
3509 /* If the result is an aggregate that is being returned in one (or more)
3510 registers, load the registers here. */
3512 else if (retval_rhs != 0
3513 && TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
3514 && REG_P (result_rtl))
3516 val = copy_blkmode_to_reg (GET_MODE (result_rtl), retval_rhs);
3517 if (val)
3519 /* Use the mode of the result value on the return register. */
3520 PUT_MODE (result_rtl, GET_MODE (val));
3521 expand_value_return (val);
3523 else
3524 expand_null_return ();
3526 else if (retval_rhs != 0
3527 && !VOID_TYPE_P (TREE_TYPE (retval_rhs))
3528 && (REG_P (result_rtl)
3529 || (GET_CODE (result_rtl) == PARALLEL)))
3531 /* Compute the return value into a temporary (usually a pseudo reg). */
3533 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl)), 0, 1);
3534 val = expand_expr (retval_rhs, val, GET_MODE (val), EXPAND_NORMAL);
3535 val = force_not_mem (val);
3536 expand_value_return (val);
3538 else
3540 /* No hard reg used; calculate value into hard return reg. */
3541 expand_expr (retval, const0_rtx, VOIDmode, EXPAND_NORMAL);
3542 expand_value_return (result_rtl);
3546 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3547 STMT that doesn't require special handling for outgoing edges. That
3548 is no tailcalls and no GIMPLE_COND. */
3550 static void
3551 expand_gimple_stmt_1 (gimple *stmt)
3553 tree op0;
3555 set_curr_insn_location (gimple_location (stmt));
3557 switch (gimple_code (stmt))
3559 case GIMPLE_GOTO:
3560 op0 = gimple_goto_dest (stmt);
3561 if (TREE_CODE (op0) == LABEL_DECL)
3562 expand_goto (op0);
3563 else
3564 expand_computed_goto (op0);
3565 break;
3566 case GIMPLE_LABEL:
3567 expand_label (gimple_label_label (as_a <glabel *> (stmt)));
3568 break;
3569 case GIMPLE_NOP:
3570 case GIMPLE_PREDICT:
3571 break;
3572 case GIMPLE_SWITCH:
3574 gswitch *swtch = as_a <gswitch *> (stmt);
3575 if (gimple_switch_num_labels (swtch) == 1)
3576 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch)));
3577 else
3578 expand_case (swtch);
3580 break;
3581 case GIMPLE_ASM:
3582 expand_asm_stmt (as_a <gasm *> (stmt));
3583 break;
3584 case GIMPLE_CALL:
3585 expand_call_stmt (as_a <gcall *> (stmt));
3586 break;
3588 case GIMPLE_RETURN:
3590 tree bnd = gimple_return_retbnd (as_a <greturn *> (stmt));
3591 op0 = gimple_return_retval (as_a <greturn *> (stmt));
3593 if (op0 && op0 != error_mark_node)
3595 tree result = DECL_RESULT (current_function_decl);
3597 /* Mark we have return statement with missing bounds. */
3598 if (!bnd
3599 && chkp_function_instrumented_p (cfun->decl)
3600 && !DECL_P (op0))
3601 bnd = error_mark_node;
3603 /* If we are not returning the current function's RESULT_DECL,
3604 build an assignment to it. */
3605 if (op0 != result)
3607 /* I believe that a function's RESULT_DECL is unique. */
3608 gcc_assert (TREE_CODE (op0) != RESULT_DECL);
3610 /* ??? We'd like to use simply expand_assignment here,
3611 but this fails if the value is of BLKmode but the return
3612 decl is a register. expand_return has special handling
3613 for this combination, which eventually should move
3614 to common code. See comments there. Until then, let's
3615 build a modify expression :-/ */
3616 op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
3617 result, op0);
3621 if (!op0)
3622 expand_null_return ();
3623 else
3624 expand_return (op0, bnd);
3626 break;
3628 case GIMPLE_ASSIGN:
3630 gassign *assign_stmt = as_a <gassign *> (stmt);
3631 tree lhs = gimple_assign_lhs (assign_stmt);
3633 /* Tree expand used to fiddle with |= and &= of two bitfield
3634 COMPONENT_REFs here. This can't happen with gimple, the LHS
3635 of binary assigns must be a gimple reg. */
3637 if (TREE_CODE (lhs) != SSA_NAME
3638 || get_gimple_rhs_class (gimple_expr_code (stmt))
3639 == GIMPLE_SINGLE_RHS)
3641 tree rhs = gimple_assign_rhs1 (assign_stmt);
3642 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
3643 == GIMPLE_SINGLE_RHS);
3644 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs)
3645 /* Do not put locations on possibly shared trees. */
3646 && !is_gimple_min_invariant (rhs))
3647 SET_EXPR_LOCATION (rhs, gimple_location (stmt));
3648 if (TREE_CLOBBER_P (rhs))
3649 /* This is a clobber to mark the going out of scope for
3650 this LHS. */
3652 else
3653 expand_assignment (lhs, rhs,
3654 gimple_assign_nontemporal_move_p (
3655 assign_stmt));
3657 else
3659 rtx target, temp;
3660 bool nontemporal = gimple_assign_nontemporal_move_p (assign_stmt);
3661 struct separate_ops ops;
3662 bool promoted = false;
3664 target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
3665 if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
3666 promoted = true;
3668 ops.code = gimple_assign_rhs_code (assign_stmt);
3669 ops.type = TREE_TYPE (lhs);
3670 switch (get_gimple_rhs_class (ops.code))
3672 case GIMPLE_TERNARY_RHS:
3673 ops.op2 = gimple_assign_rhs3 (assign_stmt);
3674 /* Fallthru */
3675 case GIMPLE_BINARY_RHS:
3676 ops.op1 = gimple_assign_rhs2 (assign_stmt);
3677 /* Fallthru */
3678 case GIMPLE_UNARY_RHS:
3679 ops.op0 = gimple_assign_rhs1 (assign_stmt);
3680 break;
3681 default:
3682 gcc_unreachable ();
3684 ops.location = gimple_location (stmt);
3686 /* If we want to use a nontemporal store, force the value to
3687 register first. If we store into a promoted register,
3688 don't directly expand to target. */
3689 temp = nontemporal || promoted ? NULL_RTX : target;
3690 temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
3691 EXPAND_NORMAL);
3693 if (temp == target)
3695 else if (promoted)
3697 int unsignedp = SUBREG_PROMOTED_SIGN (target);
3698 /* If TEMP is a VOIDmode constant, use convert_modes to make
3699 sure that we properly convert it. */
3700 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
3702 temp = convert_modes (GET_MODE (target),
3703 TYPE_MODE (ops.type),
3704 temp, unsignedp);
3705 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
3706 GET_MODE (target), temp, unsignedp);
3709 convert_move (SUBREG_REG (target), temp, unsignedp);
3711 else if (nontemporal && emit_storent_insn (target, temp))
3713 else
3715 temp = force_operand (temp, target);
3716 if (temp != target)
3717 emit_move_insn (target, temp);
3721 break;
3723 default:
3724 gcc_unreachable ();
3728 /* Expand one gimple statement STMT and return the last RTL instruction
3729 before any of the newly generated ones.
3731 In addition to generating the necessary RTL instructions this also
3732 sets REG_EH_REGION notes if necessary and sets the current source
3733 location for diagnostics. */
3735 static rtx_insn *
3736 expand_gimple_stmt (gimple *stmt)
3738 location_t saved_location = input_location;
3739 rtx_insn *last = get_last_insn ();
3740 int lp_nr;
3742 gcc_assert (cfun);
3744 /* We need to save and restore the current source location so that errors
3745 discovered during expansion are emitted with the right location. But
3746 it would be better if the diagnostic routines used the source location
3747 embedded in the tree nodes rather than globals. */
3748 if (gimple_has_location (stmt))
3749 input_location = gimple_location (stmt);
3751 expand_gimple_stmt_1 (stmt);
3753 /* Free any temporaries used to evaluate this statement. */
3754 free_temp_slots ();
3756 input_location = saved_location;
3758 /* Mark all insns that may trap. */
3759 lp_nr = lookup_stmt_eh_lp (stmt);
3760 if (lp_nr)
3762 rtx_insn *insn;
3763 for (insn = next_real_insn (last); insn;
3764 insn = next_real_insn (insn))
3766 if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
3767 /* If we want exceptions for non-call insns, any
3768 may_trap_p instruction may throw. */
3769 && GET_CODE (PATTERN (insn)) != CLOBBER
3770 && GET_CODE (PATTERN (insn)) != USE
3771 && insn_could_throw_p (insn))
3772 make_reg_eh_region_note (insn, 0, lp_nr);
3776 return last;
3779 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3780 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3781 generated a tail call (something that might be denied by the ABI
3782 rules governing the call; see calls.c).
3784 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3785 can still reach the rest of BB. The case here is __builtin_sqrt,
3786 where the NaN result goes through the external function (with a
3787 tailcall) and the normal result happens via a sqrt instruction. */
3789 static basic_block
3790 expand_gimple_tailcall (basic_block bb, gcall *stmt, bool *can_fallthru)
3792 rtx_insn *last2, *last;
3793 edge e;
3794 edge_iterator ei;
3795 profile_probability probability;
3797 last2 = last = expand_gimple_stmt (stmt);
3799 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
3800 if (CALL_P (last) && SIBLING_CALL_P (last))
3801 goto found;
3803 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
3805 *can_fallthru = true;
3806 return NULL;
3808 found:
3809 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3810 Any instructions emitted here are about to be deleted. */
3811 do_pending_stack_adjust ();
3813 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3814 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3815 EH or abnormal edges, we shouldn't have created a tail call in
3816 the first place. So it seems to me we should just be removing
3817 all edges here, or redirecting the existing fallthru edge to
3818 the exit block. */
3820 probability = profile_probability::never ();
3821 profile_count count = profile_count::zero ();
3823 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
3825 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
3827 if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
3829 e->dest->count -= e->count;
3830 e->dest->frequency -= EDGE_FREQUENCY (e);
3831 if (e->dest->frequency < 0)
3832 e->dest->frequency = 0;
3834 count += e->count;
3835 probability += e->probability;
3836 remove_edge (e);
3838 else
3839 ei_next (&ei);
3842 /* This is somewhat ugly: the call_expr expander often emits instructions
3843 after the sibcall (to perform the function return). These confuse the
3844 find_many_sub_basic_blocks code, so we need to get rid of these. */
3845 last = NEXT_INSN (last);
3846 gcc_assert (BARRIER_P (last));
3848 *can_fallthru = false;
3849 while (NEXT_INSN (last))
3851 /* For instance an sqrt builtin expander expands if with
3852 sibcall in the then and label for `else`. */
3853 if (LABEL_P (NEXT_INSN (last)))
3855 *can_fallthru = true;
3856 break;
3858 delete_insn (NEXT_INSN (last));
3861 e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_ABNORMAL
3862 | EDGE_SIBCALL);
3863 e->probability = probability;
3864 e->count = count;
3865 BB_END (bb) = last;
3866 update_bb_for_insn (bb);
3868 if (NEXT_INSN (last))
3870 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
3872 last = BB_END (bb);
3873 if (BARRIER_P (last))
3874 BB_END (bb) = PREV_INSN (last);
3877 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
3879 return bb;
3882 /* Return the difference between the floor and the truncated result of
3883 a signed division by OP1 with remainder MOD. */
3884 static rtx
3885 floor_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
3887 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3888 return gen_rtx_IF_THEN_ELSE
3889 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
3890 gen_rtx_IF_THEN_ELSE
3891 (mode, gen_rtx_LT (BImode,
3892 gen_rtx_DIV (mode, op1, mod),
3893 const0_rtx),
3894 constm1_rtx, const0_rtx),
3895 const0_rtx);
3898 /* Return the difference between the ceil and the truncated result of
3899 a signed division by OP1 with remainder MOD. */
3900 static rtx
3901 ceil_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
3903 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3904 return gen_rtx_IF_THEN_ELSE
3905 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
3906 gen_rtx_IF_THEN_ELSE
3907 (mode, gen_rtx_GT (BImode,
3908 gen_rtx_DIV (mode, op1, mod),
3909 const0_rtx),
3910 const1_rtx, const0_rtx),
3911 const0_rtx);
3914 /* Return the difference between the ceil and the truncated result of
3915 an unsigned division by OP1 with remainder MOD. */
3916 static rtx
3917 ceil_udiv_adjust (machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
3919 /* (mod != 0 ? 1 : 0) */
3920 return gen_rtx_IF_THEN_ELSE
3921 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
3922 const1_rtx, const0_rtx);
3925 /* Return the difference between the rounded and the truncated result
3926 of a signed division by OP1 with remainder MOD. Halfway cases are
3927 rounded away from zero, rather than to the nearest even number. */
3928 static rtx
3929 round_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
3931 /* (abs (mod) >= abs (op1) - abs (mod)
3932 ? (op1 / mod > 0 ? 1 : -1)
3933 : 0) */
3934 return gen_rtx_IF_THEN_ELSE
3935 (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
3936 gen_rtx_MINUS (mode,
3937 gen_rtx_ABS (mode, op1),
3938 gen_rtx_ABS (mode, mod))),
3939 gen_rtx_IF_THEN_ELSE
3940 (mode, gen_rtx_GT (BImode,
3941 gen_rtx_DIV (mode, op1, mod),
3942 const0_rtx),
3943 const1_rtx, constm1_rtx),
3944 const0_rtx);
3947 /* Return the difference between the rounded and the truncated result
3948 of a unsigned division by OP1 with remainder MOD. Halfway cases
3949 are rounded away from zero, rather than to the nearest even
3950 number. */
3951 static rtx
3952 round_udiv_adjust (machine_mode mode, rtx mod, rtx op1)
3954 /* (mod >= op1 - mod ? 1 : 0) */
3955 return gen_rtx_IF_THEN_ELSE
3956 (mode, gen_rtx_GE (BImode, mod,
3957 gen_rtx_MINUS (mode, op1, mod)),
3958 const1_rtx, const0_rtx);
3961 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3962 any rtl. */
3964 static rtx
3965 convert_debug_memory_address (scalar_int_mode mode, rtx x,
3966 addr_space_t as)
3968 #ifndef POINTERS_EXTEND_UNSIGNED
3969 gcc_assert (mode == Pmode
3970 || mode == targetm.addr_space.address_mode (as));
3971 gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode);
3972 #else
3973 rtx temp;
3975 gcc_assert (targetm.addr_space.valid_pointer_mode (mode, as));
3977 if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
3978 return x;
3980 /* X must have some form of address mode already. */
3981 scalar_int_mode xmode = as_a <scalar_int_mode> (GET_MODE (x));
3982 if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (xmode))
3983 x = lowpart_subreg (mode, x, xmode);
3984 else if (POINTERS_EXTEND_UNSIGNED > 0)
3985 x = gen_rtx_ZERO_EXTEND (mode, x);
3986 else if (!POINTERS_EXTEND_UNSIGNED)
3987 x = gen_rtx_SIGN_EXTEND (mode, x);
3988 else
3990 switch (GET_CODE (x))
3992 case SUBREG:
3993 if ((SUBREG_PROMOTED_VAR_P (x)
3994 || (REG_P (SUBREG_REG (x)) && REG_POINTER (SUBREG_REG (x)))
3995 || (GET_CODE (SUBREG_REG (x)) == PLUS
3996 && REG_P (XEXP (SUBREG_REG (x), 0))
3997 && REG_POINTER (XEXP (SUBREG_REG (x), 0))
3998 && CONST_INT_P (XEXP (SUBREG_REG (x), 1))))
3999 && GET_MODE (SUBREG_REG (x)) == mode)
4000 return SUBREG_REG (x);
4001 break;
4002 case LABEL_REF:
4003 temp = gen_rtx_LABEL_REF (mode, label_ref_label (x));
4004 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
4005 return temp;
4006 case SYMBOL_REF:
4007 temp = shallow_copy_rtx (x);
4008 PUT_MODE (temp, mode);
4009 return temp;
4010 case CONST:
4011 temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
4012 if (temp)
4013 temp = gen_rtx_CONST (mode, temp);
4014 return temp;
4015 case PLUS:
4016 case MINUS:
4017 if (CONST_INT_P (XEXP (x, 1)))
4019 temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
4020 if (temp)
4021 return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1));
4023 break;
4024 default:
4025 break;
4027 /* Don't know how to express ptr_extend as operation in debug info. */
4028 return NULL;
4030 #endif /* POINTERS_EXTEND_UNSIGNED */
4032 return x;
4035 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4036 by avoid_deep_ter_for_debug. */
4038 static hash_map<tree, tree> *deep_ter_debug_map;
4040 /* Split too deep TER chains for debug stmts using debug temporaries. */
4042 static void
4043 avoid_deep_ter_for_debug (gimple *stmt, int depth)
4045 use_operand_p use_p;
4046 ssa_op_iter iter;
4047 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
4049 tree use = USE_FROM_PTR (use_p);
4050 if (TREE_CODE (use) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (use))
4051 continue;
4052 gimple *g = get_gimple_for_ssa_name (use);
4053 if (g == NULL)
4054 continue;
4055 if (depth > 6 && !stmt_ends_bb_p (g))
4057 if (deep_ter_debug_map == NULL)
4058 deep_ter_debug_map = new hash_map<tree, tree>;
4060 tree &vexpr = deep_ter_debug_map->get_or_insert (use);
4061 if (vexpr != NULL)
4062 continue;
4063 vexpr = make_node (DEBUG_EXPR_DECL);
4064 gimple *def_temp = gimple_build_debug_bind (vexpr, use, g);
4065 DECL_ARTIFICIAL (vexpr) = 1;
4066 TREE_TYPE (vexpr) = TREE_TYPE (use);
4067 SET_DECL_MODE (vexpr, TYPE_MODE (TREE_TYPE (use)));
4068 gimple_stmt_iterator gsi = gsi_for_stmt (g);
4069 gsi_insert_after (&gsi, def_temp, GSI_NEW_STMT);
4070 avoid_deep_ter_for_debug (def_temp, 0);
4072 else
4073 avoid_deep_ter_for_debug (g, depth + 1);
4077 /* Return an RTX equivalent to the value of the parameter DECL. */
4079 static rtx
4080 expand_debug_parm_decl (tree decl)
4082 rtx incoming = DECL_INCOMING_RTL (decl);
4084 if (incoming
4085 && GET_MODE (incoming) != BLKmode
4086 && ((REG_P (incoming) && HARD_REGISTER_P (incoming))
4087 || (MEM_P (incoming)
4088 && REG_P (XEXP (incoming, 0))
4089 && HARD_REGISTER_P (XEXP (incoming, 0)))))
4091 rtx rtl = gen_rtx_ENTRY_VALUE (GET_MODE (incoming));
4093 #ifdef HAVE_window_save
4094 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4095 If the target machine has an explicit window save instruction, the
4096 actual entry value is the corresponding OUTGOING_REGNO instead. */
4097 if (REG_P (incoming)
4098 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
4099 incoming
4100 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
4101 OUTGOING_REGNO (REGNO (incoming)), 0);
4102 else if (MEM_P (incoming))
4104 rtx reg = XEXP (incoming, 0);
4105 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
4107 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
4108 incoming = replace_equiv_address_nv (incoming, reg);
4110 else
4111 incoming = copy_rtx (incoming);
4113 #endif
4115 ENTRY_VALUE_EXP (rtl) = incoming;
4116 return rtl;
4119 if (incoming
4120 && GET_MODE (incoming) != BLKmode
4121 && !TREE_ADDRESSABLE (decl)
4122 && MEM_P (incoming)
4123 && (XEXP (incoming, 0) == virtual_incoming_args_rtx
4124 || (GET_CODE (XEXP (incoming, 0)) == PLUS
4125 && XEXP (XEXP (incoming, 0), 0) == virtual_incoming_args_rtx
4126 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
4127 return copy_rtx (incoming);
4129 return NULL_RTX;
4132 /* Return an RTX equivalent to the value of the tree expression EXP. */
4134 static rtx
4135 expand_debug_expr (tree exp)
4137 rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
4138 machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
4139 machine_mode inner_mode = VOIDmode;
4140 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
4141 addr_space_t as;
4142 scalar_int_mode op0_mode, op1_mode, addr_mode;
4144 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
4146 case tcc_expression:
4147 switch (TREE_CODE (exp))
4149 case COND_EXPR:
4150 case DOT_PROD_EXPR:
4151 case SAD_EXPR:
4152 case WIDEN_MULT_PLUS_EXPR:
4153 case WIDEN_MULT_MINUS_EXPR:
4154 case FMA_EXPR:
4155 goto ternary;
4157 case TRUTH_ANDIF_EXPR:
4158 case TRUTH_ORIF_EXPR:
4159 case TRUTH_AND_EXPR:
4160 case TRUTH_OR_EXPR:
4161 case TRUTH_XOR_EXPR:
4162 goto binary;
4164 case TRUTH_NOT_EXPR:
4165 goto unary;
4167 default:
4168 break;
4170 break;
4172 ternary:
4173 op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
4174 if (!op2)
4175 return NULL_RTX;
4176 /* Fall through. */
4178 binary:
4179 case tcc_binary:
4180 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
4181 if (!op1)
4182 return NULL_RTX;
4183 switch (TREE_CODE (exp))
4185 case LSHIFT_EXPR:
4186 case RSHIFT_EXPR:
4187 case LROTATE_EXPR:
4188 case RROTATE_EXPR:
4189 case WIDEN_LSHIFT_EXPR:
4190 /* Ensure second operand isn't wider than the first one. */
4191 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
4192 if (is_a <scalar_int_mode> (inner_mode, &op1_mode)
4193 && (GET_MODE_UNIT_PRECISION (mode)
4194 < GET_MODE_PRECISION (op1_mode)))
4195 op1 = lowpart_subreg (GET_MODE_INNER (mode), op1, op1_mode);
4196 break;
4197 default:
4198 break;
4200 /* Fall through. */
4202 unary:
4203 case tcc_unary:
4204 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4205 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
4206 if (!op0)
4207 return NULL_RTX;
4208 break;
4210 case tcc_comparison:
4211 unsignedp = TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
4212 goto binary;
4214 case tcc_type:
4215 case tcc_statement:
4216 gcc_unreachable ();
4218 case tcc_constant:
4219 case tcc_exceptional:
4220 case tcc_declaration:
4221 case tcc_reference:
4222 case tcc_vl_exp:
4223 break;
4226 switch (TREE_CODE (exp))
4228 case STRING_CST:
4229 if (!lookup_constant_def (exp))
4231 if (strlen (TREE_STRING_POINTER (exp)) + 1
4232 != (size_t) TREE_STRING_LENGTH (exp))
4233 return NULL_RTX;
4234 op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
4235 op0 = gen_rtx_MEM (BLKmode, op0);
4236 set_mem_attributes (op0, exp, 0);
4237 return op0;
4239 /* Fall through. */
4241 case INTEGER_CST:
4242 case REAL_CST:
4243 case FIXED_CST:
4244 op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
4245 return op0;
4247 case COMPLEX_CST:
4248 gcc_assert (COMPLEX_MODE_P (mode));
4249 op0 = expand_debug_expr (TREE_REALPART (exp));
4250 op1 = expand_debug_expr (TREE_IMAGPART (exp));
4251 return gen_rtx_CONCAT (mode, op0, op1);
4253 case DEBUG_EXPR_DECL:
4254 op0 = DECL_RTL_IF_SET (exp);
4256 if (op0)
4257 return op0;
4259 op0 = gen_rtx_DEBUG_EXPR (mode);
4260 DEBUG_EXPR_TREE_DECL (op0) = exp;
4261 SET_DECL_RTL (exp, op0);
4263 return op0;
4265 case VAR_DECL:
4266 case PARM_DECL:
4267 case FUNCTION_DECL:
4268 case LABEL_DECL:
4269 case CONST_DECL:
4270 case RESULT_DECL:
4271 op0 = DECL_RTL_IF_SET (exp);
4273 /* This decl was probably optimized away. */
4274 if (!op0)
4276 if (!VAR_P (exp)
4277 || DECL_EXTERNAL (exp)
4278 || !TREE_STATIC (exp)
4279 || !DECL_NAME (exp)
4280 || DECL_HARD_REGISTER (exp)
4281 || DECL_IN_CONSTANT_POOL (exp)
4282 || mode == VOIDmode)
4283 return NULL;
4285 op0 = make_decl_rtl_for_debug (exp);
4286 if (!MEM_P (op0)
4287 || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
4288 || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
4289 return NULL;
4291 else
4292 op0 = copy_rtx (op0);
4294 if (GET_MODE (op0) == BLKmode
4295 /* If op0 is not BLKmode, but mode is, adjust_mode
4296 below would ICE. While it is likely a FE bug,
4297 try to be robust here. See PR43166. */
4298 || mode == BLKmode
4299 || (mode == VOIDmode && GET_MODE (op0) != VOIDmode))
4301 gcc_assert (MEM_P (op0));
4302 op0 = adjust_address_nv (op0, mode, 0);
4303 return op0;
4306 /* Fall through. */
4308 adjust_mode:
4309 case PAREN_EXPR:
4310 CASE_CONVERT:
4312 inner_mode = GET_MODE (op0);
4314 if (mode == inner_mode)
4315 return op0;
4317 if (inner_mode == VOIDmode)
4319 if (TREE_CODE (exp) == SSA_NAME)
4320 inner_mode = TYPE_MODE (TREE_TYPE (exp));
4321 else
4322 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4323 if (mode == inner_mode)
4324 return op0;
4327 if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
4329 if (GET_MODE_UNIT_BITSIZE (mode)
4330 == GET_MODE_UNIT_BITSIZE (inner_mode))
4331 op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
4332 else if (GET_MODE_UNIT_BITSIZE (mode)
4333 < GET_MODE_UNIT_BITSIZE (inner_mode))
4334 op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
4335 else
4336 op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
4338 else if (FLOAT_MODE_P (mode))
4340 gcc_assert (TREE_CODE (exp) != SSA_NAME);
4341 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
4342 op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
4343 else
4344 op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
4346 else if (FLOAT_MODE_P (inner_mode))
4348 if (unsignedp)
4349 op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
4350 else
4351 op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
4353 else if (CONSTANT_P (op0)
4354 || GET_MODE_PRECISION (mode) <= GET_MODE_PRECISION (inner_mode))
4355 op0 = lowpart_subreg (mode, op0, inner_mode);
4356 else if (UNARY_CLASS_P (exp)
4357 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
4358 : unsignedp)
4359 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
4360 else
4361 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
4363 return op0;
4366 case MEM_REF:
4367 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
4369 tree newexp = fold_binary (MEM_REF, TREE_TYPE (exp),
4370 TREE_OPERAND (exp, 0),
4371 TREE_OPERAND (exp, 1));
4372 if (newexp)
4373 return expand_debug_expr (newexp);
4375 /* FALLTHROUGH */
4376 case INDIRECT_REF:
4377 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4378 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
4379 if (!op0)
4380 return NULL;
4382 if (TREE_CODE (exp) == MEM_REF)
4384 if (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
4385 || (GET_CODE (op0) == PLUS
4386 && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR))
4387 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4388 Instead just use get_inner_reference. */
4389 goto component_ref;
4391 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
4392 if (!op1 || !CONST_INT_P (op1))
4393 return NULL;
4395 op0 = plus_constant (inner_mode, op0, INTVAL (op1));
4398 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
4400 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
4401 op0, as);
4402 if (op0 == NULL_RTX)
4403 return NULL;
4405 op0 = gen_rtx_MEM (mode, op0);
4406 set_mem_attributes (op0, exp, 0);
4407 if (TREE_CODE (exp) == MEM_REF
4408 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
4409 set_mem_expr (op0, NULL_TREE);
4410 set_mem_addr_space (op0, as);
4412 return op0;
4414 case TARGET_MEM_REF:
4415 if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
4416 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
4417 return NULL;
4419 op0 = expand_debug_expr
4420 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
4421 if (!op0)
4422 return NULL;
4424 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
4425 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
4426 op0, as);
4427 if (op0 == NULL_RTX)
4428 return NULL;
4430 op0 = gen_rtx_MEM (mode, op0);
4432 set_mem_attributes (op0, exp, 0);
4433 set_mem_addr_space (op0, as);
4435 return op0;
4437 component_ref:
4438 case ARRAY_REF:
4439 case ARRAY_RANGE_REF:
4440 case COMPONENT_REF:
4441 case BIT_FIELD_REF:
4442 case REALPART_EXPR:
4443 case IMAGPART_EXPR:
4444 case VIEW_CONVERT_EXPR:
4446 machine_mode mode1;
4447 HOST_WIDE_INT bitsize, bitpos;
4448 tree offset;
4449 int reversep, volatilep = 0;
4450 tree tem
4451 = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
4452 &unsignedp, &reversep, &volatilep);
4453 rtx orig_op0;
4455 if (bitsize == 0)
4456 return NULL;
4458 orig_op0 = op0 = expand_debug_expr (tem);
4460 if (!op0)
4461 return NULL;
4463 if (offset)
4465 machine_mode addrmode, offmode;
4467 if (!MEM_P (op0))
4468 return NULL;
4470 op0 = XEXP (op0, 0);
4471 addrmode = GET_MODE (op0);
4472 if (addrmode == VOIDmode)
4473 addrmode = Pmode;
4475 op1 = expand_debug_expr (offset);
4476 if (!op1)
4477 return NULL;
4479 offmode = GET_MODE (op1);
4480 if (offmode == VOIDmode)
4481 offmode = TYPE_MODE (TREE_TYPE (offset));
4483 if (addrmode != offmode)
4484 op1 = lowpart_subreg (addrmode, op1, offmode);
4486 /* Don't use offset_address here, we don't need a
4487 recognizable address, and we don't want to generate
4488 code. */
4489 op0 = gen_rtx_MEM (mode, simplify_gen_binary (PLUS, addrmode,
4490 op0, op1));
4493 if (MEM_P (op0))
4495 if (mode1 == VOIDmode)
4496 /* Bitfield. */
4497 mode1 = smallest_int_mode_for_size (bitsize);
4498 if (bitpos >= BITS_PER_UNIT)
4500 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
4501 bitpos %= BITS_PER_UNIT;
4503 else if (bitpos < 0)
4505 HOST_WIDE_INT units
4506 = (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4507 op0 = adjust_address_nv (op0, mode1, -units);
4508 bitpos += units * BITS_PER_UNIT;
4510 else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
4511 op0 = adjust_address_nv (op0, mode, 0);
4512 else if (GET_MODE (op0) != mode1)
4513 op0 = adjust_address_nv (op0, mode1, 0);
4514 else
4515 op0 = copy_rtx (op0);
4516 if (op0 == orig_op0)
4517 op0 = shallow_copy_rtx (op0);
4518 set_mem_attributes (op0, exp, 0);
4521 if (bitpos == 0 && mode == GET_MODE (op0))
4522 return op0;
4524 if (bitpos < 0)
4525 return NULL;
4527 if (GET_MODE (op0) == BLKmode)
4528 return NULL;
4530 if ((bitpos % BITS_PER_UNIT) == 0
4531 && bitsize == GET_MODE_BITSIZE (mode1))
4533 machine_mode opmode = GET_MODE (op0);
4535 if (opmode == VOIDmode)
4536 opmode = TYPE_MODE (TREE_TYPE (tem));
4538 /* This condition may hold if we're expanding the address
4539 right past the end of an array that turned out not to
4540 be addressable (i.e., the address was only computed in
4541 debug stmts). The gen_subreg below would rightfully
4542 crash, and the address doesn't really exist, so just
4543 drop it. */
4544 if (bitpos >= GET_MODE_BITSIZE (opmode))
4545 return NULL;
4547 if ((bitpos % GET_MODE_BITSIZE (mode)) == 0)
4548 return simplify_gen_subreg (mode, op0, opmode,
4549 bitpos / BITS_PER_UNIT);
4552 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
4553 && TYPE_UNSIGNED (TREE_TYPE (exp))
4554 ? SIGN_EXTRACT
4555 : ZERO_EXTRACT, mode,
4556 GET_MODE (op0) != VOIDmode
4557 ? GET_MODE (op0)
4558 : TYPE_MODE (TREE_TYPE (tem)),
4559 op0, GEN_INT (bitsize), GEN_INT (bitpos));
4562 case ABS_EXPR:
4563 return simplify_gen_unary (ABS, mode, op0, mode);
4565 case NEGATE_EXPR:
4566 return simplify_gen_unary (NEG, mode, op0, mode);
4568 case BIT_NOT_EXPR:
4569 return simplify_gen_unary (NOT, mode, op0, mode);
4571 case FLOAT_EXPR:
4572 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
4573 0)))
4574 ? UNSIGNED_FLOAT : FLOAT, mode, op0,
4575 inner_mode);
4577 case FIX_TRUNC_EXPR:
4578 return simplify_gen_unary (unsignedp ? UNSIGNED_FIX : FIX, mode, op0,
4579 inner_mode);
4581 case POINTER_PLUS_EXPR:
4582 /* For the rare target where pointers are not the same size as
4583 size_t, we need to check for mis-matched modes and correct
4584 the addend. */
4585 if (op0 && op1
4586 && is_a <scalar_int_mode> (GET_MODE (op0), &op0_mode)
4587 && is_a <scalar_int_mode> (GET_MODE (op1), &op1_mode)
4588 && op0_mode != op1_mode)
4590 if (GET_MODE_BITSIZE (op0_mode) < GET_MODE_BITSIZE (op1_mode)
4591 /* If OP0 is a partial mode, then we must truncate, even
4592 if it has the same bitsize as OP1 as GCC's
4593 representation of partial modes is opaque. */
4594 || (GET_MODE_CLASS (op0_mode) == MODE_PARTIAL_INT
4595 && (GET_MODE_BITSIZE (op0_mode)
4596 == GET_MODE_BITSIZE (op1_mode))))
4597 op1 = simplify_gen_unary (TRUNCATE, op0_mode, op1, op1_mode);
4598 else
4599 /* We always sign-extend, regardless of the signedness of
4600 the operand, because the operand is always unsigned
4601 here even if the original C expression is signed. */
4602 op1 = simplify_gen_unary (SIGN_EXTEND, op0_mode, op1, op1_mode);
4604 /* Fall through. */
4605 case PLUS_EXPR:
4606 return simplify_gen_binary (PLUS, mode, op0, op1);
4608 case MINUS_EXPR:
4609 return simplify_gen_binary (MINUS, mode, op0, op1);
4611 case MULT_EXPR:
4612 return simplify_gen_binary (MULT, mode, op0, op1);
4614 case RDIV_EXPR:
4615 case TRUNC_DIV_EXPR:
4616 case EXACT_DIV_EXPR:
4617 if (unsignedp)
4618 return simplify_gen_binary (UDIV, mode, op0, op1);
4619 else
4620 return simplify_gen_binary (DIV, mode, op0, op1);
4622 case TRUNC_MOD_EXPR:
4623 return simplify_gen_binary (unsignedp ? UMOD : MOD, mode, op0, op1);
4625 case FLOOR_DIV_EXPR:
4626 if (unsignedp)
4627 return simplify_gen_binary (UDIV, mode, op0, op1);
4628 else
4630 rtx div = simplify_gen_binary (DIV, mode, op0, op1);
4631 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
4632 rtx adj = floor_sdiv_adjust (mode, mod, op1);
4633 return simplify_gen_binary (PLUS, mode, div, adj);
4636 case FLOOR_MOD_EXPR:
4637 if (unsignedp)
4638 return simplify_gen_binary (UMOD, mode, op0, op1);
4639 else
4641 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
4642 rtx adj = floor_sdiv_adjust (mode, mod, op1);
4643 adj = simplify_gen_unary (NEG, mode,
4644 simplify_gen_binary (MULT, mode, adj, op1),
4645 mode);
4646 return simplify_gen_binary (PLUS, mode, mod, adj);
4649 case CEIL_DIV_EXPR:
4650 if (unsignedp)
4652 rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
4653 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
4654 rtx adj = ceil_udiv_adjust (mode, mod, op1);
4655 return simplify_gen_binary (PLUS, mode, div, adj);
4657 else
4659 rtx div = simplify_gen_binary (DIV, mode, op0, op1);
4660 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
4661 rtx adj = ceil_sdiv_adjust (mode, mod, op1);
4662 return simplify_gen_binary (PLUS, mode, div, adj);
4665 case CEIL_MOD_EXPR:
4666 if (unsignedp)
4668 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
4669 rtx adj = ceil_udiv_adjust (mode, mod, op1);
4670 adj = simplify_gen_unary (NEG, mode,
4671 simplify_gen_binary (MULT, mode, adj, op1),
4672 mode);
4673 return simplify_gen_binary (PLUS, mode, mod, adj);
4675 else
4677 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
4678 rtx adj = ceil_sdiv_adjust (mode, mod, op1);
4679 adj = simplify_gen_unary (NEG, mode,
4680 simplify_gen_binary (MULT, mode, adj, op1),
4681 mode);
4682 return simplify_gen_binary (PLUS, mode, mod, adj);
4685 case ROUND_DIV_EXPR:
4686 if (unsignedp)
4688 rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
4689 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
4690 rtx adj = round_udiv_adjust (mode, mod, op1);
4691 return simplify_gen_binary (PLUS, mode, div, adj);
4693 else
4695 rtx div = simplify_gen_binary (DIV, mode, op0, op1);
4696 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
4697 rtx adj = round_sdiv_adjust (mode, mod, op1);
4698 return simplify_gen_binary (PLUS, mode, div, adj);
4701 case ROUND_MOD_EXPR:
4702 if (unsignedp)
4704 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
4705 rtx adj = round_udiv_adjust (mode, mod, op1);
4706 adj = simplify_gen_unary (NEG, mode,
4707 simplify_gen_binary (MULT, mode, adj, op1),
4708 mode);
4709 return simplify_gen_binary (PLUS, mode, mod, adj);
4711 else
4713 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
4714 rtx adj = round_sdiv_adjust (mode, mod, op1);
4715 adj = simplify_gen_unary (NEG, mode,
4716 simplify_gen_binary (MULT, mode, adj, op1),
4717 mode);
4718 return simplify_gen_binary (PLUS, mode, mod, adj);
4721 case LSHIFT_EXPR:
4722 return simplify_gen_binary (ASHIFT, mode, op0, op1);
4724 case RSHIFT_EXPR:
4725 if (unsignedp)
4726 return simplify_gen_binary (LSHIFTRT, mode, op0, op1);
4727 else
4728 return simplify_gen_binary (ASHIFTRT, mode, op0, op1);
4730 case LROTATE_EXPR:
4731 return simplify_gen_binary (ROTATE, mode, op0, op1);
4733 case RROTATE_EXPR:
4734 return simplify_gen_binary (ROTATERT, mode, op0, op1);
4736 case MIN_EXPR:
4737 return simplify_gen_binary (unsignedp ? UMIN : SMIN, mode, op0, op1);
4739 case MAX_EXPR:
4740 return simplify_gen_binary (unsignedp ? UMAX : SMAX, mode, op0, op1);
4742 case BIT_AND_EXPR:
4743 case TRUTH_AND_EXPR:
4744 return simplify_gen_binary (AND, mode, op0, op1);
4746 case BIT_IOR_EXPR:
4747 case TRUTH_OR_EXPR:
4748 return simplify_gen_binary (IOR, mode, op0, op1);
4750 case BIT_XOR_EXPR:
4751 case TRUTH_XOR_EXPR:
4752 return simplify_gen_binary (XOR, mode, op0, op1);
4754 case TRUTH_ANDIF_EXPR:
4755 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, const0_rtx);
4757 case TRUTH_ORIF_EXPR:
4758 return gen_rtx_IF_THEN_ELSE (mode, op0, const_true_rtx, op1);
4760 case TRUTH_NOT_EXPR:
4761 return simplify_gen_relational (EQ, mode, inner_mode, op0, const0_rtx);
4763 case LT_EXPR:
4764 return simplify_gen_relational (unsignedp ? LTU : LT, mode, inner_mode,
4765 op0, op1);
4767 case LE_EXPR:
4768 return simplify_gen_relational (unsignedp ? LEU : LE, mode, inner_mode,
4769 op0, op1);
4771 case GT_EXPR:
4772 return simplify_gen_relational (unsignedp ? GTU : GT, mode, inner_mode,
4773 op0, op1);
4775 case GE_EXPR:
4776 return simplify_gen_relational (unsignedp ? GEU : GE, mode, inner_mode,
4777 op0, op1);
4779 case EQ_EXPR:
4780 return simplify_gen_relational (EQ, mode, inner_mode, op0, op1);
4782 case NE_EXPR:
4783 return simplify_gen_relational (NE, mode, inner_mode, op0, op1);
4785 case UNORDERED_EXPR:
4786 return simplify_gen_relational (UNORDERED, mode, inner_mode, op0, op1);
4788 case ORDERED_EXPR:
4789 return simplify_gen_relational (ORDERED, mode, inner_mode, op0, op1);
4791 case UNLT_EXPR:
4792 return simplify_gen_relational (UNLT, mode, inner_mode, op0, op1);
4794 case UNLE_EXPR:
4795 return simplify_gen_relational (UNLE, mode, inner_mode, op0, op1);
4797 case UNGT_EXPR:
4798 return simplify_gen_relational (UNGT, mode, inner_mode, op0, op1);
4800 case UNGE_EXPR:
4801 return simplify_gen_relational (UNGE, mode, inner_mode, op0, op1);
4803 case UNEQ_EXPR:
4804 return simplify_gen_relational (UNEQ, mode, inner_mode, op0, op1);
4806 case LTGT_EXPR:
4807 return simplify_gen_relational (LTGT, mode, inner_mode, op0, op1);
4809 case COND_EXPR:
4810 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, op2);
4812 case COMPLEX_EXPR:
4813 gcc_assert (COMPLEX_MODE_P (mode));
4814 if (GET_MODE (op0) == VOIDmode)
4815 op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
4816 if (GET_MODE (op1) == VOIDmode)
4817 op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
4818 return gen_rtx_CONCAT (mode, op0, op1);
4820 case CONJ_EXPR:
4821 if (GET_CODE (op0) == CONCAT)
4822 return gen_rtx_CONCAT (mode, XEXP (op0, 0),
4823 simplify_gen_unary (NEG, GET_MODE_INNER (mode),
4824 XEXP (op0, 1),
4825 GET_MODE_INNER (mode)));
4826 else
4828 scalar_mode imode = GET_MODE_INNER (mode);
4829 rtx re, im;
4831 if (MEM_P (op0))
4833 re = adjust_address_nv (op0, imode, 0);
4834 im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
4836 else
4838 scalar_int_mode ifmode;
4839 scalar_int_mode ihmode;
4840 rtx halfsize;
4841 if (!int_mode_for_mode (mode).exists (&ifmode)
4842 || !int_mode_for_mode (imode).exists (&ihmode))
4843 return NULL;
4844 halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
4845 re = op0;
4846 if (mode != ifmode)
4847 re = gen_rtx_SUBREG (ifmode, re, 0);
4848 re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
4849 if (imode != ihmode)
4850 re = gen_rtx_SUBREG (imode, re, 0);
4851 im = copy_rtx (op0);
4852 if (mode != ifmode)
4853 im = gen_rtx_SUBREG (ifmode, im, 0);
4854 im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
4855 if (imode != ihmode)
4856 im = gen_rtx_SUBREG (imode, im, 0);
4858 im = gen_rtx_NEG (imode, im);
4859 return gen_rtx_CONCAT (mode, re, im);
4862 case ADDR_EXPR:
4863 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
4864 if (!op0 || !MEM_P (op0))
4866 if ((TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL
4867 || TREE_CODE (TREE_OPERAND (exp, 0)) == PARM_DECL
4868 || TREE_CODE (TREE_OPERAND (exp, 0)) == RESULT_DECL)
4869 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp, 0))
4870 || target_for_debug_bind (TREE_OPERAND (exp, 0))))
4871 return gen_rtx_DEBUG_IMPLICIT_PTR (mode, TREE_OPERAND (exp, 0));
4873 if (handled_component_p (TREE_OPERAND (exp, 0)))
4875 HOST_WIDE_INT bitoffset, bitsize, maxsize;
4876 bool reverse;
4877 tree decl
4878 = get_ref_base_and_extent (TREE_OPERAND (exp, 0), &bitoffset,
4879 &bitsize, &maxsize, &reverse);
4880 if ((VAR_P (decl)
4881 || TREE_CODE (decl) == PARM_DECL
4882 || TREE_CODE (decl) == RESULT_DECL)
4883 && (!TREE_ADDRESSABLE (decl)
4884 || target_for_debug_bind (decl))
4885 && (bitoffset % BITS_PER_UNIT) == 0
4886 && bitsize > 0
4887 && bitsize == maxsize)
4889 rtx base = gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl);
4890 return plus_constant (mode, base, bitoffset / BITS_PER_UNIT);
4894 if (TREE_CODE (TREE_OPERAND (exp, 0)) == MEM_REF
4895 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4896 == ADDR_EXPR)
4898 op0 = expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp, 0),
4899 0));
4900 if (op0 != NULL
4901 && (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
4902 || (GET_CODE (op0) == PLUS
4903 && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR
4904 && CONST_INT_P (XEXP (op0, 1)))))
4906 op1 = expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp, 0),
4907 1));
4908 if (!op1 || !CONST_INT_P (op1))
4909 return NULL;
4911 return plus_constant (mode, op0, INTVAL (op1));
4915 return NULL;
4918 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
4919 addr_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (exp));
4920 op0 = convert_debug_memory_address (addr_mode, XEXP (op0, 0), as);
4922 return op0;
4924 case VECTOR_CST:
4926 unsigned i, nelts;
4928 nelts = VECTOR_CST_NELTS (exp);
4929 op0 = gen_rtx_CONCATN (mode, rtvec_alloc (nelts));
4931 for (i = 0; i < nelts; ++i)
4933 op1 = expand_debug_expr (VECTOR_CST_ELT (exp, i));
4934 if (!op1)
4935 return NULL;
4936 XVECEXP (op0, 0, i) = op1;
4939 return op0;
4942 case CONSTRUCTOR:
4943 if (TREE_CLOBBER_P (exp))
4944 return NULL;
4945 else if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
4947 unsigned i;
4948 tree val;
4950 op0 = gen_rtx_CONCATN
4951 (mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
4953 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
4955 op1 = expand_debug_expr (val);
4956 if (!op1)
4957 return NULL;
4958 XVECEXP (op0, 0, i) = op1;
4961 if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
4963 op1 = expand_debug_expr
4964 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
4966 if (!op1)
4967 return NULL;
4969 for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
4970 XVECEXP (op0, 0, i) = op1;
4973 return op0;
4975 else
4976 goto flag_unsupported;
4978 case CALL_EXPR:
4979 /* ??? Maybe handle some builtins? */
4980 return NULL;
4982 case SSA_NAME:
4984 gimple *g = get_gimple_for_ssa_name (exp);
4985 if (g)
4987 tree t = NULL_TREE;
4988 if (deep_ter_debug_map)
4990 tree *slot = deep_ter_debug_map->get (exp);
4991 if (slot)
4992 t = *slot;
4994 if (t == NULL_TREE)
4995 t = gimple_assign_rhs_to_tree (g);
4996 op0 = expand_debug_expr (t);
4997 if (!op0)
4998 return NULL;
5000 else
5002 /* If this is a reference to an incoming value of
5003 parameter that is never used in the code or where the
5004 incoming value is never used in the code, use
5005 PARM_DECL's DECL_RTL if set. */
5006 if (SSA_NAME_IS_DEFAULT_DEF (exp)
5007 && SSA_NAME_VAR (exp)
5008 && TREE_CODE (SSA_NAME_VAR (exp)) == PARM_DECL
5009 && has_zero_uses (exp))
5011 op0 = expand_debug_parm_decl (SSA_NAME_VAR (exp));
5012 if (op0)
5013 goto adjust_mode;
5014 op0 = expand_debug_expr (SSA_NAME_VAR (exp));
5015 if (op0)
5016 goto adjust_mode;
5019 int part = var_to_partition (SA.map, exp);
5021 if (part == NO_PARTITION)
5022 return NULL;
5024 gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
5026 op0 = copy_rtx (SA.partition_to_pseudo[part]);
5028 goto adjust_mode;
5031 case ERROR_MARK:
5032 return NULL;
5034 /* Vector stuff. For most of the codes we don't have rtl codes. */
5035 case REALIGN_LOAD_EXPR:
5036 case REDUC_MAX_EXPR:
5037 case REDUC_MIN_EXPR:
5038 case REDUC_PLUS_EXPR:
5039 case VEC_COND_EXPR:
5040 case VEC_PACK_FIX_TRUNC_EXPR:
5041 case VEC_PACK_SAT_EXPR:
5042 case VEC_PACK_TRUNC_EXPR:
5043 case VEC_UNPACK_FLOAT_HI_EXPR:
5044 case VEC_UNPACK_FLOAT_LO_EXPR:
5045 case VEC_UNPACK_HI_EXPR:
5046 case VEC_UNPACK_LO_EXPR:
5047 case VEC_WIDEN_MULT_HI_EXPR:
5048 case VEC_WIDEN_MULT_LO_EXPR:
5049 case VEC_WIDEN_MULT_EVEN_EXPR:
5050 case VEC_WIDEN_MULT_ODD_EXPR:
5051 case VEC_WIDEN_LSHIFT_HI_EXPR:
5052 case VEC_WIDEN_LSHIFT_LO_EXPR:
5053 case VEC_PERM_EXPR:
5054 return NULL;
5056 /* Misc codes. */
5057 case ADDR_SPACE_CONVERT_EXPR:
5058 case FIXED_CONVERT_EXPR:
5059 case OBJ_TYPE_REF:
5060 case WITH_SIZE_EXPR:
5061 case BIT_INSERT_EXPR:
5062 return NULL;
5064 case DOT_PROD_EXPR:
5065 if (SCALAR_INT_MODE_P (GET_MODE (op0))
5066 && SCALAR_INT_MODE_P (mode))
5069 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
5070 0)))
5071 ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
5072 inner_mode);
5074 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
5075 1)))
5076 ? ZERO_EXTEND : SIGN_EXTEND, mode, op1,
5077 inner_mode);
5078 op0 = simplify_gen_binary (MULT, mode, op0, op1);
5079 return simplify_gen_binary (PLUS, mode, op0, op2);
5081 return NULL;
5083 case WIDEN_MULT_EXPR:
5084 case WIDEN_MULT_PLUS_EXPR:
5085 case WIDEN_MULT_MINUS_EXPR:
5086 if (SCALAR_INT_MODE_P (GET_MODE (op0))
5087 && SCALAR_INT_MODE_P (mode))
5089 inner_mode = GET_MODE (op0);
5090 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
5091 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
5092 else
5093 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
5094 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
5095 op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode);
5096 else
5097 op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode);
5098 op0 = simplify_gen_binary (MULT, mode, op0, op1);
5099 if (TREE_CODE (exp) == WIDEN_MULT_EXPR)
5100 return op0;
5101 else if (TREE_CODE (exp) == WIDEN_MULT_PLUS_EXPR)
5102 return simplify_gen_binary (PLUS, mode, op0, op2);
5103 else
5104 return simplify_gen_binary (MINUS, mode, op2, op0);
5106 return NULL;
5108 case MULT_HIGHPART_EXPR:
5109 /* ??? Similar to the above. */
5110 return NULL;
5112 case WIDEN_SUM_EXPR:
5113 case WIDEN_LSHIFT_EXPR:
5114 if (SCALAR_INT_MODE_P (GET_MODE (op0))
5115 && SCALAR_INT_MODE_P (mode))
5118 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
5119 0)))
5120 ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
5121 inner_mode);
5122 return simplify_gen_binary (TREE_CODE (exp) == WIDEN_LSHIFT_EXPR
5123 ? ASHIFT : PLUS, mode, op0, op1);
5125 return NULL;
5127 case FMA_EXPR:
5128 return simplify_gen_ternary (FMA, mode, inner_mode, op0, op1, op2);
5130 default:
5131 flag_unsupported:
5132 if (flag_checking)
5134 debug_tree (exp);
5135 gcc_unreachable ();
5137 return NULL;
5141 /* Return an RTX equivalent to the source bind value of the tree expression
5142 EXP. */
5144 static rtx
5145 expand_debug_source_expr (tree exp)
5147 rtx op0 = NULL_RTX;
5148 machine_mode mode = VOIDmode, inner_mode;
5150 switch (TREE_CODE (exp))
5152 case PARM_DECL:
5154 mode = DECL_MODE (exp);
5155 op0 = expand_debug_parm_decl (exp);
5156 if (op0)
5157 break;
5158 /* See if this isn't an argument that has been completely
5159 optimized out. */
5160 if (!DECL_RTL_SET_P (exp)
5161 && !DECL_INCOMING_RTL (exp)
5162 && DECL_ABSTRACT_ORIGIN (current_function_decl))
5164 tree aexp = DECL_ORIGIN (exp);
5165 if (DECL_CONTEXT (aexp)
5166 == DECL_ABSTRACT_ORIGIN (current_function_decl))
5168 vec<tree, va_gc> **debug_args;
5169 unsigned int ix;
5170 tree ddecl;
5171 debug_args = decl_debug_args_lookup (current_function_decl);
5172 if (debug_args != NULL)
5174 for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl);
5175 ix += 2)
5176 if (ddecl == aexp)
5177 return gen_rtx_DEBUG_PARAMETER_REF (mode, aexp);
5181 break;
5183 default:
5184 break;
5187 if (op0 == NULL_RTX)
5188 return NULL_RTX;
5190 inner_mode = GET_MODE (op0);
5191 if (mode == inner_mode)
5192 return op0;
5194 if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
5196 if (GET_MODE_UNIT_BITSIZE (mode)
5197 == GET_MODE_UNIT_BITSIZE (inner_mode))
5198 op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
5199 else if (GET_MODE_UNIT_BITSIZE (mode)
5200 < GET_MODE_UNIT_BITSIZE (inner_mode))
5201 op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
5202 else
5203 op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
5205 else if (FLOAT_MODE_P (mode))
5206 gcc_unreachable ();
5207 else if (FLOAT_MODE_P (inner_mode))
5209 if (TYPE_UNSIGNED (TREE_TYPE (exp)))
5210 op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
5211 else
5212 op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
5214 else if (CONSTANT_P (op0)
5215 || GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (inner_mode))
5216 op0 = lowpart_subreg (mode, op0, inner_mode);
5217 else if (TYPE_UNSIGNED (TREE_TYPE (exp)))
5218 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
5219 else
5220 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
5222 return op0;
5225 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5226 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5227 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5229 static void
5230 avoid_complex_debug_insns (rtx_insn *insn, rtx *exp_p, int depth)
5232 rtx exp = *exp_p;
5234 if (exp == NULL_RTX)
5235 return;
5237 if ((OBJECT_P (exp) && !MEM_P (exp)) || GET_CODE (exp) == CLOBBER)
5238 return;
5240 if (depth == 4)
5242 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5243 rtx dval = make_debug_expr_from_rtl (exp);
5245 /* Emit a debug bind insn before INSN. */
5246 rtx bind = gen_rtx_VAR_LOCATION (GET_MODE (exp),
5247 DEBUG_EXPR_TREE_DECL (dval), exp,
5248 VAR_INIT_STATUS_INITIALIZED);
5250 emit_debug_insn_before (bind, insn);
5251 *exp_p = dval;
5252 return;
5255 const char *format_ptr = GET_RTX_FORMAT (GET_CODE (exp));
5256 int i, j;
5257 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
5258 switch (*format_ptr++)
5260 case 'e':
5261 avoid_complex_debug_insns (insn, &XEXP (exp, i), depth + 1);
5262 break;
5264 case 'E':
5265 case 'V':
5266 for (j = 0; j < XVECLEN (exp, i); j++)
5267 avoid_complex_debug_insns (insn, &XVECEXP (exp, i, j), depth + 1);
5268 break;
5270 default:
5271 break;
5275 /* Expand the _LOCs in debug insns. We run this after expanding all
5276 regular insns, so that any variables referenced in the function
5277 will have their DECL_RTLs set. */
5279 static void
5280 expand_debug_locations (void)
5282 rtx_insn *insn;
5283 rtx_insn *last = get_last_insn ();
5284 int save_strict_alias = flag_strict_aliasing;
5286 /* New alias sets while setting up memory attributes cause
5287 -fcompare-debug failures, even though it doesn't bring about any
5288 codegen changes. */
5289 flag_strict_aliasing = 0;
5291 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
5292 if (DEBUG_INSN_P (insn))
5294 tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
5295 rtx val;
5296 rtx_insn *prev_insn, *insn2;
5297 machine_mode mode;
5299 if (value == NULL_TREE)
5300 val = NULL_RTX;
5301 else
5303 if (INSN_VAR_LOCATION_STATUS (insn)
5304 == VAR_INIT_STATUS_UNINITIALIZED)
5305 val = expand_debug_source_expr (value);
5306 /* The avoid_deep_ter_for_debug function inserts
5307 debug bind stmts after SSA_NAME definition, with the
5308 SSA_NAME as the whole bind location. Disable temporarily
5309 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5310 being defined in this DEBUG_INSN. */
5311 else if (deep_ter_debug_map && TREE_CODE (value) == SSA_NAME)
5313 tree *slot = deep_ter_debug_map->get (value);
5314 if (slot)
5316 if (*slot == INSN_VAR_LOCATION_DECL (insn))
5317 *slot = NULL_TREE;
5318 else
5319 slot = NULL;
5321 val = expand_debug_expr (value);
5322 if (slot)
5323 *slot = INSN_VAR_LOCATION_DECL (insn);
5325 else
5326 val = expand_debug_expr (value);
5327 gcc_assert (last == get_last_insn ());
5330 if (!val)
5331 val = gen_rtx_UNKNOWN_VAR_LOC ();
5332 else
5334 mode = GET_MODE (INSN_VAR_LOCATION (insn));
5336 gcc_assert (mode == GET_MODE (val)
5337 || (GET_MODE (val) == VOIDmode
5338 && (CONST_SCALAR_INT_P (val)
5339 || GET_CODE (val) == CONST_FIXED
5340 || GET_CODE (val) == LABEL_REF)));
5343 INSN_VAR_LOCATION_LOC (insn) = val;
5344 prev_insn = PREV_INSN (insn);
5345 for (insn2 = insn; insn2 != prev_insn; insn2 = PREV_INSN (insn2))
5346 avoid_complex_debug_insns (insn2, &INSN_VAR_LOCATION_LOC (insn2), 0);
5349 flag_strict_aliasing = save_strict_alias;
5352 /* Performs swapping operands of commutative operations to expand
5353 the expensive one first. */
5355 static void
5356 reorder_operands (basic_block bb)
5358 unsigned int *lattice; /* Hold cost of each statement. */
5359 unsigned int i = 0, n = 0;
5360 gimple_stmt_iterator gsi;
5361 gimple_seq stmts;
5362 gimple *stmt;
5363 bool swap;
5364 tree op0, op1;
5365 ssa_op_iter iter;
5366 use_operand_p use_p;
5367 gimple *def0, *def1;
5369 /* Compute cost of each statement using estimate_num_insns. */
5370 stmts = bb_seq (bb);
5371 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
5373 stmt = gsi_stmt (gsi);
5374 if (!is_gimple_debug (stmt))
5375 gimple_set_uid (stmt, n++);
5377 lattice = XNEWVEC (unsigned int, n);
5378 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
5380 unsigned cost;
5381 stmt = gsi_stmt (gsi);
5382 if (is_gimple_debug (stmt))
5383 continue;
5384 cost = estimate_num_insns (stmt, &eni_size_weights);
5385 lattice[i] = cost;
5386 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
5388 tree use = USE_FROM_PTR (use_p);
5389 gimple *def_stmt;
5390 if (TREE_CODE (use) != SSA_NAME)
5391 continue;
5392 def_stmt = get_gimple_for_ssa_name (use);
5393 if (!def_stmt)
5394 continue;
5395 lattice[i] += lattice[gimple_uid (def_stmt)];
5397 i++;
5398 if (!is_gimple_assign (stmt)
5399 || !commutative_tree_code (gimple_assign_rhs_code (stmt)))
5400 continue;
5401 op0 = gimple_op (stmt, 1);
5402 op1 = gimple_op (stmt, 2);
5403 if (TREE_CODE (op0) != SSA_NAME
5404 || TREE_CODE (op1) != SSA_NAME)
5405 continue;
5406 /* Swap operands if the second one is more expensive. */
5407 def0 = get_gimple_for_ssa_name (op0);
5408 def1 = get_gimple_for_ssa_name (op1);
5409 if (!def1)
5410 continue;
5411 swap = false;
5412 if (!def0 || lattice[gimple_uid (def1)] > lattice[gimple_uid (def0)])
5413 swap = true;
5414 if (swap)
5416 if (dump_file && (dump_flags & TDF_DETAILS))
5418 fprintf (dump_file, "Swap operands in stmt:\n");
5419 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
5420 fprintf (dump_file, "Cost left opnd=%d, right opnd=%d\n",
5421 def0 ? lattice[gimple_uid (def0)] : 0,
5422 lattice[gimple_uid (def1)]);
5424 swap_ssa_operands (stmt, gimple_assign_rhs1_ptr (stmt),
5425 gimple_assign_rhs2_ptr (stmt));
5428 XDELETE (lattice);
5431 /* Expand basic block BB from GIMPLE trees to RTL. */
5433 static basic_block
5434 expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
5436 gimple_stmt_iterator gsi;
5437 gimple_seq stmts;
5438 gimple *stmt = NULL;
5439 rtx_note *note;
5440 rtx_insn *last;
5441 edge e;
5442 edge_iterator ei;
5444 if (dump_file)
5445 fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
5446 bb->index);
5448 /* Note that since we are now transitioning from GIMPLE to RTL, we
5449 cannot use the gsi_*_bb() routines because they expect the basic
5450 block to be in GIMPLE, instead of RTL. Therefore, we need to
5451 access the BB sequence directly. */
5452 if (optimize)
5453 reorder_operands (bb);
5454 stmts = bb_seq (bb);
5455 bb->il.gimple.seq = NULL;
5456 bb->il.gimple.phi_nodes = NULL;
5457 rtl_profile_for_bb (bb);
5458 init_rtl_bb_info (bb);
5459 bb->flags |= BB_RTL;
5461 /* Remove the RETURN_EXPR if we may fall though to the exit
5462 instead. */
5463 gsi = gsi_last (stmts);
5464 if (!gsi_end_p (gsi)
5465 && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
5467 greturn *ret_stmt = as_a <greturn *> (gsi_stmt (gsi));
5469 gcc_assert (single_succ_p (bb));
5470 gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun));
5472 if (bb->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
5473 && !gimple_return_retval (ret_stmt))
5475 gsi_remove (&gsi, false);
5476 single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
5480 gsi = gsi_start (stmts);
5481 if (!gsi_end_p (gsi))
5483 stmt = gsi_stmt (gsi);
5484 if (gimple_code (stmt) != GIMPLE_LABEL)
5485 stmt = NULL;
5488 rtx_code_label **elt = lab_rtx_for_bb->get (bb);
5490 if (stmt || elt)
5492 last = get_last_insn ();
5494 if (stmt)
5496 expand_gimple_stmt (stmt);
5497 gsi_next (&gsi);
5500 if (elt)
5501 emit_label (*elt);
5503 BB_HEAD (bb) = NEXT_INSN (last);
5504 if (NOTE_P (BB_HEAD (bb)))
5505 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
5506 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
5508 maybe_dump_rtl_for_gimple_stmt (stmt, last);
5510 else
5511 BB_HEAD (bb) = note = emit_note (NOTE_INSN_BASIC_BLOCK);
5513 NOTE_BASIC_BLOCK (note) = bb;
5515 for (; !gsi_end_p (gsi); gsi_next (&gsi))
5517 basic_block new_bb;
5519 stmt = gsi_stmt (gsi);
5521 /* If this statement is a non-debug one, and we generate debug
5522 insns, then this one might be the last real use of a TERed
5523 SSA_NAME, but where there are still some debug uses further
5524 down. Expanding the current SSA name in such further debug
5525 uses by their RHS might lead to wrong debug info, as coalescing
5526 might make the operands of such RHS be placed into the same
5527 pseudo as something else. Like so:
5528 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5529 use(a_1);
5530 a_2 = ...
5531 #DEBUG ... => a_1
5532 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5533 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5534 the write to a_2 would actually have clobbered the place which
5535 formerly held a_0.
5537 So, instead of that, we recognize the situation, and generate
5538 debug temporaries at the last real use of TERed SSA names:
5539 a_1 = a_0 + 1;
5540 #DEBUG #D1 => a_1
5541 use(a_1);
5542 a_2 = ...
5543 #DEBUG ... => #D1
5545 if (MAY_HAVE_DEBUG_INSNS
5546 && SA.values
5547 && !is_gimple_debug (stmt))
5549 ssa_op_iter iter;
5550 tree op;
5551 gimple *def;
5553 location_t sloc = curr_insn_location ();
5555 /* Look for SSA names that have their last use here (TERed
5556 names always have only one real use). */
5557 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
5558 if ((def = get_gimple_for_ssa_name (op)))
5560 imm_use_iterator imm_iter;
5561 use_operand_p use_p;
5562 bool have_debug_uses = false;
5564 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
5566 if (gimple_debug_bind_p (USE_STMT (use_p)))
5568 have_debug_uses = true;
5569 break;
5573 if (have_debug_uses)
5575 /* OP is a TERed SSA name, with DEF its defining
5576 statement, and where OP is used in further debug
5577 instructions. Generate a debug temporary, and
5578 replace all uses of OP in debug insns with that
5579 temporary. */
5580 gimple *debugstmt;
5581 tree value = gimple_assign_rhs_to_tree (def);
5582 tree vexpr = make_node (DEBUG_EXPR_DECL);
5583 rtx val;
5584 machine_mode mode;
5586 set_curr_insn_location (gimple_location (def));
5588 DECL_ARTIFICIAL (vexpr) = 1;
5589 TREE_TYPE (vexpr) = TREE_TYPE (value);
5590 if (DECL_P (value))
5591 mode = DECL_MODE (value);
5592 else
5593 mode = TYPE_MODE (TREE_TYPE (value));
5594 SET_DECL_MODE (vexpr, mode);
5596 val = gen_rtx_VAR_LOCATION
5597 (mode, vexpr, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
5599 emit_debug_insn (val);
5601 FOR_EACH_IMM_USE_STMT (debugstmt, imm_iter, op)
5603 if (!gimple_debug_bind_p (debugstmt))
5604 continue;
5606 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
5607 SET_USE (use_p, vexpr);
5609 update_stmt (debugstmt);
5613 set_curr_insn_location (sloc);
5616 currently_expanding_gimple_stmt = stmt;
5618 /* Expand this statement, then evaluate the resulting RTL and
5619 fixup the CFG accordingly. */
5620 if (gimple_code (stmt) == GIMPLE_COND)
5622 new_bb = expand_gimple_cond (bb, as_a <gcond *> (stmt));
5623 if (new_bb)
5624 return new_bb;
5626 else if (gimple_debug_bind_p (stmt))
5628 location_t sloc = curr_insn_location ();
5629 gimple_stmt_iterator nsi = gsi;
5631 for (;;)
5633 tree var = gimple_debug_bind_get_var (stmt);
5634 tree value;
5635 rtx val;
5636 machine_mode mode;
5638 if (TREE_CODE (var) != DEBUG_EXPR_DECL
5639 && TREE_CODE (var) != LABEL_DECL
5640 && !target_for_debug_bind (var))
5641 goto delink_debug_stmt;
5643 if (gimple_debug_bind_has_value_p (stmt))
5644 value = gimple_debug_bind_get_value (stmt);
5645 else
5646 value = NULL_TREE;
5648 last = get_last_insn ();
5650 set_curr_insn_location (gimple_location (stmt));
5652 if (DECL_P (var))
5653 mode = DECL_MODE (var);
5654 else
5655 mode = TYPE_MODE (TREE_TYPE (var));
5657 val = gen_rtx_VAR_LOCATION
5658 (mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
5660 emit_debug_insn (val);
5662 if (dump_file && (dump_flags & TDF_DETAILS))
5664 /* We can't dump the insn with a TREE where an RTX
5665 is expected. */
5666 PAT_VAR_LOCATION_LOC (val) = const0_rtx;
5667 maybe_dump_rtl_for_gimple_stmt (stmt, last);
5668 PAT_VAR_LOCATION_LOC (val) = (rtx)value;
5671 delink_debug_stmt:
5672 /* In order not to generate too many debug temporaries,
5673 we delink all uses of debug statements we already expanded.
5674 Therefore debug statements between definition and real
5675 use of TERed SSA names will continue to use the SSA name,
5676 and not be replaced with debug temps. */
5677 delink_stmt_imm_use (stmt);
5679 gsi = nsi;
5680 gsi_next (&nsi);
5681 if (gsi_end_p (nsi))
5682 break;
5683 stmt = gsi_stmt (nsi);
5684 if (!gimple_debug_bind_p (stmt))
5685 break;
5688 set_curr_insn_location (sloc);
5690 else if (gimple_debug_source_bind_p (stmt))
5692 location_t sloc = curr_insn_location ();
5693 tree var = gimple_debug_source_bind_get_var (stmt);
5694 tree value = gimple_debug_source_bind_get_value (stmt);
5695 rtx val;
5696 machine_mode mode;
5698 last = get_last_insn ();
5700 set_curr_insn_location (gimple_location (stmt));
5702 mode = DECL_MODE (var);
5704 val = gen_rtx_VAR_LOCATION (mode, var, (rtx)value,
5705 VAR_INIT_STATUS_UNINITIALIZED);
5707 emit_debug_insn (val);
5709 if (dump_file && (dump_flags & TDF_DETAILS))
5711 /* We can't dump the insn with a TREE where an RTX
5712 is expected. */
5713 PAT_VAR_LOCATION_LOC (val) = const0_rtx;
5714 maybe_dump_rtl_for_gimple_stmt (stmt, last);
5715 PAT_VAR_LOCATION_LOC (val) = (rtx)value;
5718 set_curr_insn_location (sloc);
5720 else
5722 gcall *call_stmt = dyn_cast <gcall *> (stmt);
5723 if (call_stmt
5724 && gimple_call_tail_p (call_stmt)
5725 && disable_tail_calls)
5726 gimple_call_set_tail (call_stmt, false);
5728 if (call_stmt && gimple_call_tail_p (call_stmt))
5730 bool can_fallthru;
5731 new_bb = expand_gimple_tailcall (bb, call_stmt, &can_fallthru);
5732 if (new_bb)
5734 if (can_fallthru)
5735 bb = new_bb;
5736 else
5737 return new_bb;
5740 else
5742 def_operand_p def_p;
5743 def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
5745 if (def_p != NULL)
5747 /* Ignore this stmt if it is in the list of
5748 replaceable expressions. */
5749 if (SA.values
5750 && bitmap_bit_p (SA.values,
5751 SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
5752 continue;
5754 last = expand_gimple_stmt (stmt);
5755 maybe_dump_rtl_for_gimple_stmt (stmt, last);
5760 currently_expanding_gimple_stmt = NULL;
5762 /* Expand implicit goto and convert goto_locus. */
5763 FOR_EACH_EDGE (e, ei, bb->succs)
5765 if (e->goto_locus != UNKNOWN_LOCATION)
5766 set_curr_insn_location (e->goto_locus);
5767 if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb)
5769 emit_jump (label_rtx_for_bb (e->dest));
5770 e->flags &= ~EDGE_FALLTHRU;
5774 /* Expanded RTL can create a jump in the last instruction of block.
5775 This later might be assumed to be a jump to successor and break edge insertion.
5776 We need to insert dummy move to prevent this. PR41440. */
5777 if (single_succ_p (bb)
5778 && (single_succ_edge (bb)->flags & EDGE_FALLTHRU)
5779 && (last = get_last_insn ())
5780 && (JUMP_P (last)
5781 || (DEBUG_INSN_P (last)
5782 && JUMP_P (prev_nondebug_insn (last)))))
5784 rtx dummy = gen_reg_rtx (SImode);
5785 emit_insn_after_noloc (gen_move_insn (dummy, dummy), last, NULL);
5788 do_pending_stack_adjust ();
5790 /* Find the block tail. The last insn in the block is the insn
5791 before a barrier and/or table jump insn. */
5792 last = get_last_insn ();
5793 if (BARRIER_P (last))
5794 last = PREV_INSN (last);
5795 if (JUMP_TABLE_DATA_P (last))
5796 last = PREV_INSN (PREV_INSN (last));
5797 BB_END (bb) = last;
5799 update_bb_for_insn (bb);
5801 return bb;
5805 /* Create a basic block for initialization code. */
5807 static basic_block
5808 construct_init_block (void)
5810 basic_block init_block, first_block;
5811 edge e = NULL;
5812 int flags;
5814 /* Multiple entry points not supported yet. */
5815 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs) == 1);
5816 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun));
5817 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun));
5818 ENTRY_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL;
5819 EXIT_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL;
5821 e = EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun), 0);
5823 /* When entry edge points to first basic block, we don't need jump,
5824 otherwise we have to jump into proper target. */
5825 if (e && e->dest != ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb)
5827 tree label = gimple_block_label (e->dest);
5829 emit_jump (jump_target_rtx (label));
5830 flags = 0;
5832 else
5833 flags = EDGE_FALLTHRU;
5835 init_block = create_basic_block (NEXT_INSN (get_insns ()),
5836 get_last_insn (),
5837 ENTRY_BLOCK_PTR_FOR_FN (cfun));
5838 init_block->frequency = ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency;
5839 init_block->count = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
5840 add_bb_to_loop (init_block, ENTRY_BLOCK_PTR_FOR_FN (cfun)->loop_father);
5841 if (e)
5843 first_block = e->dest;
5844 redirect_edge_succ (e, init_block);
5845 e = make_single_succ_edge (init_block, first_block, flags);
5847 else
5848 e = make_single_succ_edge (init_block, EXIT_BLOCK_PTR_FOR_FN (cfun),
5849 EDGE_FALLTHRU);
5851 update_bb_for_insn (init_block);
5852 return init_block;
5855 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5856 found in the block tree. */
5858 static void
5859 set_block_levels (tree block, int level)
5861 while (block)
5863 BLOCK_NUMBER (block) = level;
5864 set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
5865 block = BLOCK_CHAIN (block);
5869 /* Create a block containing landing pads and similar stuff. */
5871 static void
5872 construct_exit_block (void)
5874 rtx_insn *head = get_last_insn ();
5875 rtx_insn *end;
5876 basic_block exit_block;
5877 edge e, e2;
5878 unsigned ix;
5879 edge_iterator ei;
5880 basic_block prev_bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
5881 rtx_insn *orig_end = BB_END (prev_bb);
5883 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun));
5885 /* Make sure the locus is set to the end of the function, so that
5886 epilogue line numbers and warnings are set properly. */
5887 if (LOCATION_LOCUS (cfun->function_end_locus) != UNKNOWN_LOCATION)
5888 input_location = cfun->function_end_locus;
5890 /* Generate rtl for function exit. */
5891 expand_function_end ();
5893 end = get_last_insn ();
5894 if (head == end)
5895 return;
5896 /* While emitting the function end we could move end of the last basic
5897 block. */
5898 BB_END (prev_bb) = orig_end;
5899 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
5900 head = NEXT_INSN (head);
5901 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5902 bb frequency counting will be confused. Any instructions before that
5903 label are emitted for the case where PREV_BB falls through into the
5904 exit block, so append those instructions to prev_bb in that case. */
5905 if (NEXT_INSN (head) != return_label)
5907 while (NEXT_INSN (head) != return_label)
5909 if (!NOTE_P (NEXT_INSN (head)))
5910 BB_END (prev_bb) = NEXT_INSN (head);
5911 head = NEXT_INSN (head);
5914 exit_block = create_basic_block (NEXT_INSN (head), end, prev_bb);
5915 exit_block->frequency = EXIT_BLOCK_PTR_FOR_FN (cfun)->frequency;
5916 exit_block->count = EXIT_BLOCK_PTR_FOR_FN (cfun)->count;
5917 add_bb_to_loop (exit_block, EXIT_BLOCK_PTR_FOR_FN (cfun)->loop_father);
5919 ix = 0;
5920 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds))
5922 e = EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun), ix);
5923 if (!(e->flags & EDGE_ABNORMAL))
5924 redirect_edge_succ (e, exit_block);
5925 else
5926 ix++;
5929 e = make_single_succ_edge (exit_block, EXIT_BLOCK_PTR_FOR_FN (cfun),
5930 EDGE_FALLTHRU);
5931 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
5932 if (e2 != e)
5934 e->count -= e2->count;
5935 exit_block->count -= e2->count;
5936 exit_block->frequency -= EDGE_FREQUENCY (e2);
5938 if (exit_block->frequency < 0)
5939 exit_block->frequency = 0;
5940 update_bb_for_insn (exit_block);
5943 /* Helper function for discover_nonconstant_array_refs.
5944 Look for ARRAY_REF nodes with non-constant indexes and mark them
5945 addressable. */
5947 static tree
5948 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
5949 void *data ATTRIBUTE_UNUSED)
5951 tree t = *tp;
5953 if (IS_TYPE_OR_DECL_P (t))
5954 *walk_subtrees = 0;
5955 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
5957 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
5958 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
5959 && (!TREE_OPERAND (t, 2)
5960 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
5961 || (TREE_CODE (t) == COMPONENT_REF
5962 && (!TREE_OPERAND (t,2)
5963 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
5964 || TREE_CODE (t) == BIT_FIELD_REF
5965 || TREE_CODE (t) == REALPART_EXPR
5966 || TREE_CODE (t) == IMAGPART_EXPR
5967 || TREE_CODE (t) == VIEW_CONVERT_EXPR
5968 || CONVERT_EXPR_P (t))
5969 t = TREE_OPERAND (t, 0);
5971 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
5973 t = get_base_address (t);
5974 if (t && DECL_P (t)
5975 && DECL_MODE (t) != BLKmode)
5976 TREE_ADDRESSABLE (t) = 1;
5979 *walk_subtrees = 0;
5982 return NULL_TREE;
5985 /* RTL expansion is not able to compile array references with variable
5986 offsets for arrays stored in single register. Discover such
5987 expressions and mark variables as addressable to avoid this
5988 scenario. */
5990 static void
5991 discover_nonconstant_array_refs (void)
5993 basic_block bb;
5994 gimple_stmt_iterator gsi;
5996 FOR_EACH_BB_FN (bb, cfun)
5997 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5999 gimple *stmt = gsi_stmt (gsi);
6000 if (!is_gimple_debug (stmt))
6001 walk_gimple_op (stmt, discover_nonconstant_array_refs_r, NULL);
6005 /* This function sets crtl->args.internal_arg_pointer to a virtual
6006 register if DRAP is needed. Local register allocator will replace
6007 virtual_incoming_args_rtx with the virtual register. */
6009 static void
6010 expand_stack_alignment (void)
6012 rtx drap_rtx;
6013 unsigned int preferred_stack_boundary;
6015 if (! SUPPORTS_STACK_ALIGNMENT)
6016 return;
6018 if (cfun->calls_alloca
6019 || cfun->has_nonlocal_label
6020 || crtl->has_nonlocal_goto)
6021 crtl->need_drap = true;
6023 /* Call update_stack_boundary here again to update incoming stack
6024 boundary. It may set incoming stack alignment to a different
6025 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6026 use the minimum incoming stack alignment to check if it is OK
6027 to perform sibcall optimization since sibcall optimization will
6028 only align the outgoing stack to incoming stack boundary. */
6029 if (targetm.calls.update_stack_boundary)
6030 targetm.calls.update_stack_boundary ();
6032 /* The incoming stack frame has to be aligned at least at
6033 parm_stack_boundary. */
6034 gcc_assert (crtl->parm_stack_boundary <= INCOMING_STACK_BOUNDARY);
6036 /* Update crtl->stack_alignment_estimated and use it later to align
6037 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6038 exceptions since callgraph doesn't collect incoming stack alignment
6039 in this case. */
6040 if (cfun->can_throw_non_call_exceptions
6041 && PREFERRED_STACK_BOUNDARY > crtl->preferred_stack_boundary)
6042 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
6043 else
6044 preferred_stack_boundary = crtl->preferred_stack_boundary;
6045 if (preferred_stack_boundary > crtl->stack_alignment_estimated)
6046 crtl->stack_alignment_estimated = preferred_stack_boundary;
6047 if (preferred_stack_boundary > crtl->stack_alignment_needed)
6048 crtl->stack_alignment_needed = preferred_stack_boundary;
6050 gcc_assert (crtl->stack_alignment_needed
6051 <= crtl->stack_alignment_estimated);
6053 crtl->stack_realign_needed
6054 = INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated;
6055 crtl->stack_realign_tried = crtl->stack_realign_needed;
6057 crtl->stack_realign_processed = true;
6059 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6060 alignment. */
6061 gcc_assert (targetm.calls.get_drap_rtx != NULL);
6062 drap_rtx = targetm.calls.get_drap_rtx ();
6064 /* stack_realign_drap and drap_rtx must match. */
6065 gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
6067 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6068 if (NULL != drap_rtx)
6070 crtl->args.internal_arg_pointer = drap_rtx;
6072 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6073 needed. */
6074 fixup_tail_calls ();
6079 static void
6080 expand_main_function (void)
6082 #if (defined(INVOKE__main) \
6083 || (!defined(HAS_INIT_SECTION) \
6084 && !defined(INIT_SECTION_ASM_OP) \
6085 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6086 emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode);
6087 #endif
6091 /* Expand code to initialize the stack_protect_guard. This is invoked at
6092 the beginning of a function to be protected. */
6094 static void
6095 stack_protect_prologue (void)
6097 tree guard_decl = targetm.stack_protect_guard ();
6098 rtx x, y;
6100 x = expand_normal (crtl->stack_protect_guard);
6101 if (guard_decl)
6102 y = expand_normal (guard_decl);
6103 else
6104 y = const0_rtx;
6106 /* Allow the target to copy from Y to X without leaking Y into a
6107 register. */
6108 if (targetm.have_stack_protect_set ())
6109 if (rtx_insn *insn = targetm.gen_stack_protect_set (x, y))
6111 emit_insn (insn);
6112 return;
6115 /* Otherwise do a straight move. */
6116 emit_move_insn (x, y);
6119 /* Translate the intermediate representation contained in the CFG
6120 from GIMPLE trees to RTL.
6122 We do conversion per basic block and preserve/update the tree CFG.
6123 This implies we have to do some magic as the CFG can simultaneously
6124 consist of basic blocks containing RTL and GIMPLE trees. This can
6125 confuse the CFG hooks, so be careful to not manipulate CFG during
6126 the expansion. */
6128 namespace {
6130 const pass_data pass_data_expand =
6132 RTL_PASS, /* type */
6133 "expand", /* name */
6134 OPTGROUP_NONE, /* optinfo_flags */
6135 TV_EXPAND, /* tv_id */
6136 ( PROP_ssa | PROP_gimple_leh | PROP_cfg
6137 | PROP_gimple_lcx
6138 | PROP_gimple_lvec
6139 | PROP_gimple_lva), /* properties_required */
6140 PROP_rtl, /* properties_provided */
6141 ( PROP_ssa | PROP_trees ), /* properties_destroyed */
6142 0, /* todo_flags_start */
6143 0, /* todo_flags_finish */
6146 class pass_expand : public rtl_opt_pass
6148 public:
6149 pass_expand (gcc::context *ctxt)
6150 : rtl_opt_pass (pass_data_expand, ctxt)
6153 /* opt_pass methods: */
6154 virtual unsigned int execute (function *);
6156 }; // class pass_expand
6158 unsigned int
6159 pass_expand::execute (function *fun)
6161 basic_block bb, init_block;
6162 edge_iterator ei;
6163 edge e;
6164 rtx_insn *var_seq, *var_ret_seq;
6165 unsigned i;
6167 timevar_push (TV_OUT_OF_SSA);
6168 rewrite_out_of_ssa (&SA);
6169 timevar_pop (TV_OUT_OF_SSA);
6170 SA.partition_to_pseudo = XCNEWVEC (rtx, SA.map->num_partitions);
6172 if (MAY_HAVE_DEBUG_STMTS && flag_tree_ter)
6174 gimple_stmt_iterator gsi;
6175 FOR_EACH_BB_FN (bb, cfun)
6176 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
6177 if (gimple_debug_bind_p (gsi_stmt (gsi)))
6178 avoid_deep_ter_for_debug (gsi_stmt (gsi), 0);
6181 /* Make sure all values used by the optimization passes have sane
6182 defaults. */
6183 reg_renumber = 0;
6185 /* Some backends want to know that we are expanding to RTL. */
6186 currently_expanding_to_rtl = 1;
6187 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6188 free_dominance_info (CDI_DOMINATORS);
6190 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
6192 if (chkp_function_instrumented_p (current_function_decl))
6193 chkp_reset_rtl_bounds ();
6195 insn_locations_init ();
6196 if (!DECL_IS_BUILTIN (current_function_decl))
6198 /* Eventually, all FEs should explicitly set function_start_locus. */
6199 if (LOCATION_LOCUS (fun->function_start_locus) == UNKNOWN_LOCATION)
6200 set_curr_insn_location
6201 (DECL_SOURCE_LOCATION (current_function_decl));
6202 else
6203 set_curr_insn_location (fun->function_start_locus);
6205 else
6206 set_curr_insn_location (UNKNOWN_LOCATION);
6207 prologue_location = curr_insn_location ();
6209 #ifdef INSN_SCHEDULING
6210 init_sched_attrs ();
6211 #endif
6213 /* Make sure first insn is a note even if we don't want linenums.
6214 This makes sure the first insn will never be deleted.
6215 Also, final expects a note to appear there. */
6216 emit_note (NOTE_INSN_DELETED);
6218 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6219 discover_nonconstant_array_refs ();
6221 targetm.expand_to_rtl_hook ();
6222 crtl->init_stack_alignment ();
6223 fun->cfg->max_jumptable_ents = 0;
6225 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6226 of the function section at exapnsion time to predict distance of calls. */
6227 resolve_unique_section (current_function_decl, 0, flag_function_sections);
6229 /* Expand the variables recorded during gimple lowering. */
6230 timevar_push (TV_VAR_EXPAND);
6231 start_sequence ();
6233 var_ret_seq = expand_used_vars ();
6235 var_seq = get_insns ();
6236 end_sequence ();
6237 timevar_pop (TV_VAR_EXPAND);
6239 /* Honor stack protection warnings. */
6240 if (warn_stack_protect)
6242 if (fun->calls_alloca)
6243 warning (OPT_Wstack_protector,
6244 "stack protector not protecting local variables: "
6245 "variable length buffer");
6246 if (has_short_buffer && !crtl->stack_protect_guard)
6247 warning (OPT_Wstack_protector,
6248 "stack protector not protecting function: "
6249 "all local arrays are less than %d bytes long",
6250 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
6253 /* Set up parameters and prepare for return, for the function. */
6254 expand_function_start (current_function_decl);
6256 /* If we emitted any instructions for setting up the variables,
6257 emit them before the FUNCTION_START note. */
6258 if (var_seq)
6260 emit_insn_before (var_seq, parm_birth_insn);
6262 /* In expand_function_end we'll insert the alloca save/restore
6263 before parm_birth_insn. We've just insertted an alloca call.
6264 Adjust the pointer to match. */
6265 parm_birth_insn = var_seq;
6268 /* Now propagate the RTL assignment of each partition to the
6269 underlying var of each SSA_NAME. */
6270 tree name;
6272 FOR_EACH_SSA_NAME (i, name, cfun)
6274 /* We might have generated new SSA names in
6275 update_alias_info_with_stack_vars. They will have a NULL
6276 defining statements, and won't be part of the partitioning,
6277 so ignore those. */
6278 if (!SSA_NAME_DEF_STMT (name))
6279 continue;
6281 adjust_one_expanded_partition_var (name);
6284 /* Clean up RTL of variables that straddle across multiple
6285 partitions, and check that the rtl of any PARM_DECLs that are not
6286 cleaned up is that of their default defs. */
6287 FOR_EACH_SSA_NAME (i, name, cfun)
6289 int part;
6291 /* We might have generated new SSA names in
6292 update_alias_info_with_stack_vars. They will have a NULL
6293 defining statements, and won't be part of the partitioning,
6294 so ignore those. */
6295 if (!SSA_NAME_DEF_STMT (name))
6296 continue;
6297 part = var_to_partition (SA.map, name);
6298 if (part == NO_PARTITION)
6299 continue;
6301 /* If this decl was marked as living in multiple places, reset
6302 this now to NULL. */
6303 tree var = SSA_NAME_VAR (name);
6304 if (var && DECL_RTL_IF_SET (var) == pc_rtx)
6305 SET_DECL_RTL (var, NULL);
6306 /* Check that the pseudos chosen by assign_parms are those of
6307 the corresponding default defs. */
6308 else if (SSA_NAME_IS_DEFAULT_DEF (name)
6309 && (TREE_CODE (var) == PARM_DECL
6310 || TREE_CODE (var) == RESULT_DECL))
6312 rtx in = DECL_RTL_IF_SET (var);
6313 gcc_assert (in);
6314 rtx out = SA.partition_to_pseudo[part];
6315 gcc_assert (in == out);
6317 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6318 those expected by debug backends for each parm and for
6319 the result. This is particularly important for stabs,
6320 whose register elimination from parm's DECL_RTL may cause
6321 -fcompare-debug differences as SET_DECL_RTL changes reg's
6322 attrs. So, make sure the RTL already has the parm as the
6323 EXPR, so that it won't change. */
6324 SET_DECL_RTL (var, NULL_RTX);
6325 if (MEM_P (in))
6326 set_mem_attributes (in, var, true);
6327 SET_DECL_RTL (var, in);
6331 /* If this function is `main', emit a call to `__main'
6332 to run global initializers, etc. */
6333 if (DECL_NAME (current_function_decl)
6334 && MAIN_NAME_P (DECL_NAME (current_function_decl))
6335 && DECL_FILE_SCOPE_P (current_function_decl))
6336 expand_main_function ();
6338 /* Initialize the stack_protect_guard field. This must happen after the
6339 call to __main (if any) so that the external decl is initialized. */
6340 if (crtl->stack_protect_guard && targetm.stack_protect_runtime_enabled_p ())
6341 stack_protect_prologue ();
6343 expand_phi_nodes (&SA);
6345 /* Release any stale SSA redirection data. */
6346 redirect_edge_var_map_empty ();
6348 /* Register rtl specific functions for cfg. */
6349 rtl_register_cfg_hooks ();
6351 init_block = construct_init_block ();
6353 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6354 remaining edges later. */
6355 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs)
6356 e->flags &= ~EDGE_EXECUTABLE;
6358 lab_rtx_for_bb = new hash_map<basic_block, rtx_code_label *>;
6359 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR_FOR_FN (fun),
6360 next_bb)
6361 bb = expand_gimple_basic_block (bb, var_ret_seq != NULL_RTX);
6363 if (MAY_HAVE_DEBUG_INSNS)
6364 expand_debug_locations ();
6366 if (deep_ter_debug_map)
6368 delete deep_ter_debug_map;
6369 deep_ter_debug_map = NULL;
6372 /* Free stuff we no longer need after GIMPLE optimizations. */
6373 free_dominance_info (CDI_DOMINATORS);
6374 free_dominance_info (CDI_POST_DOMINATORS);
6375 delete_tree_cfg_annotations (fun);
6377 timevar_push (TV_OUT_OF_SSA);
6378 finish_out_of_ssa (&SA);
6379 timevar_pop (TV_OUT_OF_SSA);
6381 timevar_push (TV_POST_EXPAND);
6382 /* We are no longer in SSA form. */
6383 fun->gimple_df->in_ssa_p = false;
6384 loops_state_clear (LOOP_CLOSED_SSA);
6386 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6387 conservatively to true until they are all profile aware. */
6388 delete lab_rtx_for_bb;
6389 free_histograms (fun);
6391 construct_exit_block ();
6392 insn_locations_finalize ();
6394 if (var_ret_seq)
6396 rtx_insn *after = return_label;
6397 rtx_insn *next = NEXT_INSN (after);
6398 if (next && NOTE_INSN_BASIC_BLOCK_P (next))
6399 after = next;
6400 emit_insn_after (var_ret_seq, after);
6403 /* Zap the tree EH table. */
6404 set_eh_throw_stmt_table (fun, NULL);
6406 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6407 split edges which edge insertions might do. */
6408 rebuild_jump_labels (get_insns ());
6410 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun),
6411 EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)
6413 edge e;
6414 edge_iterator ei;
6415 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
6417 if (e->insns.r)
6419 rebuild_jump_labels_chain (e->insns.r);
6420 /* Put insns after parm birth, but before
6421 NOTE_INSNS_FUNCTION_BEG. */
6422 if (e->src == ENTRY_BLOCK_PTR_FOR_FN (fun)
6423 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun)))
6425 rtx_insn *insns = e->insns.r;
6426 e->insns.r = NULL;
6427 if (NOTE_P (parm_birth_insn)
6428 && NOTE_KIND (parm_birth_insn) == NOTE_INSN_FUNCTION_BEG)
6429 emit_insn_before_noloc (insns, parm_birth_insn, e->dest);
6430 else
6431 emit_insn_after_noloc (insns, parm_birth_insn, e->dest);
6433 else
6434 commit_one_edge_insertion (e);
6436 else
6437 ei_next (&ei);
6441 /* We're done expanding trees to RTL. */
6442 currently_expanding_to_rtl = 0;
6444 flush_mark_addressable_queue ();
6446 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun)->next_bb,
6447 EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)
6449 edge e;
6450 edge_iterator ei;
6451 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
6453 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6454 e->flags &= ~EDGE_EXECUTABLE;
6456 /* At the moment not all abnormal edges match the RTL
6457 representation. It is safe to remove them here as
6458 find_many_sub_basic_blocks will rediscover them.
6459 In the future we should get this fixed properly. */
6460 if ((e->flags & EDGE_ABNORMAL)
6461 && !(e->flags & EDGE_SIBCALL))
6462 remove_edge (e);
6463 else
6464 ei_next (&ei);
6468 auto_sbitmap blocks (last_basic_block_for_fn (fun));
6469 bitmap_ones (blocks);
6470 find_many_sub_basic_blocks (blocks);
6471 purge_all_dead_edges ();
6473 expand_stack_alignment ();
6475 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6476 function. */
6477 if (crtl->tail_call_emit)
6478 fixup_tail_calls ();
6480 /* After initial rtl generation, call back to finish generating
6481 exception support code. We need to do this before cleaning up
6482 the CFG as the code does not expect dead landing pads. */
6483 if (fun->eh->region_tree != NULL)
6484 finish_eh_generation ();
6486 /* BB subdivision may have created basic blocks that are are only reachable
6487 from unlikely bbs but not marked as such in the profile. */
6488 if (optimize)
6489 propagate_unlikely_bbs_forward ();
6491 /* Remove unreachable blocks, otherwise we cannot compute dominators
6492 which are needed for loop state verification. As a side-effect
6493 this also compacts blocks.
6494 ??? We cannot remove trivially dead insns here as for example
6495 the DRAP reg on i?86 is not magically live at this point.
6496 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6497 cleanup_cfg (CLEANUP_NO_INSN_DEL);
6499 checking_verify_flow_info ();
6501 /* Initialize pseudos allocated for hard registers. */
6502 emit_initial_value_sets ();
6504 /* And finally unshare all RTL. */
6505 unshare_all_rtl ();
6507 /* There's no need to defer outputting this function any more; we
6508 know we want to output it. */
6509 DECL_DEFER_OUTPUT (current_function_decl) = 0;
6511 /* Now that we're done expanding trees to RTL, we shouldn't have any
6512 more CONCATs anywhere. */
6513 generating_concat_p = 0;
6515 if (dump_file)
6517 fprintf (dump_file,
6518 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6519 /* And the pass manager will dump RTL for us. */
6522 /* If we're emitting a nested function, make sure its parent gets
6523 emitted as well. Doing otherwise confuses debug info. */
6525 tree parent;
6526 for (parent = DECL_CONTEXT (current_function_decl);
6527 parent != NULL_TREE;
6528 parent = get_containing_scope (parent))
6529 if (TREE_CODE (parent) == FUNCTION_DECL)
6530 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
6533 TREE_ASM_WRITTEN (current_function_decl) = 1;
6535 /* After expanding, the return labels are no longer needed. */
6536 return_label = NULL;
6537 naked_return_label = NULL;
6539 /* After expanding, the tm_restart map is no longer needed. */
6540 if (fun->gimple_df->tm_restart)
6541 fun->gimple_df->tm_restart = NULL;
6543 /* Tag the blocks with a depth number so that change_scope can find
6544 the common parent easily. */
6545 set_block_levels (DECL_INITIAL (fun->decl), 0);
6546 default_rtl_profile ();
6548 /* For -dx discard loops now, otherwise IL verify in clean_state will
6549 ICE. */
6550 if (rtl_dump_and_exit)
6552 cfun->curr_properties &= ~PROP_loops;
6553 loop_optimizer_finalize ();
6556 timevar_pop (TV_POST_EXPAND);
6558 return 0;
6561 } // anon namespace
6563 rtl_opt_pass *
6564 make_pass_expand (gcc::context *ctxt)
6566 return new pass_expand (ctxt);