1/* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
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"
79
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
87
88/* This variable holds information helping the rewriting of SSA trees
89 into RTL. */
90struct ssaexpand SA;
91
92/* This variable holds the currently expanded gimple statement for purposes
93 of comminucating the profile info to the builtin expanders. */
94gimple *currently_expanding_gimple_stmt;
95
96static rtx expand_debug_expr (tree);
97
98static bool defer_stack_allocation (tree, bool);
99
100static void record_alignment_for_reg_var (unsigned int);
101
102/* Return an expression tree corresponding to the RHS of GIMPLE
103 statement STMT. */
104
105tree
106gimple_assign_rhs_to_tree (gimple *stmt)
107{
108 tree t;
109 enum gimple_rhs_class grhs_class;
110
111 grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
112
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)
129 {
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);
138 }
139 else
140 gcc_unreachable ();
141
142 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
143 SET_EXPR_LOCATION (t, gimple_location (stmt));
144
145 return t;
146}
147
148
149#ifndef STACK_ALIGNMENT_NEEDED
150#define STACK_ALIGNMENT_NEEDED 1
151#endif
152
153#define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
154
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). */
159
160static tree
161leader_merge (tree cur, tree next)
162{
163 if (cur == NULL || cur == next)
164 return next;
165
166 if (DECL_P (cur) && DECL_IGNORED_P (cur))
167 return cur;
168
169 if (DECL_P (next) && DECL_IGNORED_P (next))
170 return next;
171
172 return cur;
173}
174
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. */
178static inline void
179set_rtl (tree t, rtx x)
180{
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));
219
220 if (x)
221 {
222 bool skip = false;
223 tree cur = NULL_TREE;
224 rtx xm = x;
225
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))
232 {
233 gcc_assert (subreg_lowpart_p (xm));
234 xm = SUBREG_REG (xm);
235 goto retry;
236 }
237 else if (GET_CODE (xm) == CONCAT)
238 {
239 xm = XEXP (xm, 0);
240 goto retry;
241 }
242 else if (GET_CODE (xm) == PARALLEL)
243 {
244 xm = XVECEXP (xm, 0, 0);
245 gcc_assert (GET_CODE (xm) == EXPR_LIST);
246 xm = XEXP (xm, 0);
247 goto retry;
248 }
249 else if (xm == pc_rtx)
250 skip = true;
251 else
252 gcc_unreachable ();
253
254 tree next = skip ? cur : leader_merge (cur, SSAVAR (t) ? SSAVAR (t) : t);
255
256 if (cur != next)
257 {
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);
265 }
266 }
267
268 if (TREE_CODE (t) == SSA_NAME)
269 {
270 int part = var_to_partition (SA.map, t);
271 if (part != NO_PARTITION)
272 {
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;
277 }
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)))
285 {
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)
293 ;
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);
302 }
303 }
304 else
305 SET_DECL_RTL (t, x);
306}
307
308/* This structure holds data relevant to one variable that will be
309 placed in a stack slot. */
310struct stack_var
311{
312 /* The Variable. */
313 tree decl;
314
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;
318
319 /* The *byte* alignment required for this variable. Or as, with the
320 size, the alignment for this partition. */
321 unsigned int alignb;
322
323 /* The partition representative. */
324 size_t representative;
325
326 /* The next stack variable in the partition, or EOC. */
327 size_t next;
328
329 /* The numbers of conflicting stack variables. */
330 bitmap conflicts;
331};
332
333#define EOC ((size_t)-1)
334
335/* We have an array of such objects while deciding allocation. */
336static struct stack_var *stack_vars;
337static size_t stack_vars_alloc;
338static size_t stack_vars_num;
339static hash_map<tree, size_t> *decl_to_stack_part;
340
341/* Conflict bitmaps go on this obstack. This allows us to destroy
342 all of them in one big sweep. */
343static bitmap_obstack stack_var_bitmap_obstack;
344
345/* An array of indices such that stack_vars[stack_vars_sorted[i]].size
346 is non-decreasing. */
347static size_t *stack_vars_sorted;
348
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. */
352static int frame_phase;
353
354/* Used during expand_used_vars to remember if we saw any decls for
355 which we'd like to enable stack smashing protection. */
356static bool has_protected_decls;
357
358/* Used during expand_used_vars. Remember if we say a character buffer
359 smaller than our cutoff threshold. Used for -Wstack-protector. */
360static bool has_short_buffer;
361
362/* Compute the byte alignment to use for DECL. Ignore alignment
363 we can't do with expected alignment of the stack boundary. */
364
365static unsigned int
366align_local_variable (tree decl)
367{
368 unsigned int align;
369
370 if (TREE_CODE (decl) == SSA_NAME)
371 align = TYPE_ALIGN (TREE_TYPE (decl));
372 else
373 {
374 align = LOCAL_DECL_ALIGNMENT (decl);
375 SET_DECL_ALIGN (decl, align);
376 }
377 return align / BITS_PER_UNIT;
378}
379
380/* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
381 down otherwise. Return truncated BASE value. */
382
383static inline unsigned HOST_WIDE_INT
384align_base (HOST_WIDE_INT base, unsigned HOST_WIDE_INT align, bool align_up)
385{
386 return align_up ? (base + align - 1) & -align : base & -align;
387}
388
389/* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
390 Return the frame offset. */
391
392static HOST_WIDE_INT
393alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
394{
395 HOST_WIDE_INT offset, new_frame_offset;
396
397 if (FRAME_GROWS_DOWNWARD)
398 {
399 new_frame_offset
400 = align_base (frame_offset - frame_phase - size,
401 align, false) + frame_phase;
402 offset = new_frame_offset;
403 }
404 else
405 {
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;
410 }
411 frame_offset = new_frame_offset;
412
413 if (frame_offset_overflow (frame_offset, cfun->decl))
414 frame_offset = offset = 0;
415
416 return offset;
417}
418
419/* Accumulate DECL into STACK_VARS. */
420
421static void
422add_stack_var (tree decl)
423{
424 struct stack_var *v;
425
426 if (stack_vars_num >= stack_vars_alloc)
427 {
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);
434 }
435 if (!decl_to_stack_part)
436 decl_to_stack_part = new hash_map<tree, size_t>;
437
438 v = &stack_vars[stack_vars_num];
439 decl_to_stack_part->put (decl, stack_vars_num);
440
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);
453
454 /* All variables are initially in their own partition. */
455 v->representative = stack_vars_num;
456 v->next = EOC;
457
458 /* All variables initially conflict with no other. */
459 v->conflicts = NULL;
460
461 /* Ensure that this decl doesn't get put onto the list twice. */
462 set_rtl (decl, pc_rtx);
463
464 stack_vars_num++;
465}
466
467/* Make the decls associated with luid's X and Y conflict. */
468
469static void
470add_stack_var_conflict (size_t x, size_t y)
471{
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);
480}
481
482/* Check whether the decls associated with luid's X and Y conflict. */
483
484static bool
485stack_var_conflict_p (size_t x, size_t y)
486{
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;
496
497 if (!a->conflicts || !b->conflicts)
498 return false;
499 return bitmap_bit_p (a->conflicts, y);
500}
501
502/* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
503 enter its partition number into bitmap DATA. */
504
505static bool
506visit_op (gimple *, tree op, tree, void *data)
507{
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)
513 {
514 size_t *v = decl_to_stack_part->get (op);
515 if (v)
516 bitmap_set_bit (active, *v);
517 }
518 return false;
519}
520
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. */
524
525static bool
526visit_conflict (gimple *, tree op, tree, void *data)
527{
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)
533 {
534 size_t *v = decl_to_stack_part->get (op);
535 if (v && bitmap_set_bit (active, *v))
536 {
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);
543 }
544 }
545 return false;
546}
547
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. */
552
553static void
554add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
555{
556 edge e;
557 edge_iterator ei;
558 gimple_stmt_iterator gsi;
559 walk_stmt_load_store_addr_fn visit;
560
561 bitmap_clear (work);
562 FOR_EACH_EDGE (e, ei, bb->preds)
563 bitmap_ior_into (work, (bitmap)e->src->aux);
564
565 visit = visit_op;
566
567 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
568 {
569 gimple *stmt = gsi_stmt (gsi);
570 walk_stmt_load_store_addr_ops (stmt, work, NULL, NULL, visit);
571 }
572 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
573 {
574 gimple *stmt = gsi_stmt (gsi);
575
576 if (gimple_clobber_p (stmt))
577 {
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);
587 }
588 else if (!is_gimple_debug (stmt))
589 {
590 if (for_conflict
591 && visit == visit_op)
592 {
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)
602 {
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);
607 }
608 visit = visit_conflict;
609 }
610 walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
611 }
612 }
613}
614
615/* Generate stack partition conflicts between all partitions that are
616 simultaneously live. */
617
618static void
619add_scope_conflicts (void)
620{
621 basic_block bb;
622 bool changed;
623 bitmap work = BITMAP_ALLOC (NULL);
624 int *rpo;
625 int n_bbs;
626
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.
634
635 We then do a mostly classical bitmap liveness algorithm. */
636
637 FOR_ALL_BB_FN (bb, cfun)
638 bb->aux = BITMAP_ALLOC (&stack_var_bitmap_obstack);
639
640 rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
641 n_bbs = pre_and_rev_post_order_compute (NULL, rpo, false);
642
643 changed = true;
644 while (changed)
645 {
646 int i;
647 changed = false;
648 for (i = 0; i < n_bbs; i++)
649 {
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;
656 }
657 }
658
659 FOR_EACH_BB_FN (bb, cfun)
660 add_scope_conflicts_1 (bb, work, true);
661
662 free (rpo);
663 BITMAP_FREE (work);
664 FOR_ALL_BB_FN (bb, cfun)
665 BITMAP_FREE (bb->aux);
666}
667
668/* A subroutine of partition_stack_vars. A comparison function for qsort,
669 sorting an array of indices by the properties of the object. */
670
671static int
672stack_var_cmp (const void *a, const void *b)
673{
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;
684
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;
690
691 /* Secondary compare on size, decreasing */
692 if (sizea > sizeb)
693 return -1;
694 if (sizea < sizeb)
695 return 1;
696
697 /* Tertiary compare on true alignment, decreasing. */
698 if (aligna < alignb)
699 return -1;
700 if (aligna > alignb)
701 return 1;
702
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)
707 {
708 if (TREE_CODE (declb) == SSA_NAME)
709 uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
710 else
711 return -1;
712 }
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;
722}
723
724struct part_traits : unbounded_int_hashmap_traits <size_t, bitmap> {};
725typedef hash_map<size_t, bitmap, part_traits> part_hashmap;
726
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. */
730
731static void
732add_partitioned_vars_to_ptset (struct pt_solution *pt,
733 part_hashmap *decls_to_partitions,
734 hash_set<bitmap> *visited, bitmap temp)
735{
736 bitmap_iterator bi;
737 unsigned i;
738 bitmap *part;
739
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;
746
747 bitmap_clear (temp);
748
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);
759}
760
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. */
765
766static void
767update_alias_info_with_stack_vars (void)
768{
769 part_hashmap *decls_to_partitions = NULL;
770 size_t i, j;
771 tree var = NULL_TREE;
772
773 for (i = 0; i < stack_vars_num; i++)
774 {
775 bitmap part = NULL;
776 tree name;
777 struct ptr_info_def *pi;
778
779 /* Not interested in partitions with single variable. */
780 if (stack_vars[i].representative != i
781 || stack_vars[i].next == EOC)
782 continue;
783
784 if (!decls_to_partitions)
785 {
786 decls_to_partitions = new part_hashmap;
787 cfun->gimple_df->decls_to_pointers = new hash_map<tree, tree>;
788 }
789
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);
796
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)
801 {
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;
809 }
810
811 /* Make the SSA name point to all partition members. */
812 pi = get_ptr_info (name);
813 pt_solution_set (&pi->pt, part, false);
814 }
815
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)
819 {
820 unsigned i;
821 tree name;
822 hash_set<bitmap> visited;
823 bitmap temp = BITMAP_ALLOC (&stack_var_bitmap_obstack);
824
825 FOR_EACH_SSA_NAME (i, name, cfun)
826 {
827 struct ptr_info_def *pi;
828
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);
833 }
834
835 add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
836 decls_to_partitions, &visited, temp);
837
838 delete decls_to_partitions;
839 BITMAP_FREE (temp);
840 }
841}
842
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. */
846
847static void
848union_stack_vars (size_t a, size_t b)
849{
850 struct stack_var *vb = &stack_vars[b];
851 bitmap_iterator bi;
852 unsigned u;
853
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;
859
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;
863
864 /* Update the interference graph and merge the conflicts. */
865 if (vb->conflicts)
866 {
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);
870 }
871}
872
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:
876
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)
884 }
885 }
886*/
887
888static void
889partition_stack_vars (void)
890{
891 size_t si, sj, n = stack_vars_num;
892
893 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
894 for (si = 0; si < n; ++si)
895 stack_vars_sorted[si] = si;
896
897 if (n == 1)
898 return;
899
900 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp);
901
902 for (si = 0; si < n; ++si)
903 {
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;
907
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;
913
914 for (sj = si + 1; sj < n; ++sj)
915 {
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;
919
920 /* Ignore objects that aren't partition representatives. */
921 if (stack_vars[j].representative != j)
922 continue;
923
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;
929
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;
938
939 /* Ignore conflicting objects. */
940 if (stack_var_conflict_p (i, j))
941 continue;
942
943 /* UNION the objects, placing J at OFFSET. */
944 union_stack_vars (i, j);
945 }
946 }
947
948 update_alias_info_with_stack_vars ();
949}
950
951/* A debugging aid for expand_used_vars. Dump the generated partitions. */
952
953static void
954dump_stack_var_partition (void)
955{
956 size_t si, i, j, n = stack_vars_num;
957
958 for (si = 0; si < n; ++si)
959 {
960 i = stack_vars_sorted[si];
961
962 /* Skip variables that aren't partition representatives, for now. */
963 if (stack_vars[i].representative != i)
964 continue;
965
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);
969
970 for (j = i; j != EOC; j = stack_vars[j].next)
971 {
972 fputc ('\t', dump_file);
973 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
974 }
975 fputc ('\n', dump_file);
976 }
977}
978
979/* Assign rtl to DECL at BASE + OFFSET. */
980
981static void
982expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
983 HOST_WIDE_INT offset)
984{
985 unsigned align;
986 rtx x;
987
988 /* If this fails, we've overflowed the stack frame. Error nicely? */
989 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
990
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);
995
996 if (TREE_CODE (decl) != SSA_NAME)
997 {
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;
1007
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. */
1011
1012 SET_DECL_ALIGN (decl, align);
1013 DECL_USER_ALIGN (decl) = 0;
1014 }
1015
1016 set_rtl (decl, x);
1017}
1018
1019struct stack_vars_data
1020{
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;
1025
1026 /* Vector of partition representative decls in between the paddings. */
1027 auto_vec<tree> asan_decl_vec;
1028
1029 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1030 rtx asan_base;
1031
1032 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1033 unsigned int asan_alignb;
1034};
1035
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. */
1039
1040static void
1041expand_stack_vars (bool (*pred) (size_t), struct stack_vars_data *data)
1042{
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;
1049
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)
1055 {
1056 /* Find the total size of these variables. */
1057 for (si = 0; si < n; ++si)
1058 {
1059 unsigned alignb;
1060
1061 i = stack_vars_sorted[si];
1062 alignb = stack_vars[i].alignb;
1063
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;
1070
1071 /* Stop when we get to the first decl with "small" alignment. */
1072 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1073 break;
1074
1075 /* Skip variables that aren't partition representatives. */
1076 if (stack_vars[i].representative != i)
1077 continue;
1078
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;
1086
1087 large_size += alignb - 1;
1088 large_size &= -(HOST_WIDE_INT)alignb;
1089 large_size += stack_vars[i].size;
1090 }
1091 }
1092
1093 for (si = 0; si < n; ++si)
1094 {
1095 rtx base;
1096 unsigned base_align, alignb;
1097 HOST_WIDE_INT offset;
1098
1099 i = stack_vars_sorted[si];
1100
1101 /* Skip variables that aren't partition representatives, for now. */
1102 if (stack_vars[i].representative != i)
1103 continue;
1104
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;
1112
1113 /* Check the predicate to see whether this variable should be
1114 allocated in this pass. */
1115 if (pred && !pred (i))
1116 continue;
1117
1118 alignb = stack_vars[i].alignb;
1119 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1120 {
1121 base = virtual_stack_vars_rtx;
1122 if ((asan_sanitize_stack_p ())
1123 && pred)
1124 {
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));
1134
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))
1143 {
1144 repr_decl = stack_vars[j].decl;
1145 break;
1146 }
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;
1158
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);
1165 }
1166 else
1167 {
1168 offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
1169 base_align = crtl->max_used_stack_slot_alignment;
1170 }
1171 }
1172 else
1173 {
1174 /* Large alignment is only processed in the last pass. */
1175 if (pred)
1176 continue;
1177
1178 /* If there were any variables requiring "large" alignment, allocate
1179 space. */
1180 if (large_size > 0 && ! large_allocation_done)
1181 {
1182 HOST_WIDE_INT loffset;
1183 rtx large_allocsize;
1184
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;
1192 }
1193 gcc_assert (large_base != NULL);
1194
1195 large_alloc += alignb - 1;
1196 large_alloc &= -(HOST_WIDE_INT)alignb;
1197 offset = large_alloc;
1198 large_alloc += stack_vars[i].size;
1199
1200 base = large_base;
1201 base_align = large_align;
1202 }
1203
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)
1207 {
1208 expand_one_stack_var_at (stack_vars[j].decl,
1209 base, base_align,
1210 offset);
1211 }
1212 }
1213
1214 gcc_assert (large_alloc == large_size);
1215}
1216
1217/* Take into account all sizes of partitions and reset DECL_RTLs. */
1218static HOST_WIDE_INT
1219account_stack_vars (void)
1220{
1221 size_t si, j, i, n = stack_vars_num;
1222 HOST_WIDE_INT size = 0;
1223
1224 for (si = 0; si < n; ++si)
1225 {
1226 i = stack_vars_sorted[si];
1227
1228 /* Skip variables that aren't partition representatives, for now. */
1229 if (stack_vars[i].representative != i)
1230 continue;
1231
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);
1235 }
1236 return size;
1237}
1238
1239/* Record the RTL assignment X for the default def of PARM. */
1240
1241extern void
1242set_parm_rtl (tree parm, rtx x)
1243{
1244 gcc_assert (TREE_CODE (parm) == PARM_DECL
1245 || TREE_CODE (parm) == RESULT_DECL);
1246
1247 if (x && !MEM_P (x))
1248 {
1249 unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (parm),
1250 TYPE_MODE (TREE_TYPE (parm)),
1251 TYPE_ALIGN (TREE_TYPE (parm)));
1252
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;
1261
1262 record_alignment_for_reg_var (align);
1263 }
1264
1265 tree ssa = ssa_default_def (cfun, parm);
1266 if (!ssa)
1267 return set_rtl (parm, x);
1268
1269 int part = var_to_partition (SA.map, ssa);
1270 gcc_assert (part != NO_PARTITION);
1271
1272 bool changed = bitmap_bit_p (SA.partitions_for_parm_default_defs, part);
1273 gcc_assert (changed);
1274
1275 set_rtl (ssa, x);
1276 gcc_assert (DECL_RTL (parm) == x);
1277}
1278
1279/* A subroutine of expand_one_var. Called to immediately assign rtl
1280 to a variable to be allocated in the stack frame. */
1281
1282static void
1283expand_one_stack_var_1 (tree var)
1284{
1285 HOST_WIDE_INT size, offset;
1286 unsigned byte_align;
1287
1288 if (TREE_CODE (var) == SSA_NAME)
1289 {
1290 tree type = TREE_TYPE (var);
1291 size = tree_to_uhwi (TYPE_SIZE_UNIT (type));
1292 byte_align = TYPE_ALIGN_UNIT (type);
1293 }
1294 else
1295 {
1296 size = tree_to_uhwi (DECL_SIZE_UNIT (var));
1297 byte_align = align_local_variable (var);
1298 }
1299
1300 /* We handle highly aligned variables in expand_stack_vars. */
1301 gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
1302
1303 offset = alloc_stack_frame_space (size, byte_align);
1304
1305 expand_one_stack_var_at (var, virtual_stack_vars_rtx,
1306 crtl->max_used_stack_slot_alignment, offset);
1307}
1308
1309/* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1310 already assigned some MEM. */
1311
1312static void
1313expand_one_stack_var (tree var)
1314{
1315 if (TREE_CODE (var) == SSA_NAME)
1316 {
1317 int part = var_to_partition (SA.map, var);
1318 if (part != NO_PARTITION)
1319 {
1320 rtx x = SA.partition_to_pseudo[part];
1321 gcc_assert (x);
1322 gcc_assert (MEM_P (x));
1323 return;
1324 }
1325 }
1326
1327 return expand_one_stack_var_1 (var);
1328}
1329
1330/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1331 that will reside in a hard register. */
1332
1333static void
1334expand_one_hard_reg_var (tree var)
1335{
1336 rest_of_decl_compilation (var, 0, 0);
1337}
1338
1339/* Record the alignment requirements of some variable assigned to a
1340 pseudo. */
1341
1342static void
1343record_alignment_for_reg_var (unsigned int align)
1344{
1345 if (SUPPORTS_STACK_ALIGNMENT
1346 && crtl->stack_alignment_estimated < align)
1347 {
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;
1352 }
1353
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;
1360}
1361
1362/* Create RTL for an SSA partition. */
1363
1364static void
1365expand_one_ssa_partition (tree var)
1366{
1367 int part = var_to_partition (SA.map, var);
1368 gcc_assert (part != NO_PARTITION);
1369
1370 if (SA.partition_to_pseudo[part])
1371 return;
1372
1373 unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1374 TYPE_MODE (TREE_TYPE (var)),
1375 TYPE_ALIGN (TREE_TYPE (var)));
1376
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;
1381
1382 record_alignment_for_reg_var (align);
1383
1384 if (!use_register_for_decl (var))
1385 {
1386 if (defer_stack_allocation (var, true))
1387 add_stack_var (var);
1388 else
1389 expand_one_stack_var_1 (var);
1390 return;
1391 }
1392
1393 machine_mode reg_mode = promote_ssa_mode (var, NULL);
1394 rtx x = gen_reg_rtx (reg_mode);
1395
1396 set_rtl (var, x);
1397
1398 /* For a promoted variable, X will not be used directly but wrapped in a
1399 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1400 will assume that its upper bits can be inferred from its lower bits.
1401 Therefore, if X isn't initialized on every path from the entry, then
1402 we must do it manually in order to fulfill the above assumption. */
1403 if (reg_mode != TYPE_MODE (TREE_TYPE (var))
1404 && bitmap_bit_p (SA.partitions_for_undefined_values, part))
1405 emit_move_insn (x, CONST0_RTX (reg_mode));
1406}
1407
1408/* Record the association between the RTL generated for partition PART
1409 and the underlying variable of the SSA_NAME VAR. */
1410
1411static void
1412adjust_one_expanded_partition_var (tree var)
1413{
1414 if (!var)
1415 return;
1416
1417 tree decl = SSA_NAME_VAR (var);
1418
1419 int part = var_to_partition (SA.map, var);
1420 if (part == NO_PARTITION)
1421 return;
1422
1423 rtx x = SA.partition_to_pseudo[part];
1424
1425 gcc_assert (x);
1426
1427 set_rtl (var, x);
1428
1429 if (!REG_P (x))
1430 return;
1431
1432 /* Note if the object is a user variable. */
1433 if (decl && !DECL_ARTIFICIAL (decl))
1434 mark_user_reg (x);
1435
1436 if (POINTER_TYPE_P (decl ? TREE_TYPE (decl) : TREE_TYPE (var)))
1437 mark_reg_pointer (x, get_pointer_alignment (var));
1438}
1439
1440/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1441 that will reside in a pseudo register. */
1442
1443static void
1444expand_one_register_var (tree var)
1445{
1446 if (TREE_CODE (var) == SSA_NAME)
1447 {
1448 int part = var_to_partition (SA.map, var);
1449 if (part != NO_PARTITION)
1450 {
1451 rtx x = SA.partition_to_pseudo[part];
1452 gcc_assert (x);
1453 gcc_assert (REG_P (x));
1454 return;
1455 }
1456 gcc_unreachable ();
1457 }
1458
1459 tree decl = var;
1460 tree type = TREE_TYPE (decl);
1461 machine_mode reg_mode = promote_decl_mode (decl, NULL);
1462 rtx x = gen_reg_rtx (reg_mode);
1463
1464 set_rtl (var, x);
1465
1466 /* Note if the object is a user variable. */
1467 if (!DECL_ARTIFICIAL (decl))
1468 mark_user_reg (x);
1469
1470 if (POINTER_TYPE_P (type))
1471 mark_reg_pointer (x, get_pointer_alignment (var));
1472}
1473
1474/* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1475 has some associated error, e.g. its type is error-mark. We just need
1476 to pick something that won't crash the rest of the compiler. */
1477
1478static void
1479expand_one_error_var (tree var)
1480{
1481 machine_mode mode = DECL_MODE (var);
1482 rtx x;
1483
1484 if (mode == BLKmode)
1485 x = gen_rtx_MEM (BLKmode, const0_rtx);
1486 else if (mode == VOIDmode)
1487 x = const0_rtx;
1488 else
1489 x = gen_reg_rtx (mode);
1490
1491 SET_DECL_RTL (var, x);
1492}
1493
1494/* A subroutine of expand_one_var. VAR is a variable that will be
1495 allocated to the local stack frame. Return true if we wish to
1496 add VAR to STACK_VARS so that it will be coalesced with other
1497 variables. Return false to allocate VAR immediately.
1498
1499 This function is used to reduce the number of variables considered
1500 for coalescing, which reduces the size of the quadratic problem. */
1501
1502static bool
1503defer_stack_allocation (tree var, bool toplevel)
1504{
1505 tree size_unit = TREE_CODE (var) == SSA_NAME
1506 ? TYPE_SIZE_UNIT (TREE_TYPE (var))
1507 : DECL_SIZE_UNIT (var);
1508
1509 /* Whether the variable is small enough for immediate allocation not to be
1510 a problem with regard to the frame size. */
1511 bool smallish
1512 = ((HOST_WIDE_INT) tree_to_uhwi (size_unit)
1513 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING));
1514
1515 /* If stack protection is enabled, *all* stack variables must be deferred,
1516 so that we can re-order the strings to the top of the frame.
1517 Similarly for Address Sanitizer. */
1518 if (flag_stack_protect || asan_sanitize_stack_p ())
1519 return true;
1520
1521 unsigned int align = TREE_CODE (var) == SSA_NAME
1522 ? TYPE_ALIGN (TREE_TYPE (var))
1523 : DECL_ALIGN (var);
1524
1525 /* We handle "large" alignment via dynamic allocation. We want to handle
1526 this extra complication in only one place, so defer them. */
1527 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1528 return true;
1529
1530 bool ignored = TREE_CODE (var) == SSA_NAME
1531 ? !SSAVAR (var) || DECL_IGNORED_P (SSA_NAME_VAR (var))
1532 : DECL_IGNORED_P (var);
1533
1534 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1535 might be detached from their block and appear at toplevel when we reach
1536 here. We want to coalesce them with variables from other blocks when
1537 the immediate contribution to the frame size would be noticeable. */
1538 if (toplevel && optimize > 0 && ignored && !smallish)
1539 return true;
1540
1541 /* Variables declared in the outermost scope automatically conflict
1542 with every other variable. The only reason to want to defer them
1543 at all is that, after sorting, we can more efficiently pack
1544 small variables in the stack frame. Continue to defer at -O2. */
1545 if (toplevel && optimize < 2)
1546 return false;
1547
1548 /* Without optimization, *most* variables are allocated from the
1549 stack, which makes the quadratic problem large exactly when we
1550 want compilation to proceed as quickly as possible. On the
1551 other hand, we don't want the function's stack frame size to
1552 get completely out of hand. So we avoid adding scalars and
1553 "small" aggregates to the list at all. */
1554 if (optimize == 0 && smallish)
1555 return false;
1556
1557 return true;
1558}
1559
1560/* A subroutine of expand_used_vars. Expand one variable according to
1561 its flavor. Variables to be placed on the stack are not actually
1562 expanded yet, merely recorded.
1563 When REALLY_EXPAND is false, only add stack values to be allocated.
1564 Return stack usage this variable is supposed to take.
1565*/
1566
1567static HOST_WIDE_INT
1568expand_one_var (tree var, bool toplevel, bool really_expand)
1569{
1570 unsigned int align = BITS_PER_UNIT;
1571 tree origvar = var;
1572
1573 var = SSAVAR (var);
1574
1575 if (TREE_TYPE (var) != error_mark_node && VAR_P (var))
1576 {
1577 if (is_global_var (var))
1578 return 0;
1579
1580 /* Because we don't know if VAR will be in register or on stack,
1581 we conservatively assume it will be on stack even if VAR is
1582 eventually put into register after RA pass. For non-automatic
1583 variables, which won't be on stack, we collect alignment of
1584 type and ignore user specified alignment. Similarly for
1585 SSA_NAMEs for which use_register_for_decl returns true. */
1586 if (TREE_STATIC (var)
1587 || DECL_EXTERNAL (var)
1588 || (TREE_CODE (origvar) == SSA_NAME && use_register_for_decl (var)))
1589 align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1590 TYPE_MODE (TREE_TYPE (var)),
1591 TYPE_ALIGN (TREE_TYPE (var)));
1592 else if (DECL_HAS_VALUE_EXPR_P (var)
1593 || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
1594 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1595 or variables which were assigned a stack slot already by
1596 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1597 changed from the offset chosen to it. */
1598 align = crtl->stack_alignment_estimated;
1599 else
1600 align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
1601
1602 /* If the variable alignment is very large we'll dynamicaly allocate
1603 it, which means that in-frame portion is just a pointer. */
1604 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1605 align = POINTER_SIZE;
1606 }
1607
1608 record_alignment_for_reg_var (align);
1609
1610 if (TREE_CODE (origvar) == SSA_NAME)
1611 {
1612 gcc_assert (!VAR_P (var)
1613 || (!DECL_EXTERNAL (var)
1614 && !DECL_HAS_VALUE_EXPR_P (var)
1615 && !TREE_STATIC (var)
1616 && TREE_TYPE (var) != error_mark_node
1617 && !DECL_HARD_REGISTER (var)
1618 && really_expand));
1619 }
1620 if (!VAR_P (var) && TREE_CODE (origvar) != SSA_NAME)
1621 ;
1622 else if (DECL_EXTERNAL (var))
1623 ;
1624 else if (DECL_HAS_VALUE_EXPR_P (var))
1625 ;
1626 else if (TREE_STATIC (var))
1627 ;
1628 else if (TREE_CODE (origvar) != SSA_NAME && DECL_RTL_SET_P (var))
1629 ;
1630 else if (TREE_TYPE (var) == error_mark_node)
1631 {
1632 if (really_expand)
1633 expand_one_error_var (var);
1634 }
1635 else if (VAR_P (var) && DECL_HARD_REGISTER (var))
1636 {
1637 if (really_expand)
1638 {
1639 expand_one_hard_reg_var (var);
1640 if (!DECL_HARD_REGISTER (var))
1641 /* Invalid register specification. */
1642 expand_one_error_var (var);
1643 }
1644 }
1645 else if (use_register_for_decl (var))
1646 {
1647 if (really_expand)
1648 expand_one_register_var (origvar);
1649 }
1650 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var)))
1651 {
1652 /* Reject variables which cover more than half of the address-space. */
1653 if (really_expand)
1654 {
1655 error ("size of variable %q+D is too large", var);
1656 expand_one_error_var (var);
1657 }
1658 }
1659 else if (defer_stack_allocation (var, toplevel))
1660 add_stack_var (origvar);
1661 else
1662 {
1663 if (really_expand)
1664 {
1665 if (lookup_attribute ("naked",
1666 DECL_ATTRIBUTES (current_function_decl)))
1667 error ("cannot allocate stack for variable %q+D, naked function.",
1668 var);
1669
1670 expand_one_stack_var (origvar);
1671 }
1672
1673
1674 return tree_to_uhwi (DECL_SIZE_UNIT (var));
1675 }
1676 return 0;
1677}
1678
1679/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1680 expanding variables. Those variables that can be put into registers
1681 are allocated pseudos; those that can't are put on the stack.
1682
1683 TOPLEVEL is true if this is the outermost BLOCK. */
1684
1685static void
1686expand_used_vars_for_block (tree block, bool toplevel)
1687{
1688 tree t;
1689
1690 /* Expand all variables at this level. */
1691 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1692 if (TREE_USED (t)
1693 && ((!VAR_P (t) && TREE_CODE (t) != RESULT_DECL)
1694 || !DECL_NONSHAREABLE (t)))
1695 expand_one_var (t, toplevel, true);
1696
1697 /* Expand all variables at containing levels. */
1698 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1699 expand_used_vars_for_block (t, false);
1700}
1701
1702/* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1703 and clear TREE_USED on all local variables. */
1704
1705static void
1706clear_tree_used (tree block)
1707{
1708 tree t;
1709
1710 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1711 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1712 if ((!VAR_P (t) && TREE_CODE (t) != RESULT_DECL)
1713 || !DECL_NONSHAREABLE (t))
1714 TREE_USED (t) = 0;
1715
1716 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1717 clear_tree_used (t);
1718}
1719
1720enum {
1721 SPCT_FLAG_DEFAULT = 1,
1722 SPCT_FLAG_ALL = 2,
1723 SPCT_FLAG_STRONG = 3,
1724 SPCT_FLAG_EXPLICIT = 4
1725};
1726
1727/* Examine TYPE and determine a bit mask of the following features. */
1728
1729#define SPCT_HAS_LARGE_CHAR_ARRAY 1
1730#define SPCT_HAS_SMALL_CHAR_ARRAY 2
1731#define SPCT_HAS_ARRAY 4
1732#define SPCT_HAS_AGGREGATE 8
1733
1734static unsigned int
1735stack_protect_classify_type (tree type)
1736{
1737 unsigned int ret = 0;
1738 tree t;
1739
1740 switch (TREE_CODE (type))
1741 {
1742 case ARRAY_TYPE:
1743 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1744 if (t == char_type_node
1745 || t == signed_char_type_node
1746 || t == unsigned_char_type_node)
1747 {
1748 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
1749 unsigned HOST_WIDE_INT len;
1750
1751 if (!TYPE_SIZE_UNIT (type)
1752 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type)))
1753 len = max;
1754 else
1755 len = tree_to_uhwi (TYPE_SIZE_UNIT (type));
1756
1757 if (len < max)
1758 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
1759 else
1760 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
1761 }
1762 else
1763 ret = SPCT_HAS_ARRAY;
1764 break;
1765
1766 case UNION_TYPE:
1767 case QUAL_UNION_TYPE:
1768 case RECORD_TYPE:
1769 ret = SPCT_HAS_AGGREGATE;
1770 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
1771 if (TREE_CODE (t) == FIELD_DECL)
1772 ret |= stack_protect_classify_type (TREE_TYPE (t));
1773 break;
1774
1775 default:
1776 break;
1777 }
1778
1779 return ret;
1780}
1781
1782/* Return nonzero if DECL should be segregated into the "vulnerable" upper
1783 part of the local stack frame. Remember if we ever return nonzero for
1784 any variable in this function. The return value is the phase number in
1785 which the variable should be allocated. */
1786
1787static int
1788stack_protect_decl_phase (tree decl)
1789{
1790 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
1791 int ret = 0;
1792
1793 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
1794 has_short_buffer = true;
1795
1796 if (flag_stack_protect == SPCT_FLAG_ALL
1797 || flag_stack_protect == SPCT_FLAG_STRONG
1798 || (flag_stack_protect == SPCT_FLAG_EXPLICIT
1799 && lookup_attribute ("stack_protect",
1800 DECL_ATTRIBUTES (current_function_decl))))
1801 {
1802 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
1803 && !(bits & SPCT_HAS_AGGREGATE))
1804 ret = 1;
1805 else if (bits & SPCT_HAS_ARRAY)
1806 ret = 2;
1807 }
1808 else
1809 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
1810
1811 if (ret)
1812 has_protected_decls = true;
1813
1814 return ret;
1815}
1816
1817/* Two helper routines that check for phase 1 and phase 2. These are used
1818 as callbacks for expand_stack_vars. */
1819
1820static bool
1821stack_protect_decl_phase_1 (size_t i)
1822{
1823 return stack_protect_decl_phase (stack_vars[i].decl) == 1;
1824}
1825
1826static bool
1827stack_protect_decl_phase_2 (size_t i)
1828{
1829 return stack_protect_decl_phase (stack_vars[i].decl) == 2;
1830}
1831
1832/* And helper function that checks for asan phase (with stack protector
1833 it is phase 3). This is used as callback for expand_stack_vars.
1834 Returns true if any of the vars in the partition need to be protected. */
1835
1836static bool
1837asan_decl_phase_3 (size_t i)
1838{
1839 while (i != EOC)
1840 {
1841 if (asan_protect_stack_decl (stack_vars[i].decl))
1842 return true;
1843 i = stack_vars[i].next;
1844 }
1845 return false;
1846}
1847
1848/* Ensure that variables in different stack protection phases conflict
1849 so that they are not merged and share the same stack slot. */
1850
1851static void
1852add_stack_protection_conflicts (void)
1853{
1854 size_t i, j, n = stack_vars_num;
1855 unsigned char *phase;
1856
1857 phase = XNEWVEC (unsigned char, n);
1858 for (i = 0; i < n; ++i)
1859 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
1860
1861 for (i = 0; i < n; ++i)
1862 {
1863 unsigned char ph_i = phase[i];
1864 for (j = i + 1; j < n; ++j)
1865 if (ph_i != phase[j])
1866 add_stack_var_conflict (i, j);
1867 }
1868
1869 XDELETEVEC (phase);
1870}
1871
1872/* Create a decl for the guard at the top of the stack frame. */
1873
1874static void
1875create_stack_guard (void)
1876{
1877 tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
1878 VAR_DECL, NULL, ptr_type_node);
1879 TREE_THIS_VOLATILE (guard) = 1;
1880 TREE_USED (guard) = 1;
1881 expand_one_stack_var (guard);
1882 crtl->stack_protect_guard = guard;
1883}
1884
1885/* Prepare for expanding variables. */
1886static void
1887init_vars_expansion (void)
1888{
1889 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1890 bitmap_obstack_initialize (&stack_var_bitmap_obstack);
1891
1892 /* A map from decl to stack partition. */
1893 decl_to_stack_part = new hash_map<tree, size_t>;
1894
1895 /* Initialize local stack smashing state. */
1896 has_protected_decls = false;
1897 has_short_buffer = false;
1898}
1899
1900/* Free up stack variable graph data. */
1901static void
1902fini_vars_expansion (void)
1903{
1904 bitmap_obstack_release (&stack_var_bitmap_obstack);
1905 if (stack_vars)
1906 XDELETEVEC (stack_vars);
1907 if (stack_vars_sorted)
1908 XDELETEVEC (stack_vars_sorted);
1909 stack_vars = NULL;
1910 stack_vars_sorted = NULL;
1911 stack_vars_alloc = stack_vars_num = 0;
1912 delete decl_to_stack_part;
1913 decl_to_stack_part = NULL;
1914}
1915
1916/* Make a fair guess for the size of the stack frame of the function
1917 in NODE. This doesn't have to be exact, the result is only used in
1918 the inline heuristics. So we don't want to run the full stack var
1919 packing algorithm (which is quadratic in the number of stack vars).
1920 Instead, we calculate the total size of all stack vars. This turns
1921 out to be a pretty fair estimate -- packing of stack vars doesn't
1922 happen very often. */
1923
1924HOST_WIDE_INT
1925estimated_stack_frame_size (struct cgraph_node *node)
1926{
1927 HOST_WIDE_INT size = 0;
1928 size_t i;
1929 tree var;
1930 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
1931
1932 push_cfun (fn);
1933
1934 init_vars_expansion ();
1935
1936 FOR_EACH_LOCAL_DECL (fn, i, var)
1937 if (auto_var_in_fn_p (var, fn->decl))
1938 size += expand_one_var (var, true, false);
1939
1940 if (stack_vars_num > 0)
1941 {
1942 /* Fake sorting the stack vars for account_stack_vars (). */
1943 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
1944 for (i = 0; i < stack_vars_num; ++i)
1945 stack_vars_sorted[i] = i;
1946 size += account_stack_vars ();
1947 }
1948
1949 fini_vars_expansion ();
1950 pop_cfun ();
1951 return size;
1952}
1953
1954/* Helper routine to check if a record or union contains an array field. */
1955
1956static int
1957record_or_union_type_has_array_p (const_tree tree_type)
1958{
1959 tree fields = TYPE_FIELDS (tree_type);
1960 tree f;
1961
1962 for (f = fields; f; f = DECL_CHAIN (f))
1963 if (TREE_CODE (f) == FIELD_DECL)
1964 {
1965 tree field_type = TREE_TYPE (f);
1966 if (RECORD_OR_UNION_TYPE_P (field_type)
1967 && record_or_union_type_has_array_p (field_type))
1968 return 1;
1969 if (TREE_CODE (field_type) == ARRAY_TYPE)
1970 return 1;
1971 }
1972 return 0;
1973}
1974
1975/* Check if the current function has local referenced variables that
1976 have their addresses taken, contain an array, or are arrays. */
1977
1978static bool
1979stack_protect_decl_p ()
1980{
1981 unsigned i;
1982 tree var;
1983
1984 FOR_EACH_LOCAL_DECL (cfun, i, var)
1985 if (!is_global_var (var))
1986 {
1987 tree var_type = TREE_TYPE (var);
1988 if (VAR_P (var)
1989 && (TREE_CODE (var_type) == ARRAY_TYPE
1990 || TREE_ADDRESSABLE (var)
1991 || (RECORD_OR_UNION_TYPE_P (var_type)
1992 && record_or_union_type_has_array_p (var_type))))
1993 return true;
1994 }
1995 return false;
1996}
1997
1998/* Check if the current function has calls that use a return slot. */
1999
2000static bool
2001stack_protect_return_slot_p ()
2002{
2003 basic_block bb;
2004
2005 FOR_ALL_BB_FN (bb, cfun)
2006 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
2007 !gsi_end_p (gsi); gsi_next (&gsi))
2008 {
2009 gimple *stmt = gsi_stmt (gsi);
2010 /* This assumes that calls to internal-only functions never
2011 use a return slot. */
2012 if (is_gimple_call (stmt)
2013 && !gimple_call_internal_p (stmt)
2014 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt)),
2015 gimple_call_fndecl (stmt)))
2016 return true;
2017 }
2018 return false;
2019}
2020
2021/* Expand all variables used in the function. */
2022
2023static rtx_insn *
2024expand_used_vars (void)
2025{
2026 tree var, outer_block = DECL_INITIAL (current_function_decl);
2027 auto_vec<tree> maybe_local_decls;
2028 rtx_insn *var_end_seq = NULL;
2029 unsigned i;
2030 unsigned len;
2031 bool gen_stack_protect_signal = false;
2032
2033 /* Compute the phase of the stack frame for this function. */
2034 {
2035 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
2036 int off = targetm.starting_frame_offset () % align;
2037 frame_phase = off ? align - off : 0;
2038 }
2039
2040 /* Set TREE_USED on all variables in the local_decls. */
2041 FOR_EACH_LOCAL_DECL (cfun, i, var)
2042 TREE_USED (var) = 1;
2043 /* Clear TREE_USED on all variables associated with a block scope. */
2044 clear_tree_used (DECL_INITIAL (current_function_decl));
2045
2046 init_vars_expansion ();
2047
2048 if (targetm.use_pseudo_pic_reg ())
2049 pic_offset_table_rtx = gen_reg_rtx (Pmode);
2050
2051 for (i = 0; i < SA.map->num_partitions; i++)
2052 {
2053 if (bitmap_bit_p (SA.partitions_for_parm_default_defs, i))
2054 continue;
2055
2056 tree var = partition_to_var (SA.map, i);
2057
2058 gcc_assert (!virtual_operand_p (var));
2059
2060 expand_one_ssa_partition (var);
2061 }
2062
2063 if (flag_stack_protect == SPCT_FLAG_STRONG)
2064 gen_stack_protect_signal
2065 = stack_protect_decl_p () || stack_protect_return_slot_p ();
2066
2067 /* At this point all variables on the local_decls with TREE_USED
2068 set are not associated with any block scope. Lay them out. */
2069
2070 len = vec_safe_length (cfun->local_decls);
2071 FOR_EACH_LOCAL_DECL (cfun, i, var)
2072 {
2073 bool expand_now = false;
2074
2075 /* Expanded above already. */
2076 if (is_gimple_reg (var))
2077 {
2078 TREE_USED (var) = 0;
2079 goto next;
2080 }
2081 /* We didn't set a block for static or extern because it's hard
2082 to tell the difference between a global variable (re)declared
2083 in a local scope, and one that's really declared there to
2084 begin with. And it doesn't really matter much, since we're
2085 not giving them stack space. Expand them now. */
2086 else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
2087 expand_now = true;
2088
2089 /* Expand variables not associated with any block now. Those created by
2090 the optimizers could be live anywhere in the function. Those that
2091 could possibly have been scoped originally and detached from their
2092 block will have their allocation deferred so we coalesce them with
2093 others when optimization is enabled. */
2094 else if (TREE_USED (var))
2095 expand_now = true;
2096
2097 /* Finally, mark all variables on the list as used. We'll use
2098 this in a moment when we expand those associated with scopes. */
2099 TREE_USED (var) = 1;
2100
2101 if (expand_now)
2102 expand_one_var (var, true, true);
2103
2104 next:
2105 if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
2106 {
2107 rtx rtl = DECL_RTL_IF_SET (var);
2108
2109 /* Keep artificial non-ignored vars in cfun->local_decls
2110 chain until instantiate_decls. */
2111 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
2112 add_local_decl (cfun, var);
2113 else if (rtl == NULL_RTX)
2114 /* If rtl isn't set yet, which can happen e.g. with
2115 -fstack-protector, retry before returning from this
2116 function. */
2117 maybe_local_decls.safe_push (var);
2118 }
2119 }
2120
2121 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2122
2123 +-----------------+-----------------+
2124 | ...processed... | ...duplicates...|
2125 +-----------------+-----------------+
2126 ^
2127 +-- LEN points here.
2128
2129 We just want the duplicates, as those are the artificial
2130 non-ignored vars that we want to keep until instantiate_decls.
2131 Move them down and truncate the array. */
2132 if (!vec_safe_is_empty (cfun->local_decls))
2133 cfun->local_decls->block_remove (0, len);
2134
2135 /* At this point, all variables within the block tree with TREE_USED
2136 set are actually used by the optimized function. Lay them out. */
2137 expand_used_vars_for_block (outer_block, true);
2138
2139 if (stack_vars_num > 0)
2140 {
2141 add_scope_conflicts ();
2142
2143 /* If stack protection is enabled, we don't share space between
2144 vulnerable data and non-vulnerable data. */
2145 if (flag_stack_protect != 0
2146 && (flag_stack_protect != SPCT_FLAG_EXPLICIT
2147 || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2148 && lookup_attribute ("stack_protect",
2149 DECL_ATTRIBUTES (current_function_decl)))))
2150 add_stack_protection_conflicts ();
2151
2152 /* Now that we have collected all stack variables, and have computed a
2153 minimal interference graph, attempt to save some stack space. */
2154 partition_stack_vars ();
2155 if (dump_file)
2156 dump_stack_var_partition ();
2157 }
2158
2159 switch (flag_stack_protect)
2160 {
2161 case SPCT_FLAG_ALL:
2162 create_stack_guard ();
2163 break;
2164
2165 case SPCT_FLAG_STRONG:
2166 if (gen_stack_protect_signal
2167 || cfun->calls_alloca || has_protected_decls
2168 || lookup_attribute ("stack_protect",
2169 DECL_ATTRIBUTES (current_function_decl)))
2170 create_stack_guard ();
2171 break;
2172
2173 case SPCT_FLAG_DEFAULT:
2174 if (cfun->calls_alloca || has_protected_decls
2175 || lookup_attribute ("stack_protect",
2176 DECL_ATTRIBUTES (current_function_decl)))
2177 create_stack_guard ();
2178 break;
2179
2180 case SPCT_FLAG_EXPLICIT:
2181 if (lookup_attribute ("stack_protect",
2182 DECL_ATTRIBUTES (current_function_decl)))
2183 create_stack_guard ();
2184 break;
2185 default:
2186 ;
2187 }
2188
2189 /* Assign rtl to each variable based on these partitions. */
2190 if (stack_vars_num > 0)
2191 {
2192 struct stack_vars_data data;
2193
2194 data.asan_base = NULL_RTX;
2195 data.asan_alignb = 0;
2196
2197 /* Reorder decls to be protected by iterating over the variables
2198 array multiple times, and allocating out of each phase in turn. */
2199 /* ??? We could probably integrate this into the qsort we did
2200 earlier, such that we naturally see these variables first,
2201 and thus naturally allocate things in the right order. */
2202 if (has_protected_decls)
2203 {
2204 /* Phase 1 contains only character arrays. */
2205 expand_stack_vars (stack_protect_decl_phase_1, &data);
2206
2207 /* Phase 2 contains other kinds of arrays. */
2208 if (flag_stack_protect == SPCT_FLAG_ALL
2209 || flag_stack_protect == SPCT_FLAG_STRONG
2210 || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2211 && lookup_attribute ("stack_protect",
2212 DECL_ATTRIBUTES (current_function_decl))))
2213 expand_stack_vars (stack_protect_decl_phase_2, &data);
2214 }
2215
2216 if (asan_sanitize_stack_p ())
2217 /* Phase 3, any partitions that need asan protection
2218 in addition to phase 1 and 2. */
2219 expand_stack_vars (asan_decl_phase_3, &data);
2220
2221 if (!data.asan_vec.is_empty ())
2222 {
2223 HOST_WIDE_INT prev_offset = frame_offset;
2224 HOST_WIDE_INT offset, sz, redzonesz;
2225 redzonesz = ASAN_RED_ZONE_SIZE;
2226 sz = data.asan_vec[0] - prev_offset;
2227 if (data.asan_alignb > ASAN_RED_ZONE_SIZE
2228 && data.asan_alignb <= 4096
2229 && sz + ASAN_RED_ZONE_SIZE >= (int) data.asan_alignb)
2230 redzonesz = ((sz + ASAN_RED_ZONE_SIZE + data.asan_alignb - 1)
2231 & ~(data.asan_alignb - HOST_WIDE_INT_1)) - sz;
2232 offset
2233 = alloc_stack_frame_space (redzonesz, ASAN_RED_ZONE_SIZE);
2234 data.asan_vec.safe_push (prev_offset);
2235 data.asan_vec.safe_push (offset);
2236 /* Leave space for alignment if STRICT_ALIGNMENT. */
2237 if (STRICT_ALIGNMENT)
2238 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode)
2239 << ASAN_SHADOW_SHIFT)
2240 / BITS_PER_UNIT, 1);
2241
2242 var_end_seq
2243 = asan_emit_stack_protection (virtual_stack_vars_rtx,
2244 data.asan_base,
2245 data.asan_alignb,
2246 data.asan_vec.address (),
2247 data.asan_decl_vec.address (),
2248 data.asan_vec.length ());
2249 }
2250
2251 expand_stack_vars (NULL, &data);
2252 }
2253
2254 if (asan_sanitize_allocas_p () && cfun->calls_alloca)
2255 var_end_seq = asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx,
2256 virtual_stack_vars_rtx,
2257 var_end_seq);
2258
2259 fini_vars_expansion ();
2260
2261 /* If there were any artificial non-ignored vars without rtl
2262 found earlier, see if deferred stack allocation hasn't assigned
2263 rtl to them. */
2264 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls, i, var)
2265 {
2266 rtx rtl = DECL_RTL_IF_SET (var);
2267
2268 /* Keep artificial non-ignored vars in cfun->local_decls
2269 chain until instantiate_decls. */
2270 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
2271 add_local_decl (cfun, var);
2272 }
2273
2274 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2275 if (STACK_ALIGNMENT_NEEDED)
2276 {
2277 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
2278 if (!FRAME_GROWS_DOWNWARD)
2279 frame_offset += align - 1;
2280 frame_offset &= -align;
2281 }
2282
2283 return var_end_seq;
2284}
2285
2286
2287/* If we need to produce a detailed dump, print the tree representation
2288 for STMT to the dump file. SINCE is the last RTX after which the RTL
2289 generated for STMT should have been appended. */
2290
2291static void
2292maybe_dump_rtl_for_gimple_stmt (gimple *stmt, rtx_insn *since)
2293{
2294 if (dump_file && (dump_flags & TDF_DETAILS))
2295 {
2296 fprintf (dump_file, "\n;; ");
2297 print_gimple_stmt (dump_file, stmt, 0,
2298 TDF_SLIM | (dump_flags & TDF_LINENO));
2299 fprintf (dump_file, "\n");
2300
2301 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
2302 }
2303}
2304
2305/* Maps the blocks that do not contain tree labels to rtx labels. */
2306
2307static hash_map<basic_block, rtx_code_label *> *lab_rtx_for_bb;
2308
2309/* Returns the label_rtx expression for a label starting basic block BB. */
2310
2311static rtx_code_label *
2312label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
2313{
2314 gimple_stmt_iterator gsi;
2315 tree lab;
2316
2317 if (bb->flags & BB_RTL)
2318 return block_label (bb);
2319
2320 rtx_code_label **elt = lab_rtx_for_bb->get (bb);
2321 if (elt)
2322 return *elt;
2323
2324 /* Find the tree label if it is present. */
2325
2326 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2327 {
2328 glabel *lab_stmt;
2329
2330 if (is_gimple_debug (gsi_stmt (gsi)))
2331 continue;
2332
2333 lab_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
2334 if (!lab_stmt)
2335 break;
2336
2337 lab = gimple_label_label (lab_stmt);
2338 if (DECL_NONLOCAL (lab))
2339 break;
2340
2341 return jump_target_rtx (lab);
2342 }
2343
2344 rtx_code_label *l = gen_label_rtx ();
2345 lab_rtx_for_bb->put (bb, l);
2346 return l;
2347}
2348
2349
2350/* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2351 of a basic block where we just expanded the conditional at the end,
2352 possibly clean up the CFG and instruction sequence. LAST is the
2353 last instruction before the just emitted jump sequence. */
2354
2355static void
2356maybe_cleanup_end_of_block (edge e, rtx_insn *last)
2357{
2358 /* Special case: when jumpif decides that the condition is
2359 trivial it emits an unconditional jump (and the necessary
2360 barrier). But we still have two edges, the fallthru one is
2361 wrong. purge_dead_edges would clean this up later. Unfortunately
2362 we have to insert insns (and split edges) before
2363 find_many_sub_basic_blocks and hence before purge_dead_edges.
2364 But splitting edges might create new blocks which depend on the
2365 fact that if there are two edges there's no barrier. So the
2366 barrier would get lost and verify_flow_info would ICE. Instead
2367 of auditing all edge splitters to care for the barrier (which
2368 normally isn't there in a cleaned CFG), fix it here. */
2369 if (BARRIER_P (get_last_insn ()))
2370 {
2371 rtx_insn *insn;
2372 remove_edge (e);
2373 /* Now, we have a single successor block, if we have insns to
2374 insert on the remaining edge we potentially will insert
2375 it at the end of this block (if the dest block isn't feasible)
2376 in order to avoid splitting the edge. This insertion will take
2377 place in front of the last jump. But we might have emitted
2378 multiple jumps (conditional and one unconditional) to the
2379 same destination. Inserting in front of the last one then
2380 is a problem. See PR 40021. We fix this by deleting all
2381 jumps except the last unconditional one. */
2382 insn = PREV_INSN (get_last_insn ());
2383 /* Make sure we have an unconditional jump. Otherwise we're
2384 confused. */
2385 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
2386 for (insn = PREV_INSN (insn); insn != last;)
2387 {
2388 insn = PREV_INSN (insn);
2389 if (JUMP_P (NEXT_INSN (insn)))
2390 {
2391 if (!any_condjump_p (NEXT_INSN (insn)))
2392 {
2393 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))));
2394 delete_insn (NEXT_INSN (NEXT_INSN (insn)));
2395 }
2396 delete_insn (NEXT_INSN (insn));
2397 }
2398 }
2399 }
2400}
2401
2402/* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2403 Returns a new basic block if we've terminated the current basic
2404 block and created a new one. */
2405
2406static basic_block
2407expand_gimple_cond (basic_block bb, gcond *stmt)
2408{
2409 basic_block new_bb, dest;
2410 edge true_edge;
2411 edge false_edge;
2412 rtx_insn *last2, *last;
2413 enum tree_code code;
2414 tree op0, op1;
2415
2416 code = gimple_cond_code (stmt);
2417 op0 = gimple_cond_lhs (stmt);
2418 op1 = gimple_cond_rhs (stmt);
2419 /* We're sometimes presented with such code:
2420 D.123_1 = x < y;
2421 if (D.123_1 != 0)
2422 ...
2423 This would expand to two comparisons which then later might
2424 be cleaned up by combine. But some pattern matchers like if-conversion
2425 work better when there's only one compare, so make up for this
2426 here as special exception if TER would have made the same change. */
2427 if (SA.values
2428 && TREE_CODE (op0) == SSA_NAME
2429 && TREE_CODE (TREE_TYPE (op0)) == BOOLEAN_TYPE
2430 && TREE_CODE (op1) == INTEGER_CST
2431 && ((gimple_cond_code (stmt) == NE_EXPR
2432 && integer_zerop (op1))
2433 || (gimple_cond_code (stmt) == EQ_EXPR
2434 && integer_onep (op1)))
2435 && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
2436 {
2437 gimple *second = SSA_NAME_DEF_STMT (op0);
2438 if (gimple_code (second) == GIMPLE_ASSIGN)
2439 {
2440 enum tree_code code2 = gimple_assign_rhs_code (second);
2441 if (TREE_CODE_CLASS (code2) == tcc_comparison)
2442 {
2443 code = code2;
2444 op0 = gimple_assign_rhs1 (second);
2445 op1 = gimple_assign_rhs2 (second);
2446 }
2447 /* If jumps are cheap and the target does not support conditional
2448 compare, turn some more codes into jumpy sequences. */
2449 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2450 && targetm.gen_ccmp_first == NULL)
2451 {
2452 if ((code2 == BIT_AND_EXPR
2453 && TYPE_PRECISION (TREE_TYPE (op0)) == 1
2454 && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
2455 || code2 == TRUTH_AND_EXPR)
2456 {
2457 code = TRUTH_ANDIF_EXPR;
2458 op0 = gimple_assign_rhs1 (second);
2459 op1 = gimple_assign_rhs2 (second);
2460 }
2461 else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
2462 {
2463 code = TRUTH_ORIF_EXPR;
2464 op0 = gimple_assign_rhs1 (second);
2465 op1 = gimple_assign_rhs2 (second);
2466 }
2467 }
2468 }
2469 }
2470
2471 last2 = last = get_last_insn ();
2472
2473 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2474 set_curr_insn_location (gimple_location (stmt));
2475
2476 /* These flags have no purpose in RTL land. */
2477 true_edge->flags &= ~EDGE_TRUE_VALUE;
2478 false_edge->flags &= ~EDGE_FALSE_VALUE;
2479
2480 /* We can either have a pure conditional jump with one fallthru edge or
2481 two-way jump that needs to be decomposed into two basic blocks. */
2482 if (false_edge->dest == bb->next_bb)
2483 {
2484 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2485 true_edge->probability);
2486 maybe_dump_rtl_for_gimple_stmt (stmt, last);
2487 if (true_edge->goto_locus != UNKNOWN_LOCATION)
2488 set_curr_insn_location (true_edge->goto_locus);
2489 false_edge->flags |= EDGE_FALLTHRU;
2490 maybe_cleanup_end_of_block (false_edge, last);
2491 return NULL;
2492 }
2493 if (true_edge->dest == bb->next_bb)
2494 {
2495 jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
2496 false_edge->probability);
2497 maybe_dump_rtl_for_gimple_stmt (stmt, last);
2498 if (false_edge->goto_locus != UNKNOWN_LOCATION)
2499 set_curr_insn_location (false_edge->goto_locus);
2500 true_edge->flags |= EDGE_FALLTHRU;
2501 maybe_cleanup_end_of_block (true_edge, last);
2502 return NULL;
2503 }
2504
2505 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2506 true_edge->probability);
2507 last = get_last_insn ();
2508 if (false_edge->goto_locus != UNKNOWN_LOCATION)
2509 set_curr_insn_location (false_edge->goto_locus);
2510 emit_jump (label_rtx_for_bb (false_edge->dest));
2511
2512 BB_END (bb) = last;
2513 if (BARRIER_P (BB_END (bb)))
2514 BB_END (bb) = PREV_INSN (BB_END (bb));
2515 update_bb_for_insn (bb);
2516
2517 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2518 dest = false_edge->dest;
2519 redirect_edge_succ (false_edge, new_bb);
2520 false_edge->flags |= EDGE_FALLTHRU;
2521 new_bb->count = false_edge->count ();
2522 loop_p loop = find_common_loop (bb->loop_father, dest->loop_father);
2523 add_bb_to_loop (new_bb, loop);
2524 if (loop->latch == bb
2525 && loop->header == dest)
2526 loop->latch = new_bb;
2527 make_single_succ_edge (new_bb, dest, 0);
2528 if (BARRIER_P (BB_END (new_bb)))
2529 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
2530 update_bb_for_insn (new_bb);
2531
2532 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2533
2534 if (true_edge->goto_locus != UNKNOWN_LOCATION)
2535 {
2536 set_curr_insn_location (true_edge->goto_locus);
2537 true_edge->goto_locus = curr_insn_location ();
2538 }
2539
2540 return new_bb;
2541}
2542
2543/* Mark all calls that can have a transaction restart. */
2544
2545static void
2546mark_transaction_restart_calls (gimple *stmt)
2547{
2548 struct tm_restart_node dummy;
2549 tm_restart_node **slot;
2550
2551 if (!cfun->gimple_df->tm_restart)
2552 return;
2553
2554 dummy.stmt = stmt;
2555 slot = cfun->gimple_df->tm_restart->find_slot (&dummy, NO_INSERT);
2556 if (slot)
2557 {
2558 struct tm_restart_node *n = *slot;
2559 tree list = n->label_or_list;
2560 rtx_insn *insn;
2561
2562 for (insn = next_real_insn (get_last_insn ());
2563 !CALL_P (insn);
2564 insn = next_real_insn (insn))
2565 continue;
2566
2567 if (TREE_CODE (list) == LABEL_DECL)
2568 add_reg_note (insn, REG_TM, label_rtx (list));
2569 else
2570 for (; list ; list = TREE_CHAIN (list))
2571 add_reg_note (insn, REG_TM, label_rtx (TREE_VALUE (list)));
2572 }
2573}
2574
2575/* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2576 statement STMT. */
2577
2578static void
2579expand_call_stmt (gcall *stmt)
2580{
2581 tree exp, decl, lhs;
2582 bool builtin_p;
2583 size_t i;
2584
2585 if (gimple_call_internal_p (stmt))
2586 {
2587 expand_internal_call (stmt);
2588 return;
2589 }
2590
2591 /* If this is a call to a built-in function and it has no effect other
2592 than setting the lhs, try to implement it using an internal function
2593 instead. */
2594 decl = gimple_call_fndecl (stmt);
2595 if (gimple_call_lhs (stmt)
2596 && !gimple_has_side_effects (stmt)
2597 && (optimize || (decl && called_as_built_in (decl))))
2598 {
2599 internal_fn ifn = replacement_internal_fn (stmt);
2600 if (ifn != IFN_LAST)
2601 {
2602 expand_internal_call (ifn, stmt);
2603 return;
2604 }
2605 }
2606
2607 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2608
2609 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2610 builtin_p = decl && DECL_BUILT_IN (decl);
2611
2612 /* If this is not a builtin function, the function type through which the
2613 call is made may be different from the type of the function. */
2614 if (!builtin_p)
2615 CALL_EXPR_FN (exp)
2616 = fold_convert (build_pointer_type (gimple_call_fntype (stmt)),
2617 CALL_EXPR_FN (exp));
2618
2619 TREE_TYPE (exp) = gimple_call_return_type (stmt);
2620 CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2621
2622 for (i = 0; i < gimple_call_num_args (stmt); i++)
2623 {
2624 tree arg = gimple_call_arg (stmt, i);
2625 gimple *def;
2626 /* TER addresses into arguments of builtin functions so we have a
2627 chance to infer more correct alignment information. See PR39954. */
2628 if (builtin_p
2629 && TREE_CODE (arg) == SSA_NAME
2630 && (def = get_gimple_for_ssa_name (arg))
2631 && gimple_assign_rhs_code (def) == ADDR_EXPR)
2632 arg = gimple_assign_rhs1 (def);
2633 CALL_EXPR_ARG (exp, i) = arg;
2634 }
2635
2636 if (gimple_has_side_effects (stmt))
2637 TREE_SIDE_EFFECTS (exp) = 1;
2638
2639 if (gimple_call_nothrow_p (stmt))
2640 TREE_NOTHROW (exp) = 1;
2641
2642 CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
2643 CALL_EXPR_MUST_TAIL_CALL (exp) = gimple_call_must_tail_p (stmt);
2644 CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
2645 if (decl
2646 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2647 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl)))
2648 CALL_ALLOCA_FOR_VAR_P (exp) = gimple_call_alloca_for_var_p (stmt);
2649 else
2650 CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
2651 CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
2652 CALL_EXPR_BY_DESCRIPTOR (exp) = gimple_call_by_descriptor_p (stmt);
2653 SET_EXPR_LOCATION (exp, gimple_location (stmt));
2654 CALL_WITH_BOUNDS_P (exp) = gimple_call_with_bounds_p (stmt);
2655
2656 /* Ensure RTL is created for debug args. */
2657 if (decl && DECL_HAS_DEBUG_ARGS_P (decl))
2658 {
2659 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (decl);
2660 unsigned int ix;
2661 tree dtemp;
2662
2663 if (debug_args)
2664 for (ix = 1; (*debug_args)->iterate (ix, &dtemp); ix += 2)
2665 {
2666 gcc_assert (TREE_CODE (dtemp) == DEBUG_EXPR_DECL);
2667 expand_debug_expr (dtemp);
2668 }
2669 }
2670
2671 rtx_insn *before_call = get_last_insn ();
2672 lhs = gimple_call_lhs (stmt);
2673 if (lhs)
2674 expand_assignment (lhs, exp, false);
2675 else
2676 expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
2677
2678 /* If the gimple call is an indirect call and has 'nocf_check'
2679 attribute find a generated CALL insn to mark it as no
2680 control-flow verification is needed. */
2681 if (gimple_call_nocf_check_p (stmt)
2682 && !gimple_call_fndecl (stmt))
2683 {
2684 rtx_insn *last = get_last_insn ();
2685 while (!CALL_P (last)
2686 && last != before_call)
2687 last = PREV_INSN (last);
2688
2689 if (last != before_call)
2690 add_reg_note (last, REG_CALL_NOCF_CHECK, const0_rtx);
2691 }
2692
2693 mark_transaction_restart_calls (stmt);
2694}
2695
2696
2697/* Generate RTL for an asm statement (explicit assembler code).
2698 STRING is a STRING_CST node containing the assembler code text,
2699 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2700 insn is volatile; don't optimize it. */
2701
2702static void
2703expand_asm_loc (tree string, int vol, location_t locus)
2704{
2705 rtx body;
2706
2707 body = gen_rtx_ASM_INPUT_loc (VOIDmode,
2708 ggc_strdup (TREE_STRING_POINTER (string)),
2709 locus);
2710
2711 MEM_VOLATILE_P (body) = vol;
2712
2713 /* Non-empty basic ASM implicitly clobbers memory. */
2714 if (TREE_STRING_LENGTH (string) != 0)
2715 {
2716 rtx asm_op, clob;
2717 unsigned i, nclobbers;
2718 auto_vec<rtx> input_rvec, output_rvec;
2719 auto_vec<const char *> constraints;
2720 auto_vec<rtx> clobber_rvec;
2721 HARD_REG_SET clobbered_regs;
2722 CLEAR_HARD_REG_SET (clobbered_regs);
2723
2724 clob = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
2725 clobber_rvec.safe_push (clob);
2726
2727 if (targetm.md_asm_adjust)
2728 targetm.md_asm_adjust (output_rvec, input_rvec,
2729 constraints, clobber_rvec,
2730 clobbered_regs);
2731
2732 asm_op = body;
2733 nclobbers = clobber_rvec.length ();
2734 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (1 + nclobbers));
2735
2736 XVECEXP (body, 0, 0) = asm_op;
2737 for (i = 0; i < nclobbers; i++)
2738 XVECEXP (body, 0, i + 1) = gen_rtx_CLOBBER (VOIDmode, clobber_rvec[i]);
2739 }
2740
2741 emit_insn (body);
2742}
2743
2744/* Return the number of times character C occurs in string S. */
2745static int
2746n_occurrences (int c, const char *s)
2747{
2748 int n = 0;
2749 while (*s)
2750 n += (*s++ == c);
2751 return n;
2752}
2753
2754/* A subroutine of expand_asm_operands. Check that all operands have
2755 the same number of alternatives. Return true if so. */
2756
2757static bool
2758check_operand_nalternatives (const vec<const char *> &constraints)
2759{
2760 unsigned len = constraints.length();
2761 if (len > 0)
2762 {
2763 int nalternatives = n_occurrences (',', constraints[0]);
2764
2765 if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES)
2766 {
2767 error ("too many alternatives in %<asm%>");
2768 return false;
2769 }
2770
2771 for (unsigned i = 1; i < len; ++i)
2772 if (n_occurrences (',', constraints[i]) != nalternatives)
2773 {
2774 error ("operand constraints for %<asm%> differ "
2775 "in number of alternatives");
2776 return false;
2777 }
2778 }
2779 return true;
2780}
2781
2782/* Check for overlap between registers marked in CLOBBERED_REGS and
2783 anything inappropriate in T. Emit error and return the register
2784 variable definition for error, NULL_TREE for ok. */
2785
2786static bool
2787tree_conflicts_with_clobbers_p (tree t, HARD_REG_SET *clobbered_regs)
2788{
2789 /* Conflicts between asm-declared register variables and the clobber
2790 list are not allowed. */
2791 tree overlap = tree_overlaps_hard_reg_set (t, clobbered_regs);
2792
2793 if (overlap)
2794 {
2795 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2796 DECL_NAME (overlap));
2797
2798 /* Reset registerness to stop multiple errors emitted for a single
2799 variable. */
2800 DECL_REGISTER (overlap) = 0;
2801 return true;
2802 }
2803
2804 return false;
2805}
2806
2807/* Generate RTL for an asm statement with arguments.
2808 STRING is the instruction template.
2809 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2810 Each output or input has an expression in the TREE_VALUE and
2811 a tree list in TREE_PURPOSE which in turn contains a constraint
2812 name in TREE_VALUE (or NULL_TREE) and a constraint string
2813 in TREE_PURPOSE.
2814 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2815 that is clobbered by this insn.
2816
2817 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2818 should be the fallthru basic block of the asm goto.
2819
2820 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2821 Some elements of OUTPUTS may be replaced with trees representing temporary
2822 values. The caller should copy those temporary values to the originally
2823 specified lvalues.
2824
2825 VOL nonzero means the insn is volatile; don't optimize it. */
2826
2827static void
2828expand_asm_stmt (gasm *stmt)
2829{
2830 class save_input_location
2831 {
2832 location_t old;
2833
2834 public:
2835 explicit save_input_location(location_t where)
2836 {
2837 old = input_location;
2838 input_location = where;
2839 }
2840
2841 ~save_input_location()
2842 {
2843 input_location = old;
2844 }
2845 };
2846
2847 location_t locus = gimple_location (stmt);
2848
2849 if (gimple_asm_input_p (stmt))
2850 {
2851 const char *s = gimple_asm_string (stmt);
2852 tree string = build_string (strlen (s), s);
2853 expand_asm_loc (string, gimple_asm_volatile_p (stmt), locus);
2854 return;
2855 }
2856
2857 /* There are some legacy diagnostics in here, and also avoids a
2858 sixth parameger to targetm.md_asm_adjust. */
2859 save_input_location s_i_l(locus);
2860
2861 unsigned noutputs = gimple_asm_noutputs (stmt);
2862 unsigned ninputs = gimple_asm_ninputs (stmt);
2863 unsigned nlabels = gimple_asm_nlabels (stmt);
2864 unsigned i;
2865
2866 /* ??? Diagnose during gimplification? */
2867 if (ninputs + noutputs + nlabels > MAX_RECOG_OPERANDS)
2868 {
2869 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS);
2870 return;
2871 }
2872
2873 auto_vec<tree, MAX_RECOG_OPERANDS> output_tvec;
2874 auto_vec<tree, MAX_RECOG_OPERANDS> input_tvec;
2875 auto_vec<const char *, MAX_RECOG_OPERANDS> constraints;
2876
2877 /* Copy the gimple vectors into new vectors that we can manipulate. */
2878
2879 output_tvec.safe_grow (noutputs);
2880 input_tvec.safe_grow (ninputs);
2881 constraints.safe_grow (noutputs + ninputs);
2882
2883 for (i = 0; i < noutputs; ++i)
2884 {
2885 tree t = gimple_asm_output_op (stmt, i);
2886 output_tvec[i] = TREE_VALUE (t);
2887 constraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
2888 }
2889 for (i = 0; i < ninputs; i++)
2890 {
2891 tree t = gimple_asm_input_op (stmt, i);
2892 input_tvec[i] = TREE_VALUE (t);
2893 constraints[i + noutputs]
2894 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
2895 }
2896
2897 /* ??? Diagnose during gimplification? */
2898 if (! check_operand_nalternatives (constraints))
2899 return;
2900
2901 /* Count the number of meaningful clobbered registers, ignoring what
2902 we would ignore later. */
2903 auto_vec<rtx> clobber_rvec;
2904 HARD_REG_SET clobbered_regs;
2905 CLEAR_HARD_REG_SET (clobbered_regs);
2906
2907 if (unsigned n = gimple_asm_nclobbers (stmt))
2908 {
2909 clobber_rvec.reserve (n);
2910 for (i = 0; i < n; i++)
2911 {
2912 tree t = gimple_asm_clobber_op (stmt, i);
2913 const char *regname = TREE_STRING_POINTER (TREE_VALUE (t));
2914 int nregs, j;
2915
2916 j = decode_reg_name_and_count (regname, &nregs);
2917 if (j < 0)
2918 {
2919 if (j == -2)
2920 {
2921 /* ??? Diagnose during gimplification? */
2922 error ("unknown register name %qs in %<asm%>", regname);
2923 }
2924 else if (j == -4)
2925 {
2926 rtx x = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
2927 clobber_rvec.safe_push (x);
2928 }
2929 else
2930 {
2931 /* Otherwise we should have -1 == empty string
2932 or -3 == cc, which is not a register. */
2933 gcc_assert (j == -1 || j == -3);
2934 }
2935 }
2936 else
2937 for (int reg = j; reg < j + nregs; reg++)
2938 {
2939 /* Clobbering the PIC register is an error. */
2940 if (reg == (int) PIC_OFFSET_TABLE_REGNUM)
2941 {
2942 /* ??? Diagnose during gimplification? */
2943 error ("PIC register clobbered by %qs in %<asm%>",
2944 regname);
2945 return;
2946 }
2947
2948 SET_HARD_REG_BIT (clobbered_regs, reg);
2949 rtx x = gen_rtx_REG (reg_raw_mode[reg], reg);
2950 clobber_rvec.safe_push (x);
2951 }
2952 }
2953 }
2954 unsigned nclobbers = clobber_rvec.length();
2955
2956 /* First pass over inputs and outputs checks validity and sets
2957 mark_addressable if needed. */
2958 /* ??? Diagnose during gimplification? */
2959
2960 for (i = 0; i < noutputs; ++i)
2961 {
2962 tree val = output_tvec[i];
2963 tree type = TREE_TYPE (val);
2964 const char *constraint;
2965 bool is_inout;
2966 bool allows_reg;
2967 bool allows_mem;
2968
2969 /* Try to parse the output constraint. If that fails, there's
2970 no point in going further. */
2971 constraint = constraints[i];
2972 if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
2973 &allows_mem, &allows_reg, &is_inout))
2974 return;
2975
2976 if (! allows_reg
2977 && (allows_mem
2978 || is_inout
2979 || (DECL_P (val)
2980 && REG_P (DECL_RTL (val))
2981 && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type))))
2982 mark_addressable (val);
2983 }
2984
2985 for (i = 0; i < ninputs; ++i)
2986 {
2987 bool allows_reg, allows_mem;
2988 const char *constraint;
2989
2990 constraint = constraints[i + noutputs];
2991 if (! parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
2992 constraints.address (),
2993 &allows_mem, &allows_reg))
2994 return;
2995
2996 if (! allows_reg && allows_mem)
2997 mark_addressable (input_tvec[i]);
2998 }
2999
3000 /* Second pass evaluates arguments. */
3001
3002 /* Make sure stack is consistent for asm goto. */
3003 if (nlabels > 0)
3004 do_pending_stack_adjust ();
3005 int old_generating_concat_p = generating_concat_p;
3006
3007 /* Vector of RTX's of evaluated output operands. */
3008 auto_vec<rtx, MAX_RECOG_OPERANDS> output_rvec;
3009 auto_vec<int, MAX_RECOG_OPERANDS> inout_opnum;
3010 rtx_insn *after_rtl_seq = NULL, *after_rtl_end = NULL;
3011
3012 output_rvec.safe_grow (noutputs);
3013
3014 for (i = 0; i < noutputs; ++i)
3015 {
3016 tree val = output_tvec[i];
3017 tree type = TREE_TYPE (val);
3018 bool is_inout, allows_reg, allows_mem, ok;
3019 rtx op;
3020
3021 ok = parse_output_constraint (&constraints[i], i, ninputs,
3022 noutputs, &allows_mem, &allows_reg,
3023 &is_inout);
3024 gcc_assert (ok);
3025
3026 /* If an output operand is not a decl or indirect ref and our constraint
3027 allows a register, make a temporary to act as an intermediate.
3028 Make the asm insn write into that, then we will copy it to
3029 the real output operand. Likewise for promoted variables. */
3030
3031 generating_concat_p = 0;
3032
3033 if ((TREE_CODE (val) == INDIRECT_REF
3034 && allows_mem)
3035 || (DECL_P (val)
3036 && (allows_mem || REG_P (DECL_RTL (val)))
3037 && ! (REG_P (DECL_RTL (val))
3038 && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))
3039 || ! allows_reg
3040 || is_inout)
3041 {
3042 op = expand_expr (val, NULL_RTX, VOIDmode,
3043 !allows_reg ? EXPAND_MEMORY : EXPAND_WRITE);
3044 if (MEM_P (op))
3045 op = validize_mem (op);
3046
3047 if (! allows_reg && !MEM_P (op))
3048 error ("output number %d not directly addressable", i);
3049 if ((! allows_mem && MEM_P (op))
3050 || GET_CODE (op) == CONCAT)
3051 {
3052 rtx old_op = op;
3053 op = gen_reg_rtx (GET_MODE (op));
3054
3055 generating_concat_p = old_generating_concat_p;
3056
3057 if (is_inout)
3058 emit_move_insn (op, old_op);
3059
3060 push_to_sequence2 (after_rtl_seq, after_rtl_end);
3061 emit_move_insn (old_op, op);
3062 after_rtl_seq = get_insns ();
3063 after_rtl_end = get_last_insn ();
3064 end_sequence ();
3065 }
3066 }
3067 else
3068 {
3069 op = assign_temp (type, 0, 1);
3070 op = validize_mem (op);
3071 if (!MEM_P (op) && TREE_CODE (val) == SSA_NAME)
3072 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val), op);
3073
3074 generating_concat_p = old_generating_concat_p;
3075
3076 push_to_sequence2 (after_rtl_seq, after_rtl_end);
3077 expand_assignment (val, make_tree (type, op), false);
3078 after_rtl_seq = get_insns ();
3079 after_rtl_end = get_last_insn ();
3080 end_sequence ();
3081 }
3082 output_rvec[i] = op;
3083
3084 if (is_inout)
3085 inout_opnum.safe_push (i);
3086 }
3087
3088 auto_vec<rtx, MAX_RECOG_OPERANDS> input_rvec;
3089 auto_vec<machine_mode, MAX_RECOG_OPERANDS> input_mode;
3090
3091 input_rvec.safe_grow (ninputs);
3092 input_mode.safe_grow (ninputs);
3093
3094 generating_concat_p = 0;
3095
3096 for (i = 0; i < ninputs; ++i)
3097 {
3098 tree val = input_tvec[i];
3099 tree type = TREE_TYPE (val);
3100 bool allows_reg, allows_mem, ok;
3101 const char *constraint;
3102 rtx op;
3103
3104 constraint = constraints[i + noutputs];
3105 ok = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
3106 constraints.address (),
3107 &allows_mem, &allows_reg);
3108 gcc_assert (ok);
3109
3110 /* EXPAND_INITIALIZER will not generate code for valid initializer
3111 constants, but will still generate code for other types of operand.
3112 This is the behavior we want for constant constraints. */
3113 op = expand_expr (val, NULL_RTX, VOIDmode,
3114 allows_reg ? EXPAND_NORMAL
3115 : allows_mem ? EXPAND_MEMORY
3116 : EXPAND_INITIALIZER);
3117
3118 /* Never pass a CONCAT to an ASM. */
3119 if (GET_CODE (op) == CONCAT)
3120 op = force_reg (GET_MODE (op), op);
3121 else if (MEM_P (op))
3122 op = validize_mem (op);
3123
3124 if (asm_operand_ok (op, constraint, NULL) <= 0)
3125 {
3126 if (allows_reg && TYPE_MODE (type) != BLKmode)
3127 op = force_reg (TYPE_MODE (type), op);
3128 else if (!allows_mem)
3129 warning (0, "asm operand %d probably doesn%'t match constraints",
3130 i + noutputs);
3131 else if (MEM_P (op))
3132 {
3133 /* We won't recognize either volatile memory or memory
3134 with a queued address as available a memory_operand
3135 at this point. Ignore it: clearly this *is* a memory. */
3136 }
3137 else
3138 gcc_unreachable ();
3139 }
3140 input_rvec[i] = op;
3141 input_mode[i] = TYPE_MODE (type);
3142 }
3143
3144 /* For in-out operands, copy output rtx to input rtx. */
3145 unsigned ninout = inout_opnum.length();
3146 for (i = 0; i < ninout; i++)
3147 {
3148 int j = inout_opnum[i];
3149 rtx o = output_rvec[j];
3150
3151 input_rvec.safe_push (o);
3152 input_mode.safe_push (GET_MODE (o));
3153
3154 char buffer[16];
3155 sprintf (buffer, "%d", j);
3156 constraints.safe_push (ggc_strdup (buffer));
3157 }
3158 ninputs += ninout;
3159
3160 /* Sometimes we wish to automatically clobber registers across an asm.
3161 Case in point is when the i386 backend moved from cc0 to a hard reg --
3162 maintaining source-level compatibility means automatically clobbering
3163 the flags register. */
3164 rtx_insn *after_md_seq = NULL;
3165 if (targetm.md_asm_adjust)
3166 after_md_seq = targetm.md_asm_adjust (output_rvec, input_rvec,
3167 constraints, clobber_rvec,
3168 clobbered_regs);
3169
3170 /* Do not allow the hook to change the output and input count,
3171 lest it mess up the operand numbering. */
3172 gcc_assert (output_rvec.length() == noutputs);
3173 gcc_assert (input_rvec.length() == ninputs);
3174 gcc_assert (constraints.length() == noutputs + ninputs);
3175
3176 /* But it certainly can adjust the clobbers. */
3177 nclobbers = clobber_rvec.length();
3178
3179 /* Third pass checks for easy conflicts. */
3180 /* ??? Why are we doing this on trees instead of rtx. */
3181
3182 bool clobber_conflict_found = 0;
3183 for (i = 0; i < noutputs; ++i)
3184 if (tree_conflicts_with_clobbers_p (output_tvec[i], &clobbered_regs))
3185 clobber_conflict_found = 1;
3186 for (i = 0; i < ninputs - ninout; ++i)
3187 if (tree_conflicts_with_clobbers_p (input_tvec[i], &clobbered_regs))
3188 clobber_conflict_found = 1;
3189
3190 /* Make vectors for the expression-rtx, constraint strings,
3191 and named operands. */
3192
3193 rtvec argvec = rtvec_alloc (ninputs);
3194 rtvec constraintvec = rtvec_alloc (ninputs);
3195 rtvec labelvec = rtvec_alloc (nlabels);
3196
3197 rtx body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
3198 : GET_MODE (output_rvec[0])),
3199 ggc_strdup (gimple_asm_string (stmt)),
3200 "", 0, argvec, constraintvec,
3201 labelvec, locus);
3202 MEM_VOLATILE_P (body) = gimple_asm_volatile_p (stmt);
3203
3204 for (i = 0; i < ninputs; ++i)
3205 {
3206 ASM_OPERANDS_INPUT (body, i) = input_rvec[i];
3207 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)
3208 = gen_rtx_ASM_INPUT_loc (input_mode[i],
3209 constraints[i + noutputs],
3210 locus);
3211 }
3212
3213 /* Copy labels to the vector. */
3214 rtx_code_label *fallthru_label = NULL;
3215 if (nlabels > 0)
3216 {
3217 basic_block fallthru_bb = NULL;
3218 edge fallthru = find_fallthru_edge (gimple_bb (stmt)->succs);
3219 if (fallthru)
3220 fallthru_bb = fallthru->dest;
3221
3222 for (i = 0; i < nlabels; ++i)
3223 {
3224 tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
3225 rtx_insn *r;
3226 /* If asm goto has any labels in the fallthru basic block, use
3227 a label that we emit immediately after the asm goto. Expansion
3228 may insert further instructions into the same basic block after
3229 asm goto and if we don't do this, insertion of instructions on
3230 the fallthru edge might misbehave. See PR58670. */
3231 if (fallthru_bb && label_to_block_fn (cfun, label) == fallthru_bb)
3232 {
3233 if (fallthru_label == NULL_RTX)
3234 fallthru_label = gen_label_rtx ();
3235 r = fallthru_label;
3236 }
3237 else
3238 r = label_rtx (label);
3239 ASM_OPERANDS_LABEL (body, i) = gen_rtx_LABEL_REF (Pmode, r);
3240 }
3241 }
3242
3243 /* Now, for each output, construct an rtx
3244 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3245 ARGVEC CONSTRAINTS OPNAMES))
3246 If there is more than one, put them inside a PARALLEL. */
3247
3248 if (nlabels > 0 && nclobbers == 0)
3249 {
3250 gcc_assert (noutputs == 0);
3251 emit_jump_insn (body);
3252 }
3253 else if (noutputs == 0 && nclobbers == 0)
3254 {
3255 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3256 emit_insn (body);
3257 }
3258 else if (noutputs == 1 && nclobbers == 0)
3259 {
3260 ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = constraints[0];
3261 emit_insn (gen_rtx_SET (output_rvec[0], body));
3262 }
3263 else
3264 {
3265 rtx obody = body;
3266 int num = noutputs;
3267
3268 if (num == 0)
3269 num = 1;
3270
3271 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num + nclobbers));
3272
3273 /* For each output operand, store a SET. */
3274 for (i = 0; i < noutputs; ++i)
3275 {
3276 rtx src, o = output_rvec[i];
3277 if (i == 0)
3278 {
3279 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody) = constraints[0];
3280 src = obody;
3281 }
3282 else
3283 {
3284 src = gen_rtx_ASM_OPERANDS (GET_MODE (o),
3285 ASM_OPERANDS_TEMPLATE (obody),
3286 constraints[i], i, argvec,
3287 constraintvec, labelvec, locus);
3288 MEM_VOLATILE_P (src) = gimple_asm_volatile_p (stmt);
3289 }
3290 XVECEXP (body, 0, i) = gen_rtx_SET (o, src);
3291 }
3292
3293 /* If there are no outputs (but there are some clobbers)
3294 store the bare ASM_OPERANDS into the PARALLEL. */
3295 if (i == 0)
3296 XVECEXP (body, 0, i++) = obody;
3297
3298 /* Store (clobber REG) for each clobbered register specified. */
3299 for (unsigned j = 0; j < nclobbers; ++j)
3300 {
3301 rtx clobbered_reg = clobber_rvec[j];
3302
3303 /* Do sanity check for overlap between clobbers and respectively
3304 input and outputs that hasn't been handled. Such overlap
3305 should have been detected and reported above. */
3306 if (!clobber_conflict_found && REG_P (clobbered_reg))
3307 {
3308 /* We test the old body (obody) contents to avoid
3309 tripping over the under-construction body. */
3310 for (unsigned k = 0; k < noutputs; ++k)
3311 if (reg_overlap_mentioned_p (clobbered_reg, output_rvec[k]))
3312 internal_error ("asm clobber conflict with output operand");
3313
3314 for (unsigned k = 0; k < ninputs - ninout; ++k)
3315 if (reg_overlap_mentioned_p (clobbered_reg, input_rvec[k]))
3316 internal_error ("asm clobber conflict with input operand");
3317 }
3318
3319 XVECEXP (body, 0, i++) = gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
3320 }
3321
3322 if (nlabels > 0)
3323 emit_jump_insn (body);
3324 else
3325 emit_insn (body);
3326 }
3327
3328 generating_concat_p = old_generating_concat_p;
3329
3330 if (fallthru_label)
3331 emit_label (fallthru_label);
3332
3333 if (after_md_seq)
3334 emit_insn (after_md_seq);
3335 if (after_rtl_seq)
3336 emit_insn (after_rtl_seq);
3337
3338 free_temp_slots ();
3339 crtl->has_asm_statement = 1;
3340}
3341
3342/* Emit code to jump to the address
3343 specified by the pointer expression EXP. */
3344
3345static void
3346expand_computed_goto (tree exp)
3347{
3348 rtx x = expand_normal (exp);
3349
3350 do_pending_stack_adjust ();
3351 emit_indirect_jump (x);
3352}
3353
3354/* Generate RTL code for a `goto' statement with target label LABEL.
3355 LABEL should be a LABEL_DECL tree node that was or will later be
3356 defined with `expand_label'. */
3357
3358static void
3359expand_goto (tree label)
3360{
3361 if (flag_checking)
3362 {
3363 /* Check for a nonlocal goto to a containing function. Should have
3364 gotten translated to __builtin_nonlocal_goto. */
3365 tree context = decl_function_context (label);
3366 gcc_assert (!context || context == current_function_decl);
3367 }
3368
3369 emit_jump (jump_target_rtx (label));
3370}
3371
3372/* Output a return with no value. */
3373
3374static void
3375expand_null_return_1 (void)
3376{
3377 clear_pending_stack_adjust ();
3378 do_pending_stack_adjust ();
3379 emit_jump (return_label);
3380}
3381
3382/* Generate RTL to return from the current function, with no value.
3383 (That is, we do not do anything about returning any value.) */
3384
3385void
3386expand_null_return (void)
3387{
3388 /* If this function was declared to return a value, but we
3389 didn't, clobber the return registers so that they are not
3390 propagated live to the rest of the function. */
3391 clobber_return_register ();
3392
3393 expand_null_return_1 ();
3394}
3395
3396/* Generate RTL to return from the current function, with value VAL. */
3397
3398static void
3399expand_value_return (rtx val)
3400{
3401 /* Copy the value to the return location unless it's already there. */
3402
3403 tree decl = DECL_RESULT (current_function_decl);
3404 rtx return_reg = DECL_RTL (decl);
3405 if (return_reg != val)
3406 {
3407 tree funtype = TREE_TYPE (current_function_decl);
3408 tree type = TREE_TYPE (decl);
3409 int unsignedp = TYPE_UNSIGNED (type);
3410 machine_mode old_mode = DECL_MODE (decl);
3411 machine_mode mode;
3412 if (DECL_BY_REFERENCE (decl))
3413 mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 2);
3414 else
3415 mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 1);
3416
3417 if (mode != old_mode)
3418 val = convert_modes (mode, old_mode, val, unsignedp);
3419
3420 if (GET_CODE (return_reg) == PARALLEL)
3421 emit_group_load (return_reg, val, type, int_size_in_bytes (type));
3422 else
3423 emit_move_insn (return_reg, val);
3424 }
3425
3426 expand_null_return_1 ();
3427}
3428
3429/* Generate RTL to evaluate the expression RETVAL and return it
3430 from the current function. */
3431
3432static void
3433expand_return (tree retval, tree bounds)
3434{
3435 rtx result_rtl;
3436 rtx val = 0;
3437 tree retval_rhs;
3438 rtx bounds_rtl;
3439
3440 /* If function wants no value, give it none. */
3441 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
3442 {
3443 expand_normal (retval);
3444 expand_null_return ();
3445 return;
3446 }
3447
3448 if (retval == error_mark_node)
3449 {
3450 /* Treat this like a return of no value from a function that
3451 returns a value. */
3452 expand_null_return ();
3453 return;
3454 }
3455 else if ((TREE_CODE (retval) == MODIFY_EXPR
3456 || TREE_CODE (retval) == INIT_EXPR)
3457 && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
3458 retval_rhs = TREE_OPERAND (retval, 1);
3459 else
3460 retval_rhs = retval;
3461
3462 result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
3463
3464 /* Put returned bounds to the right place. */
3465 bounds_rtl = DECL_BOUNDS_RTL (DECL_RESULT (current_function_decl));
3466 if (bounds_rtl)
3467 {
3468 rtx addr = NULL;
3469 rtx bnd = NULL;
3470
3471 if (bounds && bounds != error_mark_node)
3472 {
3473 bnd = expand_normal (bounds);
3474 targetm.calls.store_returned_bounds (bounds_rtl, bnd);
3475 }
3476 else if (REG_P (bounds_rtl))
3477 {
3478 if (bounds)
3479 bnd = chkp_expand_zero_bounds ();
3480 else
3481 {
3482 addr = expand_normal (build_fold_addr_expr (retval_rhs));
3483 addr = gen_rtx_MEM (Pmode, addr);
3484 bnd = targetm.calls.load_bounds_for_arg (addr, NULL, NULL);
3485 }
3486
3487 targetm.calls.store_returned_bounds (bounds_rtl, bnd);
3488 }
3489 else
3490 {
3491 int n;
3492
3493 gcc_assert (GET_CODE (bounds_rtl) == PARALLEL);
3494
3495 if (bounds)
3496 bnd = chkp_expand_zero_bounds ();
3497 else
3498 {
3499 addr = expand_normal (build_fold_addr_expr (retval_rhs));
3500 addr = gen_rtx_MEM (Pmode, addr);
3501 }
3502
3503 for (n = 0; n < XVECLEN (bounds_rtl, 0); n++)
3504 {
3505 rtx slot = XEXP (XVECEXP (bounds_rtl, 0, n), 0);
3506 if (!bounds)
3507 {
3508 rtx offs = XEXP (XVECEXP (bounds_rtl, 0, n), 1);
3509 rtx from = adjust_address (addr, Pmode, INTVAL (offs));
3510 bnd = targetm.calls.load_bounds_for_arg (from, NULL, NULL);
3511 }
3512 targetm.calls.store_returned_bounds (slot, bnd);
3513 }
3514 }
3515 }
3516 else if (chkp_function_instrumented_p (current_function_decl)
3517 && !BOUNDED_P (retval_rhs)
3518 && chkp_type_has_pointer (TREE_TYPE (retval_rhs))
3519 && TREE_CODE (retval_rhs) != RESULT_DECL)
3520 {
3521 rtx addr = expand_normal (build_fold_addr_expr (retval_rhs));
3522 addr = gen_rtx_MEM (Pmode, addr);
3523
3524 gcc_assert (MEM_P (result_rtl));
3525
3526 chkp_copy_bounds_for_stack_parm (result_rtl, addr, TREE_TYPE (retval_rhs));
3527 }
3528
3529 /* If we are returning the RESULT_DECL, then the value has already
3530 been stored into it, so we don't have to do anything special. */
3531 if (TREE_CODE (retval_rhs) == RESULT_DECL)
3532 expand_value_return (result_rtl);
3533
3534 /* If the result is an aggregate that is being returned in one (or more)
3535 registers, load the registers here. */
3536
3537 else if (retval_rhs != 0
3538 && TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
3539 && REG_P (result_rtl))
3540 {
3541 val = copy_blkmode_to_reg (GET_MODE (result_rtl), retval_rhs);
3542 if (val)
3543 {
3544 /* Use the mode of the result value on the return register. */
3545 PUT_MODE (result_rtl, GET_MODE (val));
3546 expand_value_return (val);
3547 }
3548 else
3549 expand_null_return ();
3550 }
3551 else if (retval_rhs != 0
3552 && !VOID_TYPE_P (TREE_TYPE (retval_rhs))
3553 && (REG_P (result_rtl)
3554 || (GET_CODE (result_rtl) == PARALLEL)))
3555 {
3556 /* Compute the return value into a temporary (usually a pseudo reg). */
3557 val
3558 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl)), 0, 1);
3559 val = expand_expr (retval_rhs, val, GET_MODE (val), EXPAND_NORMAL);
3560 val = force_not_mem (val);
3561 expand_value_return (val);
3562 }
3563 else
3564 {
3565 /* No hard reg used; calculate value into hard return reg. */
3566 expand_expr (retval, const0_rtx, VOIDmode, EXPAND_NORMAL);
3567 expand_value_return (result_rtl);
3568 }
3569}
3570
3571/* A subroutine of expand_gimple_stmt, expanding one gimple statement
3572 STMT that doesn't require special handling for outgoing edges. That
3573 is no tailcalls and no GIMPLE_COND. */
3574
3575static void
3576expand_gimple_stmt_1 (gimple *stmt)
3577{
3578 tree op0;
3579
3580 set_curr_insn_location (gimple_location (stmt));
3581
3582 switch (gimple_code (stmt))
3583 {
3584 case GIMPLE_GOTO:
3585 op0 = gimple_goto_dest (stmt);
3586 if (TREE_CODE (op0) == LABEL_DECL)
3587 expand_goto (op0);
3588 else
3589 expand_computed_goto (op0);
3590 break;
3591 case GIMPLE_LABEL:
3592 expand_label (gimple_label_label (as_a <glabel *> (stmt)));
3593 break;
3594 case GIMPLE_NOP:
3595 case GIMPLE_PREDICT:
3596 break;
3597 case GIMPLE_SWITCH:
3598 {
3599 gswitch *swtch = as_a <gswitch *> (stmt);
3600 if (gimple_switch_num_labels (swtch) == 1)
3601 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch)));
3602 else
3603 expand_case (swtch);
3604 }
3605 break;
3606 case GIMPLE_ASM:
3607 expand_asm_stmt (as_a <gasm *> (stmt));
3608 break;
3609 case GIMPLE_CALL:
3610 expand_call_stmt (as_a <gcall *> (stmt));
3611 break;
3612
3613 case GIMPLE_RETURN:
3614 {
3615 tree bnd = gimple_return_retbnd (as_a <greturn *> (stmt));
3616 op0 = gimple_return_retval (as_a <greturn *> (stmt));
3617
3618 if (op0 && op0 != error_mark_node)
3619 {
3620 tree result = DECL_RESULT (current_function_decl);
3621
3622 /* Mark we have return statement with missing bounds. */
3623 if (!bnd
3624 && chkp_function_instrumented_p (cfun->decl)
3625 && !DECL_P (op0))
3626 bnd = error_mark_node;
3627
3628 /* If we are not returning the current function's RESULT_DECL,
3629 build an assignment to it. */
3630 if (op0 != result)
3631 {
3632 /* I believe that a function's RESULT_DECL is unique. */
3633 gcc_assert (TREE_CODE (op0) != RESULT_DECL);
3634
3635 /* ??? We'd like to use simply expand_assignment here,
3636 but this fails if the value is of BLKmode but the return
3637 decl is a register. expand_return has special handling
3638 for this combination, which eventually should move
3639 to common code. See comments there. Until then, let's
3640 build a modify expression :-/ */
3641 op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
3642 result, op0);
3643 }
3644 }
3645
3646 if (!op0)
3647 expand_null_return ();
3648 else
3649 expand_return (op0, bnd);
3650 }
3651 break;
3652
3653 case GIMPLE_ASSIGN:
3654 {
3655 gassign *assign_stmt = as_a <gassign *> (stmt);
3656 tree lhs = gimple_assign_lhs (assign_stmt);
3657
3658 /* Tree expand used to fiddle with |= and &= of two bitfield
3659 COMPONENT_REFs here. This can't happen with gimple, the LHS
3660 of binary assigns must be a gimple reg. */
3661
3662 if (TREE_CODE (lhs) != SSA_NAME
3663 || get_gimple_rhs_class (gimple_expr_code (stmt))
3664 == GIMPLE_SINGLE_RHS)
3665 {
3666 tree rhs = gimple_assign_rhs1 (assign_stmt);
3667 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
3668 == GIMPLE_SINGLE_RHS);
3669 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs)
3670 /* Do not put locations on possibly shared trees. */
3671 && !is_gimple_min_invariant (rhs))
3672 SET_EXPR_LOCATION (rhs, gimple_location (stmt));
3673 if (TREE_CLOBBER_P (rhs))
3674 /* This is a clobber to mark the going out of scope for
3675 this LHS. */
3676 ;
3677 else
3678 expand_assignment (lhs, rhs,
3679 gimple_assign_nontemporal_move_p (
3680 assign_stmt));
3681 }
3682 else
3683 {
3684 rtx target, temp;
3685 bool nontemporal = gimple_assign_nontemporal_move_p (assign_stmt);
3686 struct separate_ops ops;
3687 bool promoted = false;
3688
3689 target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
3690 if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
3691 promoted = true;
3692
3693 ops.code = gimple_assign_rhs_code (assign_stmt);
3694 ops.type = TREE_TYPE (lhs);
3695 switch (get_gimple_rhs_class (ops.code))
3696 {
3697 case GIMPLE_TERNARY_RHS:
3698 ops.op2 = gimple_assign_rhs3 (assign_stmt);
3699 /* Fallthru */
3700 case GIMPLE_BINARY_RHS:
3701 ops.op1 = gimple_assign_rhs2 (assign_stmt);
3702 /* Fallthru */
3703 case GIMPLE_UNARY_RHS:
3704 ops.op0 = gimple_assign_rhs1 (assign_stmt);
3705 break;
3706 default:
3707 gcc_unreachable ();
3708 }
3709 ops.location = gimple_location (stmt);
3710
3711 /* If we want to use a nontemporal store, force the value to
3712 register first. If we store into a promoted register,
3713 don't directly expand to target. */
3714 temp = nontemporal || promoted ? NULL_RTX : target;
3715 temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
3716 EXPAND_NORMAL);
3717
3718 if (temp == target)
3719 ;
3720 else if (promoted)
3721 {
3722 int unsignedp = SUBREG_PROMOTED_SIGN (target);
3723 /* If TEMP is a VOIDmode constant, use convert_modes to make
3724 sure that we properly convert it. */
3725 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
3726 {
3727 temp = convert_modes (GET_MODE (target),
3728 TYPE_MODE (ops.type),
3729 temp, unsignedp);
3730 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
3731 GET_MODE (target), temp, unsignedp);
3732 }
3733
3734 convert_move (SUBREG_REG (target), temp, unsignedp);
3735 }
3736 else if (nontemporal && emit_storent_insn (target, temp))
3737 ;
3738 else
3739 {
3740 temp = force_operand (temp, target);
3741 if (temp != target)
3742 emit_move_insn (target, temp);
3743 }
3744 }
3745 }
3746 break;
3747
3748 default:
3749 gcc_unreachable ();
3750 }
3751}
3752
3753/* Expand one gimple statement STMT and return the last RTL instruction
3754 before any of the newly generated ones.
3755
3756 In addition to generating the necessary RTL instructions this also
3757 sets REG_EH_REGION notes if necessary and sets the current source
3758 location for diagnostics. */
3759
3760static rtx_insn *
3761expand_gimple_stmt (gimple *stmt)
3762{
3763 location_t saved_location = input_location;
3764 rtx_insn *last = get_last_insn ();
3765 int lp_nr;
3766
3767 gcc_assert (cfun);
3768
3769 /* We need to save and restore the current source location so that errors
3770 discovered during expansion are emitted with the right location. But
3771 it would be better if the diagnostic routines used the source location
3772 embedded in the tree nodes rather than globals. */
3773 if (gimple_has_location (stmt))
3774 input_location = gimple_location (stmt);
3775
3776 expand_gimple_stmt_1 (stmt);
3777
3778 /* Free any temporaries used to evaluate this statement. */
3779 free_temp_slots ();
3780
3781 input_location = saved_location;
3782
3783 /* Mark all insns that may trap. */
3784 lp_nr = lookup_stmt_eh_lp (stmt);
3785 if (lp_nr)
3786 {
3787 rtx_insn *insn;
3788 for (insn = next_real_insn (last); insn;
3789 insn = next_real_insn (insn))
3790 {
3791 if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
3792 /* If we want exceptions for non-call insns, any
3793 may_trap_p instruction may throw. */
3794 && GET_CODE (PATTERN (insn)) != CLOBBER
3795 && GET_CODE (PATTERN (insn)) != USE
3796 && insn_could_throw_p (insn))
3797 make_reg_eh_region_note (insn, 0, lp_nr);
3798 }
3799 }
3800
3801 return last;
3802}
3803
3804/* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3805 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3806 generated a tail call (something that might be denied by the ABI
3807 rules governing the call; see calls.c).
3808
3809 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3810 can still reach the rest of BB. The case here is __builtin_sqrt,
3811 where the NaN result goes through the external function (with a
3812 tailcall) and the normal result happens via a sqrt instruction. */
3813
3814static basic_block
3815expand_gimple_tailcall (basic_block bb, gcall *stmt, bool *can_fallthru)
3816{
3817 rtx_insn *last2, *last;
3818 edge e;
3819 edge_iterator ei;
3820 profile_probability probability;
3821
3822 last2 = last = expand_gimple_stmt (stmt);
3823
3824 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
3825 if (CALL_P (last) && SIBLING_CALL_P (last))
3826 goto found;
3827
3828 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
3829
3830 *can_fallthru = true;
3831 return NULL;
3832
3833 found:
3834 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3835 Any instructions emitted here are about to be deleted. */
3836 do_pending_stack_adjust ();
3837
3838 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3839 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3840 EH or abnormal edges, we shouldn't have created a tail call in
3841 the first place. So it seems to me we should just be removing
3842 all edges here, or redirecting the existing fallthru edge to
3843 the exit block. */
3844
3845 probability = profile_probability::never ();
3846
3847 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
3848 {
3849 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
3850 {
3851 if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
3852 e->dest->count -= e->count ();
3853 probability += e->probability;
3854 remove_edge (e);
3855 }
3856 else
3857 ei_next (&ei);
3858 }
3859
3860 /* This is somewhat ugly: the call_expr expander often emits instructions
3861 after the sibcall (to perform the function return). These confuse the
3862 find_many_sub_basic_blocks code, so we need to get rid of these. */
3863 last = NEXT_INSN (last);
3864 gcc_assert (BARRIER_P (last));
3865
3866 *can_fallthru = false;
3867 while (NEXT_INSN (last))
3868 {
3869 /* For instance an sqrt builtin expander expands if with
3870 sibcall in the then and label for `else`. */
3871 if (LABEL_P (NEXT_INSN (last)))
3872 {
3873 *can_fallthru = true;
3874 break;
3875 }
3876 delete_insn (NEXT_INSN (last));
3877 }
3878
3879 e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_ABNORMAL
3880 | EDGE_SIBCALL);
3881 e->probability = probability;
3882 BB_END (bb) = last;
3883 update_bb_for_insn (bb);
3884
3885 if (NEXT_INSN (last))
3886 {
3887 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
3888
3889 last = BB_END (bb);
3890 if (BARRIER_P (last))
3891 BB_END (bb) = PREV_INSN (last);
3892 }
3893
3894 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
3895
3896 return bb;
3897}
3898
3899/* Return the difference between the floor and the truncated result of
3900 a signed division by OP1 with remainder MOD. */
3901static rtx
3902floor_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
3903{
3904 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3905 return gen_rtx_IF_THEN_ELSE
3906 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
3907 gen_rtx_IF_THEN_ELSE
3908 (mode, gen_rtx_LT (BImode,
3909 gen_rtx_DIV (mode, op1, mod),
3910 const0_rtx),
3911 constm1_rtx, const0_rtx),
3912 const0_rtx);
3913}
3914
3915/* Return the difference between the ceil and the truncated result of
3916 a signed division by OP1 with remainder MOD. */
3917static rtx
3918ceil_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
3919{
3920 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3921 return gen_rtx_IF_THEN_ELSE
3922 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
3923 gen_rtx_IF_THEN_ELSE
3924 (mode, gen_rtx_GT (BImode,
3925 gen_rtx_DIV (mode, op1, mod),
3926 const0_rtx),
3927 const1_rtx, const0_rtx),
3928 const0_rtx);
3929}
3930
3931/* Return the difference between the ceil and the truncated result of
3932 an unsigned division by OP1 with remainder MOD. */
3933static rtx
3934ceil_udiv_adjust (machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
3935{
3936 /* (mod != 0 ? 1 : 0) */
3937 return gen_rtx_IF_THEN_ELSE
3938 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
3939 const1_rtx, const0_rtx);
3940}
3941
3942/* Return the difference between the rounded and the truncated result
3943 of a signed division by OP1 with remainder MOD. Halfway cases are
3944 rounded away from zero, rather than to the nearest even number. */
3945static rtx
3946round_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
3947{
3948 /* (abs (mod) >= abs (op1) - abs (mod)
3949 ? (op1 / mod > 0 ? 1 : -1)
3950 : 0) */
3951 return gen_rtx_IF_THEN_ELSE
3952 (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
3953 gen_rtx_MINUS (mode,
3954 gen_rtx_ABS (mode, op1),
3955 gen_rtx_ABS (mode, mod))),
3956 gen_rtx_IF_THEN_ELSE
3957 (mode, gen_rtx_GT (BImode,
3958 gen_rtx_DIV (mode, op1, mod),
3959 const0_rtx),
3960 const1_rtx, constm1_rtx),
3961 const0_rtx);
3962}
3963
3964/* Return the difference between the rounded and the truncated result
3965 of a unsigned division by OP1 with remainder MOD. Halfway cases
3966 are rounded away from zero, rather than to the nearest even
3967 number. */
3968static rtx
3969round_udiv_adjust (machine_mode mode, rtx mod, rtx op1)
3970{
3971 /* (mod >= op1 - mod ? 1 : 0) */
3972 return gen_rtx_IF_THEN_ELSE
3973 (mode, gen_rtx_GE (BImode, mod,
3974 gen_rtx_MINUS (mode, op1, mod)),
3975 const1_rtx, const0_rtx);
3976}
3977
3978/* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3979 any rtl. */
3980
3981static rtx
3982convert_debug_memory_address (scalar_int_mode mode, rtx x,
3983 addr_space_t as)
3984{
3985#ifndef POINTERS_EXTEND_UNSIGNED
3986 gcc_assert (mode == Pmode
3987 || mode == targetm.addr_space.address_mode (as));
3988 gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode);
3989#else
3990 rtx temp;
3991
3992 gcc_assert (targetm.addr_space.valid_pointer_mode (mode, as));
3993
3994 if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
3995 return x;
3996
3997 /* X must have some form of address mode already. */
3998 scalar_int_mode xmode = as_a <scalar_int_mode> (GET_MODE (x));
3999 if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (xmode))
4000 x = lowpart_subreg (mode, x, xmode);
4001 else if (POINTERS_EXTEND_UNSIGNED > 0)
4002 x = gen_rtx_ZERO_EXTEND (mode, x);
4003 else if (!POINTERS_EXTEND_UNSIGNED)
4004 x = gen_rtx_SIGN_EXTEND (mode, x);
4005 else
4006 {
4007 switch (GET_CODE (x))
4008 {
4009 case SUBREG:
4010 if ((SUBREG_PROMOTED_VAR_P (x)
4011 || (REG_P (SUBREG_REG (x)) && REG_POINTER (SUBREG_REG (x)))
4012 || (GET_CODE (SUBREG_REG (x)) == PLUS
4013 && REG_P (XEXP (SUBREG_REG (x), 0))
4014 && REG_POINTER (XEXP (SUBREG_REG (x), 0))
4015 && CONST_INT_P (XEXP (SUBREG_REG (x), 1))))
4016 && GET_MODE (SUBREG_REG (x)) == mode)
4017 return SUBREG_REG (x);
4018 break;
4019 case LABEL_REF:
4020 temp = gen_rtx_LABEL_REF (mode, label_ref_label (x));
4021 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
4022 return temp;
4023 case SYMBOL_REF:
4024 temp = shallow_copy_rtx (x);
4025 PUT_MODE (temp, mode);
4026 return temp;
4027 case CONST:
4028 temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
4029 if (temp)
4030 temp = gen_rtx_CONST (mode, temp);
4031 return temp;
4032 case PLUS:
4033 case MINUS:
4034 if (CONST_INT_P (XEXP (x, 1)))
4035 {
4036 temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
4037 if (temp)
4038 return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1));
4039 }
4040 break;
4041 default:
4042 break;
4043 }
4044 /* Don't know how to express ptr_extend as operation in debug info. */
4045 return NULL;
4046 }
4047#endif /* POINTERS_EXTEND_UNSIGNED */
4048
4049 return x;
4050}
4051
4052/* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4053 by avoid_deep_ter_for_debug. */
4054
4055static hash_map<tree, tree> *deep_ter_debug_map;
4056
4057/* Split too deep TER chains for debug stmts using debug temporaries. */
4058
4059static void
4060avoid_deep_ter_for_debug (gimple *stmt, int depth)
4061{
4062 use_operand_p use_p;
4063 ssa_op_iter iter;
4064 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
4065 {
4066 tree use = USE_FROM_PTR (use_p);
4067 if (TREE_CODE (use) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (use))
4068 continue;
4069 gimple *g = get_gimple_for_ssa_name (use);
4070 if (g == NULL)
4071 continue;
4072 if (depth > 6 && !stmt_ends_bb_p (g))
4073 {
4074 if (deep_ter_debug_map == NULL)
4075 deep_ter_debug_map = new hash_map<tree, tree>;
4076
4077 tree &vexpr = deep_ter_debug_map->get_or_insert (use);
4078 if (vexpr != NULL)
4079 continue;
4080 vexpr = make_node (DEBUG_EXPR_DECL);
4081 gimple *def_temp = gimple_build_debug_bind (vexpr, use, g);
4082 DECL_ARTIFICIAL (vexpr) = 1;
4083 TREE_TYPE (vexpr) = TREE_TYPE (use);
4084 SET_DECL_MODE (vexpr, TYPE_MODE (TREE_TYPE (use)));
4085 gimple_stmt_iterator gsi = gsi_for_stmt (g);
4086 gsi_insert_after (&gsi, def_temp, GSI_NEW_STMT);
4087 avoid_deep_ter_for_debug (def_temp, 0);
4088 }
4089 else
4090 avoid_deep_ter_for_debug (g, depth + 1);
4091 }
4092}
4093
4094/* Return an RTX equivalent to the value of the parameter DECL. */
4095
4096static rtx
4097expand_debug_parm_decl (tree decl)
4098{
4099 rtx incoming = DECL_INCOMING_RTL (decl);
4100
4101 if (incoming
4102 && GET_MODE (incoming) != BLKmode
4103 && ((REG_P (incoming) && HARD_REGISTER_P (incoming))
4104 || (MEM_P (incoming)
4105 && REG_P (XEXP (incoming, 0))
4106 && HARD_REGISTER_P (XEXP (incoming, 0)))))
4107 {
4108 rtx rtl = gen_rtx_ENTRY_VALUE (GET_MODE (incoming));
4109
4110#ifdef HAVE_window_save
4111 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4112 If the target machine has an explicit window save instruction, the
4113 actual entry value is the corresponding OUTGOING_REGNO instead. */
4114 if (REG_P (incoming)
4115 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
4116 incoming
4117 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
4118 OUTGOING_REGNO (REGNO (incoming)), 0);
4119 else if (MEM_P (incoming))
4120 {
4121 rtx reg = XEXP (incoming, 0);
4122 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
4123 {
4124 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
4125 incoming = replace_equiv_address_nv (incoming, reg);
4126 }
4127 else
4128 incoming = copy_rtx (incoming);
4129 }
4130#endif
4131
4132 ENTRY_VALUE_EXP (rtl) = incoming;
4133 return rtl;
4134 }
4135
4136 if (incoming
4137 && GET_MODE (incoming) != BLKmode
4138 && !TREE_ADDRESSABLE (decl)
4139 && MEM_P (incoming)
4140 && (XEXP (incoming, 0) == virtual_incoming_args_rtx
4141 || (GET_CODE (XEXP (incoming, 0)) == PLUS
4142 && XEXP (XEXP (incoming, 0), 0) == virtual_incoming_args_rtx
4143 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
4144 return copy_rtx (incoming);
4145
4146 return NULL_RTX;
4147}
4148
4149/* Return an RTX equivalent to the value of the tree expression EXP. */
4150
4151static rtx
4152expand_debug_expr (tree exp)
4153{
4154 rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
4155 machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
4156 machine_mode inner_mode = VOIDmode;
4157 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
4158 addr_space_t as;
4159 scalar_int_mode op0_mode, op1_mode, addr_mode;
4160
4161 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
4162 {
4163 case tcc_expression:
4164 switch (TREE_CODE (exp))
4165 {
4166 case COND_EXPR:
4167 case DOT_PROD_EXPR:
4168 case SAD_EXPR:
4169 case WIDEN_MULT_PLUS_EXPR:
4170 case WIDEN_MULT_MINUS_EXPR:
4171 case FMA_EXPR:
4172 goto ternary;
4173
4174 case TRUTH_ANDIF_EXPR:
4175 case TRUTH_ORIF_EXPR:
4176 case TRUTH_AND_EXPR:
4177 case TRUTH_OR_EXPR:
4178 case TRUTH_XOR_EXPR:
4179 goto binary;
4180
4181 case TRUTH_NOT_EXPR:
4182 goto unary;
4183
4184 default:
4185 break;
4186 }
4187 break;
4188
4189 ternary:
4190 op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
4191 if (!op2)
4192 return NULL_RTX;
4193 /* Fall through. */
4194
4195 binary:
4196 case tcc_binary:
4197 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
4198 if (!op1)
4199 return NULL_RTX;
4200 switch (TREE_CODE (exp))
4201 {
4202 case LSHIFT_EXPR:
4203 case RSHIFT_EXPR:
4204 case LROTATE_EXPR:
4205 case RROTATE_EXPR:
4206 case WIDEN_LSHIFT_EXPR:
4207 /* Ensure second operand isn't wider than the first one. */
4208 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
4209 if (is_a <scalar_int_mode> (inner_mode, &op1_mode)
4210 && (GET_MODE_UNIT_PRECISION (mode)
4211 < GET_MODE_PRECISION (op1_mode)))
4212 op1 = lowpart_subreg (GET_MODE_INNER (mode), op1, op1_mode);
4213 break;
4214 default:
4215 break;
4216 }
4217 /* Fall through. */
4218
4219 unary:
4220 case tcc_unary:
4221 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4222 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
4223 if (!op0)
4224 return NULL_RTX;
4225 break;
4226
4227 case tcc_comparison:
4228 unsignedp = TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
4229 goto binary;
4230
4231 case tcc_type:
4232 case tcc_statement:
4233 gcc_unreachable ();
4234
4235 case tcc_constant:
4236 case tcc_exceptional:
4237 case tcc_declaration:
4238 case tcc_reference:
4239 case tcc_vl_exp:
4240 break;
4241 }
4242
4243 switch (TREE_CODE (exp))
4244 {
4245 case STRING_CST:
4246 if (!lookup_constant_def (exp))
4247 {
4248 if (strlen (TREE_STRING_POINTER (exp)) + 1
4249 != (size_t) TREE_STRING_LENGTH (exp))
4250 return NULL_RTX;
4251 op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
4252 op0 = gen_rtx_MEM (BLKmode, op0);
4253 set_mem_attributes (op0, exp, 0);
4254 return op0;
4255 }
4256 /* Fall through. */
4257
4258 case INTEGER_CST:
4259 case REAL_CST:
4260 case FIXED_CST:
4261 op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
4262 return op0;
4263
4264 case COMPLEX_CST:
4265 gcc_assert (COMPLEX_MODE_P (mode));
4266 op0 = expand_debug_expr (TREE_REALPART (exp));
4267 op1 = expand_debug_expr (TREE_IMAGPART (exp));
4268 return gen_rtx_CONCAT (mode, op0, op1);
4269
4270 case DEBUG_EXPR_DECL:
4271 op0 = DECL_RTL_IF_SET (exp);
4272
4273 if (op0)
4274 return op0;
4275
4276 op0 = gen_rtx_DEBUG_EXPR (mode);
4277 DEBUG_EXPR_TREE_DECL (op0) = exp;
4278 SET_DECL_RTL (exp, op0);
4279
4280 return op0;
4281
4282 case VAR_DECL:
4283 case PARM_DECL:
4284 case FUNCTION_DECL:
4285 case LABEL_DECL:
4286 case CONST_DECL:
4287 case RESULT_DECL:
4288 op0 = DECL_RTL_IF_SET (exp);
4289
4290 /* This decl was probably optimized away. */
4291 if (!op0)
4292 {
4293 if (!VAR_P (exp)
4294 || DECL_EXTERNAL (exp)
4295 || !TREE_STATIC (exp)
4296 || !DECL_NAME (exp)
4297 || DECL_HARD_REGISTER (exp)
4298 || DECL_IN_CONSTANT_POOL (exp)
4299 || mode == VOIDmode)
4300 return NULL;
4301
4302 op0 = make_decl_rtl_for_debug (exp);
4303 if (!MEM_P (op0)
4304 || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
4305 || SYMBOL_REF_DECL (