Branch data Line data Source code
1 : : /* A pass for lowering trees to RTL.
2 : : Copyright (C) 2004-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
6 : : GCC is free software; you can redistribute it and/or modify
7 : : it under the terms of the GNU General Public License as published by
8 : : the Free Software Foundation; either version 3, or (at your option)
9 : : any later version.
10 : :
11 : : GCC is distributed in the hope that it will be useful,
12 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : GNU General Public License for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
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 "tree-inline.h"
65 : : #include "value-prof.h"
66 : : #include "tree-ssa-live.h"
67 : : #include "tree-outof-ssa.h"
68 : : #include "cfgloop.h"
69 : : #include "insn-attr.h" /* For INSN_SCHEDULING. */
70 : : #include "stringpool.h"
71 : : #include "attribs.h"
72 : : #include "asan.h"
73 : : #include "tree-ssa-address.h"
74 : : #include "output.h"
75 : : #include "builtins.h"
76 : : #include "opts.h"
77 : :
78 : : /* Some systems use __main in a way incompatible with its use in gcc, in these
79 : : cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80 : : give the same symbol without quotes for an alternative entry point. You
81 : : must define both, or neither. */
82 : : #ifndef NAME__MAIN
83 : : #define NAME__MAIN "__main"
84 : : #endif
85 : :
86 : : /* This variable holds information helping the rewriting of SSA trees
87 : : into RTL. */
88 : : struct ssaexpand SA;
89 : :
90 : : /* This variable holds the currently expanded gimple statement for purposes
91 : : of comminucating the profile info to the builtin expanders. */
92 : : gimple *currently_expanding_gimple_stmt;
93 : :
94 : : static rtx expand_debug_expr (tree);
95 : :
96 : : static bool defer_stack_allocation (tree, bool);
97 : :
98 : : static void record_alignment_for_reg_var (unsigned int);
99 : :
100 : : /* Return an expression tree corresponding to the RHS of GIMPLE
101 : : statement STMT. */
102 : :
103 : : tree
104 : 2763658 : gimple_assign_rhs_to_tree (gimple *stmt)
105 : : {
106 : 2763658 : tree t;
107 : 2763658 : switch (gimple_assign_rhs_class (stmt))
108 : : {
109 : 585 : case GIMPLE_TERNARY_RHS:
110 : 585 : t = build3 (gimple_assign_rhs_code (stmt),
111 : 585 : TREE_TYPE (gimple_assign_lhs (stmt)),
112 : : gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt),
113 : : gimple_assign_rhs3 (stmt));
114 : 585 : break;
115 : 959780 : case GIMPLE_BINARY_RHS:
116 : 959780 : t = build2 (gimple_assign_rhs_code (stmt),
117 : 959780 : TREE_TYPE (gimple_assign_lhs (stmt)),
118 : : gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt));
119 : 959780 : break;
120 : 313544 : case GIMPLE_UNARY_RHS:
121 : 313544 : t = build1 (gimple_assign_rhs_code (stmt),
122 : 313544 : TREE_TYPE (gimple_assign_lhs (stmt)),
123 : : gimple_assign_rhs1 (stmt));
124 : 313544 : break;
125 : 1489749 : case GIMPLE_SINGLE_RHS:
126 : 1489749 : {
127 : 1489749 : t = gimple_assign_rhs1 (stmt);
128 : : /* Avoid modifying this tree in place below. */
129 : 2912719 : if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
130 : 1385238 : && gimple_location (stmt) != EXPR_LOCATION (t))
131 : 1630046 : || (gimple_block (stmt) && currently_expanding_to_rtl
132 : 41427 : && EXPR_P (t)))
133 : 1310392 : t = copy_node (t);
134 : : break;
135 : : }
136 : 0 : default:
137 : 0 : gcc_unreachable ();
138 : : }
139 : :
140 : 2763658 : if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
141 : 2586699 : SET_EXPR_LOCATION (t, gimple_location (stmt));
142 : :
143 : 2763658 : return t;
144 : : }
145 : :
146 : :
147 : : #ifndef STACK_ALIGNMENT_NEEDED
148 : : #define STACK_ALIGNMENT_NEEDED 1
149 : : #endif
150 : :
151 : : #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
152 : :
153 : : /* Choose either CUR or NEXT as the leader DECL for a partition.
154 : : Prefer ignored decls, to simplify debug dumps and reduce ambiguity
155 : : out of the same user variable being in multiple partitions (this is
156 : : less likely for compiler-introduced temps). */
157 : :
158 : : static tree
159 : 58360486 : leader_merge (tree cur, tree next)
160 : : {
161 : 58360486 : if (cur == NULL || cur == next)
162 : : return next;
163 : :
164 : 2988083 : if (DECL_P (cur) && DECL_IGNORED_P (cur))
165 : : return cur;
166 : :
167 : 2153823 : if (DECL_P (next) && DECL_IGNORED_P (next))
168 : 146504 : return next;
169 : :
170 : : return cur;
171 : : }
172 : :
173 : : /* Associate declaration T with storage space X. If T is no
174 : : SSA name this is exactly SET_DECL_RTL, otherwise make the
175 : : partition of T associated with X. */
176 : : static inline void
177 : 68605934 : set_rtl (tree t, rtx x)
178 : : {
179 : 68605934 : gcc_checking_assert (!x
180 : : || !(TREE_CODE (t) == SSA_NAME || is_gimple_reg (t))
181 : : || (use_register_for_decl (t)
182 : : ? (REG_P (x)
183 : : || (GET_CODE (x) == CONCAT
184 : : && (REG_P (XEXP (x, 0))
185 : : || SUBREG_P (XEXP (x, 0)))
186 : : && (REG_P (XEXP (x, 1))
187 : : || SUBREG_P (XEXP (x, 1))))
188 : : /* We need to accept PARALLELs for RESUT_DECLs
189 : : because of vector types with BLKmode returned
190 : : in multiple registers, but they are supposed
191 : : to be uncoalesced. */
192 : : || (GET_CODE (x) == PARALLEL
193 : : && SSAVAR (t)
194 : : && TREE_CODE (SSAVAR (t)) == RESULT_DECL
195 : : && (GET_MODE (x) == BLKmode
196 : : || !flag_tree_coalesce_vars)))
197 : : : (MEM_P (x) || x == pc_rtx
198 : : || (GET_CODE (x) == CONCAT
199 : : && MEM_P (XEXP (x, 0))
200 : : && MEM_P (XEXP (x, 1))))));
201 : : /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
202 : : RESULT_DECLs has the expected mode. For memory, we accept
203 : : unpromoted modes, since that's what we're likely to get. For
204 : : PARM_DECLs and RESULT_DECLs, we'll have been called by
205 : : set_parm_rtl, which will give us the default def, so we don't
206 : : have to compute it ourselves. For RESULT_DECLs, we accept mode
207 : : mismatches too, as long as we have BLKmode or are not coalescing
208 : : across variables, so that we don't reject BLKmode PARALLELs or
209 : : unpromoted REGs. */
210 : 63685964 : gcc_checking_assert (!x || x == pc_rtx || TREE_CODE (t) != SSA_NAME
211 : : || (SSAVAR (t)
212 : : && TREE_CODE (SSAVAR (t)) == RESULT_DECL
213 : : && (promote_ssa_mode (t, NULL) == BLKmode
214 : : || !flag_tree_coalesce_vars))
215 : : || !use_register_for_decl (t)
216 : : || GET_MODE (x) == promote_ssa_mode (t, NULL));
217 : :
218 : : if (x)
219 : : {
220 : 64020029 : bool skip = false;
221 : 64020029 : tree cur = NULL_TREE;
222 : : rtx xm = x;
223 : :
224 : 64020029 : retry:
225 : 64020029 : if (MEM_P (xm))
226 : 4649967 : cur = MEM_EXPR (xm);
227 : : else if (REG_P (xm))
228 : 53710519 : cur = REG_EXPR (xm);
229 : : else if (SUBREG_P (xm))
230 : : {
231 : 0 : gcc_assert (subreg_lowpart_p (xm));
232 : 0 : xm = SUBREG_REG (xm);
233 : 0 : goto retry;
234 : : }
235 : : else if (GET_CODE (xm) == CONCAT)
236 : : {
237 : 331030 : xm = XEXP (xm, 0);
238 : 331030 : goto retry;
239 : : }
240 : : else if (GET_CODE (xm) == PARALLEL)
241 : : {
242 : 3035 : xm = XVECEXP (xm, 0, 0);
243 : 3035 : gcc_assert (GET_CODE (xm) == EXPR_LIST);
244 : 3035 : xm = XEXP (xm, 0);
245 : 3035 : goto retry;
246 : : }
247 : 5325478 : else if (xm == pc_rtx)
248 : : skip = true;
249 : : else
250 : 0 : gcc_unreachable ();
251 : :
252 : 58360486 : tree next = skip ? cur : leader_merge (cur, SSAVAR (t) ? SSAVAR (t) : t);
253 : :
254 : 63685964 : if (cur != next)
255 : : {
256 : 26888763 : if (MEM_P (x))
257 : 3836950 : set_mem_attributes (x,
258 : 1918475 : next && TREE_CODE (next) == SSA_NAME
259 : 12300 : ? TREE_TYPE (next)
260 : : : next, true);
261 : : else
262 : 24970288 : set_reg_attrs_for_decl_rtl (next, x);
263 : : }
264 : : }
265 : :
266 : 68605934 : if (TREE_CODE (t) == SSA_NAME)
267 : : {
268 : 55958507 : int part = var_to_partition (SA.map, t);
269 : 55958507 : if (part != NO_PARTITION)
270 : : {
271 : 55958507 : if (SA.partition_to_pseudo[part])
272 : 30595510 : gcc_assert (SA.partition_to_pseudo[part] == x);
273 : 25362997 : else if (x != pc_rtx)
274 : 25360309 : SA.partition_to_pseudo[part] = x;
275 : : }
276 : : /* For the benefit of debug information at -O0 (where
277 : : vartracking doesn't run) record the place also in the base
278 : : DECL. For PARMs and RESULTs, do so only when setting the
279 : : default def. */
280 : 111914326 : if (x && x != pc_rtx && SSA_NAME_VAR (t)
281 : 73589738 : && (VAR_P (SSA_NAME_VAR (t))
282 : 7220634 : || SSA_NAME_IS_DEFAULT_DEF (t)))
283 : : {
284 : 17457987 : tree var = SSA_NAME_VAR (t);
285 : : /* If we don't yet have something recorded, just record it now. */
286 : 17457987 : if (!DECL_RTL_SET_P (var))
287 : 7342216 : SET_DECL_RTL (var, x);
288 : : /* If we have it set already to "multiple places" don't
289 : : change this. */
290 : 10115771 : else if (DECL_RTL (var) == pc_rtx)
291 : : ;
292 : : /* If we have something recorded and it's not the same place
293 : : as we want to record now, we have multiple partitions for the
294 : : same base variable, with different places. We can't just
295 : : randomly chose one, hence we have to say that we don't know.
296 : : This only happens with optimization, and there var-tracking
297 : : will figure out the right thing. */
298 : 9029310 : else if (DECL_RTL (var) != x)
299 : 240606 : SET_DECL_RTL (var, pc_rtx);
300 : : }
301 : : }
302 : : else
303 : 12647427 : SET_DECL_RTL (t, x);
304 : 68605934 : }
305 : :
306 : : /* This structure holds data relevant to one variable that will be
307 : : placed in a stack slot. */
308 : : class stack_var
309 : : {
310 : : public:
311 : : /* The Variable. */
312 : : tree decl;
313 : :
314 : : /* Initially, the size of the variable. Later, the size of the partition,
315 : : if this variable becomes it's partition's representative. */
316 : : poly_uint64 size;
317 : :
318 : : /* The *byte* alignment required for this variable. Or as, with the
319 : : size, the alignment for this partition. */
320 : : unsigned int alignb;
321 : :
322 : : /* The partition representative. */
323 : : unsigned representative;
324 : :
325 : : /* The next stack variable in the partition, or EOC. */
326 : : unsigned next;
327 : :
328 : : /* The numbers of conflicting stack variables. */
329 : : bitmap conflicts;
330 : : };
331 : :
332 : : #define EOC ((unsigned)-1)
333 : :
334 : : /* We have an array of such objects while deciding allocation. */
335 : : static class stack_var *stack_vars;
336 : : static unsigned stack_vars_alloc;
337 : : static unsigned stack_vars_num;
338 : : static hash_map<tree, unsigned> *decl_to_stack_part;
339 : :
340 : : /* Conflict bitmaps go on this obstack. This allows us to destroy
341 : : all of them in one big sweep. */
342 : : static bitmap_obstack stack_var_bitmap_obstack;
343 : :
344 : : /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
345 : : is non-decreasing. */
346 : : static unsigned *stack_vars_sorted;
347 : :
348 : : /* The phase of the stack frame. This is the known misalignment of
349 : : virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
350 : : (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
351 : : static int frame_phase;
352 : :
353 : : /* Used during expand_used_vars to remember if we saw any decls for
354 : : which we'd like to enable stack smashing protection. */
355 : : static bool has_protected_decls;
356 : :
357 : : /* Used during expand_used_vars. Remember if we say a character buffer
358 : : smaller than our cutoff threshold. Used for -Wstack-protector. */
359 : : static bool has_short_buffer;
360 : :
361 : : /* Compute the byte alignment to use for DECL. Ignore alignment
362 : : we can't do with expected alignment of the stack boundary. */
363 : :
364 : : static unsigned int
365 : 6106653 : align_local_variable (tree decl, bool really_expand)
366 : : {
367 : 6106653 : unsigned int align;
368 : :
369 : 6106653 : if (TREE_CODE (decl) == SSA_NAME)
370 : : {
371 : 441870 : tree type = TREE_TYPE (decl);
372 : 441870 : machine_mode mode = TYPE_MODE (type);
373 : :
374 : 441870 : align = TYPE_ALIGN (type);
375 : 441870 : if (mode != BLKmode
376 : 441870 : && align < GET_MODE_ALIGNMENT (mode))
377 : 454 : align = GET_MODE_ALIGNMENT (mode);
378 : : }
379 : : else
380 : 5664783 : align = LOCAL_DECL_ALIGNMENT (decl);
381 : :
382 : 6106653 : if (hwasan_sanitize_stack_p ())
383 : 265 : align = MAX (align, (unsigned) HWASAN_TAG_GRANULE_SIZE * BITS_PER_UNIT);
384 : :
385 : 6106653 : if (TREE_CODE (decl) != SSA_NAME && really_expand)
386 : : /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
387 : : That is done before IPA and could bump alignment based on host
388 : : backend even for offloaded code which wants different
389 : : LOCAL_DECL_ALIGNMENT. */
390 : 1468424 : SET_DECL_ALIGN (decl, align);
391 : :
392 : 6106653 : return align / BITS_PER_UNIT;
393 : : }
394 : :
395 : : /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
396 : : down otherwise. Return truncated BASE value. */
397 : :
398 : : static inline unsigned HOST_WIDE_INT
399 : : align_base (HOST_WIDE_INT base, unsigned HOST_WIDE_INT align, bool align_up)
400 : : {
401 : : return align_up ? (base + align - 1) & -align : base & -align;
402 : : }
403 : :
404 : : /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
405 : : Return the frame offset. */
406 : :
407 : : static poly_int64
408 : 1674372 : alloc_stack_frame_space (poly_int64 size, unsigned HOST_WIDE_INT align)
409 : : {
410 : 1674372 : poly_int64 offset, new_frame_offset;
411 : :
412 : 1674372 : if (FRAME_GROWS_DOWNWARD)
413 : : {
414 : 1674372 : new_frame_offset
415 : 1674372 : = aligned_lower_bound (frame_offset - frame_phase - size,
416 : 1674372 : align) + frame_phase;
417 : 1674372 : offset = new_frame_offset;
418 : : }
419 : : else
420 : : {
421 : : new_frame_offset
422 : : = aligned_upper_bound (frame_offset - frame_phase,
423 : : align) + frame_phase;
424 : : offset = new_frame_offset;
425 : : new_frame_offset += size;
426 : : }
427 : 1674372 : frame_offset = new_frame_offset;
428 : :
429 : 1674372 : if (frame_offset_overflow (frame_offset, cfun->decl))
430 : 0 : frame_offset = offset = 0;
431 : :
432 : 1674372 : return offset;
433 : : }
434 : :
435 : : /* Ensure that the stack is aligned to ALIGN bytes.
436 : : Return the new frame offset. */
437 : : static poly_int64
438 : 1598 : align_frame_offset (unsigned HOST_WIDE_INT align)
439 : : {
440 : 0 : return alloc_stack_frame_space (0, align);
441 : : }
442 : :
443 : : /* Accumulate DECL into STACK_VARS. */
444 : :
445 : : static void
446 : 5325478 : add_stack_var (tree decl, bool really_expand)
447 : : {
448 : 5325478 : class stack_var *v;
449 : :
450 : 5325478 : if (stack_vars_num >= stack_vars_alloc)
451 : : {
452 : 1235167 : if (stack_vars_alloc)
453 : 31536 : stack_vars_alloc = stack_vars_alloc * 3 / 2;
454 : : else
455 : 1203631 : stack_vars_alloc = 32;
456 : 1235167 : stack_vars
457 : 1235167 : = XRESIZEVEC (class stack_var, stack_vars, stack_vars_alloc);
458 : : }
459 : 5325478 : if (!decl_to_stack_part)
460 : 0 : decl_to_stack_part = new hash_map<tree, unsigned>;
461 : :
462 : 5325478 : v = &stack_vars[stack_vars_num];
463 : 5325478 : decl_to_stack_part->put (decl, stack_vars_num);
464 : :
465 : 5325478 : v->decl = decl;
466 : 5325478 : tree size = TREE_CODE (decl) == SSA_NAME
467 : 10648268 : ? TYPE_SIZE_UNIT (TREE_TYPE (decl))
468 : 5322790 : : DECL_SIZE_UNIT (decl);
469 : 5325478 : v->size = tree_to_poly_uint64 (size);
470 : : /* Ensure that all variables have size, so that &a != &b for any two
471 : : variables that are simultaneously live. */
472 : 5325478 : if (known_eq (v->size, 0U))
473 : 23398 : v->size = 1;
474 : 5325478 : v->alignb = align_local_variable (decl, really_expand);
475 : : /* An alignment of zero can mightily confuse us later. */
476 : 5325478 : gcc_assert (v->alignb != 0);
477 : :
478 : : /* All variables are initially in their own partition. */
479 : 5325478 : v->representative = stack_vars_num;
480 : 5325478 : v->next = EOC;
481 : :
482 : : /* All variables initially conflict with no other. */
483 : 5325478 : v->conflicts = NULL;
484 : :
485 : : /* Ensure that this decl doesn't get put onto the list twice. */
486 : 5325478 : set_rtl (decl, pc_rtx);
487 : :
488 : 5325478 : stack_vars_num++;
489 : 5325478 : }
490 : :
491 : : /* Make the decls associated with luid's X and Y conflict. */
492 : :
493 : : static void
494 : 10698613 : add_stack_var_conflict (unsigned x, unsigned y)
495 : : {
496 : 10698613 : class stack_var *a = &stack_vars[x];
497 : 10698613 : class stack_var *b = &stack_vars[y];
498 : 10698613 : if (x == y)
499 : : return;
500 : 9697644 : if (!a->conflicts)
501 : 606486 : a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
502 : 9697644 : if (!b->conflicts)
503 : 105851 : b->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
504 : 9697644 : bitmap_set_bit (a->conflicts, y);
505 : 9697644 : bitmap_set_bit (b->conflicts, x);
506 : : }
507 : :
508 : : /* Check whether the decls associated with luid's X and Y conflict. */
509 : :
510 : : static bool
511 : 10947480 : stack_var_conflict_p (unsigned x, unsigned y)
512 : : {
513 : 10947480 : class stack_var *a = &stack_vars[x];
514 : 10947480 : class stack_var *b = &stack_vars[y];
515 : 10947480 : if (x == y)
516 : : return false;
517 : : /* Partitions containing an SSA name result from gimple registers
518 : : with things like unsupported modes. They are top-level and
519 : : hence conflict with everything else. */
520 : 10947480 : if (TREE_CODE (a->decl) == SSA_NAME || TREE_CODE (b->decl) == SSA_NAME)
521 : : return true;
522 : :
523 : 10913692 : if (!a->conflicts || !b->conflicts)
524 : : return false;
525 : 10859729 : return bitmap_bit_p (a->conflicts, y);
526 : : }
527 : :
528 : : /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
529 : : enter its partition number into bitmap DATA. */
530 : :
531 : : static bool
532 : 27405146 : visit_op (gimple *, tree op, tree, void *data)
533 : : {
534 : 27405146 : bitmap active = (bitmap)data;
535 : 27405146 : op = get_base_address (op);
536 : 27405146 : if (op
537 : 27405146 : && DECL_P (op)
538 : 47805897 : && DECL_RTL_IF_SET (op) == pc_rtx)
539 : : {
540 : 12749693 : unsigned *v = decl_to_stack_part->get (op);
541 : 12749693 : if (v)
542 : 12749693 : bitmap_set_bit (active, *v);
543 : : }
544 : 27405146 : return false;
545 : : }
546 : :
547 : : /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
548 : : record conflicts between it and all currently active other partitions
549 : : from bitmap DATA. */
550 : :
551 : : static bool
552 : 12418915 : visit_conflict (gimple *, tree op, tree, void *data)
553 : : {
554 : 12418915 : bitmap active = (bitmap)data;
555 : 12418915 : op = get_base_address (op);
556 : 12418915 : if (op
557 : 12418915 : && DECL_P (op)
558 : 21647641 : && DECL_RTL_IF_SET (op) == pc_rtx)
559 : : {
560 : 5841749 : unsigned *v = decl_to_stack_part->get (op);
561 : 5841749 : if (v && bitmap_set_bit (active, *v))
562 : : {
563 : 923409 : unsigned num = *v;
564 : 923409 : bitmap_iterator bi;
565 : 923409 : unsigned i;
566 : 923409 : gcc_assert (num < stack_vars_num);
567 : 10354951 : EXECUTE_IF_SET_IN_BITMAP (active, 0, i, bi)
568 : 9431542 : add_stack_var_conflict (num, i);
569 : : }
570 : : }
571 : 12418915 : return false;
572 : : }
573 : :
574 : : /* Helper function for add_scope_conflicts_1. For USE on
575 : : a stmt, if it is a SSA_NAME and in its SSA_NAME_DEF_STMT is known to be
576 : : based on some ADDR_EXPR, invoke VISIT on that ADDR_EXPR. */
577 : :
578 : : static inline void
579 : 58436710 : add_scope_conflicts_2 (tree use, bitmap work,
580 : : walk_stmt_load_store_addr_fn visit)
581 : : {
582 : 58436710 : if (TREE_CODE (use) == SSA_NAME
583 : 58436710 : && (POINTER_TYPE_P (TREE_TYPE (use))
584 : 35409157 : || INTEGRAL_TYPE_P (TREE_TYPE (use))))
585 : : {
586 : 52328108 : gimple *g = SSA_NAME_DEF_STMT (use);
587 : 52328108 : if (gassign *a = dyn_cast <gassign *> (g))
588 : : {
589 : 33258758 : if (tree op = gimple_assign_rhs1 (a))
590 : 33258758 : if (TREE_CODE (op) == ADDR_EXPR)
591 : 1351848 : visit (a, TREE_OPERAND (op, 0), op, work);
592 : : }
593 : 19069350 : else if (gphi *p = dyn_cast <gphi *> (g))
594 : 36413788 : for (unsigned i = 0; i < gimple_phi_num_args (p); ++i)
595 : 26030372 : if (TREE_CODE (use = gimple_phi_arg_def (p, i)) == SSA_NAME)
596 : 37466076 : if (gassign *a = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (use)))
597 : : {
598 : 11435704 : if (tree op = gimple_assign_rhs1 (a))
599 : 11435704 : if (TREE_CODE (op) == ADDR_EXPR)
600 : 328207 : visit (a, TREE_OPERAND (op, 0), op, work);
601 : : }
602 : : }
603 : 58436710 : }
604 : :
605 : : /* Helper routine for add_scope_conflicts, calculating the active partitions
606 : : at the end of BB, leaving the result in WORK. We're called to generate
607 : : conflicts when FOR_CONFLICT is true, otherwise we're just tracking
608 : : liveness. */
609 : :
610 : : static void
611 : 14928489 : add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
612 : : {
613 : 14928489 : edge e;
614 : 14928489 : edge_iterator ei;
615 : 14928489 : gimple_stmt_iterator gsi;
616 : 14928489 : walk_stmt_load_store_addr_fn visit;
617 : 14928489 : use_operand_p use_p;
618 : 14928489 : ssa_op_iter iter;
619 : :
620 : 14928489 : bitmap_clear (work);
621 : 37674704 : FOR_EACH_EDGE (e, ei, bb->preds)
622 : 22746215 : bitmap_ior_into (work, (bitmap)e->src->aux);
623 : :
624 : 14928489 : visit = visit_op;
625 : :
626 : 19686176 : for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
627 : : {
628 : 4757687 : gimple *stmt = gsi_stmt (gsi);
629 : 4757687 : gphi *phi = as_a <gphi *> (stmt);
630 : 4757687 : walk_stmt_load_store_addr_ops (stmt, work, NULL, NULL, visit);
631 : 16770752 : FOR_EACH_PHI_ARG (use_p, phi, iter, SSA_OP_USE)
632 : 12013065 : add_scope_conflicts_2 (USE_FROM_PTR (use_p), work, visit);
633 : : }
634 : 152283673 : for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
635 : : {
636 : 137355184 : gimple *stmt = gsi_stmt (gsi);
637 : :
638 : 137355184 : if (gimple_clobber_p (stmt))
639 : : {
640 : 3134462 : tree lhs = gimple_assign_lhs (stmt);
641 : 3134462 : unsigned *v;
642 : : /* Handle only plain var clobbers.
643 : : Nested functions lowering and C++ front-end inserts clobbers
644 : : which are not just plain variables. */
645 : 3134462 : if (!VAR_P (lhs))
646 : 589648 : continue;
647 : 2544814 : if (DECL_RTL_IF_SET (lhs) == pc_rtx
648 : 2544814 : && (v = decl_to_stack_part->get (lhs)))
649 : 2030309 : bitmap_clear_bit (work, *v);
650 : : }
651 : 134220722 : else if (!is_gimple_debug (stmt))
652 : : {
653 : 55207330 : if (for_conflict && visit == visit_op)
654 : : {
655 : : /* When we are inheriting live variables from our predecessors
656 : : through a CFG merge we might not see an actual mention of
657 : : the variables to record the approprate conflict as defs/uses
658 : : might be through indirect stores/loads. For this reason
659 : : we have to make sure each live variable conflicts with
660 : : each other. When there's just a single predecessor the
661 : : set of conflicts is already up-to-date.
662 : : We perform this delayed at the first real instruction to
663 : : allow clobbers starting this block to remove variables from
664 : : the set of live variables. */
665 : 4484064 : bitmap_iterator bi;
666 : 4484064 : unsigned i;
667 : 4484064 : if (EDGE_COUNT (bb->preds) > 1)
668 : 11857709 : EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
669 : : {
670 : 10546497 : class stack_var *a = &stack_vars[i];
671 : 10546497 : if (!a->conflicts)
672 : 231279 : a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
673 : 10546497 : bitmap_ior_into (a->conflicts, work);
674 : : }
675 : 4484064 : visit = visit_conflict;
676 : : }
677 : 55207330 : walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
678 : 101630975 : FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
679 : 46423645 : add_scope_conflicts_2 (USE_FROM_PTR (use_p), work, visit);
680 : : }
681 : : }
682 : :
683 : : /* When there was no real instruction but there's a CFG merge we need
684 : : to add the conflicts now. */
685 : 14928489 : if (for_conflict && visit == visit_op && EDGE_COUNT (bb->preds) > 1)
686 : : {
687 : 151214 : bitmap_iterator bi;
688 : 151214 : unsigned i;
689 : 1002254 : EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
690 : : {
691 : 851040 : class stack_var *a = &stack_vars[i];
692 : 851040 : if (!a->conflicts)
693 : 40681 : a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
694 : 851040 : bitmap_ior_into (a->conflicts, work);
695 : : }
696 : : }
697 : 14928489 : }
698 : :
699 : : /* Generate stack partition conflicts between all partitions that are
700 : : simultaneously live. */
701 : :
702 : : static void
703 : 223597 : add_scope_conflicts (void)
704 : : {
705 : : /* If there is only one variable, there is nothing to be done as
706 : : there is only possible partition. */
707 : 223597 : if (stack_vars_num == 1)
708 : : return;
709 : :
710 : 140186 : basic_block bb;
711 : 140186 : bool changed;
712 : 140186 : bitmap work = BITMAP_ALLOC (NULL);
713 : 140186 : int *rpo;
714 : 140186 : int n_bbs;
715 : :
716 : : /* We approximate the live range of a stack variable by taking the first
717 : : mention of its name as starting point(s), and by the end-of-scope
718 : : death clobber added by gimplify as ending point(s) of the range.
719 : : This overapproximates in the case we for instance moved an address-taken
720 : : operation upward, without also moving a dereference to it upwards.
721 : : But it's conservatively correct as a variable never can hold values
722 : : before its name is mentioned at least once.
723 : :
724 : : We then do a mostly classical bitmap liveness algorithm. */
725 : :
726 : 5110956 : FOR_ALL_BB_FN (bb, cfun)
727 : 4970770 : bb->aux = BITMAP_ALLOC (&stack_var_bitmap_obstack);
728 : :
729 : 140186 : rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
730 : 140186 : n_bbs = pre_and_rev_post_order_compute (NULL, rpo, false);
731 : :
732 : 140186 : changed = true;
733 : 568907 : while (changed)
734 : : {
735 : : int i;
736 : : changed = false;
737 : 10526626 : for (i = 0; i < n_bbs; i++)
738 : : {
739 : 10238091 : bitmap active;
740 : 10238091 : bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]);
741 : 10238091 : active = (bitmap)bb->aux;
742 : 10238091 : add_scope_conflicts_1 (bb, work, false);
743 : 10238091 : if (bitmap_ior_into (active, work))
744 : 4162997 : changed = true;
745 : : }
746 : : }
747 : :
748 : 4830584 : FOR_EACH_BB_FN (bb, cfun)
749 : 4690398 : add_scope_conflicts_1 (bb, work, true);
750 : :
751 : 140186 : free (rpo);
752 : 140186 : BITMAP_FREE (work);
753 : 5110956 : FOR_ALL_BB_FN (bb, cfun)
754 : 4970770 : BITMAP_FREE (bb->aux);
755 : : }
756 : :
757 : : /* A subroutine of partition_stack_vars. A comparison function for qsort,
758 : : sorting an array of indices by the properties of the object. */
759 : :
760 : : static int
761 : 18636334 : stack_var_cmp (const void *a, const void *b)
762 : : {
763 : 18636334 : unsigned ia = *(const unsigned *)a;
764 : 18636334 : unsigned ib = *(const unsigned *)b;
765 : 18636334 : unsigned int aligna = stack_vars[ia].alignb;
766 : 18636334 : unsigned int alignb = stack_vars[ib].alignb;
767 : 18636334 : poly_int64 sizea = stack_vars[ia].size;
768 : 18636334 : poly_int64 sizeb = stack_vars[ib].size;
769 : 18636334 : tree decla = stack_vars[ia].decl;
770 : 18636334 : tree declb = stack_vars[ib].decl;
771 : 18636334 : bool largea, largeb;
772 : 18636334 : unsigned int uida, uidb;
773 : :
774 : : /* Primary compare on "large" alignment. Large comes first. */
775 : 18636334 : largea = (aligna * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
776 : 18636334 : largeb = (alignb * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
777 : 18636334 : if (largea != largeb)
778 : 0 : return (int)largeb - (int)largea;
779 : :
780 : : /* Secondary compare on size, decreasing */
781 : 18636334 : int diff = compare_sizes_for_sort (sizeb, sizea);
782 : 18636334 : if (diff != 0)
783 : 8312359 : return diff;
784 : :
785 : : /* Tertiary compare on true alignment, decreasing. */
786 : 10323975 : if (aligna < alignb)
787 : : return -1;
788 : 9986314 : if (aligna > alignb)
789 : : return 1;
790 : :
791 : : /* Final compare on ID for sort stability, increasing.
792 : : Two SSA names are compared by their version, SSA names come before
793 : : non-SSA names, and two normal decls are compared by their DECL_UID. */
794 : 9704989 : if (TREE_CODE (decla) == SSA_NAME)
795 : : {
796 : 35534 : if (TREE_CODE (declb) == SSA_NAME)
797 : 31031 : uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
798 : : else
799 : : return -1;
800 : : }
801 : 9669455 : else if (TREE_CODE (declb) == SSA_NAME)
802 : : return 1;
803 : : else
804 : 9664055 : uida = DECL_UID (decla), uidb = DECL_UID (declb);
805 : 9695086 : if (uida < uidb)
806 : : return 1;
807 : 4841450 : if (uida > uidb)
808 : 4841450 : return -1;
809 : : return 0;
810 : : }
811 : :
812 : : struct part_traits : unbounded_int_hashmap_traits <unsigned , bitmap> {};
813 : : typedef hash_map<unsigned, bitmap, part_traits> part_hashmap;
814 : :
815 : : /* If the points-to solution *PI points to variables that are in a partition
816 : : together with other variables add all partition members to the pointed-to
817 : : variables bitmap. */
818 : :
819 : : static void
820 : 1477228 : add_partitioned_vars_to_ptset (struct pt_solution *pt,
821 : : part_hashmap *decls_to_partitions,
822 : : hash_set<bitmap> *visited, bitmap temp)
823 : : {
824 : 1477228 : bitmap_iterator bi;
825 : 1477228 : unsigned i;
826 : 1477228 : bitmap *part;
827 : :
828 : 1477228 : if (pt->anything
829 : 1416110 : || pt->vars == NULL
830 : : /* The pointed-to vars bitmap is shared, it is enough to
831 : : visit it once. */
832 : 2893338 : || visited->add (pt->vars))
833 : 1207771 : return;
834 : :
835 : 269457 : bitmap_clear (temp);
836 : :
837 : : /* By using a temporary bitmap to store all members of the partitions
838 : : we have to add we make sure to visit each of the partitions only
839 : : once. */
840 : 1218355 : EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
841 : 948898 : if ((!temp
842 : 948898 : || !bitmap_bit_p (temp, i))
843 : 1527871 : && (part = decls_to_partitions->get (i)))
844 : 177116 : bitmap_ior_into (temp, *part);
845 : 269457 : if (!bitmap_empty_p (temp))
846 : 141337 : bitmap_ior_into (pt->vars, temp);
847 : : }
848 : :
849 : : /* Update points-to sets based on partition info, so we can use them on RTL.
850 : : The bitmaps representing stack partitions will be saved until expand,
851 : : where partitioned decls used as bases in memory expressions will be
852 : : rewritten.
853 : :
854 : : It is not necessary to update TBAA info on accesses to the coalesced
855 : : storage since our memory model doesn't allow TBAA to be used for
856 : : WAW or WAR dependences. For RAW when the write is to an old object
857 : : the new object would not have been initialized at the point of the
858 : : read, invoking undefined behavior. */
859 : :
860 : : static void
861 : 140186 : update_alias_info_with_stack_vars (void)
862 : : {
863 : 140186 : part_hashmap *decls_to_partitions = NULL;
864 : 140186 : unsigned i, j;
865 : 140186 : tree var = NULL_TREE;
866 : :
867 : 1185894 : for (i = 0; i < stack_vars_num; i++)
868 : : {
869 : 1045708 : bitmap part = NULL;
870 : 1045708 : tree name;
871 : 1045708 : struct ptr_info_def *pi;
872 : :
873 : : /* Not interested in partitions with single variable. */
874 : 1045708 : if (stack_vars[i].representative != i
875 : 806760 : || stack_vars[i].next == EOC)
876 : 980098 : continue;
877 : :
878 : 65610 : if (!decls_to_partitions)
879 : : {
880 : 39834 : decls_to_partitions = new part_hashmap;
881 : 39834 : cfun->gimple_df->decls_to_pointers = new hash_map<tree, tree>;
882 : : }
883 : :
884 : : /* Create an SSA_NAME that points to the partition for use
885 : : as base during alias-oracle queries on RTL for bases that
886 : : have been partitioned. */
887 : 65610 : if (var == NULL_TREE)
888 : 39834 : var = create_tmp_var (ptr_type_node);
889 : 65610 : name = make_ssa_name (var);
890 : :
891 : : /* Create bitmaps representing partitions. They will be used for
892 : : points-to sets later, so use GGC alloc. */
893 : 65610 : part = BITMAP_GGC_ALLOC ();
894 : 370168 : for (j = i; j != EOC; j = stack_vars[j].next)
895 : : {
896 : 304558 : tree decl = stack_vars[j].decl;
897 : 304558 : unsigned int uid = DECL_PT_UID (decl);
898 : 304558 : bitmap_set_bit (part, uid);
899 : 304558 : decls_to_partitions->put (uid, part);
900 : 304558 : cfun->gimple_df->decls_to_pointers->put (decl, name);
901 : 304558 : if (TREE_ADDRESSABLE (decl))
902 : 270878 : TREE_ADDRESSABLE (name) = 1;
903 : : }
904 : :
905 : : /* Make the SSA name point to all partition members. */
906 : 65610 : pi = get_ptr_info (name);
907 : 65610 : pt_solution_set (&pi->pt, part, false);
908 : : }
909 : :
910 : : /* Make all points-to sets that contain one member of a partition
911 : : contain all members of the partition. */
912 : 140186 : if (decls_to_partitions)
913 : : {
914 : 39834 : unsigned i;
915 : 39834 : tree name;
916 : 39834 : hash_set<bitmap> visited;
917 : 39834 : bitmap temp = BITMAP_ALLOC (&stack_var_bitmap_obstack);
918 : :
919 : 14874064 : FOR_EACH_SSA_NAME (i, name, cfun)
920 : : {
921 : 9592582 : struct ptr_info_def *pi;
922 : :
923 : 17620818 : if (POINTER_TYPE_P (TREE_TYPE (name))
924 : 9671503 : && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
925 : 1397560 : add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
926 : : &visited, temp);
927 : : }
928 : :
929 : 39834 : add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
930 : : decls_to_partitions, &visited, temp);
931 : 39834 : add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped_return,
932 : : decls_to_partitions, &visited, temp);
933 : 39834 : delete decls_to_partitions;
934 : 39834 : BITMAP_FREE (temp);
935 : 39834 : }
936 : 140186 : }
937 : :
938 : : /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
939 : : partitioning algorithm. Partitions A and B are known to be non-conflicting.
940 : : Merge them into a single partition A. */
941 : :
942 : : static void
943 : 238948 : union_stack_vars (unsigned a, unsigned b)
944 : : {
945 : 238948 : class stack_var *vb = &stack_vars[b];
946 : 238948 : bitmap_iterator bi;
947 : 238948 : unsigned u;
948 : :
949 : 238948 : gcc_assert (stack_vars[b].next == EOC);
950 : : /* Add B to A's partition. */
951 : 238948 : stack_vars[b].next = stack_vars[a].next;
952 : 238948 : stack_vars[b].representative = a;
953 : 238948 : stack_vars[a].next = b;
954 : :
955 : : /* Make sure A is big enough to hold B. */
956 : 238948 : stack_vars[a].size = upper_bound (stack_vars[a].size, stack_vars[b].size);
957 : :
958 : : /* Update the required alignment of partition A to account for B. */
959 : 238948 : if (stack_vars[a].alignb < stack_vars[b].alignb)
960 : 2559 : stack_vars[a].alignb = stack_vars[b].alignb;
961 : :
962 : : /* Update the interference graph and merge the conflicts. */
963 : 238948 : if (vb->conflicts)
964 : : {
965 : 1453985 : EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)
966 : 1266752 : add_stack_var_conflict (a, stack_vars[u].representative);
967 : 187233 : BITMAP_FREE (vb->conflicts);
968 : : }
969 : 238948 : }
970 : :
971 : : /* A subroutine of expand_used_vars. Binpack the variables into
972 : : partitions constrained by the interference graph. The overall
973 : : algorithm used is as follows:
974 : :
975 : : Sort the objects by size in descending order.
976 : : For each object A {
977 : : S = size(A)
978 : : O = 0
979 : : loop {
980 : : Look for the largest non-conflicting object B with size <= S.
981 : : UNION (A, B)
982 : : }
983 : : }
984 : : */
985 : :
986 : : static void
987 : 223597 : partition_stack_vars (void)
988 : : {
989 : 223597 : unsigned si, sj, n = stack_vars_num;
990 : :
991 : 223597 : stack_vars_sorted = XNEWVEC (unsigned, stack_vars_num);
992 : 1352716 : for (si = 0; si < n; ++si)
993 : 1129119 : stack_vars_sorted[si] = si;
994 : :
995 : 223597 : if (n == 1)
996 : : return;
997 : :
998 : 140186 : qsort (stack_vars_sorted, n, sizeof (unsigned), stack_var_cmp);
999 : :
1000 : 1185894 : for (si = 0; si < n; ++si)
1001 : : {
1002 : 1045708 : unsigned i = stack_vars_sorted[si];
1003 : 1045708 : unsigned int ialign = stack_vars[i].alignb;
1004 : 1045708 : poly_int64 isize = stack_vars[i].size;
1005 : :
1006 : : /* Ignore objects that aren't partition representatives. If we
1007 : : see a var that is not a partition representative, it must
1008 : : have been merged earlier. */
1009 : 1045708 : if (stack_vars[i].representative != i)
1010 : 238948 : continue;
1011 : :
1012 : 12268048 : for (sj = si + 1; sj < n; ++sj)
1013 : : {
1014 : 11462212 : unsigned j = stack_vars_sorted[sj];
1015 : 11462212 : unsigned int jalign = stack_vars[j].alignb;
1016 : 11462212 : poly_int64 jsize = stack_vars[j].size;
1017 : :
1018 : : /* Ignore objects that aren't partition representatives. */
1019 : 11462212 : if (stack_vars[j].representative != j)
1020 : 11461288 : continue;
1021 : :
1022 : : /* Do not mix objects of "small" (supported) alignment
1023 : : and "large" (unsupported) alignment. */
1024 : 10948404 : if ((ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1025 : 10948404 : != (jalign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT))
1026 : : break;
1027 : :
1028 : : /* For Address Sanitizer do not mix objects with different
1029 : : sizes, as the shorter vars wouldn't be adequately protected.
1030 : : Don't do that for "large" (unsupported) alignment objects,
1031 : : those aren't protected anyway. */
1032 : 10948404 : if (asan_sanitize_stack_p ()
1033 : 4926 : && maybe_ne (isize, jsize)
1034 : 10949328 : && ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1035 : : break;
1036 : :
1037 : : /* Ignore conflicting objects. */
1038 : 10947480 : if (stack_var_conflict_p (i, j))
1039 : 10708532 : continue;
1040 : :
1041 : : /* UNION the objects, placing J at OFFSET. */
1042 : 238948 : union_stack_vars (i, j);
1043 : : }
1044 : : }
1045 : :
1046 : 140186 : update_alias_info_with_stack_vars ();
1047 : : }
1048 : :
1049 : : /* A debugging aid for expand_used_vars. Dump the generated partitions. */
1050 : :
1051 : : static void
1052 : 29 : dump_stack_var_partition (void)
1053 : : {
1054 : 29 : unsigned si, i, j, n = stack_vars_num;
1055 : :
1056 : 65 : for (si = 0; si < n; ++si)
1057 : : {
1058 : 36 : i = stack_vars_sorted[si];
1059 : :
1060 : : /* Skip variables that aren't partition representatives, for now. */
1061 : 36 : if (stack_vars[i].representative != i)
1062 : 3 : continue;
1063 : :
1064 : 33 : fprintf (dump_file, "Partition %u: size ", i);
1065 : 33 : print_dec (stack_vars[i].size, dump_file);
1066 : 33 : fprintf (dump_file, " align %u\n", stack_vars[i].alignb);
1067 : :
1068 : 102 : for (j = i; j != EOC; j = stack_vars[j].next)
1069 : : {
1070 : 36 : fputc ('\t', dump_file);
1071 : 36 : print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
1072 : : }
1073 : 33 : fputc ('\n', dump_file);
1074 : : }
1075 : 29 : }
1076 : :
1077 : : /* Assign rtl to DECL at BASE + OFFSET. */
1078 : :
1079 : : static void
1080 : 1910294 : expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
1081 : : poly_int64 offset)
1082 : : {
1083 : 1910294 : unsigned align;
1084 : 1910294 : rtx x;
1085 : :
1086 : : /* If this fails, we've overflowed the stack frame. Error nicely? */
1087 : 1910294 : gcc_assert (known_eq (offset, trunc_int_for_mode (offset, Pmode)));
1088 : :
1089 : 1910294 : if (hwasan_sanitize_stack_p ())
1090 : 85 : x = targetm.memtag.add_tag (base, offset,
1091 : 85 : hwasan_current_frame_tag ());
1092 : : else
1093 : 1910209 : x = plus_constant (Pmode, base, offset);
1094 : :
1095 : 3820588 : x = gen_rtx_MEM (TREE_CODE (decl) == SSA_NAME
1096 : 441870 : ? TYPE_MODE (TREE_TYPE (decl))
1097 : 1468424 : : DECL_MODE (decl), x);
1098 : :
1099 : : /* Set alignment we actually gave this decl if it isn't an SSA name.
1100 : : If it is we generate stack slots only accidentally so it isn't as
1101 : : important, we'll simply set the alignment directly on the MEM. */
1102 : :
1103 : 1910294 : if (stack_vars_base_reg_p (base))
1104 : 1907647 : offset -= frame_phase;
1105 : 1910294 : align = known_alignment (offset);
1106 : 1910294 : align *= BITS_PER_UNIT;
1107 : 1910294 : if (align == 0 || align > base_align)
1108 : 774659 : align = base_align;
1109 : :
1110 : 1910294 : if (TREE_CODE (decl) != SSA_NAME)
1111 : : {
1112 : : /* One would think that we could assert that we're not decreasing
1113 : : alignment here, but (at least) the i386 port does exactly this
1114 : : via the MINIMUM_ALIGNMENT hook. */
1115 : :
1116 : 1468424 : SET_DECL_ALIGN (decl, align);
1117 : 1468424 : DECL_USER_ALIGN (decl) = 0;
1118 : : }
1119 : :
1120 : 1910294 : set_rtl (decl, x);
1121 : :
1122 : 1910294 : set_mem_align (x, align);
1123 : 1910294 : }
1124 : :
1125 : 223597 : class stack_vars_data
1126 : : {
1127 : : public:
1128 : : /* Vector of offset pairs, always end of some padding followed
1129 : : by start of the padding that needs Address Sanitizer protection.
1130 : : The vector is in reversed, highest offset pairs come first. */
1131 : : auto_vec<HOST_WIDE_INT> asan_vec;
1132 : :
1133 : : /* Vector of partition representative decls in between the paddings. */
1134 : : auto_vec<tree> asan_decl_vec;
1135 : :
1136 : : /* Base pseudo register for Address Sanitizer protected automatic vars. */
1137 : : rtx asan_base;
1138 : :
1139 : : /* Alignment needed for the Address Sanitizer protected automatic vars. */
1140 : : unsigned int asan_alignb;
1141 : : };
1142 : :
1143 : : /* A subroutine of expand_used_vars. Give each partition representative
1144 : : a unique location within the stack frame. Update each partition member
1145 : : with that location. */
1146 : : static void
1147 : 225364 : expand_stack_vars (bool (*pred) (unsigned), class stack_vars_data *data)
1148 : : {
1149 : 225364 : unsigned si, i, j, n = stack_vars_num;
1150 : 225364 : poly_uint64 large_size = 0, large_alloc = 0;
1151 : 225364 : rtx large_base = NULL;
1152 : 225364 : rtx large_untagged_base = NULL;
1153 : 225364 : unsigned large_align = 0;
1154 : 225364 : bool large_allocation_done = false;
1155 : 225364 : tree decl;
1156 : :
1157 : : /* Determine if there are any variables requiring "large" alignment.
1158 : : Since these are dynamically allocated, we only process these if
1159 : : no predicate involved. */
1160 : 225364 : large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT;
1161 : 225364 : if (pred == NULL && large_align > MAX_SUPPORTED_STACK_ALIGNMENT)
1162 : : {
1163 : : /* Find the total size of these variables. */
1164 : 0 : for (si = 0; si < n; ++si)
1165 : : {
1166 : 0 : unsigned alignb;
1167 : :
1168 : 0 : i = stack_vars_sorted[si];
1169 : 0 : alignb = stack_vars[i].alignb;
1170 : :
1171 : : /* All "large" alignment decls come before all "small" alignment
1172 : : decls, but "large" alignment decls are not sorted based on
1173 : : their alignment. Increase large_align to track the largest
1174 : : required alignment. */
1175 : 0 : if ((alignb * BITS_PER_UNIT) > large_align)
1176 : : large_align = alignb * BITS_PER_UNIT;
1177 : :
1178 : : /* Stop when we get to the first decl with "small" alignment. */
1179 : 0 : if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1180 : : break;
1181 : :
1182 : : /* Skip variables that aren't partition representatives. */
1183 : 0 : if (stack_vars[i].representative != i)
1184 : 0 : continue;
1185 : :
1186 : : /* Skip variables that have already had rtl assigned. See also
1187 : : add_stack_var where we perpetrate this pc_rtx hack. */
1188 : 0 : decl = stack_vars[i].decl;
1189 : 0 : if (TREE_CODE (decl) == SSA_NAME
1190 : 0 : ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
1191 : 0 : : DECL_RTL (decl) != pc_rtx)
1192 : 0 : continue;
1193 : :
1194 : 0 : large_size = aligned_upper_bound (large_size, alignb);
1195 : 0 : large_size += stack_vars[i].size;
1196 : : }
1197 : : }
1198 : :
1199 : 1358229 : for (si = 0; si < n; ++si)
1200 : : {
1201 : 1132865 : rtx base;
1202 : 1132865 : unsigned base_align, alignb;
1203 : 1132865 : poly_int64 offset = 0;
1204 : :
1205 : 1132865 : i = stack_vars_sorted[si];
1206 : :
1207 : : /* Skip variables that aren't partition representatives, for now. */
1208 : 1132865 : if (stack_vars[i].representative != i)
1209 : 1371824 : continue;
1210 : :
1211 : : /* Skip variables that have already had rtl assigned. See also
1212 : : add_stack_var where we perpetrate this pc_rtx hack. */
1213 : 893906 : decl = stack_vars[i].decl;
1214 : 893906 : if (TREE_CODE (decl) == SSA_NAME
1215 : 893906 : ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)] != NULL_RTX
1216 : 890697 : : DECL_RTL (decl) != pc_rtx)
1217 : 2884 : continue;
1218 : :
1219 : : /* Check the predicate to see whether this variable should be
1220 : : allocated in this pass. */
1221 : 891022 : if (pred && !pred (i))
1222 : 851 : continue;
1223 : :
1224 : 890171 : base = (hwasan_sanitize_stack_p ()
1225 : 890171 : ? hwasan_frame_base ()
1226 : 890115 : : virtual_stack_vars_rtx);
1227 : 890171 : alignb = stack_vars[i].alignb;
1228 : 890171 : if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
1229 : : {
1230 : 890171 : poly_int64 hwasan_orig_offset;
1231 : 890171 : if (hwasan_sanitize_stack_p ())
1232 : : {
1233 : : /* There must be no tag granule "shared" between different
1234 : : objects. This means that no HWASAN_TAG_GRANULE_SIZE byte
1235 : : chunk can have more than one object in it.
1236 : :
1237 : : We ensure this by forcing the end of the last bit of data to
1238 : : be aligned to HWASAN_TAG_GRANULE_SIZE bytes here, and setting
1239 : : the start of each variable to be aligned to
1240 : : HWASAN_TAG_GRANULE_SIZE bytes in `align_local_variable`.
1241 : :
1242 : : We can't align just one of the start or end, since there are
1243 : : untagged things stored on the stack which we do not align to
1244 : : HWASAN_TAG_GRANULE_SIZE bytes. If we only aligned the start
1245 : : or the end of tagged objects then untagged objects could end
1246 : : up sharing the first granule of a tagged object or sharing the
1247 : : last granule of a tagged object respectively. */
1248 : 56 : hwasan_orig_offset = align_frame_offset (HWASAN_TAG_GRANULE_SIZE);
1249 : 56 : gcc_assert (stack_vars[i].alignb >= HWASAN_TAG_GRANULE_SIZE);
1250 : : }
1251 : : /* ASAN description strings don't yet have a syntax for expressing
1252 : : polynomial offsets. */
1253 : 890171 : HOST_WIDE_INT prev_offset;
1254 : 890171 : if (asan_sanitize_stack_p ()
1255 : 3213 : && pred
1256 : 2642 : && frame_offset.is_constant (&prev_offset)
1257 : 890171 : && stack_vars[i].size.is_constant ())
1258 : : {
1259 : 2642 : if (data->asan_vec.is_empty ())
1260 : : {
1261 : 1428 : align_frame_offset (ASAN_RED_ZONE_SIZE);
1262 : 1428 : prev_offset = frame_offset.to_constant ();
1263 : : }
1264 : 2642 : prev_offset = align_base (prev_offset,
1265 : : ASAN_MIN_RED_ZONE_SIZE,
1266 : : !FRAME_GROWS_DOWNWARD);
1267 : 2642 : tree repr_decl = NULL_TREE;
1268 : 2642 : unsigned HOST_WIDE_INT size
1269 : 2642 : = asan_var_and_redzone_size (stack_vars[i].size.to_constant ());
1270 : 2642 : if (data->asan_vec.is_empty ())
1271 : 1428 : size = MAX (size, ASAN_RED_ZONE_SIZE);
1272 : :
1273 : 2642 : unsigned HOST_WIDE_INT alignment = MAX (alignb,
1274 : : ASAN_MIN_RED_ZONE_SIZE);
1275 : 2642 : offset = alloc_stack_frame_space (size, alignment);
1276 : :
1277 : 2642 : data->asan_vec.safe_push (prev_offset);
1278 : : /* Allocating a constant amount of space from a constant
1279 : : starting offset must give a constant result. */
1280 : 2642 : data->asan_vec.safe_push ((offset + stack_vars[i].size)
1281 : 2642 : .to_constant ());
1282 : : /* Find best representative of the partition.
1283 : : Prefer those with DECL_NAME, even better
1284 : : satisfying asan_protect_stack_decl predicate. */
1285 : 3138 : for (j = i; j != EOC; j = stack_vars[j].next)
1286 : 2646 : if (asan_protect_stack_decl (stack_vars[j].decl)
1287 : 2646 : && DECL_NAME (stack_vars[j].decl))
1288 : : {
1289 : 2150 : repr_decl = stack_vars[j].decl;
1290 : 2150 : break;
1291 : : }
1292 : 496 : else if (repr_decl == NULL_TREE
1293 : 496 : && DECL_P (stack_vars[j].decl)
1294 : 992 : && DECL_NAME (stack_vars[j].decl))
1295 : 0 : repr_decl = stack_vars[j].decl;
1296 : 2642 : if (repr_decl == NULL_TREE)
1297 : 492 : repr_decl = stack_vars[i].decl;
1298 : 2642 : data->asan_decl_vec.safe_push (repr_decl);
1299 : :
1300 : : /* Make sure a representative is unpoison if another
1301 : : variable in the partition is handled by
1302 : : use-after-scope sanitization. */
1303 : 2642 : if (asan_handled_variables != NULL
1304 : 2642 : && !asan_handled_variables->contains (repr_decl))
1305 : : {
1306 : 304 : for (j = i; j != EOC; j = stack_vars[j].next)
1307 : 154 : if (asan_handled_variables->contains (stack_vars[j].decl))
1308 : : break;
1309 : 152 : if (j != EOC)
1310 : 2 : asan_handled_variables->add (repr_decl);
1311 : : }
1312 : :
1313 : 2642 : data->asan_alignb = MAX (data->asan_alignb, alignb);
1314 : 2642 : if (data->asan_base == NULL)
1315 : 1428 : data->asan_base = gen_reg_rtx (Pmode);
1316 : 2642 : base = data->asan_base;
1317 : :
1318 : 2642 : if (!STRICT_ALIGNMENT)
1319 : 2642 : base_align = crtl->max_used_stack_slot_alignment;
1320 : : else
1321 : : base_align = MAX (crtl->max_used_stack_slot_alignment,
1322 : : GET_MODE_ALIGNMENT (SImode)
1323 : : << ASAN_SHADOW_SHIFT);
1324 : : }
1325 : : else
1326 : : {
1327 : 887529 : offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
1328 : 887529 : base_align = crtl->max_used_stack_slot_alignment;
1329 : :
1330 : 887529 : if (hwasan_sanitize_stack_p ())
1331 : : {
1332 : : /* Align again since the point of this alignment is to handle
1333 : : the "end" of the object (i.e. smallest address after the
1334 : : stack object). For FRAME_GROWS_DOWNWARD that requires
1335 : : aligning the stack before allocating, but for a frame that
1336 : : grows upwards that requires aligning the stack after
1337 : : allocation.
1338 : :
1339 : : Use `frame_offset` to record the offset value rather than
1340 : : `offset` since the `frame_offset` describes the extent
1341 : : allocated for this particular variable while `offset`
1342 : : describes the address that this variable starts at. */
1343 : 56 : align_frame_offset (HWASAN_TAG_GRANULE_SIZE);
1344 : 56 : hwasan_record_stack_var (virtual_stack_vars_rtx, base,
1345 : : hwasan_orig_offset, frame_offset);
1346 : : }
1347 : : }
1348 : : }
1349 : : else
1350 : : {
1351 : : /* Large alignment is only processed in the last pass. */
1352 : 0 : if (pred)
1353 : 0 : continue;
1354 : :
1355 : : /* If there were any variables requiring "large" alignment, allocate
1356 : : space. */
1357 : 0 : if (maybe_ne (large_size, 0U) && ! large_allocation_done)
1358 : : {
1359 : 0 : poly_int64 loffset;
1360 : 0 : rtx large_allocsize;
1361 : :
1362 : 0 : large_allocsize = gen_int_mode (large_size, Pmode);
1363 : 0 : get_dynamic_stack_size (&large_allocsize, 0, large_align, NULL);
1364 : 0 : loffset = alloc_stack_frame_space
1365 : 0 : (rtx_to_poly_int64 (large_allocsize),
1366 : 0 : PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT);
1367 : 0 : large_base = get_dynamic_stack_base (loffset, large_align, base);
1368 : 0 : large_allocation_done = true;
1369 : : }
1370 : :
1371 : 0 : gcc_assert (large_base != NULL);
1372 : 0 : large_alloc = aligned_upper_bound (large_alloc, alignb);
1373 : 0 : offset = large_alloc;
1374 : 0 : large_alloc += stack_vars[i].size;
1375 : 0 : if (hwasan_sanitize_stack_p ())
1376 : : {
1377 : : /* An object with a large alignment requirement means that the
1378 : : alignment requirement is greater than the required alignment
1379 : : for tags. */
1380 : 0 : if (!large_untagged_base)
1381 : 0 : large_untagged_base
1382 : 0 : = targetm.memtag.untagged_pointer (large_base, NULL_RTX);
1383 : : /* Ensure the end of the variable is also aligned correctly. */
1384 : 0 : poly_int64 align_again
1385 : 0 : = aligned_upper_bound (large_alloc, HWASAN_TAG_GRANULE_SIZE);
1386 : : /* For large allocations we always allocate a chunk of space
1387 : : (which is addressed by large_untagged_base/large_base) and
1388 : : then use positive offsets from that. Hence the farthest
1389 : : offset is `align_again` and the nearest offset from the base
1390 : : is `offset`. */
1391 : 0 : hwasan_record_stack_var (large_untagged_base, large_base,
1392 : : offset, align_again);
1393 : : }
1394 : :
1395 : : base = large_base;
1396 : : base_align = large_align;
1397 : : }
1398 : :
1399 : : /* Create rtl for each variable based on their location within the
1400 : : partition. */
1401 : 2019290 : for (j = i; j != EOC; j = stack_vars[j].next)
1402 : : {
1403 : 1129119 : expand_one_stack_var_at (stack_vars[j].decl,
1404 : : base, base_align, offset);
1405 : : }
1406 : 890171 : if (hwasan_sanitize_stack_p ())
1407 : 56 : hwasan_increment_frame_tag ();
1408 : : }
1409 : :
1410 : 225364 : gcc_assert (known_eq (large_alloc, large_size));
1411 : 225364 : }
1412 : :
1413 : : /* Take into account all sizes of partitions and reset DECL_RTLs. */
1414 : : static poly_uint64
1415 : 980034 : account_stack_vars (void)
1416 : : {
1417 : 980034 : unsigned si, j, i, n = stack_vars_num;
1418 : 980034 : poly_uint64 size = 0;
1419 : :
1420 : 5176393 : for (si = 0; si < n; ++si)
1421 : : {
1422 : 4196359 : i = stack_vars_sorted[si];
1423 : :
1424 : : /* Skip variables that aren't partition representatives, for now. */
1425 : 4196359 : if (stack_vars[i].representative != i)
1426 : 0 : continue;
1427 : :
1428 : 8392718 : size += stack_vars[i].size;
1429 : 8392718 : for (j = i; j != EOC; j = stack_vars[j].next)
1430 : 4196359 : set_rtl (stack_vars[j].decl, NULL);
1431 : : }
1432 : 980034 : return size;
1433 : : }
1434 : :
1435 : : /* Record the RTL assignment X for the default def of PARM. */
1436 : :
1437 : : extern void
1438 : 4608425 : set_parm_rtl (tree parm, rtx x)
1439 : : {
1440 : 4608425 : gcc_assert (TREE_CODE (parm) == PARM_DECL
1441 : : || TREE_CODE (parm) == RESULT_DECL);
1442 : :
1443 : 4608425 : if (x && !MEM_P (x))
1444 : : {
1445 : 2934843 : unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (parm),
1446 : : TYPE_MODE (TREE_TYPE (parm)),
1447 : : TYPE_ALIGN (TREE_TYPE (parm)));
1448 : :
1449 : : /* If the variable alignment is very large we'll dynamicaly
1450 : : allocate it, which means that in-frame portion is just a
1451 : : pointer. ??? We've got a pseudo for sure here, do we
1452 : : actually dynamically allocate its spilling area if needed?
1453 : : ??? Isn't it a problem when Pmode alignment also exceeds
1454 : : MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1455 : 2934843 : if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1456 : 0 : align = GET_MODE_ALIGNMENT (Pmode);
1457 : :
1458 : 2934843 : record_alignment_for_reg_var (align);
1459 : : }
1460 : :
1461 : 4608425 : tree ssa = ssa_default_def (cfun, parm);
1462 : 4608425 : if (!ssa)
1463 : 1084733 : return set_rtl (parm, x);
1464 : :
1465 : 3523692 : int part = var_to_partition (SA.map, ssa);
1466 : 3523692 : gcc_assert (part != NO_PARTITION);
1467 : :
1468 : 3523692 : bool changed = bitmap_bit_p (SA.partitions_for_parm_default_defs, part);
1469 : 3523692 : gcc_assert (changed);
1470 : :
1471 : 3523692 : set_rtl (ssa, x);
1472 : 3523692 : gcc_assert (DECL_RTL (parm) == x);
1473 : : }
1474 : :
1475 : : /* A subroutine of expand_one_var. Called to immediately assign rtl
1476 : : to a variable to be allocated in the stack frame. */
1477 : :
1478 : : static void
1479 : 781175 : expand_one_stack_var_1 (tree var)
1480 : : {
1481 : 781175 : poly_uint64 size;
1482 : 781175 : poly_int64 offset;
1483 : 781175 : unsigned byte_align;
1484 : :
1485 : 781175 : if (TREE_CODE (var) == SSA_NAME)
1486 : : {
1487 : 439182 : tree type = TREE_TYPE (var);
1488 : 439182 : size = tree_to_poly_uint64 (TYPE_SIZE_UNIT (type));
1489 : : }
1490 : : else
1491 : 341993 : size = tree_to_poly_uint64 (DECL_SIZE_UNIT (var));
1492 : :
1493 : 781175 : byte_align = align_local_variable (var, true);
1494 : :
1495 : : /* We handle highly aligned variables in expand_stack_vars. */
1496 : 781175 : gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
1497 : :
1498 : 781175 : rtx base;
1499 : 781175 : if (hwasan_sanitize_stack_p ())
1500 : : {
1501 : : /* Allocate zero bytes to align the stack. */
1502 : 29 : poly_int64 hwasan_orig_offset
1503 : 29 : = align_frame_offset (HWASAN_TAG_GRANULE_SIZE);
1504 : 29 : offset = alloc_stack_frame_space (size, byte_align);
1505 : 29 : align_frame_offset (HWASAN_TAG_GRANULE_SIZE);
1506 : 29 : base = hwasan_frame_base ();
1507 : : /* Use `frame_offset` to automatically account for machines where the
1508 : : frame grows upwards.
1509 : :
1510 : : `offset` will always point to the "start" of the stack object, which
1511 : : will be the smallest address, for ! FRAME_GROWS_DOWNWARD this is *not*
1512 : : the "furthest" offset from the base delimiting the current stack
1513 : : object. `frame_offset` will always delimit the extent that the frame.
1514 : : */
1515 : 29 : hwasan_record_stack_var (virtual_stack_vars_rtx, base,
1516 : : hwasan_orig_offset, frame_offset);
1517 : : }
1518 : : else
1519 : : {
1520 : 781146 : offset = alloc_stack_frame_space (size, byte_align);
1521 : 781146 : base = virtual_stack_vars_rtx;
1522 : : }
1523 : :
1524 : 781175 : expand_one_stack_var_at (var, base,
1525 : : crtl->max_used_stack_slot_alignment, offset);
1526 : :
1527 : 781175 : if (hwasan_sanitize_stack_p ())
1528 : 29 : hwasan_increment_frame_tag ();
1529 : 781175 : }
1530 : :
1531 : : /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1532 : : already assigned some MEM. */
1533 : :
1534 : : static void
1535 : 341993 : expand_one_stack_var (tree var)
1536 : : {
1537 : 341993 : if (TREE_CODE (var) == SSA_NAME)
1538 : : {
1539 : 0 : int part = var_to_partition (SA.map, var);
1540 : 0 : if (part != NO_PARTITION)
1541 : : {
1542 : 0 : rtx x = SA.partition_to_pseudo[part];
1543 : 0 : gcc_assert (x);
1544 : 0 : gcc_assert (MEM_P (x));
1545 : : return;
1546 : : }
1547 : : }
1548 : :
1549 : 341993 : return expand_one_stack_var_1 (var);
1550 : : }
1551 : :
1552 : : /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1553 : : that will reside in a hard register. */
1554 : :
1555 : : static void
1556 : 1075 : expand_one_hard_reg_var (tree var)
1557 : : {
1558 : 0 : rest_of_decl_compilation (var, 0, 0);
1559 : 0 : }
1560 : :
1561 : : /* Record the alignment requirements of some variable assigned to a
1562 : : pseudo. */
1563 : :
1564 : : static void
1565 : 39268258 : record_alignment_for_reg_var (unsigned int align)
1566 : : {
1567 : 39268258 : if (SUPPORTS_STACK_ALIGNMENT
1568 : 39268258 : && crtl->stack_alignment_estimated < align)
1569 : : {
1570 : : /* stack_alignment_estimated shouldn't change after stack
1571 : : realign decision made */
1572 : 1805844 : gcc_assert (!crtl->stack_realign_processed);
1573 : 1805844 : crtl->stack_alignment_estimated = align;
1574 : : }
1575 : :
1576 : : /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1577 : : So here we only make sure stack_alignment_needed >= align. */
1578 : 39268258 : if (crtl->stack_alignment_needed < align)
1579 : 543434 : crtl->stack_alignment_needed = align;
1580 : 39268258 : if (crtl->max_used_stack_slot_alignment < align)
1581 : 543434 : crtl->max_used_stack_slot_alignment = align;
1582 : 39268258 : }
1583 : :
1584 : : /* Create RTL for an SSA partition. */
1585 : :
1586 : : static void
1587 : 21836617 : expand_one_ssa_partition (tree var)
1588 : : {
1589 : 21836617 : int part = var_to_partition (SA.map, var);
1590 : 21836617 : gcc_assert (part != NO_PARTITION);
1591 : :
1592 : 21836617 : if (SA.partition_to_pseudo[part])
1593 : : return;
1594 : :
1595 : 21836617 : unsigned int align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1596 : : TYPE_MODE (TREE_TYPE (var)),
1597 : : TYPE_ALIGN (TREE_TYPE (var)));
1598 : :
1599 : : /* If the variable alignment is very large we'll dynamicaly allocate
1600 : : it, which means that in-frame portion is just a pointer. */
1601 : 21836617 : if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1602 : 0 : align = GET_MODE_ALIGNMENT (Pmode);
1603 : :
1604 : 21836617 : record_alignment_for_reg_var (align);
1605 : :
1606 : 21836617 : if (!use_register_for_decl (var))
1607 : : {
1608 : 441870 : if (defer_stack_allocation (var, true))
1609 : 2688 : add_stack_var (var, true);
1610 : : else
1611 : 439182 : expand_one_stack_var_1 (var);
1612 : 441870 : return;
1613 : : }
1614 : :
1615 : 21394747 : machine_mode reg_mode = promote_ssa_mode (var, NULL);
1616 : 21394747 : rtx x = gen_reg_rtx (reg_mode);
1617 : :
1618 : 21394747 : set_rtl (var, x);
1619 : :
1620 : : /* For a promoted variable, X will not be used directly but wrapped in a
1621 : : SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1622 : : will assume that its upper bits can be inferred from its lower bits.
1623 : : Therefore, if X isn't initialized on every path from the entry, then
1624 : : we must do it manually in order to fulfill the above assumption. */
1625 : 21394747 : if (reg_mode != TYPE_MODE (TREE_TYPE (var))
1626 : 21394747 : && bitmap_bit_p (SA.partitions_for_undefined_values, part))
1627 : 0 : emit_move_insn (x, CONST0_RTX (reg_mode));
1628 : : }
1629 : :
1630 : : /* Record the association between the RTL generated for partition PART
1631 : : and the underlying variable of the SSA_NAME VAR. */
1632 : :
1633 : : static void
1634 : 47297493 : adjust_one_expanded_partition_var (tree var)
1635 : : {
1636 : 47297493 : if (!var)
1637 : : return;
1638 : :
1639 : 47297493 : tree decl = SSA_NAME_VAR (var);
1640 : :
1641 : 47297493 : int part = var_to_partition (SA.map, var);
1642 : 47297493 : if (part == NO_PARTITION)
1643 : : return;
1644 : :
1645 : 30595510 : rtx x = SA.partition_to_pseudo[part];
1646 : :
1647 : 30595510 : gcc_assert (x);
1648 : :
1649 : 30595510 : set_rtl (var, x);
1650 : :
1651 : 30595510 : if (!REG_P (x))
1652 : : return;
1653 : :
1654 : : /* Note if the object is a user variable. */
1655 : 28639405 : if (decl && !DECL_ARTIFICIAL (decl))
1656 : 3940991 : mark_user_reg (x);
1657 : :
1658 : 28639405 : if (POINTER_TYPE_P (decl ? TREE_TYPE (decl) : TREE_TYPE (var)))
1659 : 7073653 : mark_reg_pointer (x, get_pointer_alignment (var));
1660 : : }
1661 : :
1662 : : /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1663 : : that will reside in a pseudo register. */
1664 : :
1665 : : static void
1666 : 575121 : expand_one_register_var (tree var)
1667 : : {
1668 : 575121 : if (TREE_CODE (var) == SSA_NAME)
1669 : : {
1670 : 0 : int part = var_to_partition (SA.map, var);
1671 : 0 : if (part != NO_PARTITION)
1672 : : {
1673 : 0 : rtx x = SA.partition_to_pseudo[part];
1674 : 0 : gcc_assert (x);
1675 : 0 : gcc_assert (REG_P (x));
1676 : : return;
1677 : : }
1678 : 0 : gcc_unreachable ();
1679 : : }
1680 : :
1681 : 575121 : tree decl = var;
1682 : 575121 : tree type = TREE_TYPE (decl);
1683 : 575121 : machine_mode reg_mode = promote_decl_mode (decl, NULL);
1684 : 575121 : rtx x = gen_reg_rtx (reg_mode);
1685 : :
1686 : 575121 : set_rtl (var, x);
1687 : :
1688 : : /* Note if the object is a user variable. */
1689 : 575121 : if (!DECL_ARTIFICIAL (decl))
1690 : 104204 : mark_user_reg (x);
1691 : :
1692 : 575121 : if (POINTER_TYPE_P (type))
1693 : 169 : mark_reg_pointer (x, get_pointer_alignment (var));
1694 : : }
1695 : :
1696 : : /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1697 : : has some associated error, e.g. its type is error-mark. We just need
1698 : : to pick something that won't crash the rest of the compiler. */
1699 : :
1700 : : static void
1701 : 29 : expand_one_error_var (tree var)
1702 : : {
1703 : 29 : machine_mode mode = DECL_MODE (var);
1704 : 29 : rtx x;
1705 : :
1706 : 29 : if (mode == BLKmode)
1707 : 1 : x = gen_rtx_MEM (BLKmode, const0_rtx);
1708 : 28 : else if (mode == VOIDmode)
1709 : 0 : x = const0_rtx;
1710 : : else
1711 : 28 : x = gen_reg_rtx (mode);
1712 : :
1713 : 29 : SET_DECL_RTL (var, x);
1714 : 29 : }
1715 : :
1716 : : /* A subroutine of expand_one_var. VAR is a variable that will be
1717 : : allocated to the local stack frame. Return true if we wish to
1718 : : add VAR to STACK_VARS so that it will be coalesced with other
1719 : : variables. Return false to allocate VAR immediately.
1720 : :
1721 : : This function is used to reduce the number of variables considered
1722 : : for coalescing, which reduces the size of the quadratic problem. */
1723 : :
1724 : : static bool
1725 : 6234067 : defer_stack_allocation (tree var, bool toplevel)
1726 : : {
1727 : 6234067 : tree size_unit = TREE_CODE (var) == SSA_NAME
1728 : 12026264 : ? TYPE_SIZE_UNIT (TREE_TYPE (var))
1729 : 5792197 : : DECL_SIZE_UNIT (var);
1730 : 6234067 : poly_uint64 size;
1731 : :
1732 : : /* Whether the variable is small enough for immediate allocation not to be
1733 : : a problem with regard to the frame size. */
1734 : 6234067 : bool smallish
1735 : 6234067 : = (poly_int_tree_p (size_unit, &size)
1736 : 6234067 : && (estimated_poly_value (size)
1737 : 6234067 : < param_min_size_for_stack_sharing));
1738 : :
1739 : : /* If stack protection is enabled, *all* stack variables must be deferred,
1740 : : so that we can re-order the strings to the top of the frame.
1741 : : Similarly for Address Sanitizer. */
1742 : 6234067 : if (flag_stack_protect || asan_sanitize_stack_p ())
1743 : 10831 : return true;
1744 : :
1745 : 6223236 : unsigned int align = TREE_CODE (var) == SSA_NAME
1746 : 6223236 : ? TYPE_ALIGN (TREE_TYPE (var))
1747 : 5781890 : : DECL_ALIGN (var);
1748 : :
1749 : : /* We handle "large" alignment via dynamic allocation. We want to handle
1750 : : this extra complication in only one place, so defer them. */
1751 : : if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1752 : : return true;
1753 : :
1754 : 6223236 : bool ignored = TREE_CODE (var) == SSA_NAME
1755 : 6229425 : ? !SSAVAR (var) || DECL_IGNORED_P (SSA_NAME_VAR (var))
1756 : 5781890 : : DECL_IGNORED_P (var);
1757 : :
1758 : : /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1759 : : might be detached from their block and appear at toplevel when we reach
1760 : : here. We want to coalesce them with variables from other blocks when
1761 : : the immediate contribution to the frame size would be noticeable. */
1762 : 6223236 : if (toplevel && optimize > 0 && ignored && !smallish)
1763 : : return true;
1764 : :
1765 : : /* Variables declared in the outermost scope automatically conflict
1766 : : with every other variable. The only reason to want to defer them
1767 : : at all is that, after sorting, we can more efficiently pack
1768 : : small variables in the stack frame. Continue to defer at -O2. */
1769 : 4824406 : if (toplevel && optimize < 2)
1770 : : return false;
1771 : :
1772 : : /* Without optimization, *most* variables are allocated from the
1773 : : stack, which makes the quadratic problem large exactly when we
1774 : : want compilation to proceed as quickly as possible. On the
1775 : : other hand, we don't want the function's stack frame size to
1776 : : get completely out of hand. So we avoid adding scalars and
1777 : : "small" aggregates to the list at all. */
1778 : 4200382 : if (optimize == 0 && smallish)
1779 : : return false;
1780 : :
1781 : : return true;
1782 : : }
1783 : :
1784 : : /* A subroutine of expand_used_vars. Expand one variable according to
1785 : : its flavor. Variables to be placed on the stack are not actually
1786 : : expanded yet, merely recorded.
1787 : : When REALLY_EXPAND is false, only add stack values to be allocated.
1788 : : Return stack usage this variable is supposed to take.
1789 : : */
1790 : :
1791 : : static poly_uint64
1792 : 14890535 : expand_one_var (tree var, bool toplevel, bool really_expand,
1793 : : bitmap forced_stack_var = NULL)
1794 : : {
1795 : 14890535 : unsigned int align = BITS_PER_UNIT;
1796 : 14890535 : tree origvar = var;
1797 : :
1798 : 14890535 : var = SSAVAR (var);
1799 : :
1800 : 14890535 : if (TREE_TYPE (var) != error_mark_node && VAR_P (var))
1801 : : {
1802 : 14890535 : if (is_global_var (var))
1803 : 393737 : return 0;
1804 : :
1805 : : /* Because we don't know if VAR will be in register or on stack,
1806 : : we conservatively assume it will be on stack even if VAR is
1807 : : eventually put into register after RA pass. For non-automatic
1808 : : variables, which won't be on stack, we collect alignment of
1809 : : type and ignore user specified alignment. Similarly for
1810 : : SSA_NAMEs for which use_register_for_decl returns true. */
1811 : 14496798 : if (TREE_STATIC (var)
1812 : 14496798 : || DECL_EXTERNAL (var)
1813 : 28993596 : || (TREE_CODE (origvar) == SSA_NAME && use_register_for_decl (var)))
1814 : 0 : align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1815 : : TYPE_MODE (TREE_TYPE (var)),
1816 : : TYPE_ALIGN (TREE_TYPE (var)));
1817 : 14496798 : else if (DECL_HAS_VALUE_EXPR_P (var)
1818 : 14496798 : || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
1819 : : /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1820 : : or variables which were assigned a stack slot already by
1821 : : expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1822 : : changed from the offset chosen to it. */
1823 : 15271 : align = crtl->stack_alignment_estimated;
1824 : : else
1825 : 14481527 : align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
1826 : :
1827 : : /* If the variable alignment is very large we'll dynamicaly allocate
1828 : : it, which means that in-frame portion is just a pointer. */
1829 : 14496798 : if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1830 : 0 : align = GET_MODE_ALIGNMENT (Pmode);
1831 : : }
1832 : :
1833 : 14496798 : record_alignment_for_reg_var (align);
1834 : :
1835 : 14496798 : poly_uint64 size;
1836 : 14496798 : if (TREE_CODE (origvar) == SSA_NAME)
1837 : : {
1838 : 0 : gcc_assert (!VAR_P (var)
1839 : : || (!DECL_EXTERNAL (var)
1840 : : && !DECL_HAS_VALUE_EXPR_P (var)
1841 : : && !TREE_STATIC (var)
1842 : : && TREE_TYPE (var) != error_mark_node
1843 : : && !DECL_HARD_REGISTER (var)
1844 : : && really_expand));
1845 : : }
1846 : 14496798 : if (!VAR_P (var) && TREE_CODE (origvar) != SSA_NAME)
1847 : : ;
1848 : 14496798 : else if (DECL_EXTERNAL (var))
1849 : : ;
1850 : 14496798 : else if (DECL_HAS_VALUE_EXPR_P (var))
1851 : : ;
1852 : 14481568 : else if (TREE_STATIC (var))
1853 : : ;
1854 : 14481568 : else if (TREE_CODE (origvar) != SSA_NAME && DECL_RTL_SET_P (var))
1855 : : ;
1856 : 14481485 : else if (TREE_TYPE (var) == error_mark_node)
1857 : : {
1858 : 0 : if (really_expand)
1859 : 0 : expand_one_error_var (var);
1860 : : }
1861 : 14481485 : else if (VAR_P (var) && DECL_HARD_REGISTER (var))
1862 : : {
1863 : 4095 : if (really_expand)
1864 : : {
1865 : 1075 : expand_one_hard_reg_var (var);
1866 : 1075 : if (!DECL_HARD_REGISTER (var))
1867 : : /* Invalid register specification. */
1868 : 29 : expand_one_error_var (var);
1869 : : }
1870 : : }
1871 : 14477390 : else if (use_register_for_decl (var)
1872 : 14477390 : && (!forced_stack_var
1873 : 585218 : || !bitmap_bit_p (forced_stack_var, DECL_UID (var))))
1874 : : {
1875 : 8685193 : if (really_expand)
1876 : 575121 : expand_one_register_var (origvar);
1877 : : }
1878 : 5792197 : else if (!poly_int_tree_p (DECL_SIZE_UNIT (var), &size)
1879 : 5792197 : || !valid_constant_size_p (DECL_SIZE_UNIT (var)))
1880 : : {
1881 : : /* Reject variables which cover more than half of the address-space. */
1882 : 0 : if (really_expand)
1883 : : {
1884 : 0 : if (DECL_NONLOCAL_FRAME (var))
1885 : 0 : error_at (DECL_SOURCE_LOCATION (current_function_decl),
1886 : : "total size of local objects is too large");
1887 : : else
1888 : 0 : error_at (DECL_SOURCE_LOCATION (var),
1889 : : "size of variable %q+D is too large", var);
1890 : 0 : expand_one_error_var (var);
1891 : : }
1892 : : }
1893 : 5792197 : else if (defer_stack_allocation (var, toplevel))
1894 : 5322790 : add_stack_var (origvar, really_expand);
1895 : : else
1896 : : {
1897 : 469407 : if (really_expand)
1898 : : {
1899 : 341771 : if (lookup_attribute ("naked",
1900 : 341771 : DECL_ATTRIBUTES (current_function_decl)))
1901 : 0 : error ("cannot allocate stack for variable %q+D, naked function",
1902 : : var);
1903 : :
1904 : 341771 : expand_one_stack_var (origvar);
1905 : : }
1906 : 469407 : return size;
1907 : : }
1908 : 14027391 : return 0;
1909 : : }
1910 : :
1911 : : /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1912 : : expanding variables. Those variables that can be put into registers
1913 : : are allocated pseudos; those that can't are put on the stack.
1914 : :
1915 : : TOPLEVEL is true if this is the outermost BLOCK. */
1916 : :
1917 : : static void
1918 : 14437514 : expand_used_vars_for_block (tree block, bool toplevel, bitmap forced_stack_vars)
1919 : : {
1920 : 14437514 : tree t;
1921 : :
1922 : : /* Expand all variables at this level. */
1923 : 29793046 : for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1924 : 15355532 : if (TREE_USED (t)
1925 : 15355532 : && ((!VAR_P (t) && TREE_CODE (t) != RESULT_DECL)
1926 : 790437 : || !DECL_NONSHAREABLE (t)))
1927 : 790437 : expand_one_var (t, toplevel, true, forced_stack_vars);
1928 : :
1929 : : /* Expand all variables at containing levels. */
1930 : 27387747 : for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1931 : 12950233 : expand_used_vars_for_block (t, false, forced_stack_vars);
1932 : 14437514 : }
1933 : :
1934 : : /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1935 : : and clear TREE_USED on all local variables. */
1936 : :
1937 : : static void
1938 : 14437514 : clear_tree_used (tree block)
1939 : : {
1940 : 14437514 : tree t;
1941 : :
1942 : 29793046 : for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1943 : : /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1944 : 838112 : if ((!VAR_P (t) && TREE_CODE (t) != RESULT_DECL)
1945 : 15355532 : || !DECL_NONSHAREABLE (t))
1946 : 15355532 : TREE_USED (t) = 0;
1947 : :
1948 : 27387747 : for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1949 : 12950233 : clear_tree_used (t);
1950 : 14437514 : }
1951 : :
1952 : : /* Examine TYPE and determine a bit mask of the following features. */
1953 : :
1954 : : #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1955 : : #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1956 : : #define SPCT_HAS_ARRAY 4
1957 : : #define SPCT_HAS_AGGREGATE 8
1958 : :
1959 : : static unsigned int
1960 : 2576 : stack_protect_classify_type (tree type)
1961 : : {
1962 : 2576 : unsigned int ret = 0;
1963 : 2576 : tree t;
1964 : :
1965 : 2576 : switch (TREE_CODE (type))
1966 : : {
1967 : 580 : case ARRAY_TYPE:
1968 : 580 : t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1969 : 580 : if (t == char_type_node
1970 : 142 : || t == signed_char_type_node
1971 : 142 : || t == unsigned_char_type_node)
1972 : : {
1973 : 438 : unsigned HOST_WIDE_INT max = param_ssp_buffer_size;
1974 : 438 : unsigned HOST_WIDE_INT len;
1975 : :
1976 : 438 : if (!TYPE_SIZE_UNIT (type)
1977 : 438 : || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type)))
1978 : : len = max;
1979 : : else
1980 : 438 : len = tree_to_uhwi (TYPE_SIZE_UNIT (type));
1981 : :
1982 : 438 : if (len < max)
1983 : : ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
1984 : : else
1985 : 414 : ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
1986 : : }
1987 : : else
1988 : : ret = SPCT_HAS_ARRAY;
1989 : : break;
1990 : :
1991 : 1010 : case UNION_TYPE:
1992 : 1010 : case QUAL_UNION_TYPE:
1993 : 1010 : case RECORD_TYPE:
1994 : 1010 : ret = SPCT_HAS_AGGREGATE;
1995 : 10875 : for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
1996 : 9865 : if (TREE_CODE (t) == FIELD_DECL)
1997 : 1673 : ret |= stack_protect_classify_type (TREE_TYPE (t));
1998 : : break;
1999 : :
2000 : : default:
2001 : : break;
2002 : : }
2003 : :
2004 : 2576 : return ret;
2005 : : }
2006 : :
2007 : : /* Return nonzero if DECL should be segregated into the "vulnerable" upper
2008 : : part of the local stack frame. Remember if we ever return nonzero for
2009 : : any variable in this function. The return value is the phase number in
2010 : : which the variable should be allocated. */
2011 : :
2012 : : static int
2013 : 903 : stack_protect_decl_phase (tree decl)
2014 : : {
2015 : 903 : unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
2016 : 903 : int ret = 0;
2017 : :
2018 : 903 : if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
2019 : 24 : has_short_buffer = true;
2020 : :
2021 : 903 : tree attribs = DECL_ATTRIBUTES (current_function_decl);
2022 : 903 : if (!lookup_attribute ("no_stack_protector", attribs)
2023 : 903 : && (flag_stack_protect == SPCT_FLAG_ALL
2024 : 903 : || flag_stack_protect == SPCT_FLAG_STRONG
2025 : 143 : || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2026 : 5 : && lookup_attribute ("stack_protect", attribs))))
2027 : : {
2028 : 765 : if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
2029 : 342 : && !(bits & SPCT_HAS_AGGREGATE))
2030 : : ret = 1;
2031 : 711 : else if (bits & SPCT_HAS_ARRAY)
2032 : : ret = 2;
2033 : : }
2034 : : else
2035 : 138 : ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
2036 : :
2037 : 138 : if (ret)
2038 : 570 : has_protected_decls = true;
2039 : :
2040 : 903 : return ret;
2041 : : }
2042 : :
2043 : : /* Two helper routines that check for phase 1 and phase 2. These are used
2044 : : as callbacks for expand_stack_vars. */
2045 : :
2046 : : static bool
2047 : 291 : stack_protect_decl_phase_1 (unsigned i)
2048 : : {
2049 : 291 : return stack_protect_decl_phase (stack_vars[i].decl) == 1;
2050 : : }
2051 : :
2052 : : static bool
2053 : 204 : stack_protect_decl_phase_2 (unsigned i)
2054 : : {
2055 : 204 : return stack_protect_decl_phase (stack_vars[i].decl) == 2;
2056 : : }
2057 : :
2058 : : /* And helper function that checks for asan phase (with stack protector
2059 : : it is phase 3). This is used as callback for expand_stack_vars.
2060 : : Returns true if any of the vars in the partition need to be protected. */
2061 : :
2062 : : static bool
2063 : 3128 : asan_decl_phase_3 (unsigned i)
2064 : : {
2065 : 3699 : while (i != EOC)
2066 : : {
2067 : 3128 : if (asan_protect_stack_decl (stack_vars[i].decl))
2068 : : return true;
2069 : 571 : i = stack_vars[i].next;
2070 : : }
2071 : : return false;
2072 : : }
2073 : :
2074 : : /* Ensure that variables in different stack protection phases conflict
2075 : : so that they are not merged and share the same stack slot.
2076 : : Return true if there are any address taken variables. */
2077 : :
2078 : : static bool
2079 : 207 : add_stack_protection_conflicts (void)
2080 : : {
2081 : 207 : unsigned i, j, n = stack_vars_num;
2082 : 207 : unsigned char *phase;
2083 : 207 : bool ret = false;
2084 : :
2085 : 207 : phase = XNEWVEC (unsigned char, n);
2086 : 822 : for (i = 0; i < n; ++i)
2087 : : {
2088 : 408 : phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
2089 : 408 : if (TREE_ADDRESSABLE (stack_vars[i].decl))
2090 : 335 : ret = true;
2091 : : }
2092 : :
2093 : 615 : for (i = 0; i < n; ++i)
2094 : : {
2095 : 408 : unsigned char ph_i = phase[i];
2096 : 1111 : for (j = i + 1; j < n; ++j)
2097 : 703 : if (ph_i != phase[j])
2098 : 319 : add_stack_var_conflict (i, j);
2099 : : }
2100 : :
2101 : 207 : XDELETEVEC (phase);
2102 : 207 : return ret;
2103 : : }
2104 : :
2105 : : /* Create a decl for the guard at the top of the stack frame. */
2106 : :
2107 : : static void
2108 : 222 : create_stack_guard (void)
2109 : : {
2110 : 222 : tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
2111 : : VAR_DECL, NULL, ptr_type_node);
2112 : 222 : TREE_THIS_VOLATILE (guard) = 1;
2113 : 222 : TREE_USED (guard) = 1;
2114 : 222 : expand_one_stack_var (guard);
2115 : 222 : crtl->stack_protect_guard = guard;
2116 : 222 : }
2117 : :
2118 : : /* Prepare for expanding variables. */
2119 : : static void
2120 : 7406124 : init_vars_expansion (void)
2121 : : {
2122 : : /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
2123 : 7406124 : bitmap_obstack_initialize (&stack_var_bitmap_obstack);
2124 : :
2125 : : /* A map from decl to stack partition. */
2126 : 7406124 : decl_to_stack_part = new hash_map<tree, unsigned>;
2127 : :
2128 : : /* Initialize local stack smashing state. */
2129 : 7406124 : has_protected_decls = false;
2130 : 7406124 : has_short_buffer = false;
2131 : 7406124 : if (hwasan_sanitize_stack_p ())
2132 : 1190 : hwasan_record_frame_init ();
2133 : 7406124 : }
2134 : :
2135 : : /* Free up stack variable graph data. */
2136 : : static void
2137 : 7406124 : fini_vars_expansion (void)
2138 : : {
2139 : 7406124 : bitmap_obstack_release (&stack_var_bitmap_obstack);
2140 : 7406124 : if (stack_vars)
2141 : 1203631 : XDELETEVEC (stack_vars);
2142 : 7406124 : if (stack_vars_sorted)
2143 : 1203631 : XDELETEVEC (stack_vars_sorted);
2144 : 7406124 : stack_vars = NULL;
2145 : 7406124 : stack_vars_sorted = NULL;
2146 : 7406124 : stack_vars_alloc = stack_vars_num = 0;
2147 : 14812248 : delete decl_to_stack_part;
2148 : 7406124 : decl_to_stack_part = NULL;
2149 : 7406124 : }
2150 : :
2151 : : /* Make a fair guess for the size of the stack frame of the function
2152 : : in NODE. This doesn't have to be exact, the result is only used in
2153 : : the inline heuristics. So we don't want to run the full stack var
2154 : : packing algorithm (which is quadratic in the number of stack vars).
2155 : : Instead, we calculate the total size of all stack vars. This turns
2156 : : out to be a pretty fair estimate -- packing of stack vars doesn't
2157 : : happen very often. */
2158 : :
2159 : : HOST_WIDE_INT
2160 : 5918843 : estimated_stack_frame_size (struct cgraph_node *node)
2161 : : {
2162 : 5918843 : poly_int64 size = 0;
2163 : 5918843 : unsigned i;
2164 : 5918843 : tree var;
2165 : 5918843 : struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
2166 : :
2167 : 5918843 : push_cfun (fn);
2168 : :
2169 : 5918843 : init_vars_expansion ();
2170 : :
2171 : 23911354 : FOR_EACH_LOCAL_DECL (fn, i, var)
2172 : 13142880 : if (auto_var_in_fn_p (var, fn->decl))
2173 : 12437129 : size += expand_one_var (var, true, false);
2174 : :
2175 : 5918843 : if (stack_vars_num > 0)
2176 : : {
2177 : : /* Fake sorting the stack vars for account_stack_vars (). */
2178 : 980034 : stack_vars_sorted = XNEWVEC (unsigned , stack_vars_num);
2179 : 5176393 : for (i = 0; i < stack_vars_num; ++i)
2180 : 4196359 : stack_vars_sorted[i] = i;
2181 : 980034 : size += account_stack_vars ();
2182 : : }
2183 : :
2184 : 5918843 : fini_vars_expansion ();
2185 : 5918843 : pop_cfun ();
2186 : 5918843 : return estimated_poly_value (size);
2187 : : }
2188 : :
2189 : : /* Check if the current function has calls that use a return slot. */
2190 : :
2191 : : static bool
2192 : 399 : stack_protect_return_slot_p ()
2193 : : {
2194 : 399 : basic_block bb;
2195 : :
2196 : 1750 : FOR_ALL_BB_FN (bb, cfun)
2197 : 2758 : for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
2198 : 3626 : !gsi_end_p (gsi); gsi_next (&gsi))
2199 : : {
2200 : 2275 : gimple *stmt = gsi_stmt (gsi);
2201 : : /* This assumes that calls to internal-only functions never
2202 : : use a return slot. */
2203 : 2275 : if (is_gimple_call (stmt)
2204 : 460 : && !gimple_call_internal_p (stmt)
2205 : 2727 : && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt)),
2206 : 452 : gimple_call_fndecl (stmt)))
2207 : 399 : return true;
2208 : : }
2209 : : return false;
2210 : : }
2211 : :
2212 : : /* Expand all variables used in the function. */
2213 : :
2214 : : static rtx_insn *
2215 : 1487281 : expand_used_vars (bitmap forced_stack_vars)
2216 : : {
2217 : 1487281 : tree var, outer_block = DECL_INITIAL (current_function_decl);
2218 : 1487281 : auto_vec<tree> maybe_local_decls;
2219 : 1487281 : rtx_insn *var_end_seq = NULL;
2220 : 1487281 : unsigned i;
2221 : 1487281 : unsigned len;
2222 : 1487281 : bool gen_stack_protect_signal = false;
2223 : :
2224 : : /* Compute the phase of the stack frame for this function. */
2225 : 1487281 : {
2226 : 1487281 : int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
2227 : 1487281 : int off = targetm.starting_frame_offset () % align;
2228 : 1487281 : frame_phase = off ? align - off : 0;
2229 : : }
2230 : :
2231 : : /* Set TREE_USED on all variables in the local_decls. */
2232 : 10383418 : FOR_EACH_LOCAL_DECL (cfun, i, var)
2233 : 7641904 : TREE_USED (var) = 1;
2234 : : /* Clear TREE_USED on all variables associated with a block scope. */
2235 : 1487281 : clear_tree_used (DECL_INITIAL (current_function_decl));
2236 : :
2237 : 1487281 : init_vars_expansion ();
2238 : :
2239 : 1487281 : if (targetm.use_pseudo_pic_reg ())
2240 : 39600 : pic_offset_table_rtx = gen_reg_rtx (Pmode);
2241 : :
2242 : 26847590 : for (i = 0; i < SA.map->num_partitions; i++)
2243 : : {
2244 : 25360309 : if (bitmap_bit_p (SA.partitions_for_parm_default_defs, i))
2245 : 3523692 : continue;
2246 : :
2247 : 21836617 : tree var = partition_to_var (SA.map, i);
2248 : :
2249 : 43673234 : gcc_assert (!virtual_operand_p (var));
2250 : :
2251 : 21836617 : expand_one_ssa_partition (var);
2252 : : }
2253 : :
2254 : 1487281 : if (flag_stack_protect == SPCT_FLAG_STRONG)
2255 : 399 : gen_stack_protect_signal = stack_protect_return_slot_p ();
2256 : :
2257 : : /* At this point all variables on the local_decls with TREE_USED
2258 : : set are not associated with any block scope. Lay them out. */
2259 : :
2260 : 1487281 : len = vec_safe_length (cfun->local_decls);
2261 : 9129185 : FOR_EACH_LOCAL_DECL (cfun, i, var)
2262 : : {
2263 : 7641904 : bool expand_now = false;
2264 : :
2265 : : /* Expanded above already. */
2266 : 7641904 : if (is_gimple_reg (var))
2267 : : {
2268 : 5311227 : TREE_USED (var) = 0;
2269 : 5311227 : goto next;
2270 : : }
2271 : : /* We didn't set a block for static or extern because it's hard
2272 : : to tell the difference between a global variable (re)declared
2273 : : in a local scope, and one that's really declared there to
2274 : : begin with. And it doesn't really matter much, since we're
2275 : : not giving them stack space. Expand them now. */
2276 : 2330677 : else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
2277 : : expand_now = true;
2278 : :
2279 : : /* Expand variables not associated with any block now. Those created by
2280 : : the optimizers could be live anywhere in the function. Those that
2281 : : could possibly have been scoped originally and detached from their
2282 : : block will have their allocation deferred so we coalesce them with
2283 : : others when optimization is enabled. */
2284 : 2059669 : else if (TREE_USED (var))
2285 : 1662969 : expand_now = true;
2286 : :
2287 : : /* Finally, mark all variables on the list as used. We'll use
2288 : : this in a moment when we expand those associated with scopes. */
2289 : 2330677 : TREE_USED (var) = 1;
2290 : :
2291 : 2330677 : if (expand_now)
2292 : 1662969 : expand_one_var (var, true, true, forced_stack_vars);
2293 : :
2294 : 667708 : next:
2295 : 7641904 : if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
2296 : : {
2297 : 404762 : rtx rtl = DECL_RTL_IF_SET (var);
2298 : :
2299 : : /* Keep artificial non-ignored vars in cfun->local_decls
2300 : : chain until instantiate_decls. */
2301 : 307358 : if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
2302 : 19045 : add_local_decl (cfun, var);
2303 : 97404 : else if (rtl == NULL_RTX)
2304 : : /* If rtl isn't set yet, which can happen e.g. with
2305 : : -fstack-protector, retry before returning from this
2306 : : function. */
2307 : 97404 : maybe_local_decls.safe_push (var);
2308 : : }
2309 : : }
2310 : :
2311 : : /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2312 : :
2313 : : +-----------------+-----------------+
2314 : : | ...processed... | ...duplicates...|
2315 : : +-----------------+-----------------+
2316 : : ^
2317 : : +-- LEN points here.
2318 : :
2319 : : We just want the duplicates, as those are the artificial
2320 : : non-ignored vars that we want to keep until instantiate_decls.
2321 : : Move them down and truncate the array. */
2322 : 1487281 : if (!vec_safe_is_empty (cfun->local_decls))
2323 : 867389 : cfun->local_decls->block_remove (0, len);
2324 : :
2325 : : /* At this point, all variables within the block tree with TREE_USED
2326 : : set are actually used by the optimized function. Lay them out. */
2327 : 1487281 : expand_used_vars_for_block (outer_block, true, forced_stack_vars);
2328 : :
2329 : 1487281 : tree attribs = DECL_ATTRIBUTES (current_function_decl);
2330 : 1487281 : if (stack_vars_num > 0)
2331 : : {
2332 : 223597 : bool has_addressable_vars = false;
2333 : :
2334 : 223597 : add_scope_conflicts ();
2335 : :
2336 : : /* If stack protection is enabled, we don't share space between
2337 : : vulnerable data and non-vulnerable data. */
2338 : 223597 : if (flag_stack_protect != 0
2339 : 207 : && !lookup_attribute ("no_stack_protector", attribs)
2340 : 223804 : && (flag_stack_protect != SPCT_FLAG_EXPLICIT
2341 : : || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2342 : 1 : && lookup_attribute ("stack_protect", attribs))))
2343 : 207 : has_addressable_vars = add_stack_protection_conflicts ();
2344 : :
2345 : 223597 : if (flag_stack_protect == SPCT_FLAG_STRONG && has_addressable_vars)
2346 : 223597 : gen_stack_protect_signal = true;
2347 : :
2348 : : /* Now that we have collected all stack variables, and have computed a
2349 : : minimal interference graph, attempt to save some stack space. */
2350 : 223597 : partition_stack_vars ();
2351 : 223597 : if (dump_file)
2352 : 29 : dump_stack_var_partition ();
2353 : : }
2354 : :
2355 : :
2356 : 1487281 : if (!lookup_attribute ("no_stack_protector", attribs))
2357 : 1487272 : switch (flag_stack_protect)
2358 : : {
2359 : 16 : case SPCT_FLAG_ALL:
2360 : 16 : create_stack_guard ();
2361 : 16 : break;
2362 : :
2363 : 399 : case SPCT_FLAG_STRONG:
2364 : 399 : if (gen_stack_protect_signal
2365 : 264 : || cfun->calls_alloca
2366 : 262 : || has_protected_decls
2367 : 653 : || lookup_attribute ("stack_protect", attribs))
2368 : 145 : create_stack_guard ();
2369 : : break;
2370 : :
2371 : 137 : case SPCT_FLAG_DEFAULT:
2372 : 137 : if (cfun->calls_alloca
2373 : 134 : || has_protected_decls
2374 : 223 : || lookup_attribute ("stack_protect", attribs))
2375 : 51 : create_stack_guard ();
2376 : : break;
2377 : :
2378 : 14 : case SPCT_FLAG_EXPLICIT:
2379 : 14 : if (lookup_attribute ("stack_protect", attribs))
2380 : 10 : create_stack_guard ();
2381 : : break;
2382 : :
2383 : : default:
2384 : : break;
2385 : : }
2386 : :
2387 : : /* Assign rtl to each variable based on these partitions. */
2388 : 1487281 : if (stack_vars_num > 0)
2389 : : {
2390 : 223597 : class stack_vars_data data;
2391 : :
2392 : 223597 : data.asan_base = NULL_RTX;
2393 : 223597 : data.asan_alignb = 0;
2394 : :
2395 : : /* Reorder decls to be protected by iterating over the variables
2396 : : array multiple times, and allocating out of each phase in turn. */
2397 : : /* ??? We could probably integrate this into the qsort we did
2398 : : earlier, such that we naturally see these variables first,
2399 : : and thus naturally allocate things in the right order. */
2400 : 223597 : if (has_protected_decls)
2401 : : {
2402 : : /* Phase 1 contains only character arrays. */
2403 : 114 : expand_stack_vars (stack_protect_decl_phase_1, &data);
2404 : :
2405 : : /* Phase 2 contains other kinds of arrays. */
2406 : 114 : if (!lookup_attribute ("no_stack_protector", attribs)
2407 : 114 : && (flag_stack_protect == SPCT_FLAG_ALL
2408 : 114 : || flag_stack_protect == SPCT_FLAG_STRONG
2409 : 49 : || (flag_stack_protect == SPCT_FLAG_EXPLICIT
2410 : 1 : && lookup_attribute ("stack_protect", attribs))))
2411 : 66 : expand_stack_vars (stack_protect_decl_phase_2, &data);
2412 : : }
2413 : :
2414 : 223597 : if (asan_sanitize_stack_p ())
2415 : : /* Phase 3, any partitions that need asan protection
2416 : : in addition to phase 1 and 2. */
2417 : 1587 : expand_stack_vars (asan_decl_phase_3, &data);
2418 : :
2419 : : /* ASAN description strings don't yet have a syntax for expressing
2420 : : polynomial offsets. */
2421 : 223597 : HOST_WIDE_INT prev_offset;
2422 : 225025 : if (!data.asan_vec.is_empty ()
2423 : 1428 : && frame_offset.is_constant (&prev_offset))
2424 : : {
2425 : 1428 : HOST_WIDE_INT offset, sz, redzonesz;
2426 : 1428 : redzonesz = ASAN_RED_ZONE_SIZE;
2427 : 1428 : sz = data.asan_vec[0] - prev_offset;
2428 : 1428 : if (data.asan_alignb > ASAN_RED_ZONE_SIZE
2429 : 1428 : && data.asan_alignb <= 4096
2430 : 45 : && sz + ASAN_RED_ZONE_SIZE >= (int) data.asan_alignb)
2431 : 45 : redzonesz = ((sz + ASAN_RED_ZONE_SIZE + data.asan_alignb - 1)
2432 : 45 : & ~(data.asan_alignb - HOST_WIDE_INT_1)) - sz;
2433 : : /* Allocating a constant amount of space from a constant
2434 : : starting offset must give a constant result. */
2435 : 1428 : offset = (alloc_stack_frame_space (redzonesz, ASAN_RED_ZONE_SIZE)
2436 : 1428 : .to_constant ());
2437 : 1428 : data.asan_vec.safe_push (prev_offset);
2438 : 1428 : data.asan_vec.safe_push (offset);
2439 : : /* Leave space for alignment if STRICT_ALIGNMENT. */
2440 : 1428 : if (STRICT_ALIGNMENT)
2441 : : alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode)
2442 : : << ASAN_SHADOW_SHIFT)
2443 : : / BITS_PER_UNIT, 1);
2444 : :
2445 : 1428 : var_end_seq
2446 : 2856 : = asan_emit_stack_protection (virtual_stack_vars_rtx,
2447 : : data.asan_base,
2448 : : data.asan_alignb,
2449 : : data.asan_vec.address (),
2450 : : data.asan_decl_vec.address (),
2451 : 1428 : data.asan_vec.length ());
2452 : : }
2453 : :
2454 : 223597 : expand_stack_vars (NULL, &data);
2455 : 223597 : }
2456 : :
2457 : 1487281 : if (hwasan_sanitize_stack_p ())
2458 : 446 : hwasan_emit_prologue ();
2459 : 1487281 : if (asan_sanitize_allocas_p () && cfun->calls_alloca)
2460 : 178 : var_end_seq = asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx,
2461 : : virtual_stack_vars_rtx,
2462 : : var_end_seq);
2463 : 1487103 : else if (hwasan_sanitize_allocas_p () && cfun->calls_alloca)
2464 : : /* When using out-of-line instrumentation we only want to emit one function
2465 : : call for clearing the tags in a region of shadow stack. When there are
2466 : : alloca calls in this frame we want to emit a call using the
2467 : : virtual_stack_dynamic_rtx, but when not we use the hwasan_frame_extent
2468 : : rtx we created in expand_stack_vars. */
2469 : 0 : var_end_seq = hwasan_emit_untag_frame (virtual_stack_dynamic_rtx,
2470 : : virtual_stack_vars_rtx);
2471 : 1487103 : else if (hwasan_sanitize_stack_p ())
2472 : : /* If no variables were stored on the stack, `hwasan_get_frame_extent`
2473 : : will return NULL_RTX and hence `hwasan_emit_untag_frame` will return
2474 : : NULL (i.e. an empty sequence). */
2475 : 446 : var_end_seq = hwasan_emit_untag_frame (hwasan_get_frame_extent (),
2476 : : virtual_stack_vars_rtx);
2477 : :
2478 : 1487281 : fini_vars_expansion ();
2479 : :
2480 : : /* If there were any artificial non-ignored vars without rtl
2481 : : found earlier, see if deferred stack allocation hasn't assigned
2482 : : rtl to them. */
2483 : 1625063 : FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls, i, var)
2484 : : {
2485 : 101041 : rtx rtl = DECL_RTL_IF_SET (var);
2486 : :
2487 : : /* Keep artificial non-ignored vars in cfun->local_decls
2488 : : chain until instantiate_decls. */
2489 : 3637 : if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
2490 : 3492 : add_local_decl (cfun, var);
2491 : : }
2492 : :
2493 : : /* If the target requires that FRAME_OFFSET be aligned, do it. */
2494 : 1487281 : if (STACK_ALIGNMENT_NEEDED)
2495 : : {
2496 : 1487281 : HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
2497 : 1487281 : if (FRAME_GROWS_DOWNWARD)
2498 : 1487281 : frame_offset = aligned_lower_bound (frame_offset, align);
2499 : : else
2500 : : frame_offset = aligned_upper_bound (frame_offset, align);
2501 : : }
2502 : :
2503 : 1487281 : return var_end_seq;
2504 : 1487281 : }
2505 : :
2506 : :
2507 : : /* If we need to produce a detailed dump, print the tree representation
2508 : : for STMT to the dump file. SINCE is the last RTX after which the RTL
2509 : : generated for STMT should have been appended. */
2510 : :
2511 : : static void
2512 : 40625371 : maybe_dump_rtl_for_gimple_stmt (gimple *stmt, rtx_insn *since)
2513 : : {
2514 : 40625371 : if (dump_file && (dump_flags & TDF_DETAILS))
2515 : : {
2516 : 189 : fprintf (dump_file, "\n;; ");
2517 : 189 : print_gimple_stmt (dump_file, stmt, 0,
2518 : : TDF_SLIM | (dump_flags & TDF_LINENO));
2519 : 189 : fprintf (dump_file, "\n");
2520 : :
2521 : 189 : print_rtl (dump_file, since ? NEXT_INSN (since) : since);
2522 : : }
2523 : 40625371 : }
2524 : :
2525 : : /* Maps the blocks that do not contain tree labels to rtx labels. */
2526 : :
2527 : : static hash_map<basic_block, rtx_code_label *> *lab_rtx_for_bb;
2528 : :
2529 : : /* Returns the label_rtx expression for a label starting basic block BB. */
2530 : :
2531 : : static rtx_code_label *
2532 : 7684048 : label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
2533 : : {
2534 : 7684048 : if (bb->flags & BB_RTL)
2535 : 1859422 : return block_label (bb);
2536 : :
2537 : 5824626 : rtx_code_label **elt = lab_rtx_for_bb->get (bb);
2538 : 5824626 : if (elt)
2539 : 1189241 : return *elt;
2540 : :
2541 : : /* Find the tree label if it is present. */
2542 : 4635385 : gimple_stmt_iterator gsi = gsi_start_bb (bb);
2543 : 4635385 : glabel *lab_stmt;
2544 : 4635385 : if (!gsi_end_p (gsi)
2545 : 4510978 : && (lab_stmt = dyn_cast <glabel *> (gsi_stmt (gsi)))
2546 : 4844920 : && !DECL_NONLOCAL (gimple_label_label (lab_stmt)))
2547 : 209535 : return jump_target_rtx (gimple_label_label (lab_stmt));
2548 : :
2549 : 4425850 : rtx_code_label *l = gen_label_rtx ();
2550 : 4425850 : lab_rtx_for_bb->put (bb, l);
2551 : 4425850 : return l;
2552 : : }
2553 : :
2554 : :
2555 : : /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2556 : : of a basic block where we just expanded the conditional at the end,
2557 : : possibly clean up the CFG and instruction sequence. LAST is the
2558 : : last instruction before the just emitted jump sequence. */
2559 : :
2560 : : static void
2561 : 5282128 : maybe_cleanup_end_of_block (edge e, rtx_insn *last)
2562 : : {
2563 : : /* Special case: when jumpif decides that the condition is
2564 : : trivial it emits an unconditional jump (and the necessary
2565 : : barrier). But we still have two edges, the fallthru one is
2566 : : wrong. purge_dead_edges would clean this up later. Unfortunately
2567 : : we have to insert insns (and split edges) before
2568 : : find_many_sub_basic_blocks and hence before purge_dead_edges.
2569 : : But splitting edges might create new blocks which depend on the
2570 : : fact that if there are two edges there's no barrier. So the
2571 : : barrier would get lost and verify_flow_info would ICE. Instead
2572 : : of auditing all edge splitters to care for the barrier (which
2573 : : normally isn't there in a cleaned CFG), fix it here. */
2574 : 5282128 : if (BARRIER_P (get_last_insn ()))
2575 : : {
2576 : 61 : rtx_insn *insn;
2577 : 61 : remove_edge (e);
2578 : : /* Now, we have a single successor block, if we have insns to
2579 : : insert on the remaining edge we potentially will insert
2580 : : it at the end of this block (if the dest block isn't feasible)
2581 : : in order to avoid splitting the edge. This insertion will take
2582 : : place in front of the last jump. But we might have emitted
2583 : : multiple jumps (conditional and one unconditional) to the
2584 : : same destination. Inserting in front of the last one then
2585 : : is a problem. See PR 40021. We fix this by deleting all
2586 : : jumps except the last unconditional one. */
2587 : 61 : insn = PREV_INSN (get_last_insn ());
2588 : : /* Make sure we have an unconditional jump. Otherwise we're
2589 : : confused. */
2590 : 61 : gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
2591 : 122 : for (insn = PREV_INSN (insn); insn != last;)
2592 : : {
2593 : 0 : insn = PREV_INSN (insn);
2594 : 0 : if (JUMP_P (NEXT_INSN (insn)))
2595 : : {
2596 : 0 : if (!any_condjump_p (NEXT_INSN (insn)))
2597 : : {
2598 : 0 : gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))));
2599 : 0 : delete_insn (NEXT_INSN (NEXT_INSN (insn)));
2600 : : }
2601 : 0 : delete_insn (NEXT_INSN (insn));
2602 : : }
2603 : : }
2604 : : }
2605 : 5282128 : }
2606 : :
2607 : : /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2608 : : Returns a new basic block if we've terminated the current basic
2609 : : block and created a new one. */
2610 : :
2611 : : static basic_block
2612 : 5725732 : expand_gimple_cond (basic_block bb, gcond *stmt)
2613 : : {
2614 : 5725732 : basic_block new_bb, dest;
2615 : 5725732 : edge true_edge;
2616 : 5725732 : edge false_edge;
2617 : 5725732 : rtx_insn *last2, *last;
2618 : 5725732 : enum tree_code code;
2619 : 5725732 : tree op0, op1;
2620 : :
2621 : 5725732 : code = gimple_cond_code (stmt);
2622 : 5725732 : op0 = gimple_cond_lhs (stmt);
2623 : 5725732 : op1 = gimple_cond_rhs (stmt);
2624 : : /* We're sometimes presented with such code:
2625 : : D.123_1 = x < y;
2626 : : if (D.123_1 != 0)
2627 : : ...
2628 : : This would expand to two comparisons which then later might
2629 : : be cleaned up by combine. But some pattern matchers like if-conversion
2630 : : work better when there's only one compare, so make up for this
2631 : : here as special exception if TER would have made the same change. */
2632 : 5725732 : if (SA.values
2633 : 4217411 : && TREE_CODE (op0) == SSA_NAME
2634 : 4147487 : && TREE_CODE (TREE_TYPE (op0)) == BOOLEAN_TYPE
2635 : 358884 : && TREE_CODE (op1) == INTEGER_CST
2636 : 349858 : && ((gimple_cond_code (stmt) == NE_EXPR
2637 : 349841 : && integer_zerop (op1))
2638 : 17 : || (gimple_cond_code (stmt) == EQ_EXPR
2639 : 17 : && integer_onep (op1)))
2640 : 6075590 : && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
2641 : : {
2642 : 191753 : gimple *second = SSA_NAME_DEF_STMT (op0);
2643 : 191753 : if (gimple_code (second) == GIMPLE_ASSIGN)
2644 : : {
2645 : 191753 : enum tree_code code2 = gimple_assign_rhs_code (second);
2646 : 191753 : if (TREE_CODE_CLASS (code2) == tcc_comparison)
2647 : : {
2648 : 632 : code = code2;
2649 : 632 : op0 = gimple_assign_rhs1 (second);
2650 : 632 : op1 = gimple_assign_rhs2 (second);
2651 : : }
2652 : : /* If jumps are cheap and the target does not support conditional
2653 : : compare, turn some more codes into jumpy sequences. */
2654 : 191121 : else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2655 : 191121 : && !targetm.have_ccmp ())
2656 : : {
2657 : 191118 : if ((code2 == BIT_AND_EXPR
2658 : 54937 : && TYPE_PRECISION (TREE_TYPE (op0)) == 1
2659 : 54937 : && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
2660 : 191118 : || code2 == TRUTH_AND_EXPR)
2661 : : {
2662 : 54937 : code = TRUTH_ANDIF_EXPR;
2663 : 54937 : op0 = gimple_assign_rhs1 (second);
2664 : 54937 : op1 = gimple_assign_rhs2 (second);
2665 : : }
2666 : 136181 : else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
2667 : : {
2668 : 61814 : code = TRUTH_ORIF_EXPR;
2669 : 61814 : op0 = gimple_assign_rhs1 (second);
2670 : 61814 : op1 = gimple_assign_rhs2 (second);
2671 : : }
2672 : : }
2673 : : }
2674 : : }
2675 : :
2676 : : /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2677 : : into (x - C2) * C3 < C4. */
2678 : 5725732 : if ((code == EQ_EXPR || code == NE_EXPR)
2679 : 4569399 : && TREE_CODE (op0) == SSA_NAME
2680 : 4498384 : && TREE_CODE (op1) == INTEGER_CST)
2681 : 3185168 : code = maybe_optimize_mod_cmp (code, &op0, &op1);
2682 : :
2683 : : /* Optimize (x - y) < 0 into x < y if x - y has undefined overflow. */
2684 : 5725732 : if (!TYPE_UNSIGNED (TREE_TYPE (op0))
2685 : 2184595 : && (code == LT_EXPR || code == LE_EXPR
2686 : 2184595 : || code == GT_EXPR || code == GE_EXPR)
2687 : 662143 : && integer_zerop (op1)
2688 : 5914146 : && TREE_CODE (op0) == SSA_NAME)
2689 : 188414 : maybe_optimize_sub_cmp_0 (code, &op0, &op1);
2690 : :
2691 : 5725732 : last2 = last = get_last_insn ();
2692 : :
2693 : 5725732 : extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2694 : 5725732 : set_curr_insn_location (gimple_location (stmt));
2695 : :
2696 : : /* These flags have no purpose in RTL land. */
2697 : 5725732 : true_edge->flags &= ~EDGE_TRUE_VALUE;
2698 : 5725732 : false_edge->flags &= ~EDGE_FALSE_VALUE;
2699 : :
2700 : : /* We can either have a pure conditional jump with one fallthru edge or
2701 : : two-way jump that needs to be decomposed into two basic blocks. */
2702 : 5725732 : if (false_edge->dest == bb->next_bb)
2703 : : {
2704 : 2452917 : jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2705 : : true_edge->probability);
2706 : 2452917 : maybe_dump_rtl_for_gimple_stmt (stmt, last);
2707 : 2452917 : if (true_edge->goto_locus != UNKNOWN_LOCATION)
2708 : 1747999 : set_curr_insn_location (true_edge->goto_locus);
2709 : 2452917 : false_edge->flags |= EDGE_FALLTHRU;
2710 : 2452917 : maybe_cleanup_end_of_block (false_edge, last);
2711 : 2452917 : return NULL;
2712 : : }
2713 : 3272815 : if (true_edge->dest == bb->next_bb)
2714 : : {
2715 : 2829211 : jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
2716 : : false_edge->probability);
2717 : 2829211 : maybe_dump_rtl_for_gimple_stmt (stmt, last);
2718 : 2829211 : if (false_edge->goto_locus != UNKNOWN_LOCATION)
2719 : 2533775 : set_curr_insn_location (false_edge->goto_locus);
2720 : 2829211 : true_edge->flags |= EDGE_FALLTHRU;
2721 : 2829211 : maybe_cleanup_end_of_block (true_edge, last);
2722 : 2829211 : return NULL;
2723 : : }
2724 : :
2725 : 443604 : jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
2726 : : true_edge->probability);
2727 : 443604 : last = get_last_insn ();
2728 : 443604 : if (false_edge->goto_locus != UNKNOWN_LOCATION)
2729 : 247259 : set_curr_insn_location (false_edge->goto_locus);
2730 : 443604 : emit_jump (label_rtx_for_bb (false_edge->dest));
2731 : :
2732 : 443604 : BB_END (bb) = last;
2733 : 443604 : if (BARRIER_P (BB_END (bb)))
2734 : 15 : BB_END (bb) = PREV_INSN (BB_END (bb));
2735 : 443604 : update_bb_for_insn (bb);
2736 : :
2737 : 443604 : new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2738 : 443604 : dest = false_edge->dest;
2739 : 443604 : redirect_edge_succ (false_edge, new_bb);
2740 : 443604 : false_edge->flags |= EDGE_FALLTHRU;
2741 : 443604 : new_bb->count = false_edge->count ();
2742 : 443604 : loop_p loop = find_common_loop (bb->loop_father, dest->loop_father);
2743 : 443604 : add_bb_to_loop (new_bb, loop);
2744 : 443604 : if (loop->latch == bb
2745 : 27343 : && loop->header == dest)
2746 : 27342 : loop->latch = new_bb;
2747 : 443604 : make_single_succ_edge (new_bb, dest, 0);
2748 : 443604 : if (BARRIER_P (BB_END (new_bb)))
2749 : 443604 : BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
2750 : 443604 : update_bb_for_insn (new_bb);
2751 : :
2752 : 443604 : maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2753 : :
2754 : 443604 : if (true_edge->goto_locus != UNKNOWN_LOCATION)
2755 : : {
2756 : 247248 : set_curr_insn_location (true_edge->goto_locus);
2757 : 247248 : true_edge->goto_locus = curr_insn_location ();
2758 : : }
2759 : :
2760 : : return new_bb;
2761 : : }
2762 : :
2763 : : /* Mark all calls that can have a transaction restart. */
2764 : :
2765 : : static void
2766 : 6511864 : mark_transaction_restart_calls (gimple *stmt)
2767 : : {
2768 : 6511864 : struct tm_restart_node dummy;
2769 : 6511864 : tm_restart_node **slot;
2770 : :
2771 : 6511864 : if (!cfun->gimple_df->tm_restart)
2772 : 6508886 : return;
2773 : :
2774 : 2978 : dummy.stmt = stmt;
2775 : 2978 : slot = cfun->gimple_df->tm_restart->find_slot (&dummy, NO_INSERT);
2776 : 2978 : if (slot)
2777 : : {
2778 : 0 : struct tm_restart_node *n = *slot;
2779 : 0 : tree list = n->label_or_list;
2780 : 0 : rtx_insn *insn;
2781 : :
2782 : 0 : for (insn = next_real_insn (get_last_insn ());
2783 : 0 : !CALL_P (insn);
2784 : 0 : insn = next_real_insn (insn))
2785 : 0 : continue;
2786 : :
2787 : 0 : if (TREE_CODE (list) == LABEL_DECL)
2788 : 0 : add_reg_note (insn, REG_TM, label_rtx (list));
2789 : : else
2790 : 0 : for (; list ; list = TREE_CHAIN (list))
2791 : 0 : add_reg_note (insn, REG_TM, label_rtx (TREE_VALUE (list)));
2792 : 0 : }
2793 : : }
2794 : :
2795 : : /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2796 : : statement STMT. */
2797 : :
2798 : : static void
2799 : 6728482 : expand_call_stmt (gcall *stmt)
2800 : : {
2801 : 6728482 : tree exp, decl, lhs;
2802 : 6728482 : bool builtin_p;
2803 : 6728482 : size_t i;
2804 : :
2805 : 6728482 : if (gimple_call_internal_p (stmt))
2806 : : {
2807 : 182439 : expand_internal_call (stmt);
2808 : 182439 : return;
2809 : : }
2810 : :
2811 : : /* If this is a call to a built-in function and it has no effect other
2812 : : than setting the lhs, try to implement it using an internal function
2813 : : instead. */
2814 : 6546043 : decl = gimple_call_fndecl (stmt);
2815 : 6546043 : if (gimple_call_lhs (stmt)
2816 : 2244897 : && !gimple_has_side_effects (stmt)
2817 : 7212857 : && (optimize || (decl && called_as_built_in (decl))))
2818 : : {
2819 : 651729 : internal_fn ifn = replacement_internal_fn (stmt);
2820 : 651729 : if (ifn != IFN_LAST)
2821 : : {
2822 : 34179 : expand_internal_call (ifn, stmt);
2823 : 34179 : return;
2824 : : }
2825 : : }
2826 : :
2827 : 6511864 : exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2828 : :
2829 : 6511864 : CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2830 : 6511864 : builtin_p = decl && fndecl_built_in_p (decl);
2831 : :
2832 : : /* If this is not a builtin function, the function type through which the
2833 : : call is made may be different from the type of the function. */
2834 : 4492661 : if (!builtin_p)
2835 : 8985322 : CALL_EXPR_FN (exp)
2836 : 13477983 : = fold_convert (build_pointer_type (gimple_call_fntype (stmt)),
2837 : : CALL_EXPR_FN (exp));
2838 : :
2839 : 6511864 : TREE_TYPE (exp) = gimple_call_return_type (stmt);
2840 : 6511864 : CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2841 : :
2842 : 19403495 : for (i = 0; i < gimple_call_num_args (stmt); i++)
2843 : : {
2844 : 12891631 : tree arg = gimple_call_arg (stmt, i);
2845 : 12891631 : gimple *def;
2846 : : /* TER addresses into arguments of builtin functions so we have a
2847 : : chance to infer more correct alignment information. See PR39954. */
2848 : 12891631 : if (builtin_p
2849 : 3960268 : && TREE_CODE (arg) == SSA_NAME
2850 : 1281644 : && (def = get_gimple_for_ssa_name (arg))
2851 : 13217863 : && gimple_assign_rhs_code (def) == ADDR_EXPR)
2852 : 14587 : arg = gimple_assign_rhs1 (def);
2853 : 12891631 : CALL_EXPR_ARG (exp, i) = arg;
2854 : : }
2855 : :
2856 : 6511864 : if (gimple_has_side_effects (stmt)
2857 : : /* ??? Downstream in expand_expr_real_1 we assume that expressions
2858 : : w/o side-effects do not throw so work around this here. */
2859 : 6511864 : || stmt_could_throw_p (cfun, stmt))
2860 : 5882108 : TREE_SIDE_EFFECTS (exp) = 1;
2861 : :
2862 : 6511864 : if (gimple_call_nothrow_p (stmt))
2863 : 3000300 : TREE_NOTHROW (exp) = 1;
2864 : :
2865 : 6511864 : CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
2866 : 6511864 : CALL_EXPR_MUST_TAIL_CALL (exp) = gimple_call_must_tail_p (stmt);
2867 : 6511864 : CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
2868 : 6511864 : if (decl
2869 : 6331803 : && fndecl_built_in_p (decl, BUILT_IN_NORMAL)
2870 : 8356730 : && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl)))
2871 : 25205 : CALL_ALLOCA_FOR_VAR_P (exp) = gimple_call_alloca_for_var_p (stmt);
2872 : : else
2873 : 6486659 : CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
2874 : 6511864 : CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
2875 : 6511864 : CALL_EXPR_BY_DESCRIPTOR (exp) = gimple_call_by_descriptor_p (stmt);
2876 : 6511864 : SET_EXPR_LOCATION (exp, gimple_location (stmt));
2877 : :
2878 : : /* Must come after copying location. */
2879 : 6511864 : copy_warning (exp, stmt);
2880 : :
2881 : : /* Ensure RTL is created for debug args. */
2882 : 12843667 : if (decl && DECL_HAS_DEBUG_ARGS_P (decl))
2883 : : {
2884 : 48299 : vec<tree, va_gc> **debug_args = decl_debug_args_lookup (decl);
2885 : 48299 : unsigned int ix;
2886 : 48299 : tree dtemp;
2887 : :
2888 : 48299 : if (debug_args)
2889 : 104708 : for (ix = 1; (*debug_args)->iterate (ix, &dtemp); ix += 2)
2890 : : {
2891 : 56409 : gcc_assert (TREE_CODE (dtemp) == DEBUG_EXPR_DECL);
2892 : 56409 : expand_debug_expr (dtemp);
2893 : : }
2894 : : }
2895 : :
2896 : 6511864 : rtx_insn *before_call = get_last_insn ();
2897 : 6511864 : lhs = gimple_call_lhs (stmt);
2898 : 6511864 : if (lhs)
2899 : 2210718 : expand_assignment (lhs, exp, false);
2900 : : else
2901 : 4301146 : expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
2902 : :
2903 : : /* If the gimple call is an indirect call and has 'nocf_check'
2904 : : attribute find a generated CALL insn to mark it as no
2905 : : control-flow verification is needed. */
2906 : 6511864 : if (gimple_call_nocf_check_p (stmt)
2907 : 6511885 : && !gimple_call_fndecl (stmt))
2908 : : {
2909 : 20 : rtx_insn *last = get_last_insn ();
2910 : 20 : while (!CALL_P (last)
2911 : 34 : && last != before_call)
2912 : 14 : last = PREV_INSN (last);
2913 : :
2914 : 20 : if (last != before_call)
2915 : 20 : add_reg_note (last, REG_CALL_NOCF_CHECK, const0_rtx);
2916 : : }
2917 : :
2918 : 6511864 : mark_transaction_restart_calls (stmt);
2919 : : }
2920 : :
2921 : :
2922 : : /* Generate RTL for an asm statement (explicit assembler code).
2923 : : STRING is a STRING_CST node containing the assembler code text,
2924 : : or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2925 : : insn is volatile; don't optimize it. */
2926 : :
2927 : : static void
2928 : 2813 : expand_asm_loc (tree string, int vol, location_t locus)
2929 : : {
2930 : 2813 : rtx body;
2931 : :
2932 : 2813 : body = gen_rtx_ASM_INPUT_loc (VOIDmode,
2933 : : ggc_strdup (TREE_STRING_POINTER (string)),
2934 : : locus);
2935 : :
2936 : 2813 : MEM_VOLATILE_P (body) = vol;
2937 : :
2938 : : /* Non-empty basic ASM implicitly clobbers memory. */
2939 : 2813 : if (TREE_STRING_LENGTH (string) != 0)
2940 : : {
2941 : 948 : rtx asm_op, clob;
2942 : 948 : unsigned i, nclobbers;
2943 : 948 : auto_vec<rtx> input_rvec, output_rvec;
2944 : 948 : auto_vec<machine_mode> input_mode;
2945 : 948 : auto_vec<const char *> constraints;
2946 : 948 : auto_vec<rtx> use_rvec;
2947 : 948 : auto_vec<rtx> clobber_rvec;
2948 : 948 : HARD_REG_SET clobbered_regs;
2949 : 948 : CLEAR_HARD_REG_SET (clobbered_regs);
2950 : :
2951 : 948 : clob = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
2952 : 948 : clobber_rvec.safe_push (clob);
2953 : :
2954 : 948 : if (targetm.md_asm_adjust)
2955 : 948 : targetm.md_asm_adjust (output_rvec, input_rvec, input_mode,
2956 : : constraints, use_rvec, clobber_rvec,
2957 : : clobbered_regs, locus);
2958 : :
2959 : 948 : asm_op = body;
2960 : 948 : nclobbers = clobber_rvec.length ();
2961 : 948 : auto nuses = use_rvec.length ();
2962 : 948 : body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (1 + nuses + nclobbers));
2963 : :
2964 : 948 : i = 0;
2965 : 948 : XVECEXP (body, 0, i++) = asm_op;
2966 : 948 : for (rtx use : use_rvec)
2967 : 0 : XVECEXP (body, 0, i++) = gen_rtx_USE (VOIDmode, use);
2968 : 4740 : for (rtx clobber : clobber_rvec)
2969 : 1896 : XVECEXP (body, 0, i++) = gen_rtx_CLOBBER (VOIDmode, clobber);
2970 : 948 : }
2971 : :
2972 : 2813 : emit_insn (body);
2973 : 2813 : }
2974 : :
2975 : : /* Return the number of times character C occurs in string S. */
2976 : : static int
2977 : 123581 : n_occurrences (int c, const char *s)
2978 : : {
2979 : 123581 : int n = 0;
2980 : 323678 : while (*s)
2981 : 200097 : n += (*s++ == c);
2982 : 123581 : return n;
2983 : : }
2984 : :
2985 : : /* A subroutine of expand_asm_operands. Check that all operands have
2986 : : the same number of alternatives. Return true if so. */
2987 : :
2988 : : static bool
2989 : 168870 : check_operand_nalternatives (const vec<const char *> &constraints)
2990 : : {
2991 : 168870 : unsigned len = constraints.length();
2992 : 168870 : if (len > 0)
2993 : : {
2994 : 39903 : int nalternatives = n_occurrences (',', constraints[0]);
2995 : :
2996 : 39903 : if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES)
2997 : : {
2998 : 0 : error ("too many alternatives in %<asm%>");
2999 : 0 : return false;
3000 : : }
3001 : :
3002 : 123581 : for (unsigned i = 1; i < len; ++i)
3003 : 167356 : if (n_occurrences (',', constraints[i]) != nalternatives)
3004 : : {
3005 : 0 : error ("operand constraints for %<asm%> differ "
3006 : : "in number of alternatives");
3007 : 0 : return false;
3008 : : }
3009 : : }
3010 : : return true;
3011 : : }
3012 : :
3013 : : /* Check for overlap between registers marked in CLOBBERED_REGS and
3014 : : anything inappropriate in T. Emit error and return the register
3015 : : variable definition for error, NULL_TREE for ok. */
3016 : :
3017 : : static bool
3018 : 123572 : tree_conflicts_with_clobbers_p (tree t, HARD_REG_SET *clobbered_regs,
3019 : : location_t loc)
3020 : : {
3021 : : /* Conflicts between asm-declared register variables and the clobber
3022 : : list are not allowed. */
3023 : 123572 : tree overlap = tree_overlaps_hard_reg_set (t, clobbered_regs);
3024 : :
3025 : 123572 : if (overlap)
3026 : : {
3027 : 21 : error_at (loc, "%<asm%> specifier for variable %qE conflicts with "
3028 : 21 : "%<asm%> clobber list", DECL_NAME (overlap));
3029 : :
3030 : : /* Reset registerness to stop multiple errors emitted for a single
3031 : : variable. */
3032 : 21 : DECL_REGISTER (overlap) = 0;
3033 : 21 : return true;
3034 : : }
3035 : :
3036 : : return false;
3037 : : }
3038 : :
3039 : : /* Check that the given REGNO spanning NREGS is a valid
3040 : : asm clobber operand. Some HW registers cannot be
3041 : : saved/restored, hence they should not be clobbered by
3042 : : asm statements. */
3043 : : static bool
3044 : 41470 : asm_clobber_reg_is_valid (int regno, int nregs, const char *regname)
3045 : : {
3046 : 41470 : bool is_valid = true;
3047 : 41470 : HARD_REG_SET regset;
3048 : :
3049 : 41470 : CLEAR_HARD_REG_SET (regset);
3050 : :
3051 : 41470 : add_range_to_hard_reg_set (®set, regno, nregs);
3052 : :
3053 : : /* Clobbering the PIC register is an error. */
3054 : 41470 : if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3055 : 0 : && overlaps_hard_reg_set_p (regset, Pmode, PIC_OFFSET_TABLE_REGNUM))
3056 : : {
3057 : : /* ??? Diagnose during gimplification? */
3058 : 0 : error ("PIC register clobbered by %qs in %<asm%>", regname);
3059 : 0 : is_valid = false;
3060 : : }
3061 : 41470 : else if (!in_hard_reg_set_p
3062 : 41470 : (accessible_reg_set, reg_raw_mode[regno], regno))
3063 : : {
3064 : : /* ??? Diagnose during gimplification? */
3065 : 0 : error ("the register %qs cannot be clobbered in %<asm%>"
3066 : : " for the current target", regname);
3067 : 0 : is_valid = false;
3068 : : }
3069 : :
3070 : : /* Clobbering the stack pointer register is deprecated. GCC expects
3071 : : the value of the stack pointer after an asm statement to be the same
3072 : : as it was before, so no asm can validly clobber the stack pointer in
3073 : : the usual sense. Adding the stack pointer to the clobber list has
3074 : : traditionally had some undocumented and somewhat obscure side-effects. */
3075 : 41470 : if (overlaps_hard_reg_set_p (regset, Pmode, STACK_POINTER_REGNUM))
3076 : : {
3077 : 1 : crtl->sp_is_clobbered_by_asm = true;
3078 : 1 : if (warning (OPT_Wdeprecated, "listing the stack pointer register"
3079 : : " %qs in a clobber list is deprecated", regname))
3080 : 1 : inform (input_location, "the value of the stack pointer after"
3081 : : " an %<asm%> statement must be the same as it was before"
3082 : : " the statement");
3083 : : }
3084 : :
3085 : 41470 : return is_valid;
3086 : : }
3087 : :
3088 : : /* Generate RTL for an asm statement with arguments.
3089 : : STRING is the instruction template.
3090 : : OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
3091 : : Each output or input has an expression in the TREE_VALUE and
3092 : : a tree list in TREE_PURPOSE which in turn contains a constraint
3093 : : name in TREE_VALUE (or NULL_TREE) and a constraint string
3094 : : in TREE_PURPOSE.
3095 : : CLOBBERS is a list of STRING_CST nodes each naming a hard register
3096 : : that is clobbered by this insn.
3097 : :
3098 : : LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
3099 : : should be the fallthru basic block of the asm goto.
3100 : :
3101 : : Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
3102 : : Some elements of OUTPUTS may be replaced with trees representing temporary
3103 : : values. The caller should copy those temporary values to the originally
3104 : : specified lvalues.
3105 : :
3106 : : VOL nonzero means the insn is volatile; don't optimize it. */
3107 : :
3108 : : static void
3109 : 171688 : expand_asm_stmt (gasm *stmt)
3110 : : {
3111 : 171688 : class save_input_location
3112 : : {
3113 : : location_t old;
3114 : :
3115 : : public:
3116 : 168875 : explicit save_input_location(location_t where)
3117 : 168875 : {
3118 : 168875 : old = input_location;
3119 : 168875 : input_location = where;
3120 : : }
3121 : :
3122 : 168875 : ~save_input_location()
3123 : : {
3124 : 168875 : input_location = old;
3125 : 5 : }
3126 : : };
3127 : :
3128 : 171688 : location_t locus = gimple_location (stmt);
3129 : :
3130 : 171688 : if (gimple_asm_basic_p (stmt))
3131 : : {
3132 : 2813 : const char *s = gimple_asm_string (stmt);
3133 : 2813 : tree string = build_string (strlen (s), s);
3134 : 2813 : expand_asm_loc (string, gimple_asm_volatile_p (stmt), locus);
3135 : 5631 : return;
3136 : : }
3137 : :
3138 : : /* There are some legacy diagnostics in here. */
3139 : 168875 : save_input_location s_i_l(locus);
3140 : :
3141 : 168875 : unsigned noutputs = gimple_asm_noutputs (stmt);
3142 : 168875 : unsigned ninputs = gimple_asm_ninputs (stmt);
3143 : 168875 : unsigned nlabels = gimple_asm_nlabels (stmt);
3144 : 168875 : unsigned i;
3145 : 168875 : bool error_seen = false;
3146 : :
3147 : : /* ??? Diagnose during gimplification? */
3148 : 168875 : if (ninputs + noutputs + nlabels > MAX_RECOG_OPERANDS)
3149 : : {
3150 : 5 : error_at (locus, "more than %d operands in %<asm%>", MAX_RECOG_OPERANDS);
3151 : 5 : return;
3152 : : }
3153 : :
3154 : 168870 : auto_vec<tree, MAX_RECOG_OPERANDS> output_tvec;
3155 : 168870 : auto_vec<tree, MAX_RECOG_OPERANDS> input_tvec;
3156 : 168870 : auto_vec<const char *, MAX_RECOG_OPERANDS> constraints;
3157 : :
3158 : : /* Copy the gimple vectors into new vectors that we can manipulate. */
3159 : :
3160 : 168870 : output_tvec.safe_grow (noutputs, true);
3161 : 168870 : input_tvec.safe_grow (ninputs, true);
3162 : 168870 : constraints.safe_grow (noutputs + ninputs, true);
3163 : :
3164 : 240665 : for (i = 0; i < noutputs; ++i)
3165 : : {
3166 : 71795 : tree t = gimple_asm_output_op (stmt, i);
3167 : 71795 : output_tvec[i] = TREE_VALUE (t);
3168 : 71795 : constraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
3169 : : }
3170 : 220656 : for (i = 0; i < ninputs; i++)
3171 : : {
3172 : 51786 : tree t = gimple_asm_input_op (stmt, i);
3173 : 51786 : input_tvec[i] = TREE_VALUE (t);
3174 : 51786 : constraints[i + noutputs]
3175 : 51786 : = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
3176 : : }
3177 : :
3178 : : /* ??? Diagnose during gimplification? */
3179 : 168870 : if (! check_operand_nalternatives (constraints))
3180 : : return;
3181 : :
3182 : : /* Count the number of meaningful clobbered registers, ignoring what
3183 : : we would ignore later. */
3184 : 168870 : auto_vec<rtx> clobber_rvec;
3185 : 168870 : HARD_REG_SET clobbered_regs;
3186 : 168870 : CLEAR_HARD_REG_SET (clobbered_regs);
3187 : :
3188 : 168870 : if (unsigned n = gimple_asm_nclobbers (stmt))
3189 : : {
3190 : 133606 : clobber_rvec.reserve (n);
3191 : 294727 : for (i = 0; i < n; i++)
3192 : : {
3193 : 161121 : tree t = gimple_asm_clobber_op (stmt, i);
3194 : 161121 : const char *regname = TREE_STRING_POINTER (TREE_VALUE (t));
3195 : 161121 : int nregs, j;
3196 : :
3197 : 161121 : j = decode_reg_name_and_count (regname, &nregs);
3198 : 161121 : if (j < 0)
3199 : : {
3200 : 119651 : if (j == -2)
3201 : : {
3202 : : /* ??? Diagnose during gimplification? */
3203 : 7 : error_at (locus, "unknown register name %qs in %<asm%>",
3204 : : regname);
3205 : 7 : error_seen = true;
3206 : : }
3207 : 119644 : else if (j == -4)
3208 : : {
3209 : 103925 : rtx x = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
3210 : 103925 : clobber_rvec.safe_push (x);
3211 : : }
3212 : 15719 : else if (j == -5)
3213 : : {
3214 : 2 : if (targetm.redzone_clobber)
3215 : 2 : if (rtx x = targetm.redzone_clobber ())
3216 : 2 : clobber_rvec.safe_push (x);
3217 : : }
3218 : : else
3219 : : {
3220 : : /* Otherwise we should have -1 == empty string
3221 : : or -3 == cc, which is not a register. */
3222 : 15717 : gcc_assert (j == -1 || j == -3);
3223 : : }
3224 : : }
3225 : : else
3226 : 82940 : for (int reg = j; reg < j + nregs; reg++)
3227 : : {
3228 : 41470 : if (!asm_clobber_reg_is_valid (reg, nregs, regname))
3229 : 0 : return;
3230 : :
3231 : 41470 : SET_HARD_REG_BIT (clobbered_regs, reg);
3232 : 41470 : rtx x = gen_rtx_REG (reg_raw_mode[reg], reg);
3233 : 41470 : clobber_rvec.safe_push (x);
3234 : : }
3235 : : }
3236 : : }
3237 : :
3238 : : /* First pass over inputs and outputs checks validity and sets
3239 : : mark_addressable if needed. */
3240 : : /* ??? Diagnose during gimplification? */
3241 : :
3242 : 240665 : for (i = 0; i < noutputs; ++i)
3243 : : {
3244 : 71795 : tree val = output_tvec[i];
3245 : 71795 : tree type = TREE_TYPE (val);
3246 : 71795 : const char *constraint;
3247 : 71795 : bool is_inout;
3248 : 71795 : bool allows_reg;
3249 : 71795 : bool allows_mem;
3250 : :
3251 : : /* Try to parse the output constraint. If that fails, there's
3252 : : no point in going further. */
3253 : 71795 : constraint = constraints[i];
3254 : 71795 : if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
3255 : : &allows_mem, &allows_reg, &is_inout))
3256 : 0 : return;
3257 : :
3258 : : /* If the output is a hard register, verify it doesn't conflict with
3259 : : any other operand's possible hard register use. */
3260 : 71795 : if (DECL_P (val)
3261 : 7531 : && REG_P (DECL_RTL (val))
3262 : 72752 : && HARD_REGISTER_P (DECL_RTL (val)))
3263 : : {
3264 : 940 : unsigned j, output_hregno = REGNO (DECL_RTL (val));
3265 : 940 : bool early_clobber_p = strchr (constraints[i], '&') != NULL;
3266 : 940 : unsigned long match;
3267 : :
3268 : : /* Verify the other outputs do not use the same hard register. */
3269 : 1100 : for (j = i + 1; j < noutputs; ++j)
3270 : 160 : if (DECL_P (output_tvec[j])
3271 : 158 : && REG_P (DECL_RTL (output_tvec[j]))
3272 : 158 : && HARD_REGISTER_P (DECL_RTL (output_tvec[j]))
3273 : 318 : && output_hregno == REGNO (DECL_RTL (output_tvec[j])))
3274 : : {
3275 : 1 : error_at (locus, "invalid hard register usage between output "
3276 : : "operands");
3277 : 1 : error_seen = true;
3278 : : }
3279 : :
3280 : : /* Verify matching constraint operands use the same hard register
3281 : : and that the non-matching constraint operands do not use the same
3282 : : hard register if the output is an early clobber operand. */
3283 : 1851 : for (j = 0; j < ninputs; ++j)
3284 : 911 : if (DECL_P (input_tvec[j])
3285 : 772 : && REG_P (DECL_RTL (input_tvec[j]))
3286 : 1683 : && HARD_REGISTER_P (DECL_RTL (input_tvec[j])))
3287 : : {
3288 : 772 : unsigned input_hregno = REGNO (DECL_RTL (input_tvec[j]));
3289 : 772 : switch (*constraints[j + noutputs])
3290 : : {
3291 : 760 : case '0': case '1': case '2': case '3': case '4':
3292 : 760 : case '5': case '6': case '7': case '8': case '9':
3293 : 760 : match = strtoul (constraints[j + noutputs], NULL, 10);
3294 : 760 : break;
3295 : : default:
3296 : : match = ULONG_MAX;
3297 : : break;
3298 : : }
3299 : 760 : if (i == match
3300 : 661 : && output_hregno != input_hregno)
3301 : : {
3302 : 1 : error_at (locus, "invalid hard register usage between "
3303 : : "output operand and matching constraint operand");
3304 : 1 : error_seen = true;
3305 : : }
3306 : 771 : else if (early_clobber_p
3307 : 6 : && i != match
3308 : 4 : && output_hregno == input_hregno)
3309 : : {
3310 : 2 : error_at (locus, "invalid hard register usage between "
3311 : : "earlyclobber operand and input operand");
3312 : 2 : error_seen = true;
3313 : : }
3314 : : }
3315 : : }
3316 : :
3317 : 71795 : if (! allows_reg
3318 : 71795 : && (allows_mem
3319 : 0 : || is_inout
3320 : 0 : || (DECL_P (val)
3321 : 0 : && REG_P (DECL_RTL (val))
3322 : 0 : && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type))))
3323 : 6262 : mark_addressable (val);
3324 : : }
3325 : :
3326 : 220656 : for (i = 0; i < ninputs; ++i)
3327 : : {
3328 : 51786 : bool allows_reg, allows_mem;
3329 : 51786 : const char *constraint;
3330 : :
3331 : 51786 : constraint = constraints[i + noutputs];
3332 : 51786 : if (! parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
3333 : 51786 : constraints.address (),
3334 : : &allows_mem, &allows_reg))
3335 : 0 : return;
3336 : :
3337 : 51786 : if (! allows_reg && allows_mem)
3338 : 6926 : mark_addressable (input_tvec[i]);
3339 : : }
3340 : :
3341 : : /* Second pass evaluates arguments. */
3342 : :
3343 : : /* Make sure stack is consistent for asm goto. */
3344 : 168870 : if (nlabels > 0)
3345 : 445 : do_pending_stack_adjust ();
3346 : 168870 : int old_generating_concat_p = generating_concat_p;
3347 : :
3348 : : /* Vector of RTX's of evaluated output operands. */
3349 : 337740 : auto_vec<rtx, MAX_RECOG_OPERANDS> output_rvec;
3350 : 168870 : auto_vec<int, MAX_RECOG_OPERANDS> inout_opnum;
3351 : 168870 : rtx_insn *after_rtl_seq = NULL, *after_rtl_end = NULL;
3352 : :
3353 : 168870 : output_rvec.safe_grow (noutputs, true);
3354 : :
3355 : 240665 : for (i = 0; i < noutputs; ++i)
3356 : : {
3357 : 71795 : tree val = output_tvec[i];
3358 : 71795 : tree type = TREE_TYPE (val);
3359 : 71795 : bool is_inout, allows_reg, allows_mem, ok;
3360 : 71795 : rtx op;
3361 : :
3362 : 71795 : ok = parse_output_constraint (&constraints[i], i, ninputs,
3363 : : noutputs, &allows_mem, &allows_reg,
3364 : : &is_inout);
3365 : 71795 : gcc_assert (ok);
3366 : :
3367 : : /* If an output operand is not a decl or indirect ref and our constraint
3368 : : allows a register, make a temporary to act as an intermediate.
3369 : : Make the asm insn write into that, then we will copy it to
3370 : : the real output operand. Likewise for promoted variables. */
3371 : :
3372 : 71795 : generating_concat_p = 0;
3373 : :
3374 : 71795 : gcc_assert (TREE_CODE (val) != INDIRECT_REF);
3375 : 71795 : if (((TREE_CODE (val) == MEM_REF
3376 : 2795 : && TREE_CODE (TREE_OPERAND (val, 0)) != ADDR_EXPR)
3377 : 2694 : && allows_mem)
3378 : 71397 : || (DECL_P (val)
3379 : 7531 : && (allows_mem || REG_P (DECL_RTL (val)))
3380 : 7796 : && ! (REG_P (DECL_RTL (val))
3381 : 957 : && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))
3382 : 64558 : || ! allows_reg
3383 : 64368 : || is_inout
3384 : 64368 : || TREE_ADDRESSABLE (type)
3385 : 136163 : || (!tree_fits_poly_int64_p (TYPE_SIZE (type))
3386 : 0 : && !known_size_p (max_int_size_in_bytes (type))))
3387 : : {
3388 : 7427 : op = expand_expr (val, NULL_RTX, VOIDmode,
3389 : : !allows_reg ? EXPAND_MEMORY : EXPAND_WRITE);
3390 : 7427 : if (MEM_P (op))
3391 : 6470 : op = validize_mem (op);
3392 : :
3393 : 7427 : if (! allows_reg && !MEM_P (op))
3394 : : {
3395 : 0 : error_at (locus, "output number %d not directly addressable", i);
3396 : 0 : error_seen = true;
3397 : : }
3398 : 7427 : if ((! allows_mem && MEM_P (op) && GET_MODE (op) != BLKmode)
3399 : 7427 : || GET_CODE (op) == CONCAT)
3400 : : {
3401 : 0 : rtx old_op = op;
3402 : 0 : op = gen_reg_rtx (GET_MODE (op));
3403 : :
3404 : 0 : generating_concat_p = old_generating_concat_p;
3405 : :
3406 : 0 : if (is_inout)
3407 : 0 : emit_move_insn (op, old_op);
3408 : :
3409 : 0 : push_to_sequence2 (after_rtl_seq, after_rtl_end);
3410 : 0 : emit_move_insn (old_op, op);
3411 : 0 : after_rtl_seq = get_insns ();
3412 : 0 : after_rtl_end = get_last_insn ();
3413 : 0 : end_sequence ();
3414 : : }
3415 : : }
3416 : : else
3417 : : {
3418 : 64368 : op = assign_temp (type, 0, 1);
3419 : 64368 : op = validize_mem (op);
3420 : 64368 : if (!MEM_P (op) && TREE_CODE (val) == SSA_NAME)
3421 : 60615 : set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val), op);
3422 : :
3423 : 64368 : generating_concat_p = old_generating_concat_p;
3424 : :
3425 : 64368 : push_to_sequence2 (after_rtl_seq, after_rtl_end);
3426 : 64368 : expand_assignment (val, make_tree (type, op), false);
3427 : 64368 : after_rtl_seq = get_insns ();
3428 : 64368 : after_rtl_end = get_last_insn ();
3429 : 64368 : end_sequence ();
3430 : : }
3431 : 71795 : output_rvec[i] = op;
3432 : :
3433 : 71795 : if (is_inout)
3434 : 0 : inout_opnum.safe_push (i);
3435 : : }
3436 : :
3437 : 168870 : const char *str = gimple_asm_string (stmt);
3438 : 168870 : if (error_seen)
3439 : : {
3440 : 11 : ninputs = 0;
3441 : 11 : noutputs = 0;
3442 : 11 : inout_opnum.truncate (0);
3443 : 11 : output_rvec.truncate (0);
3444 : 11 : clobber_rvec.truncate (0);
3445 : 11 : constraints.truncate (0);
3446 : 11 : CLEAR_HARD_REG_SET (clobbered_regs);
3447 : : str = "";
3448 : : }
3449 : :
3450 : 337740 : auto_vec<rtx, MAX_RECOG_OPERANDS> input_rvec;
3451 : 168870 : auto_vec<machine_mode, MAX_RECOG_OPERANDS> input_mode;
3452 : :
3453 : 168870 : input_rvec.safe_grow (ninputs, true);
3454 : 168870 : input_mode.safe_grow (ninputs, true);
3455 : :
3456 : 168870 : generating_concat_p = 0;
3457 : :
3458 : 220653 : for (i = 0; i < ninputs; ++i)
3459 : : {
3460 : 51783 : tree val = input_tvec[i];
3461 : 51783 : tree type = TREE_TYPE (val);
3462 : 51783 : bool allows_reg, allows_mem, ok;
3463 : 51783 : const char *constraint;
3464 : 51783 : rtx op;
3465 : :
3466 : 51783 : constraint = constraints[i + noutputs];
3467 : 51783 : ok = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
3468 : 51783 : constraints.address (),
3469 : : &allows_mem, &allows_reg);
3470 : 51783 : gcc_assert (ok);
3471 : :
3472 : : /* EXPAND_INITIALIZER will not generate code for valid initializer
3473 : : constants, but will still generate code for other types of operand.
3474 : : This is the behavior we want for constant constraints. */
3475 : 51783 : op = expand_expr (val, NULL_RTX, VOIDmode,
3476 : : allows_reg ? EXPAND_NORMAL
3477 : 8161 : : allows_mem ? EXPAND_MEMORY
3478 : : : EXPAND_INITIALIZER);
3479 : :
3480 : : /* Never pass a CONCAT to an ASM. */
3481 : 51783 : if (GET_CODE (op) == CONCAT)
3482 : 2 : op = force_reg (GET_MODE (op), op);
3483 : 51781 : else if (MEM_P (op))
3484 : 12164 : op = validize_mem (op);
3485 : :
3486 : 51783 : if (asm_operand_ok (op, constraint, NULL) <= 0)
3487 : : {
3488 : 24463 : if (allows_reg && TYPE_MODE (type) != BLKmode)
3489 : 24076 : op = force_reg (TYPE_MODE (type), op);
3490 : 387 : else if (!allows_mem)
3491 : 20 : warning_at (locus, 0, "%<asm%> operand %d probably does not match "
3492 : : "constraints", i + noutputs);
3493 : 367 : else if (MEM_P (op))
3494 : : {
3495 : : /* We won't recognize either volatile memory or memory
3496 : : with a queued address as available a memory_operand
3497 : : at this point. Ignore it: clearly this *is* a memory. */
3498 : : }
3499 : : else
3500 : 0 : gcc_unreachable ();
3501 : : }
3502 : 51783 : input_rvec[i] = op;
3503 : 51783 : input_mode[i] = TYPE_MODE (type);
3504 : : }
3505 : :
3506 : : /* For in-out operands, copy output rtx to input rtx. */
3507 : 168870 : unsigned ninout = inout_opnum.length ();
3508 : 168870 : for (i = 0; i < ninout; i++)
3509 : : {
3510 : 0 : int j = inout_opnum[i];
3511 : 0 : rtx o = output_rvec[j];
3512 : :
3513 : 0 : input_rvec.safe_push (o);
3514 : 0 : input_mode.safe_push (GET_MODE (o));
3515 : :
3516 : 0 : char buffer[16];
3517 : 0 : sprintf (buffer, "%d", j);
3518 : 0 : constraints.safe_push (ggc_strdup (buffer));
3519 : : }
3520 : 168870 : ninputs += ninout;
3521 : :
3522 : : /* Sometimes we wish to automatically clobber registers across an asm.
3523 : : Case in point is when the i386 backend moved from cc0 to a hard reg --
3524 : : maintaining source-level compatibility means automatically clobbering
3525 : : the flags register. */
3526 : 168870 : rtx_insn *after_md_seq = NULL;
3527 : 337740 : auto_vec<rtx> use_rvec;
3528 : 168870 : if (targetm.md_asm_adjust)
3529 : 168870 : after_md_seq
3530 : 168870 : = targetm.md_asm_adjust (output_rvec, input_rvec, input_mode,
3531 : : constraints, use_rvec, clobber_rvec,
3532 : : clobbered_regs, locus);
3533 : :
3534 : : /* Do not allow the hook to change the output and input count,
3535 : : lest it mess up the operand numbering. */
3536 : 337740 : gcc_assert (output_rvec.length() == noutputs);
3537 : 337740 : gcc_assert (input_rvec.length() == ninputs);
3538 : 337740 : gcc_assert (constraints.length() == noutputs + ninputs);
3539 : :
3540 : : /* But it certainly can adjust the uses and clobbers. */
3541 : 168870 : unsigned nuses = use_rvec.length ();
3542 : 168870 : unsigned nclobbers = clobber_rvec.length ();
3543 : :
3544 : : /* Third pass checks for easy conflicts. */
3545 : : /* ??? Why are we doing this on trees instead of rtx. */
3546 : :
3547 : 168870 : bool clobber_conflict_found = 0;
3548 : 240659 : for (i = 0; i < noutputs; ++i)
3549 : 71789 : if (tree_conflicts_with_clobbers_p (output_tvec[i], &clobbered_regs, locus))
3550 : 10 : clobber_conflict_found = 1;
3551 : 220653 : for (i = 0; i < ninputs - ninout; ++i)
3552 : 51783 : if (tree_conflicts_with_clobbers_p (input_tvec[i], &clobbered_regs, locus))
3553 : 11 : clobber_conflict_found = 1;
3554 : :
3555 : : /* Make vectors for the expression-rtx, constraint strings,
3556 : : and named operands. */
3557 : :
3558 : 168870 : rtvec argvec = rtvec_alloc (ninputs);
3559 : 168870 : rtvec constraintvec = rtvec_alloc (ninputs);
3560 : 168870 : rtvec labelvec = rtvec_alloc (nlabels);
3561 : :
3562 : 201669 : rtx body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
3563 : : : GET_MODE (output_rvec[0])),
3564 : : ggc_strdup (str),
3565 : : "", 0, argvec, constraintvec,
3566 : : labelvec, locus);
3567 : 168870 : MEM_VOLATILE_P (body) = gimple_asm_volatile_p (stmt);
3568 : :
3569 : 220653 : for (i = 0; i < ninputs; ++i)
3570 : : {
3571 : 51783 : ASM_OPERANDS_INPUT (body, i) = input_rvec[i];
3572 : 103566 : ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)
3573 : 51783 : = gen_rtx_ASM_INPUT_loc (input_mode[i],
3574 : : constraints[i + noutputs],
3575 : : locus);
3576 : : }
3577 : :
3578 : : /* Copy labels to the vector. */
3579 : 168870 : rtx_code_label *fallthru_label = NULL;
3580 : 168870 : if (nlabels > 0)
3581 : : {
3582 : 445 : basic_block fallthru_bb = NULL;
3583 : 445 : edge fallthru = find_fallthru_edge (gimple_bb (stmt)->succs);
3584 : 445 : if (fallthru)
3585 : 445 : fallthru_bb = fallthru->dest;
3586 : :
3587 : 1133 : for (i = 0; i < nlabels; ++i)
3588 : : {
3589 : 688 : tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
3590 : 688 : rtx_insn *r;
3591 : : /* If asm goto has any labels in the fallthru basic block, use
3592 : : a label that we emit immediately after the asm goto. Expansion
3593 : : may insert further instructions into the same basic block after
3594 : : asm goto and if we don't do this, insertion of instructions on
3595 : : the fallthru edge might misbehave. See PR58670. */
3596 : 688 : if (fallthru_bb && label_to_block (cfun, label) == fallthru_bb)
3597 : : {
3598 : 240 : if (fallthru_label == NULL_RTX)
3599 : 235 : fallthru_label = gen_label_rtx ();
3600 : : r = fallthru_label;
3601 : : }
3602 : : else
3603 : 448 : r = label_rtx (label);
3604 : 688 : ASM_OPERANDS_LABEL (body, i) = gen_rtx_LABEL_REF (Pmode, r);
3605 : : }
3606 : : }
3607 : :
3608 : : /* Now, for each output, construct an rtx
3609 : : (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3610 : : ARGVEC CONSTRAINTS OPNAMES))
3611 : : If there is more than one, put them inside a PARALLEL. */
3612 : :
3613 : 168870 : if (noutputs == 0 && nuses == 0 && nclobbers == 0)
3614 : : {
3615 : : /* No output operands: put in a raw ASM_OPERANDS rtx. */
3616 : 0 : if (nlabels > 0)
3617 : 0 : emit_jump_insn (body);
3618 : : else
3619 : 0 : emit_insn (body);
3620 : : }
3621 : 168870 : else if (noutputs == 1 && nuses == 0 && nclobbers == 0)
3622 : : {
3623 : 62 : ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = constraints[0];
3624 : 62 : if (nlabels > 0)
3625 : 0 : emit_jump_insn (gen_rtx_SET (output_rvec[0], body));
3626 : : else
3627 : 62 : emit_insn (gen_rtx_SET (output_rvec[0], body));
3628 : : }
3629 : : else
3630 : : {
3631 : 168808 : rtx obody = body;
3632 : 168808 : int num = noutputs;
3633 : :
3634 : 168808 : if (num == 0)
3635 : 136071 : num = 1;
3636 : :
3637 : 168808 : body = gen_rtx_PARALLEL (VOIDmode,
3638 : : rtvec_alloc (num + nuses + nclobbers));
3639 : :
3640 : : /* For each output operand, store a SET. */
3641 : 240535 : for (i = 0; i < noutputs; ++i)
3642 : : {
3643 : 71727 : rtx src, o = output_rvec[i];
3644 : 71727 : if (i == 0)
3645 : : {
3646 : 32737 : ASM_OPERANDS_OUTPUT_CONSTRAINT (obody) = constraints[0];
3647 : 32737 : src = obody;
3648 : : }
3649 : : else
3650 : : {
3651 : 38990 : src = gen_rtx_ASM_OPERANDS (GET_MODE (o),
3652 : : ASM_OPERANDS_TEMPLATE (obody),
3653 : : constraints[i], i, argvec,
3654 : : constraintvec, labelvec, locus);
3655 : 38990 : MEM_VOLATILE_P (src) = gimple_asm_volatile_p (stmt);
3656 : : }
3657 : 71727 : XVECEXP (body, 0, i) = gen_rtx_SET (o, src);
3658 : : }
3659 : :
3660 : : /* If there are no outputs (but there are some clobbers)
3661 : : store the bare ASM_OPERANDS into the PARALLEL. */
3662 : 168808 : if (i == 0)
3663 : 136071 : XVECEXP (body, 0, i++) = obody;
3664 : :
3665 : : /* Add the uses specified by the target hook. No checking should
3666 : : be needed since this doesn't come directly from user code. */
3667 : 168808 : for (rtx use : use_rvec)
3668 : 0 : XVECEXP (body, 0, i++) = gen_rtx_USE (VOIDmode, use);
3669 : :
3670 : : /* Store (clobber REG) for each clobbered register specified. */
3671 : 483001 : for (unsigned j = 0; j < nclobbers; ++j)
3672 : : {
3673 : 314193 : rtx clobbered_reg = clobber_rvec[j];
3674 : :
3675 : : /* Do sanity check for overlap between clobbers and respectively
3676 : : input and outputs that hasn't been handled. Such overlap
3677 : : should have been detected and reported above. */
3678 : 314193 : if (!clobber_conflict_found && REG_P (clobbered_reg))
3679 : : {
3680 : : /* We test the old body (obody) contents to avoid
3681 : : tripping over the under-construction body. */
3682 : 282897 : for (unsigned k = 0; k < noutputs; ++k)
3683 : 72661 : if (reg_overlap_mentioned_p (clobbered_reg, output_rvec[k]))
3684 : 0 : internal_error ("%<asm%> clobber conflict with "
3685 : : "output operand");
3686 : :
3687 : 264778 : for (unsigned k = 0; k < ninputs - ninout; ++k)
3688 : 54542 : if (reg_overlap_mentioned_p (clobbered_reg, input_rvec[k]))
3689 : 0 : internal_error ("%<asm%> clobber conflict with "
3690 : : "input operand");
3691 : : }
3692 : :
3693 : 314193 : XVECEXP (body, 0, i++) = gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
3694 : : }
3695 : :
3696 : 168808 : if (nlabels > 0)
3697 : 445 : emit_jump_insn (body);
3698 : : else
3699 : 168363 : emit_insn (body);
3700 : : }
3701 : :
3702 : 168870 : generating_concat_p = old_generating_concat_p;
3703 : :
3704 : 168870 : if (fallthru_label)
3705 : 235 : emit_label (fallthru_label);
3706 : :
3707 : 168870 : if (after_md_seq)
3708 : 71 : emit_insn (after_md_seq);
3709 : 168870 : if (after_rtl_seq)
3710 : : {
3711 : 26062 : if (nlabels == 0)
3712 : 25937 : emit_insn (after_rtl_seq);
3713 : : else
3714 : : {
3715 : 125 : edge e;
3716 : 125 : edge_iterator ei;
3717 : 125 : unsigned int cnt = EDGE_COUNT (gimple_bb (stmt)->succs);
3718 : :
3719 : 458 : FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs)
3720 : : {
3721 : 333 : rtx_insn *copy;
3722 : 333 : if (--cnt == 0)
3723 : : copy = after_rtl_seq;
3724 : : else
3725 : : {
3726 : 208 : start_sequence ();
3727 : 208 : duplicate_insn_chain (after_rtl_seq, after_rtl_end,
3728 : : NULL, NULL);
3729 : 208 : copy = get_insns ();
3730 : 208 : end_sequence ();
3731 : : }
3732 : 333 : prepend_insn_to_edge (copy, e);
3733 : : }
3734 : : }
3735 : : }
3736 : :
3737 : 168870 : free_temp_slots ();
3738 : 168870 : crtl->has_asm_statement = 1;
3739 : 168875 : }
3740 : :
3741 : : /* Emit code to jump to the address
3742 : : specified by the pointer expression EXP. */
3743 : :
3744 : : static void
3745 : 397 : expand_computed_goto (tree exp)
3746 : : {
3747 : 397 : rtx x = expand_normal (exp);
3748 : :
3749 : 397 : do_pending_stack_adjust ();
3750 : 397 : emit_indirect_jump (x);
3751 : 397 : }
3752 : :
3753 : : /* Generate RTL code for a `goto' statement with target label LABEL.
3754 : : LABEL should be a LABEL_DECL tree node that was or will later be
3755 : : defined with `expand_label'. */
3756 : :
3757 : : static void
3758 : 0 : expand_goto (tree label)
3759 : : {
3760 : 0 : if (flag_checking)
3761 : : {
3762 : : /* Check for a nonlocal goto to a containing function. Should have
3763 : : gotten translated to __builtin_nonlocal_goto. */
3764 : 0 : tree context = decl_function_context (label);
3765 : 0 : gcc_assert (!context || context == current_function_decl);
3766 : : }
3767 : :
3768 : 0 : emit_jump (jump_target_rtx (label));
3769 : 0 : }
3770 : :
3771 : : /* Output a return with no value. */
3772 : :
3773 : : static void
3774 : 800132 : expand_null_return_1 (void)
3775 : : {
3776 : 800132 : clear_pending_stack_adjust ();
3777 : 800132 : do_pending_stack_adjust ();
3778 : 800132 : emit_jump (return_label);
3779 : 800132 : }
3780 : :
3781 : : /* Generate RTL to return from the current function, with no value.
3782 : : (That is, we do not do anything about returning any value.) */
3783 : :
3784 : : void
3785 : 66581 : expand_null_return (void)
3786 : : {
3787 : : /* If this function was declared to return a value, but we
3788 : : didn't, clobber the return registers so that they are not
3789 : : propagated live to the rest of the function. */
3790 : 66581 : clobber_return_register ();
3791 : :
3792 : 66581 : expand_null_return_1 ();
3793 : 66581 : }
3794 : :
3795 : : /* Generate RTL to return from the current function, with value VAL. */
3796 : :
3797 : : static void
3798 : 733551 : expand_value_return (rtx val)
3799 : : {
3800 : : /* Copy the value to the return location unless it's already there. */
3801 : :
3802 : 733551 : tree decl = DECL_RESULT (current_function_decl);
3803 : 733551 : rtx return_reg = DECL_RTL (decl);
3804 : 733551 : if (return_reg != val)
3805 : : {
3806 : 420328 : tree funtype = TREE_TYPE (current_function_decl);
3807 : 420328 : tree type = TREE_TYPE (decl);
3808 : 420328 : int unsignedp = TYPE_UNSIGNED (type);
3809 : 420328 : machine_mode old_mode = DECL_MODE (decl);
3810 : 420328 : machine_mode mode;
3811 : 420328 : if (DECL_BY_REFERENCE (decl))
3812 : 0 : mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 2);
3813 : : else
3814 : 420328 : mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 1);
3815 : :
3816 : 420328 : if (mode != old_mode)
3817 : : {
3818 : : /* Some ABIs require scalar floating point modes to be returned
3819 : : in a wider scalar integer mode. We need to explicitly
3820 : : reinterpret to an integer mode of the correct precision
3821 : : before extending to the desired result. */
3822 : 8 : if (SCALAR_INT_MODE_P (mode)
3823 : 8 : && SCALAR_FLOAT_MODE_P (old_mode)
3824 : 8 : && known_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (old_mode)))
3825 : 0 : val = convert_float_to_wider_int (mode, old_mode, val);
3826 : : else
3827 : 8 : val = convert_modes (mode, old_mode, val, unsignedp);
3828 : : }
3829 : :
3830 : 420328 : if (GET_CODE (return_reg) == PARALLEL)
3831 : 2854 : emit_group_load (return_reg, val, type, int_size_in_bytes (type));
3832 : : else
3833 : 417474 : emit_move_insn (return_reg, val);
3834 : : }
3835 : :
3836 : 733551 : expand_null_return_1 ();
3837 : 733551 : }
3838 : :
3839 : : /* Generate RTL to evaluate the expression RETVAL and return it
3840 : : from the current function. */
3841 : :
3842 : : static void
3843 : 735556 : expand_return (tree retval)
3844 : : {
3845 : 735556 : rtx result_rtl;
3846 : 735556 : rtx val = 0;
3847 : 735556 : tree retval_rhs;
3848 : :
3849 : : /* If function wants no value, give it none. */
3850 : 735556 : if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
3851 : : {
3852 : 0 : expand_normal (retval);
3853 : 0 : expand_null_return ();
3854 : 0 : return;
3855 : : }
3856 : :
3857 : 735556 : if (retval == error_mark_node)
3858 : : {
3859 : : /* Treat this like a return of no value from a function that
3860 : : returns a value. */
3861 : 0 : expand_null_return ();
3862 : 0 : return;
3863 : : }
3864 : 735556 : else if ((TREE_CODE (retval) == MODIFY_EXPR
3865 : 735556 : || TREE_CODE (retval) == INIT_EXPR)
3866 : 735556 : && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
3867 : 673571 : retval_rhs = TREE_OPERAND (retval, 1);
3868 : : else
3869 : : retval_rhs = retval;
3870 : :
3871 : 735556 : result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
3872 : :
3873 : : /* If we are returning the RESULT_DECL, then the value has already
3874 : : been stored into it, so we don't have to do anything special. */
3875 : 735556 : if (TREE_CODE (retval_rhs) == RESULT_DECL)
3876 : 61985 : expand_value_return (result_rtl);
3877 : :
3878 : : /* If the result is an aggregate that is being returned in one (or more)
3879 : : registers, load the registers here. */
3880 : :
3881 : 673571 : else if (retval_rhs != 0
3882 : 673571 : && TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
3883 : 4602 : && REG_P (result_rtl))
3884 : : {
3885 : 3225 : val = copy_blkmode_to_reg (GET_MODE (result_rtl), retval_rhs);
3886 : 3225 : if (val)
3887 : : {
3888 : : /* Use the mode of the result value on the return register. */
3889 : 1220 : PUT_MODE (result_rtl, GET_MODE (val));
3890 : 1220 : expand_value_return (val);
3891 : : }
3892 : : else
3893 : 2005 : expand_null_return ();
3894 : : }
3895 : 670346 : else if (retval_rhs != 0
3896 : 670346 : && !VOID_TYPE_P (TREE_TYPE (retval_rhs))
3897 : 670346 : && (REG_P (result_rtl)
3898 : 5591 : || (GET_CODE (result_rtl) == PARALLEL)))
3899 : : {
3900 : : /* Compute the return value into a temporary (usually a pseudo reg). */
3901 : 667609 : val
3902 : 667609 : = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl)), 0, 1);
3903 : 667609 : val = expand_expr (retval_rhs, val, GET_MODE (val), EXPAND_NORMAL);
3904 : 667609 : val = force_not_mem (val);
3905 : 667609 : expand_value_return (val);
3906 : : }
3907 : : else
3908 : : {
3909 : : /* No hard reg used; calculate value into hard return reg. */
3910 : 2737 : expand_expr (retval, const0_rtx, VOIDmode, EXPAND_NORMAL);
3911 : 2737 : expand_value_return (result_rtl);
3912 : : }
3913 : : }
3914 : :
3915 : : /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3916 : : register, tell the rtl optimizers that its value is no longer
3917 : : needed. */
3918 : :
3919 : : static void
3920 : 1358059 : expand_clobber (tree lhs)
3921 : : {
3922 : 1358059 : if (DECL_P (lhs))
3923 : : {
3924 : 1146208 : rtx decl_rtl = DECL_RTL_IF_SET (lhs);
3925 : 1146165 : if (decl_rtl && REG_P (decl_rtl))
3926 : : {
3927 : 170182 : machine_mode decl_mode = GET_MODE (decl_rtl);
3928 : 340364 : if (maybe_gt (GET_MODE_SIZE (decl_mode),
3929 : : REGMODE_NATURAL_SIZE (decl_mode)))
3930 : 132473 : emit_clobber (decl_rtl);
3931 : : }
3932 : : }
3933 : 1358059 : }
3934 : :
3935 : : /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3936 : : STMT that doesn't require special handling for outgoing edges. That
3937 : : is no tailcalls and no GIMPLE_COND. */
3938 : :
3939 : : static void
3940 : 30473788 : expand_gimple_stmt_1 (gimple *stmt)
3941 : : {
3942 : 30473788 : tree op0;
3943 : :
3944 : 30473788 : set_curr_insn_location (gimple_location (stmt));
3945 : :
3946 : 30473788 : switch (gimple_code (stmt))
3947 : : {
3948 : 397 : case GIMPLE_GOTO:
3949 : 397 : op0 = gimple_goto_dest (stmt);
3950 : 397 : if (TREE_CODE (op0) == LABEL_DECL)
3951 : 0 : expand_goto (op0);
3952 : : else
3953 : 397 : expand_computed_goto (op0);
3954 : : break;
3955 : 597859 : case GIMPLE_LABEL:
3956 : 597859 : expand_label (gimple_label_label (as_a <glabel *> (stmt)));
3957 : 597859 : break;
3958 : : case GIMPLE_NOP:
3959 : : case GIMPLE_PREDICT:
3960 : : break;
3961 : 6555 : case GIMPLE_SWITCH:
3962 : 6555 : {
3963 : 6555 : gswitch *swtch = as_a <gswitch *> (stmt);
3964 : 6555 : if (gimple_switch_num_labels (swtch) == 1)
3965 : 0 : expand_goto (CASE_LABEL (gimple_switch_default_label (swtch)));
3966 : : else
3967 : 6555 : expand_case (swtch);
3968 : : }
3969 : : break;
3970 : 171688 : case GIMPLE_ASM:
3971 : 171688 : expand_asm_stmt (as_a <gasm *> (stmt));
3972 : 171688 : break;
3973 : 6728482 : case GIMPLE_CALL:
3974 : 6728482 : expand_call_stmt (as_a <gcall *> (stmt));
3975 : 6728482 : break;
3976 : :
3977 : 800132 : case GIMPLE_RETURN:
3978 : 800132 : {
3979 : 800132 : op0 = gimple_return_retval (as_a <greturn *> (stmt));
3980 : :
3981 : : /* If a return doesn't have a location, it very likely represents
3982 : : multiple user returns so we cannot let it inherit the location
3983 : : of the last statement of the previous basic block in RTL. */
3984 : 800132 : if (!gimple_has_location (stmt))
3985 : 212261 : set_curr_insn_location (cfun->function_end_locus);
3986 : :
3987 : 800132 : if (op0 && op0 != error_mark_node)
3988 : : {
3989 : 735556 : tree result = DECL_RESULT (current_function_decl);
3990 : :
3991 : : /* If we are not returning the current function's RESULT_DECL,
3992 : : build an assignment to it. */
3993 : 735556 : if (op0 != result)
3994 : : {
3995 : : /* I believe that a function's RESULT_DECL is unique. */
3996 : 673571 : gcc_assert (TREE_CODE (op0) != RESULT_DECL);
3997 : :
3998 : : /* ??? We'd like to use simply expand_assignment here,
3999 : : but this fails if the value is of BLKmode but the return
4000 : : decl is a register. expand_return has special handling
4001 : : for this combination, which eventually should move
4002 : : to common code. See comments there. Until then, let's
4003 : : build a modify expression :-/ */
4004 : 673571 : op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
4005 : : result, op0);
4006 : : }
4007 : : }
4008 : :
4009 : 735556 : if (!op0)
4010 : 64576 : expand_null_return ();
4011 : : else
4012 : 735556 : expand_return (op0);
4013 : : }
4014 : : break;
4015 : :
4016 : 22126061 : case GIMPLE_ASSIGN:
4017 : 22126061 : {
4018 : 22126061 : gassign *assign_stmt = as_a <gassign *> (stmt);
4019 : 22126061 : tree lhs = gimple_assign_lhs (assign_stmt);
4020 : :
4021 : : /* Tree expand used to fiddle with |= and &= of two bitfield
4022 : : COMPONENT_REFs here. This can't happen with gimple, the LHS
4023 : : of binary assigns must be a gimple reg. */
4024 : :
4025 : 22126061 : if (TREE_CODE (lhs) != SSA_NAME
4026 : 35380110 : || gimple_assign_rhs_class (assign_stmt) == GIMPLE_SINGLE_RHS)
4027 : : {
4028 : 16323542 : tree rhs = gimple_assign_rhs1 (assign_stmt);
4029 : 16323542 : gcc_assert (gimple_assign_rhs_class (assign_stmt)
4030 : : == GIMPLE_SINGLE_RHS);
4031 : 31110511 : if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs)
4032 : : /* Do not put locations on possibly shared trees. */
4033 : 22001014 : && !is_gimple_min_invariant (rhs))
4034 : 4632375 : SET_EXPR_LOCATION (rhs, gimple_location (stmt));
4035 : 16323542 : if (TREE_CLOBBER_P (rhs))
4036 : : /* This is a clobber to mark the going out of scope for
4037 : : this LHS. */
4038 : 1358059 : expand_clobber (lhs);
4039 : : else
4040 : 14965483 : expand_assignment (lhs, rhs,
4041 : 14965483 : gimple_assign_nontemporal_move_p (
4042 : : assign_stmt));
4043 : : }
4044 : : else
4045 : : {
4046 : 5802519 : rtx target, temp;
4047 : 5802519 : gcc_assert (!gimple_assign_nontemporal_move_p (assign_stmt));
4048 : 5802519 : bool promoted = false;
4049 : :
4050 : 5802519 : target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
4051 : 5802519 : if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4052 : : promoted = true;
4053 : :
4054 : : /* If we store into a promoted register, don't directly
4055 : : expand to target. */
4056 : 5802519 : temp = promoted ? NULL_RTX : target;
4057 : 11605038 : temp = expand_expr_real_gassign (assign_stmt, temp,
4058 : 5802519 : GET_MODE (target), EXPAND_NORMAL);
4059 : :
4060 : 5802519 : if (temp == target)
4061 : : ;
4062 : 833308 : else if (promoted)
4063 : : {
4064 : 3 : int unsignedp = SUBREG_PROMOTED_SIGN (target);
4065 : : /* If TEMP is a VOIDmode constant, use convert_modes to make
4066 : : sure that we properly convert it. */
4067 : 3 : if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4068 : : {
4069 : 0 : temp = convert_modes (GET_MODE (target),
4070 : 0 : TYPE_MODE (TREE_TYPE (lhs)),
4071 : : temp, unsignedp);
4072 : 0 : temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4073 : 0 : GET_MODE (target), temp, unsignedp);
4074 : : }
4075 : :
4076 : 3 : convert_move (SUBREG_REG (target), temp, unsignedp);
4077 : : }
4078 : : else
4079 : : {
4080 : 833305 : temp = force_operand (temp, target);
4081 : 833305 : if (temp == target)
4082 : : ;
4083 : 833305 : else if (GET_MODE (target) != BLKmode)
4084 : 833304 : emit_move_insn (target, temp);
4085 : : else
4086 : 1 : emit_block_move (target, temp, expr_size (lhs),
4087 : : BLOCK_OP_NORMAL);
4088 : : }
4089 : : }
4090 : : }
4091 : : break;
4092 : :
4093 : 0 : default:
4094 : 0 : gcc_unreachable ();
4095 : : }
4096 : 30473788 : }
4097 : :
4098 : : /* Expand one gimple statement STMT and return the last RTL instruction
4099 : : before any of the newly generated ones.
4100 : :
4101 : : In addition to generating the necessary RTL instructions this also
4102 : : sets REG_EH_REGION notes if necessary and sets the current source
4103 : : location for diagnostics. */
4104 : :
4105 : : static rtx_insn *
4106 : 30473788 : expand_gimple_stmt (gimple *stmt)
4107 : : {
4108 : 30473788 : location_t saved_location = input_location;
4109 : 30473788 : rtx_insn *last = get_last_insn ();
4110 : 30473788 : int lp_nr;
4111 : :
4112 : 30473788 : gcc_assert (cfun);
4113 : :
4114 : : /* We need to save and restore the current source location so that errors
4115 : : discovered during expansion are emitted with the right location. But
4116 : : it would be better if the diagnostic routines used the source location
4117 : : embedded in the tree nodes rather than globals. */
4118 : 30473788 : if (gimple_has_location (stmt))
4119 : 26612096 : input_location = gimple_location (stmt);
4120 : :
4121 : 30473788 : expand_gimple_stmt_1 (stmt);
4122 : :
4123 : : /* Free any temporaries used to evaluate this statement. */
4124 : 30473788 : free_temp_slots ();
4125 : :
4126 : 30473788 : input_location = saved_location;
4127 : :
4128 : : /* Mark all insns that may trap. */
4129 : 30473788 : lp_nr = lookup_stmt_eh_lp (stmt);
4130 : 30473788 : if (lp_nr)
4131 : : {
4132 : 674883 : rtx_insn *insn;
4133 : 3847640 : for (insn = next_real_insn (last); insn;
4134 : 3172757 : insn = next_real_insn (insn))
4135 : : {
4136 : 3172757 : if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
4137 : : /* If we want exceptions for non-call insns, any
4138 : : may_trap_p instruction may throw. */
4139 : 3172726 : && GET_CODE (PATTERN (insn)) != CLOBBER
4140 : 3172660 : && GET_CODE (PATTERN (insn)) != USE
4141 : 6345417 : && insn_could_throw_p (insn))
4142 : 733978 : make_reg_eh_region_note (insn, 0, lp_nr);
4143 : : }
4144 : : }
4145 : :
4146 : 30473788 : return last;
4147 : : }
4148 : :
4149 : : /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
4150 : : that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
4151 : : generated a tail call (something that might be denied by the ABI
4152 : : rules governing the call; see calls.cc).
4153 : :
4154 : : Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
4155 : : can still reach the rest of BB. The case here is __builtin_sqrt,
4156 : : where the NaN result goes through the external function (with a
4157 : : tailcall) and the normal result happens via a sqrt instruction. */
4158 : :
4159 : : static basic_block
4160 : 165689 : expand_gimple_tailcall (basic_block bb, gcall *stmt, bool *can_fallthru)
4161 : : {
4162 : 165689 : rtx_insn *last2, *last;
4163 : 165689 : edge e;
4164 : 165689 : edge_iterator ei;
4165 : 165689 : profile_probability probability;
4166 : :
4167 : 165689 : last2 = last = expand_gimple_stmt (stmt);
4168 : :
4169 : 727176 : for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
4170 : 676426 : if (CALL_P (last) && SIBLING_CALL_P (last))
4171 : 114939 : goto found;
4172 : :
4173 : 50750 : maybe_dump_rtl_for_gimple_stmt (stmt, last2);
4174 : :
4175 : 50750 : *can_fallthru = true;
4176 : 50750 : return NULL;
4177 : :
4178 : 114939 : found:
4179 : : /* ??? Wouldn't it be better to just reset any pending stack adjust?
4180 : : Any instructions emitted here are about to be deleted. */
4181 : 114939 : do_pending_stack_adjust ();
4182 : :
4183 : : /* Remove any non-eh, non-abnormal edges that don't go to exit. */
4184 : : /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
4185 : : EH or abnormal edges, we shouldn't have created a tail call in
4186 : : the first place. So it seems to me we should just be removing
4187 : : all edges here, or redirecting the existing fallthru edge to
4188 : : the exit block. */
4189 : :
4190 : 114939 : probability = profile_probability::never ();
4191 : :
4192 : 229878 : for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
4193 : : {
4194 : 114939 : if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
4195 : : {
4196 : 114939 : if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
4197 : 54479 : e->dest->count -= e->count ();
4198 : 114939 : probability += e->probability;
4199 : 114939 : remove_edge (e);
4200 : : }
4201 : : else
4202 : 0 : ei_next (&ei);
4203 : : }
4204 : :
4205 : : /* This is somewhat ugly: the call_expr expander often emits instructions
4206 : : after the sibcall (to perform the function return). These confuse the
4207 : : find_many_sub_basic_blocks code, so we need to get rid of these. */
4208 : 114939 : last = NEXT_INSN (last);
4209 : 114939 : gcc_assert (BARRIER_P (last));
4210 : :
4211 : 114939 : *can_fallthru = false;
4212 : 139798 : while (NEXT_INSN (last))
4213 : : {
4214 : : /* For instance an sqrt builtin expander expands if with
4215 : : sibcall in the then and label for `else`. */
4216 : 24859 : if (LABEL_P (NEXT_INSN (last)))
4217 : : {
4218 : 0 : *can_fallthru = true;
4219 : 0 : break;
4220 : : }
4221 : 24859 : delete_insn (NEXT_INSN (last));
4222 : : }
4223 : :
4224 : 114939 : e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_ABNORMAL
4225 : : | EDGE_SIBCALL);
4226 : 114939 : e->probability = probability;
4227 : 114939 : BB_END (bb) = last;
4228 : 114939 : update_bb_for_insn (bb);
4229 : :
4230 : 114939 : if (NEXT_INSN (last))
4231 : : {
4232 : 0 : bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
4233 : :
4234 : 0 : last = BB_END (bb);
4235 : 0 : if (BARRIER_P (last))
4236 : 0 : BB_END (bb) = PREV_INSN (last);
4237 : : }
4238 : :
4239 : 114939 : maybe_dump_rtl_for_gimple_stmt (stmt, last2);
4240 : :
4241 : 114939 : return bb;
4242 : : }
4243 : :
4244 : : /* Return the difference between the floor and the truncated result of
4245 : : a signed division by OP1 with remainder MOD. */
4246 : : static rtx
4247 : 6 : floor_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
4248 : : {
4249 : : /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
4250 : 6 : return gen_rtx_IF_THEN_ELSE
4251 : : (mode, gen_rtx_NE (BImode, mod, const0_rtx),
4252 : : gen_rtx_IF_THEN_ELSE
4253 : : (mode, gen_rtx_LT (BImode,
4254 : : gen_rtx_DIV (mode, op1, mod),
4255 : : const0_rtx),
4256 : : constm1_rtx, const0_rtx),
4257 : : const0_rtx);
4258 : : }
4259 : :
4260 : : /* Return the difference between the ceil and the truncated result of
4261 : : a signed division by OP1 with remainder MOD. */
4262 : : static rtx
4263 : 3 : ceil_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
4264 : : {
4265 : : /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
4266 : 3 : return gen_rtx_IF_THEN_ELSE
4267 : : (mode, gen_rtx_NE (BImode, mod, const0_rtx),
4268 : : gen_rtx_IF_THEN_ELSE
4269 : : (mode, gen_rtx_GT (BImode,
4270 : : gen_rtx_DIV (mode, op1, mod),
4271 : : const0_rtx),
4272 : : const1_rtx, const0_rtx),
4273 : : const0_rtx);
4274 : : }
4275 : :
4276 : : /* Return the difference between the ceil and the truncated result of
4277 : : an unsigned division by OP1 with remainder MOD. */
4278 : : static rtx
4279 : 0 : ceil_udiv_adjust (machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
4280 : : {
4281 : : /* (mod != 0 ? 1 : 0) */
4282 : 0 : return gen_rtx_IF_THEN_ELSE
4283 : : (mode, gen_rtx_NE (BImode, mod, const0_rtx),
4284 : : const1_rtx, const0_rtx);
4285 : : }
4286 : :
4287 : : /* Return the difference between the rounded and the truncated result
4288 : : of a signed division by OP1 with remainder MOD. Halfway cases are
4289 : : rounded away from zero, rather than to the nearest even number. */
4290 : : static rtx
4291 : 0 : round_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
4292 : : {
4293 : : /* (abs (mod) >= abs (op1) - abs (mod)
4294 : : ? (op1 / mod > 0 ? 1 : -1)
4295 : : : 0) */
4296 : 0 : return gen_rtx_IF_THEN_ELSE
4297 : : (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
4298 : : gen_rtx_MINUS (mode,
4299 : : gen_rtx_ABS (mode, op1),
4300 : : gen_rtx_ABS (mode, mod))),
4301 : : gen_rtx_IF_THEN_ELSE
4302 : : (mode, gen_rtx_GT (BImode,
4303 : : gen_rtx_DIV (mode, op1, mod),
4304 : : const0_rtx),
4305 : : const1_rtx, constm1_rtx),
4306 : : const0_rtx);
4307 : : }
4308 : :
4309 : : /* Return the difference between the rounded and the truncated result
4310 : : of a unsigned division by OP1 with remainder MOD. Halfway cases
4311 : : are rounded away from zero, rather than to the nearest even
4312 : : number. */
4313 : : static rtx
4314 : 0 : round_udiv_adjust (machine_mode mode, rtx mod, rtx op1)
4315 : : {
4316 : : /* (mod >= op1 - mod ? 1 : 0) */
4317 : 0 : return gen_rtx_IF_THEN_ELSE
4318 : : (mode, gen_rtx_GE (BImode, mod,
4319 : : gen_rtx_MINUS (mode, op1, mod)),
4320 : : const1_rtx, const0_rtx);
4321 : : }
4322 : :
4323 : : /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4324 : : any rtl. */
4325 : :
4326 : : static rtx
4327 : 5525397 : convert_debug_memory_address (scalar_int_mode mode, rtx x,
4328 : : addr_space_t as)
4329 : : {
4330 : : #ifndef POINTERS_EXTEND_UNSIGNED
4331 : : gcc_assert (mode == Pmode
4332 : : || mode == targetm.addr_space.address_mode (as));
4333 : : gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode);
4334 : : #else
4335 : 5525397 : rtx temp;
4336 : :
4337 : 5525397 : gcc_assert (targetm.addr_space.valid_pointer_mode (mode, as));
4338 : :
4339 : 5525397 : if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
4340 : : return x;
4341 : :
4342 : : /* X must have some form of address mode already. */
4343 : 0 : scalar_int_mode xmode = as_a <scalar_int_mode> (GET_MODE (x));
4344 : 0 : if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (xmode))
4345 : 0 : x = lowpart_subreg (mode, x, xmode);
4346 : 0 : else if (POINTERS_EXTEND_UNSIGNED > 0)
4347 : 0 : x = gen_rtx_ZERO_EXTEND (mode, x);
4348 : : else if (!POINTERS_EXTEND_UNSIGNED)
4349 : : x = gen_rtx_SIGN_EXTEND (mode, x);
4350 : : else
4351 : : {
4352 : : switch (GET_CODE (x))
4353 : : {
4354 : : case SUBREG:
4355 : : if ((SUBREG_PROMOTED_VAR_P (x)
4356 : : || (REG_P (SUBREG_REG (x)) && REG_POINTER (SUBREG_REG (x)))
4357 : : || (GET_CODE (SUBREG_REG (x)) == PLUS
4358 : : && REG_P (XEXP (SUBREG_REG (x), 0))
4359 : : && REG_POINTER (XEXP (SUBREG_REG (x), 0))
4360 : : && CONST_INT_P (XEXP (SUBREG_REG (x), 1))))
4361 : : && GET_MODE (SUBREG_REG (x)) == mode)
4362 : : return SUBREG_REG (x);
4363 : : break;
4364 : : case LABEL_REF:
4365 : : temp = gen_rtx_LABEL_REF (mode, label_ref_label (x));
4366 : : LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
4367 : : return temp;
4368 : : case SYMBOL_REF:
4369 : : temp = shallow_copy_rtx (x);
4370 : : PUT_MODE (temp, mode);
4371 : : return temp;
4372 : : case CONST:
4373 : : temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
4374 : : if (temp)
4375 : : temp = gen_rtx_CONST (mode, temp);
4376 : : return temp;
4377 : : case PLUS:
4378 : : case MINUS:
4379 : : if (CONST_INT_P (XEXP (x, 1)))
4380 : : {
4381 : : temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
4382 : : if (temp)
4383 : : return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1));
4384 : : }
4385 : : break;
4386 : : default:
4387 : : break;
4388 : : }
4389 : : /* Don't know how to express ptr_extend as operation in debug info. */
4390 : : return NULL;
4391 : : }
4392 : : #endif /* POINTERS_EXTEND_UNSIGNED */
4393 : :
4394 : : return x;
4395 : : }
4396 : :
4397 : : /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4398 : : by avoid_deep_ter_for_debug. */
4399 : :
4400 : : static hash_map<tree, tree> *deep_ter_debug_map;
4401 : :
4402 : : /* Split too deep TER chains for debug stmts using debug temporaries. */
4403 : :
4404 : : static void
4405 : 30797866 : avoid_deep_ter_for_debug (gimple *stmt, int depth)
4406 : : {
4407 : 30797866 : use_operand_p use_p;
4408 : 30797866 : ssa_op_iter iter;
4409 : 38628525 : FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
4410 : : {
4411 : 7830659 : tree use = USE_FROM_PTR (use_p);
4412 : 7830659 : if (TREE_CODE (use) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (use))
4413 : 6632971 : continue;
4414 : 6735158 : gimple *g = get_gimple_for_ssa_name (use);
4415 : 6735158 : if (g == NULL)
4416 : 5537380 : continue;
4417 : 1197778 : if (depth > 6 && !stmt_ends_bb_p (g))
4418 : : {
4419 : 2194 : if (deep_ter_debug_map == NULL)
4420 : 359 : deep_ter_debug_map = new hash_map<tree, tree>;
4421 : :
4422 : 2194 : tree &vexpr = deep_ter_debug_map->get_or_insert (use);
4423 : 2194 : if (vexpr != NULL)
4424 : 90 : continue;
4425 : 2104 : vexpr = build_debug_expr_decl (TREE_TYPE (use));
4426 : 2104 : gimple *def_temp = gimple_build_debug_bind (vexpr, use, g);
4427 : 2104 : gimple_stmt_iterator gsi = gsi_for_stmt (g);
4428 : 2104 : gsi_insert_after (&gsi, def_temp, GSI_NEW_STMT);
4429 : 2104 : avoid_deep_ter_for_debug (def_temp, 0);
4430 : : }
4431 : : else
4432 : 1195584 : avoid_deep_ter_for_debug (g, depth + 1);
4433 : : }
4434 : 30797866 : }
4435 : :
4436 : : /* Return an RTX equivalent to the value of the parameter DECL. */
4437 : :
4438 : : static rtx
4439 : 129743 : expand_debug_parm_decl (tree decl)
4440 : : {
4441 : 129743 : rtx incoming = DECL_INCOMING_RTL (decl);
4442 : :
4443 : 129743 : if (incoming
4444 : 17170 : && GET_MODE (incoming) != BLKmode
4445 : 146908 : && ((REG_P (incoming) && HARD_REGISTER_P (incoming))
4446 : 1761 : || (MEM_P (incoming)
4447 : 1675 : && REG_P (XEXP (incoming, 0))
4448 : 747 : && HARD_REGISTER_P (XEXP (incoming, 0)))))
4449 : : {
4450 : 15433 : rtx rtl = gen_rtx_ENTRY_VALUE (GET_MODE (incoming));
4451 : :
4452 : : #ifdef HAVE_window_save
4453 : : /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4454 : : If the target machine has an explicit window save instruction, the
4455 : : actual entry value is the corresponding OUTGOING_REGNO instead. */
4456 : : if (REG_P (incoming)
4457 : : && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
4458 : : incoming
4459 : : = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
4460 : : OUTGOING_REGNO (REGNO (incoming)), 0);
4461 : : else if (MEM_P (incoming))
4462 : : {
4463 : : rtx reg = XEXP (incoming, 0);
4464 : : if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
4465 : : {
4466 : : reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
4467 : : incoming = replace_equiv_address_nv (incoming, reg);
4468 : : }
4469 : : else
4470 : : incoming = copy_rtx (incoming);
4471 : : }
4472 : : #endif
4473 : :
4474 : 15433 : ENTRY_VALUE_EXP (rtl) = incoming;
4475 : 15433 : return rtl;
4476 : : }
4477 : :
4478 : 114310 : if (incoming
4479 : 1737 : && GET_MODE (incoming) != BLKmode
4480 : 1732 : && !TREE_ADDRESSABLE (decl)
4481 : 1732 : && MEM_P (incoming)
4482 : 1646 : && (XEXP (incoming, 0) == virtual_incoming_args_rtx
4483 : 928 : || (GET_CODE (XEXP (incoming, 0)) == PLUS
4484 : 928 : && XEXP (XEXP (incoming, 0), 0) == virtual_incoming_args_rtx
4485 : 913 : && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
4486 : 1631 : return copy_rtx (incoming);
4487 : :
4488 : : return NULL_RTX;
4489 : : }
4490 : :
4491 : : /* Return an RTX equivalent to the value of the tree expression EXP. */
4492 : :
4493 : : static rtx
4494 : 31977675 : expand_debug_expr (tree exp)
4495 : : {
4496 : 31977675 : rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
4497 : 31977675 : machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
4498 : 31977675 : machine_mode inner_mode = VOIDmode;
4499 : 31977675 : int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
4500 : 31977675 : addr_space_t as;
4501 : 31977675 : scalar_int_mode op0_mode, op1_mode, addr_mode;
4502 : :
4503 : 31977675 : switch (TREE_CODE_CLASS (TREE_CODE (exp)))
4504 : : {
4505 : 5055297 : case tcc_expression:
4506 : 5055297 : switch (TREE_CODE (exp))
4507 : : {
4508 : 9712 : case COND_EXPR:
4509 : 9712 : case DOT_PROD_EXPR:
4510 : 9712 : case SAD_EXPR:
4511 : 9712 : case WIDEN_MULT_PLUS_EXPR:
4512 : 9712 : case WIDEN_MULT_MINUS_EXPR:
4513 : 9712 : goto ternary;
4514 : :
4515 : 0 : case TRUTH_ANDIF_EXPR:
4516 : 0 : case TRUTH_ORIF_EXPR:
4517 : 0 : case TRUTH_AND_EXPR:
4518 : 0 : case TRUTH_OR_EXPR:
4519 : 0 : case TRUTH_XOR_EXPR:
4520 : 0 : goto binary;
4521 : :
4522 : 0 : case TRUTH_NOT_EXPR:
4523 : 0 : goto unary;
4524 : :
4525 : : default:
4526 : : break;
4527 : : }
4528 : : break;
4529 : :
4530 : 9712 : ternary:
4531 : 9712 : op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
4532 : 9712 : if (!op2)
4533 : : return NULL_RTX;
4534 : : /* Fall through. */
4535 : :
4536 : 9712 : binary:
4537 : 1119524 : case tcc_binary:
4538 : 1119524 : if (mode == BLKmode)
4539 : : return NULL_RTX;
4540 : 1119516 : op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
4541 : 1119516 : if (!op1)
4542 : : return NULL_RTX;
4543 : 1118779 : switch (TREE_CODE (exp))
4544 : : {
4545 : 57729 : case LSHIFT_EXPR:
4546 : 57729 : case RSHIFT_EXPR:
4547 : 57729 : case LROTATE_EXPR:
4548 : 57729 : case RROTATE_EXPR:
4549 : 57729 : case WIDEN_LSHIFT_EXPR:
4550 : : /* Ensure second operand isn't wider than the first one. */
4551 : 57729 : inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
4552 : 57729 : if (is_a <scalar_int_mode> (inner_mode, &op1_mode)
4553 : 57721 : && (GET_MODE_UNIT_PRECISION (mode)
4554 : 57721 : < GET_MODE_PRECISION (op1_mode)))
4555 : 4266 : op1 = lowpart_subreg (GET_MODE_INNER (mode), op1, op1_mode);
4556 : : break;
4557 : : default:
4558 : : break;
4559 : : }
4560 : : /* Fall through. */
4561 : :
4562 : 1682539 : unary:
4563 : 1682539 : case tcc_unary:
4564 : 1682539 : if (mode == BLKmode)
4565 : : return NULL_RTX;
4566 : 1682537 : inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4567 : 1682537 : op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
4568 : 1682537 : if (!op0)
4569 : : return NULL_RTX;
4570 : : break;
4571 : :
4572 : 57107 : case tcc_comparison:
4573 : 57107 : unsignedp = TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
4574 : 57107 : goto binary;
4575 : :
4576 : 0 : case tcc_type:
4577 : 0 : case tcc_statement:
4578 : 0 : gcc_unreachable ();
4579 : :
4580 : : case tcc_constant:
4581 : : case tcc_exceptional:
4582 : : case tcc_declaration:
4583 : : case tcc_reference:
4584 : : case tcc_vl_exp:
4585 : : break;
4586 : : }
4587 : :
4588 : 31975155 : switch (TREE_CODE (exp))
4589 : : {
4590 : 222405 : case STRING_CST:
4591 : 222405 : if (!lookup_constant_def (exp))
4592 : : {
4593 : 85921 : if (strlen (TREE_STRING_POINTER (exp)) + 1
4594 : 85921 : != (size_t) TREE_STRING_LENGTH (exp))
4595 : : return NULL_RTX;
4596 : 84937 : op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
4597 : 84937 : op0 = gen_rtx_MEM (BLKmode, op0);
4598 : 84937 : set_mem_attributes (op0, exp, 0);
4599 : 84937 : return op0;
4600 : : }
4601 : : /* Fall through. */
4602 : :
4603 : 4727699 : case INTEGER_CST:
4604 : 4727699 : if (TREE_CODE (TREE_TYPE (exp)) == BITINT_TYPE
4605 : 4727699 : && TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
4606 : : return NULL;
4607 : : /* FALLTHRU */
4608 : 4789945 : case REAL_CST:
4609 : 4789945 : case FIXED_CST:
4610 : 4789945 : op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
4611 : 4789945 : return op0;
4612 : :
4613 : 0 : case POLY_INT_CST:
4614 : 0 : return immed_wide_int_const (poly_int_cst_value (exp), mode);
4615 : :
4616 : 4546 : case COMPLEX_CST:
4617 : 4546 : gcc_assert (COMPLEX_MODE_P (mode));
4618 : 4546 : op0 = expand_debug_expr (TREE_REALPART (exp));
4619 : 4546 : op1 = expand_debug_expr (TREE_IMAGPART (exp));
4620 : 4546 : return gen_rtx_CONCAT (mode, op0, op1);
4621 : :
4622 : 4183764 : case DEBUG_EXPR_DECL:
4623 : 4183764 : op0 = DECL_RTL_IF_SET (exp);
4624 : :
4625 : 3179391 : if (op0)
4626 : : {
4627 : 3179391 : if (GET_MODE (op0) != mode)
4628 : 0 : gcc_assert (VECTOR_TYPE_P (TREE_TYPE (exp)));
4629 : : else
4630 : : return op0;
4631 : : }
4632 : :
4633 : 1004373 : op0 = gen_rtx_DEBUG_EXPR (mode);
4634 : 1004373 : DEBUG_EXPR_TREE_DECL (op0) = exp;
4635 : 1004373 : SET_DECL_RTL (exp, op0);
4636 : :
4637 : 1004373 : return op0;
4638 : :
4639 : 4061494 : case VAR_DECL:
4640 : 4061494 : case PARM_DECL:
4641 : 4061494 : case FUNCTION_DECL:
4642 : 4061494 : case LABEL_DECL:
4643 : 4061494 : case CONST_DECL:
4644 : 4061494 : case RESULT_DECL:
4645 : 4061494 : op0 = DECL_RTL_IF_SET (exp);
4646 : :
4647 : : /* This decl was probably optimized away. */
4648 : 3021128 : if (!op0
4649 : : /* At least label RTXen are sometimes replaced by
4650 : : NOTE_INSN_DELETED_LABEL. Any notes here are not
4651 : : handled by copy_rtx. */
4652 : 3021128 : || NOTE_P (op0))
4653 : : {
4654 : 1040367 : if (!VAR_P (exp)
4655 : 1033527 : || DECL_EXTERNAL (exp)
4656 : 1032964 : || !TREE_STATIC (exp)
4657 : 41620 : || !DECL_NAME (exp)
4658 : 41620 : || DECL_HARD_REGISTER (exp)
4659 : 41620 : || DECL_IN_CONSTANT_POOL (exp)
4660 : 41620 : || mode == VOIDmode
4661 : 1081987 : || symtab_node::get (exp) == NULL)
4662 : : return NULL;
4663 : :
4664 : 10510 : op0 = make_decl_rtl_for_debug (exp);
4665 : 10510 : if (!MEM_P (op0)
4666 : 10510 : || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
4667 : 21020 : || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
4668 : : return NULL;
4669 : : }
4670 : 3021127 : else if (VAR_P (exp)
4671 : 2923922 : && is_global_var (exp)
4672 : 3192431 : && symtab_node::get (exp) == NULL)
4673 : : return NULL;
4674 : : else
4675 : 3021127 : op0 = copy_rtx (op0);
4676 : :
4677 : 3031637 : if (GET_MODE (op0) == BLKmode
4678 : : /* If op0 is not BLKmode, but mode is, adjust_mode
4679 : : below would ICE. While it is likely a FE bug,
4680 : : try to be robust here. See PR43166. */
4681 : 398697 : || mode == BLKmode
4682 : 398697 : || (mode == VOIDmode && GET_MODE (op0) != VOIDmode))
4683 : : {
4684 : 2632940 : gcc_assert (MEM_P (op0));
4685 : 2632940 : op0 = adjust_address_nv (op0, mode, 0);
4686 : 2632940 : return op0;
4687 : : }
4688 : :
4689 : : /* Fall through. */
4690 : :
4691 : 398697 : adjust_mode:
4692 : 8632940 : case PAREN_EXPR:
4693 : 8632940 : CASE_CONVERT:
4694 : 8632940 : {
4695 : 8632940 : inner_mode = GET_MODE (op0);
4696 : :
4697 : 8632940 : if (mode == inner_mode)
4698 : : return op0;
4699 : :
4700 : 179526 : if (inner_mode == VOIDmode)
4701 : : {
4702 : 4731 : if (TREE_CODE (exp) == SSA_NAME)
4703 : 19 : inner_mode = TYPE_MODE (TREE_TYPE (exp));
4704 : : else
4705 : 4712 : inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4706 : 4731 : if (mode == inner_mode)
4707 : : return op0;
4708 : : }
4709 : :
4710 : 177251 : if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
4711 : : {
4712 : 6009 : if (GET_MODE_UNIT_BITSIZE (mode)
4713 : 12018 : == GET_MODE_UNIT_BITSIZE (inner_mode))
4714 : 4 : op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
4715 : 6005 : else if (GET_MODE_UNIT_BITSIZE (mode)
4716 : 12010 : < GET_MODE_UNIT_BITSIZE (inner_mode))
4717 : 3538 : op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
4718 : : else
4719 : 2467 : op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
4720 : : }
4721 : 171242 : else if (FLOAT_MODE_P (mode))
4722 : : {
4723 : 0 : gcc_assert (TREE_CODE (exp) != SSA_NAME);
4724 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
4725 : 0 : op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
4726 : : else
4727 : 0 : op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
4728 : : }
4729 : 171242 : else if (FLOAT_MODE_P (inner_mode))
4730 : : {
4731 : 0 : if (unsignedp)
4732 : 0 : op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
4733 : : else
4734 : 0 : op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
4735 : : }
4736 : 342484 : else if (GET_MODE_UNIT_PRECISION (mode)
4737 : 171242 : == GET_MODE_UNIT_PRECISION (inner_mode))
4738 : 0 : op0 = lowpart_subreg (mode, op0, inner_mode);
4739 : 342484 : else if (GET_MODE_UNIT_PRECISION (mode)
4740 : 171242 : < GET_MODE_UNIT_PRECISION (inner_mode))
4741 : 100876 : op0 = simplify_gen_unary (TRUNCATE, mode, op0, inner_mode);
4742 : 70366 : else if (UNARY_CLASS_P (exp)
4743 : 70366 : ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
4744 : 0 : : unsignedp)
4745 : 52934 : op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
4746 : : else
4747 : 17432 : op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
4748 : :
4749 : : return op0;
4750 : : }
4751 : :
4752 : 1604701 : case MEM_REF:
4753 : 1604701 : if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
4754 : : {
4755 : 589050 : tree newexp = fold_binary (MEM_REF, TREE_TYPE (exp),
4756 : : TREE_OPERAND (exp, 0),
4757 : : TREE_OPERAND (exp, 1));
4758 : 589050 : if (newexp)
4759 : 0 : return expand_debug_expr (newexp);
4760 : : }
4761 : : /* FALLTHROUGH */
4762 : 1604701 : case INDIRECT_REF:
4763 : 1604701 : inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
4764 : 1604701 : op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
4765 : 1604701 : if (!op0)
4766 : : return NULL;
4767 : :
4768 : 1602265 : if (TREE_CODE (exp) == MEM_REF)
4769 : : {
4770 : 1602265 : if (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
4771 : 1574687 : || (GET_CODE (op0) == PLUS
4772 : 200620 : && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR))
4773 : : /* (mem (debug_implicit_ptr)) might confuse aliasing.
4774 : : Instead just use get_inner_reference. */
4775 : 27578 : goto component_ref;
4776 : :
4777 : 1574687 : op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
4778 : 1574687 : poly_int64 offset;
4779 : 1574687 : if (!op1 || !poly_int_rtx_p (op1, &offset))
4780 : 0 : return NULL;
4781 : :
4782 : 1574687 : op0 = plus_constant (inner_mode, op0, offset);
4783 : : }
4784 : :
4785 : 1574687 : as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
4786 : :
4787 : 1574687 : op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
4788 : : op0, as);
4789 : 1574687 : if (op0 == NULL_RTX)
4790 : : return NULL;
4791 : :
4792 : 1574687 : op0 = gen_rtx_MEM (mode, op0);
4793 : 1574687 : set_mem_attributes (op0, exp, 0);
4794 : 1574687 : if (TREE_CODE (exp) == MEM_REF
4795 : 1574687 : && !is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
4796 : 589050 : set_mem_expr (op0, NULL_TREE);
4797 : 1574687 : set_mem_addr_space (op0, as);
4798 : :
4799 : 1574687 : return op0;
4800 : :
4801 : 40530 : case TARGET_MEM_REF:
4802 : 40530 : if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
4803 : 40530 : && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
4804 : : return NULL;
4805 : :
4806 : 40520 : op0 = expand_debug_expr
4807 : 40520 : (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
4808 : 40520 : if (!op0)
4809 : : return NULL;
4810 : :
4811 : 40520 : as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
4812 : 40520 : op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
4813 : : op0, as);
4814 : 40520 : if (op0 == NULL_RTX)
4815 : : return NULL;
4816 : :
4817 : 40520 : op0 = gen_rtx_MEM (mode, op0);
4818 : :
4819 : 40520 : set_mem_attributes (op0, exp, 0);
4820 : 40520 : set_mem_addr_space (op0, as);
4821 : :
4822 : 40520 : return op0;
4823 : :
4824 : 2789549 : component_ref:
4825 : 2789549 : case ARRAY_REF:
4826 : 2789549 : case ARRAY_RANGE_REF:
4827 : 2789549 : case COMPONENT_REF:
4828 : 2789549 : case BIT_FIELD_REF:
4829 : 2789549 : case REALPART_EXPR:
4830 : 2789549 : case IMAGPART_EXPR:
4831 : 2789549 : case VIEW_CONVERT_EXPR:
4832 : 2789549 : {
4833 : 2789549 : machine_mode mode1;
4834 : 2789549 : poly_int64 bitsize, bitpos;
4835 : 2789549 : tree offset;
4836 : 2789549 : int reversep, volatilep = 0;
4837 : 2789549 : tree tem
4838 : 2789549 : = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
4839 : : &unsignedp, &reversep, &volatilep);
4840 : 2789549 : rtx orig_op0;
4841 : :
4842 : 2789549 : if (known_eq (bitsize, 0))
4843 : : return NULL;
4844 : :
4845 : 2781764 : orig_op0 = op0 = expand_debug_expr (tem);
4846 : :
4847 : 2781764 : if (!op0)
4848 : : return NULL;
4849 : :
4850 : 2592561 : if (offset)
4851 : : {
4852 : 12953 : machine_mode addrmode, offmode;
4853 : :
4854 : 12953 : if (!MEM_P (op0))
4855 : : return NULL;
4856 : :
4857 : 12953 : op0 = XEXP (op0, 0);
4858 : 12953 : addrmode = GET_MODE (op0);
4859 : 12953 : if (addrmode == VOIDmode)
4860 : 0 : addrmode = Pmode;
4861 : :
4862 : 12953 : op1 = expand_debug_expr (offset);
4863 : 12953 : if (!op1)
4864 : : return NULL;
4865 : :
4866 : 12951 : offmode = GET_MODE (op1);
4867 : 12951 : if (offmode == VOIDmode)
4868 : 0 : offmode = TYPE_MODE (TREE_TYPE (offset));
4869 : :
4870 : 12951 : if (addrmode != offmode)
4871 : 0 : op1 = lowpart_subreg (addrmode, op1, offmode);
4872 : :
4873 : : /* Don't use offset_address here, we don't need a
4874 : : recognizable address, and we don't want to generate
4875 : : code. */
4876 : 12951 : op0 = gen_rtx_MEM (mode, simplify_gen_binary (PLUS, addrmode,
4877 : : op0, op1));
4878 : : }
4879 : :
4880 : 2592559 : if (MEM_P (op0))
4881 : : {
4882 : 2490062 : if (mode1 == VOIDmode)
4883 : : {
4884 : 2705 : if (maybe_gt (bitsize, MAX_BITSIZE_MODE_ANY_INT))
4885 : 197028 : return NULL;
4886 : : /* Bitfield. */
4887 : 2705 : mode1 = smallest_int_mode_for_size (bitsize).require ();
4888 : : }
4889 : 2490062 : poly_int64 bytepos = bits_to_bytes_round_down (bitpos);
4890 : 2490062 : if (maybe_ne (bytepos, 0))
4891 : : {
4892 : 1146590 : op0 = adjust_address_nv (op0, mode1, bytepos);
4893 : 1146590 : bitpos = num_trailing_bits (bitpos);
4894 : : }
4895 : 1343472 : else if (known_eq (bitpos, 0)
4896 : 2685167 : && known_eq (bitsize, GET_MODE_BITSIZE (mode)))
4897 : 359703 : op0 = adjust_address_nv (op0, mode, 0);
4898 : 983769 : else if (GET_MODE (op0) != mode1)
4899 : 4765 : op0 = adjust_address_nv (op0, mode1, 0);
4900 : : else
4901 : 979004 : op0 = copy_rtx (op0);
4902 : 2490062 : if (op0 == orig_op0)
4903 : 77277 : op0 = shallow_copy_rtx (op0);
4904 : 2490062 : if (TREE_CODE (tem) != SSA_NAME)
4905 : 2486913 : set_mem_attributes (op0, exp, 0);
4906 : : }
4907 : :
4908 : 2592559 : if (known_eq (bitpos, 0) && mode == GET_MODE (op0))
4909 : : return op0;
4910 : :
4911 : 79777 : if (maybe_lt (bitpos, 0))
4912 : : return NULL;
4913 : :
4914 : 79773 : if (GET_MODE (op0) == BLKmode || mode == BLKmode)
4915 : : return NULL;
4916 : :
4917 : 79762 : poly_int64 bytepos;
4918 : 80378 : if (multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
4919 : 155472 : && known_eq (bitsize, GET_MODE_BITSIZE (mode1)))
4920 : : {
4921 : 77160 : machine_mode opmode = GET_MODE (op0);
4922 : :
4923 : 77160 : if (opmode == VOIDmode)
4924 : 0 : opmode = TYPE_MODE (TREE_TYPE (tem));
4925 : :
4926 : : /* This condition may hold if we're expanding the address
4927 : : right past the end of an array that turned out not to
4928 : : be addressable (i.e., the address was only computed in
4929 : : debug stmts). The gen_subreg below would rightfully
4930 : : crash, and the address doesn't really exist, so just
4931 : : drop it. */
4932 : 154320 : if (known_ge (bitpos, GET_MODE_BITSIZE (opmode)))
4933 : : return NULL;
4934 : :
4935 : 154274 : if (multiple_p (bitpos, GET_MODE_BITSIZE (mode)))
4936 : 77097 : return simplify_gen_subreg (mode, op0, opmode, bytepos);
4937 : : }
4938 : :
4939 : 5284 : return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
4940 : 2191 : && TYPE_UNSIGNED (TREE_TYPE (exp))
4941 : : ? SIGN_EXTRACT
4942 : : : ZERO_EXTRACT, mode,
4943 : 2642 : GET_MODE (op0) != VOIDmode
4944 : : ? GET_MODE (op0)
4945 : 0 : : TYPE_MODE (TREE_TYPE (tem)),
4946 : : op0, gen_int_mode (bitsize, word_mode),
4947 : 2642 : gen_int_mode (bitpos, word_mode));
4948 : : }
4949 : :
4950 : 2128 : case ABS_EXPR:
4951 : 2128 : case ABSU_EXPR:
4952 : 2128 : return simplify_gen_unary (ABS, mode, op0, mode);
4953 : :
4954 : 13803 : case NEGATE_EXPR:
4955 : 13803 : return simplify_gen_unary (NEG, mode, op0, mode);
4956 : :
4957 : 15636 : case BIT_NOT_EXPR:
4958 : 15636 : return simplify_gen_unary (NOT, mode, op0, mode);
4959 : :
4960 : 2370 : case FLOAT_EXPR:
4961 : 2370 : return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
4962 : : 0)))
4963 : : ? UNSIGNED_FLOAT : FLOAT, mode, op0,
4964 : 2370 : inner_mode);
4965 : :
4966 : 462 : case FIX_TRUNC_EXPR:
4967 : 462 : return simplify_gen_unary (unsignedp ? UNSIGNED_FIX : FIX, mode, op0,
4968 : 462 : inner_mode);
4969 : :
4970 : 186493 : case POINTER_PLUS_EXPR:
4971 : : /* For the rare target where pointers are not the same size as
4972 : : size_t, we need to check for mis-matched modes and correct
4973 : : the addend. */
4974 : 186493 : if (op0 && op1
4975 : 186493 : && is_a <scalar_int_mode> (GET_MODE (op0), &op0_mode)
4976 : 186403 : && is_a <scalar_int_mode> (GET_MODE (op1), &op1_mode)
4977 : 287606 : && op0_mode != op1_mode)
4978 : : {
4979 : 0 : if (GET_MODE_BITSIZE (op0_mode) < GET_MODE_BITSIZE (op1_mode)
4980 : : /* If OP0 is a partial mode, then we must truncate, even
4981 : : if it has the same bitsize as OP1 as GCC's
4982 : : representation of partial modes is opaque. */
4983 : 0 : || (GET_MODE_CLASS (op0_mode) == MODE_PARTIAL_INT
4984 : 0 : && (GET_MODE_BITSIZE (op0_mode)
4985 : 0 : == GET_MODE_BITSIZE (op1_mode))))
4986 : 0 : op1 = simplify_gen_unary (TRUNCATE, op0_mode, op1, op1_mode);
4987 : : else
4988 : : /* We always sign-extend, regardless of the signedness of
4989 : : the operand, because the operand is always unsigned
4990 : : here even if the original C expression is signed. */
4991 : 0 : op1 = simplify_gen_unary (SIGN_EXTEND, op0_mode, op1, op1_mode);
4992 : : }
4993 : : /* Fall through. */
4994 : 551676 : case PLUS_EXPR:
4995 : 551676 : return simplify_gen_binary (PLUS, mode, op0, op1);
4996 : :
4997 : 109751 : case MINUS_EXPR:
4998 : 109751 : case POINTER_DIFF_EXPR:
4999 : 109751 : return simplify_gen_binary (MINUS, mode, op0, op1);
5000 : :
5001 : 107396 : case MULT_EXPR:
5002 : 107396 : return simplify_gen_binary (MULT, mode, op0, op1);
5003 : :
5004 : 57745 : case RDIV_EXPR:
5005 : 57745 : case TRUNC_DIV_EXPR:
5006 : 57745 : case EXACT_DIV_EXPR:
5007 : 57745 : if (unsignedp)
5008 : 10836 : return simplify_gen_binary (UDIV, mode, op0, op1);
5009 : : else
5010 : 46909 : return simplify_gen_binary (DIV, mode, op0, op1);
5011 : :
5012 : 6357 : case TRUNC_MOD_EXPR:
5013 : 12714 : return simplify_gen_binary (unsignedp ? UMOD : MOD, mode, op0, op1);
5014 : :
5015 : 5 : case FLOOR_DIV_EXPR:
5016 : 5 : if (unsignedp)
5017 : 0 : return simplify_gen_binary (UDIV, mode, op0, op1);
5018 : : else
5019 : : {
5020 : 5 : rtx div = simplify_gen_binary (DIV, mode, op0, op1);
5021 : 5 : rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
5022 : 5 : rtx adj = floor_sdiv_adjust (mode, mod, op1);
5023 : 5 : return simplify_gen_binary (PLUS, mode, div, adj);
5024 : : }
5025 : :
5026 : 1 : case FLOOR_MOD_EXPR:
5027 : 1 : if (unsignedp)
5028 : 0 : return simplify_gen_binary (UMOD, mode, op0, op1);
5029 : : else
5030 : : {
5031 : 1 : rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
5032 : 1 : rtx adj = floor_sdiv_adjust (mode, mod, op1);
5033 : 1 : adj = simplify_gen_unary (NEG, mode,
5034 : : simplify_gen_binary (MULT, mode, adj, op1),
5035 : : mode);
5036 : 1 : return simplify_gen_binary (PLUS, mode, mod, adj);
5037 : : }
5038 : :
5039 : 3 : case CEIL_DIV_EXPR:
5040 : 3 : if (unsignedp)
5041 : : {
5042 : 0 : rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
5043 : 0 : rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
5044 : 0 : rtx adj = ceil_udiv_adjust (mode, mod, op1);
5045 : 0 : return simplify_gen_binary (PLUS, mode, div, adj);
5046 : : }
5047 : : else
5048 : : {
5049 : 3 : rtx div = simplify_gen_binary (DIV, mode, op0, op1);
5050 : 3 : rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
5051 : 3 : rtx adj = ceil_sdiv_adjust (mode, mod, op1);
5052 : 3 : return simplify_gen_binary (PLUS, mode, div, adj);
5053 : : }
5054 : :
5055 : 0 : case CEIL_MOD_EXPR:
5056 : 0 : if (unsignedp)
5057 : : {
5058 : 0 : rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
5059 : 0 : rtx adj = ceil_udiv_adjust (mode, mod, op1);
5060 : 0 : adj = simplify_gen_unary (NEG, mode,
5061 : : simplify_gen_binary (MULT, mode, adj, op1),
5062 : : mode);
5063 : 0 : return simplify_gen_binary (PLUS, mode, mod, adj);
5064 : : }
5065 : : else
5066 : : {
5067 : 0 : rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
5068 : 0 : rtx adj = ceil_sdiv_adjust (mode, mod, op1);
5069 : 0 : adj = simplify_gen_unary (NEG, mode,
5070 : : simplify_gen_binary (MULT, mode, adj, op1),
5071 : : mode);
5072 : 0 : return simplify_gen_binary (PLUS, mode, mod, adj);
5073 : : }
5074 : :
5075 : 0 : case ROUND_DIV_EXPR:
5076 : 0 : if (unsignedp)
5077 : : {
5078 : 0 : rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
5079 : 0 : rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
5080 : 0 : rtx adj = round_udiv_adjust (mode, mod, op1);
5081 : 0 : return simplify_gen_binary (PLUS, mode, div, adj);
5082 : : }
5083 : : else
5084 : : {
5085 : 0 : rtx div = simplify_gen_binary (DIV, mode, op0, op1);
5086 : 0 : rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
5087 : 0 : rtx adj = round_sdiv_adjust (mode, mod, op1);
5088 : 0 : return simplify_gen_binary (PLUS, mode, div, adj);
5089 : : }
5090 : :
5091 : 0 : case ROUND_MOD_EXPR:
5092 : 0 : if (unsignedp)
5093 : : {
5094 : 0 : rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
5095 : 0 : rtx adj = round_udiv_adjust (mode, mod, op1);
5096 : 0 : adj = simplify_gen_unary (NEG, mode,
5097 : : simplify_gen_binary (MULT, mode, adj, op1),
5098 : : mode);
5099 : 0 : return simplify_gen_binary (PLUS, mode, mod, adj);
5100 : : }
5101 : : else
5102 : : {
5103 : 0 : rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
5104 : 0 : rtx adj = round_sdiv_adjust (mode, mod, op1);
5105 : 0 : adj = simplify_gen_unary (NEG, mode,
5106 : : simplify_gen_binary (MULT, mode, adj, op1),
5107 : : mode);
5108 : 0 : return simplify_gen_binary (PLUS, mode, mod, adj);
5109 : : }
5110 : :
5111 : 13980 : case LSHIFT_EXPR:
5112 : 13980 : return simplify_gen_binary (ASHIFT, mode, op0, op1);
5113 : :
5114 : 43008 : case RSHIFT_EXPR:
5115 : 43008 : if (unsignedp)
5116 : 40189 : return simplify_gen_binary (LSHIFTRT, mode, op0, op1);
5117 : : else
5118 : 2819 : return simplify_gen_binary (ASHIFTRT, mode, op0, op1);
5119 : :
5120 : 2 : case LROTATE_EXPR:
5121 : 2 : return simplify_gen_binary (ROTATE, mode, op0, op1);
5122 : :
5123 : 479 : case RROTATE_EXPR:
5124 : 479 : return simplify_gen_binary (ROTATERT, mode, op0, op1);
5125 : :
5126 : 11687 : case MIN_EXPR:
5127 : 23374 : return simplify_gen_binary (unsignedp ? UMIN : SMIN, mode, op0, op1);
5128 : :
5129 : 13054 : case MAX_EXPR:
5130 : 26108 : return simplify_gen_binary (unsignedp ? UMAX : SMAX, mode, op0, op1);
5131 : :
5132 : 74304 : case BIT_AND_EXPR:
5133 : 74304 : case TRUTH_AND_EXPR:
5134 : 74304 : return simplify_gen_binary (AND, mode, op0, op1);
5135 : :
5136 : 40611 : case BIT_IOR_EXPR:
5137 : 40611 : case TRUTH_OR_EXPR:
5138 : 40611 : return simplify_gen_binary (IOR, mode, op0, op1);
5139 : :
5140 : 7307 : case BIT_XOR_EXPR:
5141 : 7307 : case TRUTH_XOR_EXPR:
5142 : 7307 : return simplify_gen_binary (XOR, mode, op0, op1);
5143 : :
5144 : 0 : case TRUTH_ANDIF_EXPR:
5145 : 0 : return gen_rtx_IF_THEN_ELSE (mode, op0, op1, const0_rtx);
5146 : :
5147 : 0 : case TRUTH_ORIF_EXPR:
5148 : 0 : return gen_rtx_IF_THEN_ELSE (mode, op0, const_true_rtx, op1);
5149 : :
5150 : 0 : case TRUTH_NOT_EXPR:
5151 : 0 : return simplify_gen_relational (EQ, mode, inner_mode, op0, const0_rtx);
5152 : :
5153 : 3656 : case LT_EXPR:
5154 : 3656 : return simplify_gen_relational (unsignedp ? LTU : LT, mode, inner_mode,
5155 : 3656 : op0, op1);
5156 : :
5157 : 3782 : case LE_EXPR:
5158 : 3782 : return simplify_gen_relational (unsignedp ? LEU : LE, mode, inner_mode,
5159 : 3782 : op0, op1);
5160 : :
5161 : 10949 : case GT_EXPR:
5162 : 10949 : return simplify_gen_relational (unsignedp ? GTU : GT, mode, inner_mode,
5163 : 10949 : op0, op1);
5164 : :
5165 : 1180 : case GE_EXPR:
5166 : 1180 : return simplify_gen_relational (unsignedp ? GEU : GE, mode, inner_mode,
5167 : 1180 : op0, op1);
5168 : :
5169 : 23356 : case EQ_EXPR:
5170 : 23356 : return simplify_gen_relational (EQ, mode, inner_mode, op0, op1);
5171 : :
5172 : 14162 : case NE_EXPR:
5173 : 14162 : return simplify_gen_relational (NE, mode, inner_mode, op0, op1);
5174 : :
5175 : 0 : case UNORDERED_EXPR:
5176 : 0 : return simplify_gen_relational (UNORDERED, mode, inner_mode, op0, op1);
5177 : :
5178 : 0 : case ORDERED_EXPR:
5179 : 0 : return simplify_gen_relational (ORDERED, mode, inner_mode, op0, op1);
5180 : :
5181 : 0 : case UNLT_EXPR:
5182 : 0 : return simplify_gen_relational (UNLT, mode, inner_mode, op0, op1);
5183 : :
5184 : 0 : case UNLE_EXPR:
5185 : 0 : return simplify_gen_relational (UNLE, mode, inner_mode, op0, op1);
5186 : :
5187 : 0 : case UNGT_EXPR:
5188 : 0 : return simplify_gen_relational (UNGT, mode, inner_mode, op0, op1);
5189 : :
5190 : 0 : case UNGE_EXPR:
5191 : 0 : return simplify_gen_relational (UNGE, mode, inner_mode, op0, op1);
5192 : :
5193 : 0 : case UNEQ_EXPR:
5194 : 0 : return simplify_gen_relational (UNEQ, mode, inner_mode, op0, op1);
5195 : :
5196 : 0 : case LTGT_EXPR:
5197 : 0 : return simplify_gen_relational (LTGT, mode, inner_mode, op0, op1);
5198 : :
5199 : 9712 : case COND_EXPR:
5200 : 9712 : return gen_rtx_IF_THEN_ELSE (mode, op0, op1, op2);
5201 : :
5202 : 9168 : case COMPLEX_EXPR:
5203 : 9168 : gcc_assert (COMPLEX_MODE_P (mode));
5204 : 9168 : if (GET_MODE (op0) == VOIDmode)
5205 : 0 : op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
5206 : 9168 : if (GET_MODE (op1) == VOIDmode)
5207 : 0 : op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
5208 : 9168 : return gen_rtx_CONCAT (mode, op0, op1);
5209 : :
5210 : 0 : case CONJ_EXPR:
5211 : 0 : if (GET_CODE (op0) == CONCAT)
5212 : 0 : return gen_rtx_CONCAT (mode, XEXP (op0, 0),
5213 : : simplify_gen_unary (NEG, GET_MODE_INNER (mode),
5214 : : XEXP (op0, 1),
5215 : : GET_MODE_INNER (mode)));
5216 : : else
5217 : : {
5218 : 0 : scalar_mode imode = GET_MODE_INNER (mode);
5219 : 0 : rtx re, im;
5220 : :
5221 : 0 : if (MEM_P (op0))
5222 : : {
5223 : 0 : re = adjust_address_nv (op0, imode, 0);
5224 : 0 : im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
5225 : : }
5226 : : else
5227 : : {
5228 : 0 : scalar_int_mode ifmode;
5229 : 0 : scalar_int_mode ihmode;
5230 : 0 : rtx halfsize;
5231 : 0 : if (!int_mode_for_mode (mode).exists (&ifmode)
5232 : 0 : || !int_mode_for_mode (imode).exists (&ihmode))
5233 : 0 : return NULL;
5234 : 0 : halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
5235 : 0 : re = op0;
5236 : 0 : if (mode != ifmode)
5237 : 0 : re = gen_rtx_SUBREG (ifmode, re, 0);
5238 : 0 : re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
5239 : 0 : if (imode != ihmode)
5240 : 0 : re = gen_rtx_SUBREG (imode, re, 0);
5241 : 0 : im = copy_rtx (op0);
5242 : 0 : if (mode != ifmode)
5243 : 0 : im = gen_rtx_SUBREG (ifmode, im, 0);
5244 : 0 : im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
5245 : 0 : if (imode != ihmode)
5246 : 0 : im = gen_rtx_SUBREG (imode, im, 0);
5247 : : }
5248 : 0 : im = gen_rtx_NEG (imode, im);
5249 : 0 : return gen_rtx_CONCAT (mode, re, im);
5250 : : }
5251 : :
5252 : 5045474 : case ADDR_EXPR:
5253 : 5045474 : op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
5254 : 5045474 : if (!op0 || !MEM_P (op0))
5255 : : {
5256 : 1135284 : if ((TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL
5257 : 228046 : || TREE_CODE (TREE_OPERAND (exp, 0)) == PARM_DECL
5258 : 188280 : || TREE_CODE (TREE_OPERAND (exp, 0)) == RESULT_DECL)
5259 : 1175050 : && (!TREE_ADDRESSABLE (TREE_OPERAND (exp, 0))
5260 : 66276 : || target_for_debug_bind (TREE_OPERAND (exp, 0))))
5261 : 886320 : return gen_rtx_DEBUG_IMPLICIT_PTR (mode, TREE_OPERAND (exp, 0));
5262 : :
5263 : 248964 : if (handled_component_p (TREE_OPERAND (exp, 0)))
5264 : : {
5265 : 175161 : poly_int64 bitoffset, bitsize, maxsize, byteoffset;
5266 : 175161 : bool reverse;
5267 : 175161 : tree decl
5268 : 175161 : = get_ref_base_and_extent (TREE_OPERAND (exp, 0), &bitoffset,
5269 : : &bitsize, &maxsize, &reverse);
5270 : 175161 : if ((VAR_P (decl)
5271 : : || TREE_CODE (decl) == PARM_DECL
5272 : : || TREE_CODE (decl) == RESULT_DECL)
5273 : 170795 : && (!TREE_ADDRESSABLE (decl)
5274 : 13703 : || target_for_debug_bind (decl))
5275 : 20298 : && multiple_p (bitoffset, BITS_PER_UNIT, &byteoffset)
5276 : 157092 : && known_gt (bitsize, 0)
5277 : 154865 : && known_eq (bitsize, maxsize))
5278 : : {
5279 : 154863 : rtx base = gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl);
5280 : 154863 : return plus_constant (mode, base, byteoffset);
5281 : : }
5282 : : }
5283 : :
5284 : 94101 : if (TREE_CODE (TREE_OPERAND (exp, 0)) == MEM_REF
5285 : 94101 : && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5286 : : == ADDR_EXPR)
5287 : : {
5288 : 5437 : op0 = expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp, 0),
5289 : : 0));
5290 : 5437 : if (op0 != NULL
5291 : 3063 : && (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
5292 : 0 : || (GET_CODE (op0) == PLUS
5293 : 0 : && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR
5294 : 0 : && CONST_INT_P (XEXP (op0, 1)))))
5295 : : {
5296 : 3063 : op1 = expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp, 0),
5297 : : 1));
5298 : 3063 : poly_int64 offset;
5299 : 6126 : if (!op1 || !poly_int_rtx_p (op1, &offset))
5300 : : return NULL;
5301 : :
5302 : 3063 : return plus_constant (mode, op0, offset);
5303 : : }
5304 : : }
5305 : :
5306 : 91038 : return NULL;
5307 : : }
5308 : :
5309 : 3910190 : as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
5310 : 3910190 : addr_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (exp));
5311 : 3910190 : op0 = convert_debug_memory_address (addr_mode, XEXP (op0, 0), as);
5312 : :
5313 : 3910190 : return op0;
5314 : :
5315 : 1080 : case VECTOR_CST:
5316 : 1080 : {
5317 : 1080 : unsigned HOST_WIDE_INT i, nelts;
5318 : :
5319 : 1080 : if (!VECTOR_CST_NELTS (exp).is_constant (&nelts))
5320 : : return NULL;
5321 : :
5322 : 1080 : op0 = gen_rtx_CONCATN (mode, rtvec_alloc (nelts));
5323 : :
5324 : 5674 : for (i = 0; i < nelts; ++i)
5325 : : {
5326 : 4594 : op1 = expand_debug_expr (VECTOR_CST_ELT (exp, i));
5327 : 4594 : if (!op1)
5328 : : return NULL;
5329 : 4594 : XVECEXP (op0, 0, i) = op1;
5330 : : }
5331 : :
5332 : : return op0;
5333 : : }
5334 : :
5335 : 276 : case CONSTRUCTOR:
5336 : 276 : if (TREE_CLOBBER_P (exp))
5337 : : return NULL;
5338 : 276 : else if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
5339 : : {
5340 : 276 : unsigned i;
5341 : 276 : unsigned HOST_WIDE_INT nelts;
5342 : 276 : tree val;
5343 : :
5344 : 276 : if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)).is_constant (&nelts))
5345 : : goto flag_unsupported;
5346 : :
5347 : 276 : op0 = gen_rtx_CONCATN (mode, rtvec_alloc (nelts));
5348 : :
5349 : 1398 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
5350 : : {
5351 : 1132 : op1 = expand_debug_expr (val);
5352 : 1132 : if (!op1)
5353 : 31977675 : return NULL;
5354 : 1122 : XVECEXP (op0, 0, i) = op1;
5355 : : }
5356 : :
5357 : 266 : if (i < nelts)
5358 : : {
5359 : 22 : op1 = expand_debug_expr
5360 : 22 : (build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
5361 : :
5362 : 22 : if (!op1)
5363 : : return NULL;
5364 : :
5365 : 153 : for (; i < nelts; i++)
5366 : 131 : XVECEXP (op0, 0, i) = op1;
5367 : : }
5368 : :
5369 : 266 : return op0;
5370 : : }
5371 : : else
5372 : 0 : goto flag_unsupported;
5373 : :
5374 : : case CALL_EXPR:
5375 : : /* ??? Maybe handle some builtins? */
5376 : : return NULL;
5377 : :
5378 : 7714542 : case SSA_NAME:
5379 : 7714542 : {
5380 : 7714542 : gimple *g = get_gimple_for_ssa_name (exp);
5381 : 7714542 : if (g)
5382 : : {
5383 : 1125879 : tree t = NULL_TREE;
5384 : 1125879 : if (deep_ter_debug_map)
5385 : : {
5386 : 29083 : tree *slot = deep_ter_debug_map->get (exp);
5387 : 29083 : if (slot)
5388 : 5479 : t = *slot;
5389 : : }
5390 : 5479 : if (t == NULL_TREE)
5391 : 1122504 : t = gimple_assign_rhs_to_tree (g);
5392 : 1125879 : op0 = expand_debug_expr (t);
5393 : 1125879 : if (!op0)
5394 : : return NULL;
5395 : : }
5396 : : else
5397 : : {
5398 : : /* If this is a reference to an incoming value of
5399 : : parameter that is never used in the code or where the
5400 : : incoming value is never used in the code, use
5401 : : PARM_DECL's DECL_RTL if set. */
5402 : 6588663 : if (SSA_NAME_IS_DEFAULT_DEF (exp)
5403 : 1085422 : && SSA_NAME_VAR (exp)
5404 : 1085422 : && TREE_CODE (SSA_NAME_VAR (exp)) == PARM_DECL
5405 : 7629998 : && has_zero_uses (exp))
5406 : : {
5407 : 16704 : op0 = expand_debug_parm_decl (SSA_NAME_VAR (exp));
5408 : 16704 : if (op0)
5409 : 16613 : goto adjust_mode;
5410 : 91 : op0 = expand_debug_expr (SSA_NAME_VAR (exp));
5411 : 91 : if (op0)
5412 : 91 : goto adjust_mode;
5413 : : }
5414 : :
5415 : 6571959 : int part = var_to_partition (SA.map, exp);
5416 : :
5417 : 6571959 : if (part == NO_PARTITION)
5418 : : return NULL;
5419 : :
5420 : 6567126 : gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
5421 : :
5422 : 6567126 : op0 = copy_rtx (SA.partition_to_pseudo[part]);
5423 : : }
5424 : 7689199 : goto adjust_mode;
5425 : : }
5426 : :
5427 : : case ERROR_MARK:
5428 : : return NULL;
5429 : :
5430 : : /* Vector stuff. For most of the codes we don't have rtl codes. */
5431 : : case REALIGN_LOAD_EXPR:
5432 : : case VEC_COND_EXPR:
5433 : : case VEC_PACK_FIX_TRUNC_EXPR:
5434 : : case VEC_PACK_FLOAT_EXPR:
5435 : : case VEC_PACK_SAT_EXPR:
5436 : : case VEC_PACK_TRUNC_EXPR:
5437 : : case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
5438 : : case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
5439 : : case VEC_UNPACK_FLOAT_HI_EXPR:
5440 : : case VEC_UNPACK_FLOAT_LO_EXPR:
5441 : : case VEC_UNPACK_HI_EXPR:
5442 : : case VEC_UNPACK_LO_EXPR:
5443 : : case VEC_WIDEN_MULT_HI_EXPR:
5444 : : case VEC_WIDEN_MULT_LO_EXPR:
5445 : : case VEC_WIDEN_MULT_EVEN_EXPR:
5446 : : case VEC_WIDEN_MULT_ODD_EXPR:
5447 : : case VEC_WIDEN_LSHIFT_HI_EXPR:
5448 : : case VEC_WIDEN_LSHIFT_LO_EXPR:
5449 : : case VEC_PERM_EXPR:
5450 : : case VEC_DUPLICATE_EXPR:
5451 : : case VEC_SERIES_EXPR:
5452 : : case SAD_EXPR:
5453 : : return NULL;
5454 : :
5455 : : /* Misc codes. */
5456 : : case ADDR_SPACE_CONVERT_EXPR:
5457 : : case FIXED_CONVERT_EXPR:
5458 : : case OBJ_TYPE_REF:
5459 : : case WITH_SIZE_EXPR:
5460 : : case BIT_INSERT_EXPR:
5461 : : return NULL;
5462 : :
5463 : 0 : case DOT_PROD_EXPR:
5464 : 0 : if (SCALAR_INT_MODE_P (GET_MODE (op0))
5465 : 0 : && SCALAR_INT_MODE_P (mode))
5466 : : {
5467 : 0 : op0
5468 : 0 : = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
5469 : : 0)))
5470 : : ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
5471 : : inner_mode);
5472 : 0 : op1
5473 : 0 : = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
5474 : : 1)))
5475 : : ? ZERO_EXTEND : SIGN_EXTEND, mode, op1,
5476 : : inner_mode);
5477 : 0 : op0 = simplify_gen_binary (MULT, mode, op0, op1);
5478 : 0 : return simplify_gen_binary (PLUS, mode, op0, op2);
5479 : : }
5480 : : return NULL;
5481 : :
5482 : 4094 : case WIDEN_MULT_EXPR:
5483 : 4094 : case WIDEN_MULT_PLUS_EXPR:
5484 : 4094 : case WIDEN_MULT_MINUS_EXPR:
5485 : 4094 : if (SCALAR_INT_MODE_P (GET_MODE (op0))
5486 : 4094 : && SCALAR_INT_MODE_P (mode))
5487 : : {
5488 : 4094 : inner_mode = GET_MODE (op0);
5489 : 4094 : if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
5490 : 3475 : op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
5491 : : else
5492 : 619 : op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
5493 : 4094 : if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
5494 : 3475 : op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode);
5495 : : else
5496 : 619 : op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode);
5497 : 4094 : op0 = simplify_gen_binary (MULT, mode, op0, op1);
5498 : 4094 : if (TREE_CODE (exp) == WIDEN_MULT_EXPR)
5499 : : return op0;
5500 : 0 : else if (TREE_CODE (exp) == WIDEN_MULT_PLUS_EXPR)
5501 : 0 : return simplify_gen_binary (PLUS, mode, op0, op2);
5502 : : else
5503 : 0 : return simplify_gen_binary (MINUS, mode, op2, op0);
5504 : : }
5505 : : return NULL;
5506 : :
5507 : : case MULT_HIGHPART_EXPR:
5508 : : /* ??? Similar to the above. */
5509 : : return NULL;
5510 : :
5511 : 0 : case WIDEN_SUM_EXPR:
5512 : 0 : case WIDEN_LSHIFT_EXPR:
5513 : 0 : if (SCALAR_INT_MODE_P (GET_MODE (op0))
5514 : 0 : && SCALAR_INT_MODE_P (mode))
5515 : : {
5516 : 0 : op0
5517 : 0 : = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
5518 : : 0)))
5519 : : ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
5520 : : inner_mode);
5521 : 0 : return simplify_gen_binary (TREE_CODE (exp) == WIDEN_LSHIFT_EXPR
5522 : 0 : ? ASHIFT : PLUS, mode, op0, op1);
5523 : : }
5524 : : return NULL;
5525 : :
5526 : 0 : default:
5527 : 0 : flag_unsupported:
5528 : 0 : if (flag_checking)
5529 : : {
5530 : 0 : debug_tree (exp);
5531 : 0 : gcc_unreachable ();
5532 : : }
5533 : : return NULL;
5534 : : }
5535 : : }
5536 : :
5537 : : /* Return an RTX equivalent to the source bind value of the tree expression
5538 : : EXP. */
5539 : :
5540 : : static rtx
5541 : 113770 : expand_debug_source_expr (tree exp)
5542 : : {
5543 : 215474 : rtx op0 = NULL_RTX;
5544 : 215474 : machine_mode mode = VOIDmode, inner_mode;
5545 : :
5546 : 215474 : switch (TREE_CODE (exp))
5547 : : {
5548 : 101704 : case VAR_DECL:
5549 : 101704 : if (DECL_ABSTRACT_ORIGIN (exp))
5550 : 101704 : return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp));
5551 : : break;
5552 : 113039 : case PARM_DECL:
5553 : 113039 : {
5554 : 113039 : mode = DECL_MODE (exp);
5555 : 113039 : op0 = expand_debug_parm_decl (exp);
5556 : 113039 : if (op0)
5557 : : break;
5558 : : /* See if this isn't an argument that has been completely
5559 : : optimized out. */
5560 : 112588 : if (!DECL_RTL_SET_P (exp)
5561 : 112573 : && !DECL_INCOMING_RTL (exp)
5562 : 225161 : && DECL_ABSTRACT_ORIGIN (current_function_decl))
5563 : : {
5564 : 31621 : tree aexp = DECL_ORIGIN (exp);
5565 : 31621 : if (DECL_CONTEXT (aexp)
5566 : 31621 : == DECL_ABSTRACT_ORIGIN (current_function_decl))
5567 : : {
5568 : 13863 : vec<tree, va_gc> **debug_args;
5569 : 13863 : unsigned int ix;
5570 : 13863 : tree ddecl;
5571 : 13863 : debug_args = decl_debug_args_lookup (current_function_decl);
5572 : 13863 : if (debug_args != NULL)
5573 : : {
5574 : 17371 : for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl);
5575 : 3512 : ix += 2)
5576 : 17355 : if (ddecl == aexp)
5577 : 13843 : return gen_rtx_DEBUG_PARAMETER_REF (mode, aexp);
5578 : : }
5579 : : }
5580 : : }
5581 : : break;
5582 : : }
5583 : : default:
5584 : : break;
5585 : : }
5586 : :
5587 : 451 : if (op0 == NULL_RTX)
5588 : 99476 : return NULL_RTX;
5589 : :
5590 : 451 : inner_mode = GET_MODE (op0);
5591 : 451 : if (mode == inner_mode)
5592 : : return op0;
5593 : :
5594 : 21 : if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
5595 : : {
5596 : 7 : if (GET_MODE_UNIT_BITSIZE (mode)
5597 : 14 : == GET_MODE_UNIT_BITSIZE (inner_mode))
5598 : 0 : op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
5599 : 7 : else if (GET_MODE_UNIT_BITSIZE (mode)
5600 : 14 : < GET_MODE_UNIT_BITSIZE (inner_mode))
5601 : 7 : op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
5602 : : else
5603 : 0 : op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
5604 : : }
5605 : 14 : else if (FLOAT_MODE_P (mode))
5606 : 0 : gcc_unreachable ();
5607 : 14 : else if (FLOAT_MODE_P (inner_mode))
5608 : : {
5609 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (exp)))
5610 : 0 : op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
5611 : : else
5612 : 0 : op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
5613 : : }
5614 : 28 : else if (GET_MODE_UNIT_PRECISION (mode)
5615 : 14 : == GET_MODE_UNIT_PRECISION (inner_mode))
5616 : 0 : op0 = lowpart_subreg (mode, op0, inner_mode);
5617 : 28 : else if (GET_MODE_UNIT_PRECISION (mode)
5618 : 14 : < GET_MODE_UNIT_PRECISION (inner_mode))
5619 : 14 : op0 = simplify_gen_unary (TRUNCATE, mode, op0, inner_mode);
5620 : 0 : else if (TYPE_UNSIGNED (TREE_TYPE (exp)))
5621 : 0 : op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
5622 : : else
5623 : 0 : op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
5624 : :
5625 : : return op0;
5626 : : }
5627 : :
5628 : : /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5629 : : Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5630 : : deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5631 : :
5632 : : static void
5633 : 39322033 : avoid_complex_debug_insns (rtx_insn *insn, rtx *exp_p, int depth)
5634 : : {
5635 : 39322033 : rtx exp = *exp_p;
5636 : :
5637 : 39322033 : if (exp == NULL_RTX)
5638 : : return;
5639 : :
5640 : 39322033 : if ((OBJECT_P (exp) && !MEM_P (exp)) || GET_CODE (exp) == CLOBBER)
5641 : : return;
5642 : :
5643 : 5401356 : if (depth == 4)
5644 : : {
5645 : : /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5646 : 18522 : rtx dval = make_debug_expr_from_rtl (exp);
5647 : :
5648 : : /* Emit a debug bind insn before INSN. */
5649 : 18522 : rtx bind = gen_rtx_VAR_LOCATION (GET_MODE (exp),
5650 : : DEBUG_EXPR_TREE_DECL (dval), exp,
5651 : : VAR_INIT_STATUS_INITIALIZED);
5652 : :
5653 : 18522 : emit_debug_insn_before (bind, insn);
5654 : 18522 : *exp_p = dval;
5655 : 18522 : return;
5656 : : }
5657 : :
5658 : 5382834 : const char *format_ptr = GET_RTX_FORMAT (GET_CODE (exp));
5659 : 5382834 : int i, j;
5660 : 16048099 : for (i = 0; i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
5661 : 10665265 : switch (*format_ptr++)
5662 : : {
5663 : 9734422 : case 'e':
5664 : 9734422 : avoid_complex_debug_insns (insn, &XEXP (exp, i), depth + 1);
5665 : 9734422 : break;
5666 : :
5667 : : case 'E':
5668 : : case 'V':
5669 : 0 : for (j = 0; j < XVECLEN (exp, i); j++)
5670 : 0 : avoid_complex_debug_insns (insn, &XVECEXP (exp, i, j), depth + 1);
5671 : : break;
5672 : :
5673 : : default:
5674 : : break;
5675 : : }
5676 : : }
5677 : :
5678 : : /* Expand the _LOCs in debug insns. We run this after expanding all
5679 : : regular insns, so that any variables referenced in the function
5680 : : will have their DECL_RTLs set. */
5681 : :
5682 : : static void
5683 : 481111 : expand_debug_locations (void)
5684 : : {
5685 : 481111 : rtx_insn *insn;
5686 : 481111 : rtx_insn *last = get_last_insn ();
5687 : 481111 : int save_strict_alias = flag_strict_aliasing;
5688 : :
5689 : : /* New alias sets while setting up memory attributes cause
5690 : : -fcompare-debug failures, even though it doesn't bring about any
5691 : : codegen changes. */
5692 : 481111 : flag_strict_aliasing = 0;
5693 : :
5694 : 91660504 : for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
5695 : 91179393 : if (DEBUG_BIND_INSN_P (insn))
5696 : : {
5697 : 29569089 : tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
5698 : 29569089 : rtx val;
5699 : 29569089 : rtx_insn *prev_insn, *insn2;
5700 : 29569089 : machine_mode mode;
5701 : :
5702 : 29569089 : if (value == NULL_TREE)
5703 : : val = NULL_RTX;
5704 : : else
5705 : : {
5706 : 17013862 : if (INSN_VAR_LOCATION_STATUS (insn)
5707 : : == VAR_INIT_STATUS_UNINITIALIZED)
5708 : 113770 : val = expand_debug_source_expr (value);
5709 : : /* The avoid_deep_ter_for_debug function inserts
5710 : : debug bind stmts after SSA_NAME definition, with the
5711 : : SSA_NAME as the whole bind location. Disable temporarily
5712 : : expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5713 : : being defined in this DEBUG_INSN. */
5714 : 16900092 : else if (deep_ter_debug_map && TREE_CODE (value) == SSA_NAME)
5715 : : {
5716 : 26717 : tree *slot = deep_ter_debug_map->get (value);
5717 : 26717 : if (slot)
5718 : : {
5719 : 2319 : if (*slot == INSN_VAR_LOCATION_DECL (insn))
5720 : 2104 : *slot = NULL_TREE;
5721 : : else
5722 : : slot = NULL;
5723 : : }
5724 : 26717 : val = expand_debug_expr (value);
5725 : 26717 : if (slot)
5726 : 2104 : *slot = INSN_VAR_LOCATION_DECL (insn);
5727 : : }
5728 : : else
5729 : 16873375 : val = expand_debug_expr (value);
5730 : 17013862 : gcc_assert (last == get_last_insn ());
5731 : : }
5732 : :
5733 : 17013862 : if (!val)
5734 : 12777666 : val = gen_rtx_UNKNOWN_VAR_LOC ();
5735 : : else
5736 : : {
5737 : 16791423 : mode = GET_MODE (INSN_VAR_LOCATION (insn));
5738 : :
5739 : 16791423 : gcc_assert (mode == GET_MODE (val)
5740 : : || (GET_MODE (val) == VOIDmode
5741 : : && (CONST_SCALAR_INT_P (val)
5742 : : || GET_CODE (val) == CONST_FIXED
5743 : : || GET_CODE (val) == LABEL_REF)));
5744 : : }
5745 : :
5746 : 29569089 : INSN_VAR_LOCATION_LOC (insn) = val;
5747 : 29569089 : prev_insn = PREV_INSN (insn);
5748 : 59156700 : for (insn2 = insn; insn2 != prev_insn; insn2 = PREV_INSN (insn2))
5749 : 29587611 : avoid_complex_debug_insns (insn2, &INSN_VAR_LOCATION_LOC (insn2), 0);
5750 : : }
5751 : :
5752 : 481111 : flag_strict_aliasing = save_strict_alias;
5753 : 481111 : }
5754 : :
5755 : : /* Performs swapping operands of commutative operations to expand
5756 : : the expensive one first. */
5757 : :
5758 : : static void
5759 : 9241102 : reorder_operands (basic_block bb)
5760 : : {
5761 : 9241102 : unsigned int *lattice; /* Hold cost of each statement. */
5762 : 9241102 : unsigned int i = 0, n = 0;
5763 : 9241102 : gimple_stmt_iterator gsi;
5764 : 9241102 : gimple_seq stmts;
5765 : 9241102 : gimple *stmt;
5766 : 9241102 : bool swap;
5767 : 9241102 : tree op0, op1;
5768 : 9241102 : ssa_op_iter iter;
5769 : 9241102 : use_operand_p use_p;
5770 : 9241102 : gimple *def0, *def1;
5771 : :
5772 : : /* Compute cost of each statement using estimate_num_insns. */
5773 : 9241102 : stmts = bb_seq (bb);
5774 : 82105901 : for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
5775 : : {
5776 : 72864799 : stmt = gsi_stmt (gsi);
5777 : 72864799 : if (!is_gimple_debug (stmt))
5778 : 33070181 : gimple_set_uid (stmt, n++);
5779 : : }
5780 : 9241102 : lattice = XNEWVEC (unsigned int, n);
5781 : 82105901 : for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
5782 : : {
5783 : 72864799 : unsigned cost;
5784 : 72864799 : stmt = gsi_stmt (gsi);
5785 : 72864799 : if (is_gimple_debug (stmt))
5786 : 39794618 : continue;
5787 : 33070181 : cost = estimate_num_insns (stmt, &eni_size_weights);
5788 : 33070181 : lattice[i] = cost;
5789 : 62286836 : FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
5790 : : {
5791 : 29216655 : tree use = USE_FROM_PTR (use_p);
5792 : 29216655 : gimple *def_stmt;
5793 : 29216655 : if (TREE_CODE (use) != SSA_NAME)
5794 : 0 : continue;
5795 : 29216655 : def_stmt = get_gimple_for_ssa_name (use);
5796 : 29216655 : if (!def_stmt)
5797 : 20525274 : continue;
5798 : 8691381 : lattice[i] += lattice[gimple_uid (def_stmt)];
5799 : : }
5800 : 33070181 : i++;
5801 : 33070181 : if (!is_gimple_assign (stmt)
5802 : 33070181 : || !commutative_tree_code (gimple_assign_rhs_code (stmt)))
5803 : 29077375 : continue;
5804 : 3992806 : op0 = gimple_op (stmt, 1);
5805 : 3992806 : op1 = gimple_op (stmt, 2);
5806 : 3992806 : if (TREE_CODE (op0) != SSA_NAME
5807 : 3990737 : || TREE_CODE (op1) != SSA_NAME)
5808 : 2602688 : continue;
5809 : : /* Swap operands if the second one is more expensive. */
5810 : 1390118 : def0 = get_gimple_for_ssa_name (op0);
5811 : 1390118 : def1 = get_gimple_for_ssa_name (op1);
5812 : 1390118 : if (!def1)
5813 : 794402 : continue;
5814 : 595716 : swap = false;
5815 : 595716 : if (!def0 || lattice[gimple_uid (def1)] > lattice[gimple_uid (def0)])
5816 : 270148 : swap = true;
5817 : 270148 : if (swap)
5818 : : {
5819 : 270148 : if (dump_file && (dump_flags & TDF_DETAILS))
5820 : : {
5821 : 2 : fprintf (dump_file, "Swap operands in stmt:\n");
5822 : 2 : print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
5823 : 2 : fprintf (dump_file, "Cost left opnd=%d, right opnd=%d\n",
5824 : 1 : def0 ? lattice[gimple_uid (def0)] : 0,
5825 : 2 : lattice[gimple_uid (def1)]);
5826 : : }
5827 : 270148 : swap_ssa_operands (stmt, gimple_assign_rhs1_ptr (stmt),
5828 : : gimple_assign_rhs2_ptr (stmt));
5829 : : }
5830 : : }
5831 : 9241102 : XDELETE (lattice);
5832 : 9241102 : }
5833 : :
5834 : : /* Expand basic block BB from GIMPLE trees to RTL. */
5835 : :
5836 : : static basic_block
5837 : 12609235 : expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
5838 : : {
5839 : 12609235 : gimple_stmt_iterator gsi;
5840 : 12609235 : gimple_seq stmts;
5841 : 12609235 : gimple *stmt = NULL;
5842 : 12609235 : rtx_note *note = NULL;
5843 : 12609235 : rtx_insn *last;
5844 : 12609235 : edge e;
5845 : 12609235 : edge_iterator ei;
5846 : 12609235 : bool nondebug_stmt_seen = false;
5847 : :
5848 : 12609235 : if (dump_file)
5849 : 646 : fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
5850 : : bb->index);
5851 : :
5852 : : /* Note that since we are now transitioning from GIMPLE to RTL, we
5853 : : cannot use the gsi_*_bb() routines because they expect the basic
5854 : : block to be in GIMPLE, instead of RTL. Therefore, we need to
5855 : : access the BB sequence directly. */
5856 : 12609235 : if (optimize)
5857 : 9241102 : reorder_operands (bb);
5858 : 12609235 : stmts = bb_seq (bb);
5859 : 12609235 : bb->il.gimple.seq = NULL;
5860 : 12609235 : bb->il.gimple.phi_nodes = NULL;
5861 : 12609235 : rtl_profile_for_bb (bb);
5862 : 12609235 : init_rtl_bb_info (bb);
5863 : 12609235 : bb->flags |= BB_RTL;
5864 : :
5865 : : /* Remove the RETURN_EXPR if we may fall though to the exit
5866 : : instead. */
5867 : 12609235 : gsi = gsi_last (stmts);
5868 : 12609235 : if (!gsi_end_p (gsi)
5869 : 12609235 : && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
5870 : : {
5871 : 1458366 : greturn *ret_stmt = as_a <greturn *> (gsi_stmt (gsi));
5872 : :
5873 : 1458366 : gcc_assert (single_succ_p (bb));
5874 : 1458366 : gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun));
5875 : :
5876 : 1458366 : if (bb->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)
5877 : 1458366 : && !gimple_return_retval (ret_stmt))
5878 : : {
5879 : 644219 : gsi_remove (&gsi, false);
5880 : 644219 : single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
5881 : : }
5882 : : }
5883 : :
5884 : 12609235 : gsi = gsi_start (stmts);
5885 : 12609235 : if (!gsi_end_p (gsi))
5886 : : {
5887 : 12016816 : stmt = gsi_stmt (gsi);
5888 : 12016816 : if (gimple_code (stmt) != GIMPLE_LABEL)
5889 : 12021954 : stmt = NULL;
5890 : : }
5891 : :
5892 : 12609235 : rtx_code_label **elt = lab_rtx_for_bb->get (bb);
5893 : :
5894 : 12609235 : if (stmt || elt)
5895 : : {
5896 : 5013131 : gcc_checking_assert (!note);
5897 : 5013131 : last = get_last_insn ();
5898 : :
5899 : 5013131 : if (stmt)
5900 : : {
5901 : 587281 : expand_gimple_stmt (stmt);
5902 : 587281 : gsi_next (&gsi);
5903 : : }
5904 : :
5905 : 5013131 : if (elt)
5906 : 4425850 : emit_label (*elt);
5907 : :
5908 : 5013131 : BB_HEAD (bb) = NEXT_INSN (last);
5909 : 5013131 : if (NOTE_P (BB_HEAD (bb)))
5910 : 0 : BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
5911 : 5013131 : gcc_assert (LABEL_P (BB_HEAD (bb)));
5912 : 5013131 : note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
5913 : :
5914 : 5013131 : maybe_dump_rtl_for_gimple_stmt (stmt, last);
5915 : : }
5916 : : else
5917 : 7596104 : BB_HEAD (bb) = note = emit_note (NOTE_INSN_BASIC_BLOCK);
5918 : :
5919 : 12609235 : if (note)
5920 : 12609235 : NOTE_BASIC_BLOCK (note) = bb;
5921 : :
5922 : 63905959 : for (; !gsi_end_p (gsi); gsi_next (&gsi))
5923 : : {
5924 : 51855267 : basic_block new_bb;
5925 : :
5926 : 51855267 : stmt = gsi_stmt (gsi);
5927 : 51855267 : if (!is_gimple_debug (stmt))
5928 : 44303509 : nondebug_stmt_seen = true;
5929 : :
5930 : : /* If this statement is a non-debug one, and we generate debug
5931 : : insns, then this one might be the last real use of a TERed
5932 : : SSA_NAME, but where there are still some debug uses further
5933 : : down. Expanding the current SSA name in such further debug
5934 : : uses by their RHS might lead to wrong debug info, as coalescing
5935 : : might make the operands of such RHS be placed into the same
5936 : : pseudo as something else. Like so:
5937 : : a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5938 : : use(a_1);
5939 : : a_2 = ...
5940 : : #DEBUG ... => a_1
5941 : : As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5942 : : If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5943 : : the write to a_2 would actually have clobbered the place which
5944 : : formerly held a_0.
5945 : :
5946 : : So, instead of that, we recognize the situation, and generate
5947 : : debug temporaries at the last real use of TERed SSA names:
5948 : : a_1 = a_0 + 1;
5949 : : #DEBUG #D1 => a_1
5950 : : use(a_1);
5951 : : a_2 = ...
5952 : : #DEBUG ... => #D1
5953 : : */
5954 : 51855267 : if (MAY_HAVE_DEBUG_BIND_INSNS
5955 : 27268170 : && SA.values
5956 : 78011821 : && !is_gimple_debug (stmt))
5957 : : {
5958 : 18971954 : ssa_op_iter iter;
5959 : 18971954 : tree op;
5960 : 18971954 : gimple *def;
5961 : :
5962 : 18971954 : location_t sloc = curr_insn_location ();
5963 : :
5964 : : /* Look for SSA names that have their last use here (TERed
5965 : : names always have only one real use). */
5966 : 35992579 : FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
5967 : 17020625 : if ((def = get_gimple_for_ssa_name (op)))
5968 : : {
5969 : 4851379 : imm_use_iterator imm_iter;
5970 : 4851379 : use_operand_p use_p;
5971 : 4851379 : bool have_debug_uses = false;
5972 : :
5973 : 9683069 : FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
5974 : : {
5975 : 4870663 : if (gimple_debug_bind_p (USE_STMT (use_p)))
5976 : : {
5977 : : have_debug_uses = true;
5978 : : break;
5979 : : }
5980 : : }
5981 : :
5982 : 4851379 : if (have_debug_uses)
5983 : : {
5984 : : /* OP is a TERed SSA name, with DEF its defining
5985 : : statement, and where OP is used in further debug
5986 : : instructions. Generate a debug temporary, and
5987 : : replace all uses of OP in debug insns with that
5988 : : temporary. */
5989 : 38973 : gimple *debugstmt;
5990 : 38973 : tree value = gimple_assign_rhs_to_tree (def);
5991 : 38973 : tree vexpr = build_debug_expr_decl (TREE_TYPE (value));
5992 : 38973 : rtx val;
5993 : 38973 : machine_mode mode;
5994 : :
5995 : 38973 : set_curr_insn_location (gimple_location (def));
5996 : :
5997 : 38973 : if (DECL_P (value))
5998 : 383 : mode = DECL_MODE (value);
5999 : : else
6000 : 38590 : mode = TYPE_MODE (TREE_TYPE (value));
6001 : : /* FIXME: Is setting the mode really necessary? */
6002 : 38973 : SET_DECL_MODE (vexpr, mode);
6003 : :
6004 : 38973 : val = gen_rtx_VAR_LOCATION
6005 : 38973 : (mode, vexpr, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
6006 : :
6007 : 38973 : emit_debug_insn (val);
6008 : :
6009 : 133746 : FOR_EACH_IMM_USE_STMT (debugstmt, imm_iter, op)
6010 : : {
6011 : 94773 : if (!gimple_debug_bind_p (debugstmt))
6012 : 38973 : continue;
6013 : :
6014 : 170188 : FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
6015 : 57194 : SET_USE (use_p, vexpr);
6016 : :
6017 : 55800 : update_stmt (debugstmt);
6018 : 38973 : }
6019 : : }
6020 : : }
6021 : 18971954 : set_curr_insn_location (sloc);
6022 : : }
6023 : :
6024 : 51855267 : currently_expanding_gimple_stmt = stmt;
6025 : :
6026 : : /* Expand this statement, then evaluate the resulting RTL and
6027 : : fixup the CFG accordingly. */
6028 : 51855267 : if (gimple_code (stmt) == GIMPLE_COND)
6029 : : {
6030 : 5725732 : new_bb = expand_gimple_cond (bb, as_a <gcond *> (stmt));
6031 : 5725732 : if (new_bb)
6032 : : {
6033 : 443604 : currently_expanding_gimple_stmt = NULL;
6034 : 443604 : return new_bb;
6035 : : }
6036 : : }
6037 : 46129535 : else if (is_gimple_debug (stmt))
6038 : : {
6039 : 7551758 : location_t sloc = curr_insn_location ();
6040 : 7551758 : gimple_stmt_iterator nsi = gsi;
6041 : :
6042 : 39690389 : for (;;)
6043 : : {
6044 : 39690389 : tree var;
6045 : 39690389 : tree value = NULL_TREE;
6046 : 39690389 : rtx val = NULL_RTX;
6047 : 39690389 : machine_mode mode;
6048 : :
6049 : 39690389 : if (!gimple_debug_nonbind_marker_p (stmt))
6050 : : {
6051 : 29624728 : if (gimple_debug_bind_p (stmt))
6052 : : {
6053 : 29510958 : var = gimple_debug_bind_get_var (stmt);
6054 : :
6055 : 29510958 : if (TREE_CODE (var) != DEBUG_EXPR_DECL
6056 : 27478118 : && TREE_CODE (var) != LABEL_DECL
6057 : 56980337 : && !target_for_debug_bind (var))
6058 : 94612 : goto delink_debug_stmt;
6059 : :
6060 : 29416346 : if (DECL_P (var) && !VECTOR_TYPE_P (TREE_TYPE (var)))
6061 : 29406246 : mode = DECL_MODE (var);
6062 : : else
6063 : 10100 : mode = TYPE_MODE (TREE_TYPE (var));
6064 : :
6065 : 29416346 : if (gimple_debug_bind_has_value_p (stmt))
6066 : 16861119 : value = gimple_debug_bind_get_value (stmt);
6067 : :
6068 : 29416346 : val = gen_rtx_VAR_LOCATION
6069 : 29416346 : (mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
6070 : : }
6071 : 113770 : else if (gimple_debug_source_bind_p (stmt))
6072 : : {
6073 : 113770 : var = gimple_debug_source_bind_get_var (stmt);
6074 : :
6075 : 113770 : value = gimple_debug_source_bind_get_value (stmt);
6076 : :
6077 : 113770 : if (!VECTOR_TYPE_P (TREE_TYPE (var)))
6078 : 113770 : mode = DECL_MODE (var);
6079 : : else
6080 : 0 : mode = TYPE_MODE (TREE_TYPE (var));
6081 : :
6082 : 113770 : val = gen_rtx_VAR_LOCATION (mode, var, (rtx)value,
6083 : : VAR_INIT_STATUS_UNINITIALIZED);
6084 : : }
6085 : : else
6086 : 0 : gcc_unreachable ();
6087 : : }
6088 : : /* If this function was first compiled with markers
6089 : : enabled, but they're now disable (e.g. LTO), drop
6090 : : them on the floor. */
6091 : 10065661 : else if (gimple_debug_nonbind_marker_p (stmt)
6092 : 10065661 : && !MAY_HAVE_DEBUG_MARKER_INSNS)
6093 : 0 : goto delink_debug_stmt;
6094 : 10065661 : else if (gimple_debug_begin_stmt_p (stmt))
6095 : 4227631 : val = GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
6096 : 5838030 : else if (gimple_debug_inline_entry_p (stmt))
6097 : 5838030 : val = GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
6098 : : else
6099 : : gcc_unreachable ();
6100 : :
6101 : 39595777 : last = get_last_insn ();
6102 : :
6103 : 39595777 : set_curr_insn_location (gimple_location (stmt));
6104 : :
6105 : 39595777 : emit_debug_insn (val);
6106 : :
6107 : 39595777 : if (dump_file && (dump_flags & TDF_DETAILS))
6108 : : {
6109 : : /* We can't dump the insn with a TREE where an RTX
6110 : : is expected. */
6111 : 1 : if (GET_CODE (val) == VAR_LOCATION)
6112 : : {
6113 : 0 : gcc_checking_assert (PAT_VAR_LOCATION_LOC (val) == (rtx)value);
6114 : 0 : PAT_VAR_LOCATION_LOC (val) = const0_rtx;
6115 : : }
6116 : 1 : maybe_dump_rtl_for_gimple_stmt (stmt, last);
6117 : 1 : if (GET_CODE (val) == VAR_LOCATION)
6118 : 0 : PAT_VAR_LOCATION_LOC (val) = (rtx)value;
6119 : : }
6120 : :
6121 : 39690389 : delink_debug_stmt:
6122 : : /* In order not to generate too many debug temporaries,
6123 : : we delink all uses of debug statements we already expanded.
6124 : : Therefore debug statements between definition and real
6125 : : use of TERed SSA names will continue to use the SSA name,
6126 : : and not be replaced with debug temps. */
6127 : 39690389 : delink_stmt_imm_use (stmt);
6128 : :
6129 : 39690389 : gsi = nsi;
6130 : 39690389 : gsi_next (&nsi);
6131 : 39690389 : if (gsi_end_p (nsi))
6132 : : break;
6133 : 39068996 : stmt = gsi_stmt (nsi);
6134 : 39068996 : if (!is_gimple_debug (stmt))
6135 : : break;
6136 : : }
6137 : :
6138 : 7551758 : set_curr_insn_location (sloc);
6139 : : }
6140 : : else
6141 : : {
6142 : 38577777 : gcall *call_stmt = dyn_cast <gcall *> (stmt);
6143 : 6728482 : if (call_stmt
6144 : 6728482 : && gimple_call_tail_p (call_stmt)
6145 : 165701 : && disable_tail_calls)
6146 : 12 : gimple_call_set_tail (call_stmt, false);
6147 : :
6148 : 38577777 : if (call_stmt && gimple_call_tail_p (call_stmt))
6149 : : {
6150 : 165689 : bool can_fallthru;
6151 : 165689 : new_bb = expand_gimple_tailcall (bb, call_stmt, &can_fallthru);
6152 : 165689 : if (new_bb)
6153 : : {
6154 : 114939 : if (can_fallthru)
6155 : 0 : bb = new_bb;
6156 : : else
6157 : : {
6158 : 114939 : currently_expanding_gimple_stmt = NULL;
6159 : 114939 : return new_bb;
6160 : : }
6161 : : }
6162 : : }
6163 : : else
6164 : : {
6165 : 38412088 : def_operand_p def_p;
6166 : 38412088 : def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
6167 : :
6168 : 38412088 : if (def_p != NULL)
6169 : : {
6170 : : /* Ignore this stmt if it is in the list of
6171 : : replaceable expressions. */
6172 : 32687473 : if (SA.values
6173 : 40465534 : && bitmap_bit_p (SA.values,
6174 : 16469331 : SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
6175 : 8691270 : continue;
6176 : : }
6177 : 29720818 : last = expand_gimple_stmt (stmt);
6178 : 29720818 : maybe_dump_rtl_for_gimple_stmt (stmt, last);
6179 : : }
6180 : : }
6181 : : }
6182 : :
6183 : 12050692 : currently_expanding_gimple_stmt = NULL;
6184 : :
6185 : : /* Expand implicit goto and convert goto_locus. */
6186 : 29232060 : FOR_EACH_EDGE (e, ei, bb->succs)
6187 : : {
6188 : 17181368 : if (e->goto_locus != UNKNOWN_LOCATION || !nondebug_stmt_seen)
6189 : 11886548 : set_curr_insn_location (e->goto_locus);
6190 : 17181368 : if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb)
6191 : : {
6192 : 1514712 : emit_jump (label_rtx_for_bb (e->dest));
6193 : 1514712 : e->flags &= ~EDGE_FALLTHRU;
6194 : : }
6195 : : }
6196 : :
6197 : : /* Expanded RTL can create a jump in the last instruction of block.
6198 : : This later might be assumed to be a jump to successor and break edge insertion.
6199 : : We need to insert dummy move to prevent this. PR41440. */
6200 : 12050692 : if (single_succ_p (bb)
6201 : 5379499 : && (single_succ_edge (bb)->flags & EDGE_FALLTHRU)
6202 : 3132753 : && (last = get_last_insn ())
6203 : 14995587 : && (JUMP_P (last)
6204 : 3132705 : || (DEBUG_INSN_P (last)
6205 : 342146 : && JUMP_P (prev_nondebug_insn (last)))))
6206 : : {
6207 : 53 : rtx dummy = gen_reg_rtx (SImode);
6208 : 53 : emit_insn_after_noloc (gen_move_insn (dummy, dummy), last, NULL);
6209 : : }
6210 : :
6211 : 12050692 : do_pending_stack_adjust ();
6212 : :
6213 : : /* Find the block tail. The last insn in the block is the insn
6214 : : before a barrier and/or table jump insn. */
6215 : 12050692 : last = get_last_insn ();
6216 : 12050692 : if (BARRIER_P (last))
6217 : 3176512 : last = PREV_INSN (last);
6218 : 12050692 : if (JUMP_TABLE_DATA_P (last))
6219 : 6555 : last = PREV_INSN (PREV_INSN (last));
6220 : 12050692 : if (BARRIER_P (last))
6221 : 5498 : last = PREV_INSN (last);
6222 : 12050692 : BB_END (bb) = last;
6223 : :
6224 : 12050692 : update_bb_for_insn (bb);
6225 : :
6226 : 12050692 : return bb;
6227 : : }
6228 : :
6229 : :
6230 : : /* Create a basic block for initialization code. */
6231 : :
6232 : : static basic_block
6233 : 1487281 : construct_init_block (void)
6234 : : {
6235 : 1487281 : basic_block init_block, first_block;
6236 : 1487281 : edge e = NULL;
6237 : 1487281 : int flags;
6238 : :
6239 : : /* Multiple entry points not supported yet. */
6240 : 1487281 : gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs) == 1);
6241 : 1487281 : init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun));
6242 : 1487281 : init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun));
6243 : 1487281 : ENTRY_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL;
6244 : 1487281 : EXIT_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL;
6245 : :
6246 : 1487281 : e = EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun), 0);
6247 : :
6248 : : /* When entry edge points to first basic block, we don't need jump,
6249 : : otherwise we have to jump into proper target. */
6250 : 1487281 : if (e && e->dest != ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb)
6251 : : {
6252 : 0 : tree label = gimple_block_label (e->dest);
6253 : :
6254 : 0 : emit_jump (jump_target_rtx (label));
6255 : 0 : flags = 0;
6256 : 0 : }
6257 : : else
6258 : : flags = EDGE_FALLTHRU;
6259 : :
6260 : 1487281 : init_block = create_basic_block (NEXT_INSN (get_insns ()),
6261 : : get_last_insn (),
6262 : 1487281 : ENTRY_BLOCK_PTR_FOR_FN (cfun));
6263 : 1487281 : init_block->count = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
6264 : 1487281 : add_bb_to_loop (init_block, ENTRY_BLOCK_PTR_FOR_FN (cfun)->loop_father);
6265 : 1487281 : if (e)
6266 : : {
6267 : 1487281 : first_block = e->dest;
6268 : 1487281 : redirect_edge_succ (e, init_block);
6269 : 1487281 : make_single_succ_edge (init_block, first_block, flags);
6270 : : }
6271 : : else
6272 : 0 : make_single_succ_edge (init_block, EXIT_BLOCK_PTR_FOR_FN (cfun),
6273 : : EDGE_FALLTHRU);
6274 : :
6275 : 1487281 : update_bb_for_insn (init_block);
6276 : 1487281 : return init_block;
6277 : : }
6278 : :
6279 : : /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
6280 : : found in the block tree. */
6281 : :
6282 : : static void
6283 : 15924795 : set_block_levels (tree block, int level)
6284 : : {
6285 : 30362309 : while (block)
6286 : : {
6287 : 14437514 : BLOCK_NUMBER (block) = level;
6288 : 14437514 : set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
6289 : 14437514 : block = BLOCK_CHAIN (block);
6290 : : }
6291 : 15924795 : }
6292 : :
6293 : : /* Create a block containing landing pads and similar stuff. */
6294 : :
6295 : : static void
6296 : 1487281 : construct_exit_block (void)
6297 : : {
6298 : 1487281 : rtx_insn *head = get_last_insn ();
6299 : 1487281 : rtx_insn *end;
6300 : 1487281 : basic_block exit_block;
6301 : 1487281 : edge e, e2;
6302 : 1487281 : unsigned ix;
6303 : 1487281 : edge_iterator ei;
6304 : 1487281 : basic_block prev_bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
6305 : 1487281 : rtx_insn *orig_end = BB_END (prev_bb);
6306 : :
6307 : 1487281 : rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun));
6308 : :
6309 : : /* Make sure the locus is set to the end of the function, so that
6310 : : epilogue line numbers and warnings are set properly. */
6311 : 1487281 : if (LOCATION_LOCUS (cfun->function_end_locus) != UNKNOWN_LOCATION)
6312 : 1174313 : input_location = cfun->function_end_locus;
6313 : :
6314 : : /* Generate rtl for function exit. */
6315 : 1487281 : expand_function_end ();
6316 : :
6317 : 1487281 : end = get_last_insn ();
6318 : 1487281 : if (head == end)
6319 : 0 : return;
6320 : : /* While emitting the function end we could move end of the last basic
6321 : : block. */
6322 : 1487281 : BB_END (prev_bb) = orig_end;
6323 : 1487281 : while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
6324 : : head = NEXT_INSN (head);
6325 : : /* But make sure exit_block starts with RETURN_LABEL, otherwise the
6326 : : bb count counting will be confused. Any instructions before that
6327 : : label are emitted for the case where PREV_BB falls through into the
6328 : : exit block, so append those instructions to prev_bb in that case. */
6329 : 1487281 : if (NEXT_INSN (head) != return_label)
6330 : : {
6331 : 14598 : while (NEXT_INSN (head) != return_label)
6332 : : {
6333 : 9705 : if (!NOTE_P (NEXT_INSN (head)))
6334 : 9705 : BB_END (prev_bb) = NEXT_INSN (head);
6335 : 9705 : head = NEXT_INSN (head);
6336 : : }
6337 : : }
6338 : 1487281 : exit_block = create_basic_block (NEXT_INSN (head), end, prev_bb);
6339 : 1487281 : exit_block->count = EXIT_BLOCK_PTR_FOR_FN (cfun)->count;
6340 : 1487281 : add_bb_to_loop (exit_block, EXIT_BLOCK_PTR_FOR_FN (cfun)->loop_father);
6341 : :
6342 : 1487281 : ix = 0;
6343 : 4487785 : while (ix < EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds))
6344 : : {
6345 : 1513223 : e = EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun), ix);
6346 : 1513223 : if (!(e->flags & EDGE_ABNORMAL))
6347 : 1398284 : redirect_edge_succ (e, exit_block);
6348 : : else
6349 : 114939 : ix++;
6350 : : }
6351 : :
6352 : 1487281 : e = make_single_succ_edge (exit_block, EXIT_BLOCK_PTR_FOR_FN (cfun),
6353 : : EDGE_FALLTHRU);
6354 : 3089501 : FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
6355 : 1602220 : if (e2 != e)
6356 : : {
6357 : 114939 : exit_block->count -= e2->count ();
6358 : : }
6359 : 1487281 : update_bb_for_insn (exit_block);
6360 : : }
6361 : :
6362 : : /* Helper function for discover_nonconstant_array_refs.
6363 : : Look for ARRAY_REF nodes with non-constant indexes and mark them
6364 : : addressable. */
6365 : :
6366 : : static tree
6367 : 157635050 : discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
6368 : : void *data)
6369 : : {
6370 : 157635050 : tree t = *tp;
6371 : 157635050 : bitmap forced_stack_vars = (bitmap)((walk_stmt_info *)data)->info;
6372 : :
6373 : 157635050 : if (IS_TYPE_OR_DECL_P (t))
6374 : 32742179 : *walk_subtrees = 0;
6375 : 124892871 : else if (REFERENCE_CLASS_P (t) && TREE_THIS_VOLATILE (t))
6376 : : {
6377 : 65979 : t = get_base_address (t);
6378 : 65979 : if (t && DECL_P (t)
6379 : 53712 : && DECL_MODE (t) != BLKmode
6380 : 102450 : && !TREE_ADDRESSABLE (t))
6381 : 32626 : bitmap_set_bit (forced_stack_vars, DECL_UID (t));
6382 : 65979 : *walk_subtrees = 0;
6383 : : }
6384 : 124826892 : else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
6385 : : {
6386 : 6393783 : while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
6387 : 3017365 : && is_gimple_min_invariant (TREE_OPERAND (t, 1))
6388 : 2529945 : && (!TREE_OPERAND (t, 2)
6389 : 28427 : || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
6390 : 3891170 : || (TREE_CODE (t) == COMPONENT_REF
6391 : 1031476 : && (!TREE_OPERAND (t,2)
6392 : 0 : || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
6393 : 2859694 : || TREE_CODE (t) == BIT_FIELD_REF
6394 : : || TREE_CODE (t) == REALPART_EXPR
6395 : : || TREE_CODE (t) == IMAGPART_EXPR
6396 : : || TREE_CODE (t) == VIEW_CONVERT_EXPR
6397 : 6393783 : || CONVERT_EXPR_P (t))
6398 : 3543036 : t = TREE_OPERAND (t, 0);
6399 : :
6400 : 2850747 : if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
6401 : : {
6402 : 514752 : t = get_base_address (t);
6403 : 514752 : if (t && DECL_P (t)
6404 : 427452 : && DECL_MODE (t) != BLKmode
6405 : 537667 : && !TREE_ADDRESSABLE (t))
6406 : 14914 : bitmap_set_bit (forced_stack_vars, DECL_UID (t));
6407 : : }
6408 : :
6409 : 2850747 : *walk_subtrees = 0;
6410 : : }
6411 : : /* References of size POLY_INT_CST to a fixed-size object must go
6412 : : through memory. It's more efficient to force that here than
6413 : : to create temporary slots on the fly.
6414 : : RTL expansion expectes TARGET_MEM_REF to always address actual memory.
6415 : : Also, force to stack non-BLKmode vars accessed through VIEW_CONVERT_EXPR
6416 : : to BLKmode type. */
6417 : 121976145 : else if (TREE_CODE (t) == TARGET_MEM_REF
6418 : : || (TREE_CODE (t) == MEM_REF
6419 : 120999619 : && TYPE_SIZE (TREE_TYPE (t))
6420 : : && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t))))
6421 : 242975764 : || (TREE_CODE (t) == VIEW_CONVERT_EXPR
6422 : 313290 : && TYPE_MODE (TREE_TYPE (t)) == BLKmode))
6423 : : {
6424 : 1054260 : tree base = get_base_address (t);
6425 : 1054260 : if (base
6426 : 1054260 : && DECL_P (base)
6427 : 400718 : && !TREE_ADDRESSABLE (base)
6428 : 125416 : && DECL_MODE (base) != BLKmode
6429 : 1059618 : && GET_MODE_SIZE (DECL_MODE (base)).is_constant ())
6430 : 5358 : bitmap_set_bit (forced_stack_vars, DECL_UID (base));
6431 : 1054260 : *walk_subtrees = 0;
6432 : : }
6433 : :
6434 : 157635050 : return NULL_TREE;
6435 : : }
6436 : :
6437 : : /* If there's a chance to get a pseudo for t then if it would be of float mode
6438 : : and the actual access is via an integer mode (lowered memcpy or similar
6439 : : access) then avoid the register expansion if the mode likely is not storage
6440 : : suitable for raw bits processing (like XFmode on i?86). */
6441 : :
6442 : : static void
6443 : 6253854 : avoid_type_punning_on_regs (tree t, bitmap forced_stack_vars)
6444 : : {
6445 : 6253854 : machine_mode access_mode = TYPE_MODE (TREE_TYPE (t));
6446 : 6253854 : if (access_mode != BLKmode
6447 : 5929188 : && !SCALAR_INT_MODE_P (access_mode))
6448 : : return;
6449 : 5306898 : tree base = get_base_address (t);
6450 : 5306898 : if (DECL_P (base)
6451 : 4039631 : && !TREE_ADDRESSABLE (base)
6452 : 1183570 : && FLOAT_MODE_P (DECL_MODE (base))
6453 : 62 : && maybe_lt (GET_MODE_PRECISION (DECL_MODE (base)),
6454 : 186 : GET_MODE_BITSIZE (GET_MODE_INNER (DECL_MODE (base))))
6455 : : /* Double check in the expensive way we really would get a pseudo. */
6456 : 5306903 : && use_register_for_decl (base))
6457 : 5 : bitmap_set_bit (forced_stack_vars, DECL_UID (base));
6458 : : }
6459 : :
6460 : : /* RTL expansion is not able to compile array references with variable
6461 : : offsets for arrays stored in single register. Discover such
6462 : : expressions and mark variables as addressable to avoid this
6463 : : scenario. */
6464 : :
6465 : : static void
6466 : 1487281 : discover_nonconstant_array_refs (bitmap forced_stack_vars)
6467 : : {
6468 : 1487281 : basic_block bb;
6469 : 1487281 : gimple_stmt_iterator gsi;
6470 : :
6471 : 1487281 : walk_stmt_info wi = {};
6472 : 1487281 : wi.info = forced_stack_vars;
6473 : 14079871 : FOR_EACH_BB_FN (bb, cfun)
6474 : 110517744 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
6475 : : {
6476 : 85332564 : gimple *stmt = gsi_stmt (gsi);
6477 : 85332564 : if (!is_gimple_debug (stmt))
6478 : : {
6479 : 45537930 : walk_gimple_op (stmt, discover_nonconstant_array_refs_r, &wi);
6480 : 45537930 : gcall *call = dyn_cast <gcall *> (stmt);
6481 : 6728482 : if (call && gimple_call_internal_p (call))
6482 : : {
6483 : 182439 : tree cand = NULL_TREE;
6484 : 182439 : switch (gimple_call_internal_fn (call))
6485 : : {
6486 : 0 : case IFN_LOAD_LANES:
6487 : : /* The source must be a MEM. */
6488 : 0 : cand = gimple_call_arg (call, 0);
6489 : 0 : break;
6490 : 0 : case IFN_STORE_LANES:
6491 : : /* The destination must be a MEM. */
6492 : 0 : cand = gimple_call_lhs (call);
6493 : 0 : break;
6494 : : default:
6495 : : break;
6496 : : }
6497 : 0 : if (cand)
6498 : 0 : cand = get_base_address (cand);
6499 : 0 : if (cand
6500 : 0 : && DECL_P (cand)
6501 : 0 : && use_register_for_decl (cand))
6502 : 0 : bitmap_set_bit (forced_stack_vars, DECL_UID (cand));
6503 : : }
6504 : 139412111 : if (gimple_vdef (stmt))
6505 : : {
6506 : 14855515 : tree t = gimple_get_lhs (stmt);
6507 : 14855515 : if (t && REFERENCE_CLASS_P (t))
6508 : 6253854 : avoid_type_punning_on_regs (t, forced_stack_vars);
6509 : : }
6510 : : }
6511 : : }
6512 : 1487281 : }
6513 : :
6514 : : /* This function sets crtl->args.internal_arg_pointer to a virtual
6515 : : register if DRAP is needed. Local register allocator will replace
6516 : : virtual_incoming_args_rtx with the virtual register. */
6517 : :
6518 : : static void
6519 : 1487281 : expand_stack_alignment (void)
6520 : : {
6521 : 1487281 : rtx drap_rtx;
6522 : 1487281 : unsigned int preferred_stack_boundary;
6523 : :
6524 : 1487281 : if (! SUPPORTS_STACK_ALIGNMENT)
6525 : : return;
6526 : :
6527 : 1487281 : if (cfun->calls_alloca
6528 : 1487281 : || cfun->has_nonlocal_label
6529 : 1471819 : || crtl->has_nonlocal_goto)
6530 : 15862 : crtl->need_drap = true;
6531 : :
6532 : : /* Call update_stack_boundary here again to update incoming stack
6533 : : boundary. It may set incoming stack alignment to a different
6534 : : value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6535 : : use the minimum incoming stack alignment to check if it is OK
6536 : : to perform sibcall optimization since sibcall optimization will
6537 : : only align the outgoing stack to incoming stack boundary. */
6538 : 1487281 : if (targetm.calls.update_stack_boundary)
6539 : 1487281 : targetm.calls.update_stack_boundary ();
6540 : :
6541 : : /* The incoming stack frame has to be aligned at least at
6542 : : parm_stack_boundary. */
6543 : 1487281 : gcc_assert (crtl->parm_stack_boundary <= INCOMING_STACK_BOUNDARY);
6544 : :
6545 : : /* Update crtl->stack_alignment_estimated and use it later to align
6546 : : stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6547 : : exceptions since callgraph doesn't collect incoming stack alignment
6548 : : in this case. */
6549 : 1487281 : if (cfun->can_throw_non_call_exceptions
6550 : 262778 : && PREFERRED_STACK_BOUNDARY > crtl->preferred_stack_boundary)
6551 : : preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
6552 : : else
6553 : 1459309 : preferred_stack_boundary = crtl->preferred_stack_boundary;
6554 : 1487281 : if (preferred_stack_boundary > crtl->stack_alignment_estimated)
6555 : 706683 : crtl->stack_alignment_estimated = preferred_stack_boundary;
6556 : 1487281 : if (preferred_stack_boundary > crtl->stack_alignment_needed)
6557 : 701962 : crtl->stack_alignment_needed = preferred_stack_boundary;
6558 : :
6559 : 1487281 : gcc_assert (crtl->stack_alignment_needed
6560 : : <= crtl->stack_alignment_estimated);
6561 : :
6562 : 1487281 : crtl->stack_realign_needed
6563 : 1487281 : = INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated;
6564 : 1487281 : crtl->stack_realign_tried = crtl->stack_realign_needed;
6565 : :
6566 : 1487281 : crtl->stack_realign_processed = true;
6567 : :
6568 : : /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6569 : : alignment. */
6570 : 1487281 : gcc_assert (targetm.calls.get_drap_rtx != NULL);
6571 : 1487281 : drap_rtx = targetm.calls.get_drap_rtx ();
6572 : :
6573 : : /* stack_realign_drap and drap_rtx must match. */
6574 : 1487281 : gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
6575 : :
6576 : : /* Do nothing if NULL is returned, which means DRAP is not needed. */
6577 : 1487281 : if (drap_rtx != NULL)
6578 : : {
6579 : 7071 : crtl->args.internal_arg_pointer = drap_rtx;
6580 : :
6581 : : /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6582 : : needed. */
6583 : 7071 : fixup_tail_calls ();
6584 : : }
6585 : : }
6586 : :
6587 : :
6588 : : static void
6589 : 0 : expand_main_function (void)
6590 : : {
6591 : : #if (defined(INVOKE__main) \
6592 : : || (!defined(HAS_INIT_SECTION) \
6593 : : && !defined(INIT_SECTION_ASM_OP) \
6594 : : && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6595 : : emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode);
6596 : : #endif
6597 : 0 : }
6598 : :
6599 : :
6600 : : /* Expand code to initialize the stack_protect_guard. This is invoked at
6601 : : the beginning of a function to be protected. */
6602 : :
6603 : : static void
6604 : 221 : stack_protect_prologue (void)
6605 : : {
6606 : 221 : tree guard_decl = targetm.stack_protect_guard ();
6607 : 221 : rtx x, y;
6608 : :
6609 : 221 : crtl->stack_protect_guard_decl = guard_decl;
6610 : 221 : x = expand_normal (crtl->stack_protect_guard);
6611 : :
6612 : 221 : if (targetm.have_stack_protect_combined_set () && guard_decl)
6613 : : {
6614 : 0 : gcc_assert (DECL_P (guard_decl));
6615 : 0 : y = DECL_RTL (guard_decl);
6616 : :
6617 : : /* Allow the target to compute address of Y and copy it to X without
6618 : : leaking Y into a register. This combined address + copy pattern
6619 : : allows the target to prevent spilling of any intermediate results by
6620 : : splitting it after register allocator. */
6621 : 0 : if (rtx_insn *insn = targetm.gen_stack_protect_combined_set (x, y))
6622 : : {
6623 : 0 : emit_insn (insn);
6624 : 0 : return;
6625 : : }
6626 : : }
6627 : :
6628 : 221 : if (guard_decl)
6629 : 221 : y = expand_normal (guard_decl);
6630 : : else
6631 : 0 : y = const0_rtx;
6632 : :
6633 : : /* Allow the target to copy from Y to X without leaking Y into a
6634 : : register. */
6635 : 221 : if (targetm.have_stack_protect_set ())
6636 : 221 : if (rtx_insn *insn = targetm.gen_stack_protect_set (x, y))
6637 : : {
6638 : 221 : emit_insn (insn);
6639 : 221 : return;
6640 : : }
6641 : :
6642 : : /* Otherwise do a straight move. */
6643 : 0 : emit_move_insn (x, y);
6644 : : }
6645 : :
6646 : : /* Translate the intermediate representation contained in the CFG
6647 : : from GIMPLE trees to RTL.
6648 : :
6649 : : We do conversion per basic block and preserve/update the tree CFG.
6650 : : This implies we have to do some magic as the CFG can simultaneously
6651 : : consist of basic blocks containing RTL and GIMPLE trees. This can
6652 : : confuse the CFG hooks, so be careful to not manipulate CFG during
6653 : : the expansion. */
6654 : :
6655 : : namespace {
6656 : :
6657 : : const pass_data pass_data_expand =
6658 : : {
6659 : : RTL_PASS, /* type */
6660 : : "expand", /* name */
6661 : : OPTGROUP_NONE, /* optinfo_flags */
6662 : : TV_EXPAND, /* tv_id */
6663 : : ( PROP_ssa | PROP_gimple_leh | PROP_cfg
6664 : : | PROP_gimple_lcx
6665 : : | PROP_gimple_lvec
6666 : : | PROP_gimple_lva), /* properties_required */
6667 : : PROP_rtl, /* properties_provided */
6668 : : ( PROP_ssa | PROP_gimple ), /* properties_destroyed */
6669 : : 0, /* todo_flags_start */
6670 : : 0, /* todo_flags_finish */
6671 : : };
6672 : :
6673 : : class pass_expand : public rtl_opt_pass
6674 : : {
6675 : : public:
6676 : 281612 : pass_expand (gcc::context *ctxt)
6677 : 563224 : : rtl_opt_pass (pass_data_expand, ctxt)
6678 : : {}
6679 : :
6680 : : /* opt_pass methods: */
6681 : : unsigned int execute (function *) final override;
6682 : :
6683 : : }; // class pass_expand
6684 : :
6685 : : unsigned int
6686 : 1487281 : pass_expand::execute (function *fun)
6687 : : {
6688 : 1487281 : basic_block bb, init_block;
6689 : 1487281 : edge_iterator ei;
6690 : 1487281 : edge e;
6691 : 1487281 : rtx_insn *var_seq, *var_ret_seq;
6692 : 1487281 : unsigned i;
6693 : :
6694 : 1487281 : timevar_push (TV_OUT_OF_SSA);
6695 : 1487281 : rewrite_out_of_ssa (&SA);
6696 : 1487281 : timevar_pop (TV_OUT_OF_SSA);
6697 : 1487281 : SA.partition_to_pseudo = XCNEWVEC (rtx, SA.map->num_partitions);
6698 : :
6699 : 1487281 : if (MAY_HAVE_DEBUG_BIND_STMTS && flag_tree_ter)
6700 : : {
6701 : 481087 : gimple_stmt_iterator gsi;
6702 : 6384970 : FOR_EACH_BB_FN (bb, cfun)
6703 : 71725639 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
6704 : 89518051 : if (gimple_debug_bind_p (gsi_stmt (gsi)))
6705 : 29600178 : avoid_deep_ter_for_debug (gsi_stmt (gsi), 0);
6706 : : }
6707 : :
6708 : : /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6709 : 1487281 : auto_bitmap forced_stack_vars;
6710 : 1487281 : discover_nonconstant_array_refs (forced_stack_vars);
6711 : :
6712 : : /* Make sure all values used by the optimization passes have sane
6713 : : defaults. */
6714 : 1487281 : reg_renumber = 0;
6715 : :
6716 : : /* Some backends want to know that we are expanding to RTL. */
6717 : 1487281 : currently_expanding_to_rtl = 1;
6718 : : /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6719 : 1487281 : free_dominance_info (CDI_DOMINATORS);
6720 : :
6721 : 1487281 : rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
6722 : :
6723 : 1487281 : insn_locations_init ();
6724 : 1487281 : if (!DECL_IS_UNDECLARED_BUILTIN (current_function_decl))
6725 : : {
6726 : : /* Eventually, all FEs should explicitly set function_start_locus. */
6727 : 1366534 : if (LOCATION_LOCUS (fun->function_start_locus) == UNKNOWN_LOCATION)
6728 : 593508 : set_curr_insn_location
6729 : 593508 : (DECL_SOURCE_LOCATION (current_function_decl));
6730 : : else
6731 : 773026 : set_curr_insn_location (fun->function_start_locus);
6732 : : }
6733 : : else
6734 : 120747 : set_curr_insn_location (UNKNOWN_LOCATION);
6735 : 1487281 : prologue_location = curr_insn_location ();
6736 : :
6737 : : #ifdef INSN_SCHEDULING
6738 : 1487281 : init_sched_attrs ();
6739 : : #endif
6740 : :
6741 : : /* Make sure first insn is a note even if we don't want linenums.
6742 : : This makes sure the first insn will never be deleted.
6743 : : Also, final expects a note to appear there. */
6744 : 1487281 : emit_note (NOTE_INSN_DELETED);
6745 : :
6746 : 1487281 : targetm.expand_to_rtl_hook ();
6747 : 1487281 : crtl->init_stack_alignment ();
6748 : 1487281 : fun->cfg->max_jumptable_ents = 0;
6749 : :
6750 : : /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6751 : : of the function section at exapnsion time to predict distance of calls. */
6752 : 1487281 : resolve_unique_section (current_function_decl, 0, flag_function_sections);
6753 : :
6754 : : /* Expand the variables recorded during gimple lowering. */
6755 : 1487281 : timevar_push (TV_VAR_EXPAND);
6756 : 1487281 : start_sequence ();
6757 : :
6758 : 1487281 : var_ret_seq = expand_used_vars (forced_stack_vars);
6759 : :
6760 : 1487281 : var_seq = get_insns ();
6761 : 1487281 : end_sequence ();
6762 : 1487281 : timevar_pop (TV_VAR_EXPAND);
6763 : :
6764 : : /* Honor stack protection warnings. */
6765 : 1487281 : if (warn_stack_protect)
6766 : : {
6767 : 0 : if (fun->calls_alloca)
6768 : 0 : warning (OPT_Wstack_protector,
6769 : : "stack protector not protecting local variables: "
6770 : : "variable length buffer");
6771 : 0 : if (has_short_buffer && !crtl->stack_protect_guard)
6772 : 0 : warning (OPT_Wstack_protector,
6773 : : "stack protector not protecting function: "
6774 : : "all local arrays are less than %d bytes long",
6775 : 0 : (int) param_ssp_buffer_size);
6776 : : }
6777 : :
6778 : : /* Temporarily mark PARM_DECLs and RESULT_DECLs we need to expand to
6779 : : memory addressable so expand_function_start can emit the required
6780 : : copies. */
6781 : 1487281 : auto_vec<tree, 16> marked_parms;
6782 : 4520852 : for (tree parm = DECL_ARGUMENTS (current_function_decl); parm;
6783 : 3033571 : parm = DECL_CHAIN (parm))
6784 : 3033571 : if (!TREE_ADDRESSABLE (parm)
6785 : 3033571 : && bitmap_bit_p (forced_stack_vars, DECL_UID (parm)))
6786 : : {
6787 : 143 : TREE_ADDRESSABLE (parm) = 1;
6788 : 143 : marked_parms.safe_push (parm);
6789 : : }
6790 : 1487281 : if (DECL_RESULT (current_function_decl)
6791 : 1487281 : && !TREE_ADDRESSABLE (DECL_RESULT (current_function_decl))
6792 : 2967685 : && bitmap_bit_p (forced_stack_vars,
6793 : 1480404 : DECL_UID (DECL_RESULT (current_function_decl))))
6794 : : {
6795 : 0 : TREE_ADDRESSABLE (DECL_RESULT (current_function_decl)) = 1;
6796 : 0 : marked_parms.safe_push (DECL_RESULT (current_function_decl));
6797 : : }
6798 : :
6799 : : /* Set up parameters and prepare for return, for the function. */
6800 : 1487281 : expand_function_start (current_function_decl);
6801 : :
6802 : : /* Clear TREE_ADDRESSABLE again. */
6803 : 2974705 : while (!marked_parms.is_empty ())
6804 : 143 : TREE_ADDRESSABLE (marked_parms.pop ()) = 0;
6805 : :
6806 : : /* If we emitted any instructions for setting up the variables,
6807 : : emit them before the FUNCTION_START note. */
6808 : 1487281 : if (var_seq)
6809 : : {
6810 : 1487 : emit_insn_before (var_seq, parm_birth_insn);
6811 : :
6812 : : /* In expand_function_end we'll insert the alloca save/restore
6813 : : before parm_birth_insn. We've just insertted an alloca call.
6814 : : Adjust the pointer to match. */
6815 : 1487 : parm_birth_insn = var_seq;
6816 : : }
6817 : :
6818 : : /* Now propagate the RTL assignment of each partition to the
6819 : : underlying var of each SSA_NAME. */
6820 : : tree name;
6821 : :
6822 : 69938601 : FOR_EACH_SSA_NAME (i, name, cfun)
6823 : : {
6824 : : /* We might have generated new SSA names in
6825 : : update_alias_info_with_stack_vars. They will have a NULL
6826 : : defining statements, and won't be part of the partitioning,
6827 : : so ignore those. */
6828 : 47363103 : if (!SSA_NAME_DEF_STMT (name))
6829 : 65610 : continue;
6830 : :
6831 : 47297493 : adjust_one_expanded_partition_var (name);
6832 : : }
6833 : :
6834 : : /* Clean up RTL of variables that straddle across multiple
6835 : : partitions, and check that the rtl of any PARM_DECLs that are not
6836 : : cleaned up is that of their default defs. */
6837 : 69938601 : FOR_EACH_SSA_NAME (i, name, cfun)
6838 : : {
6839 : 47363103 : int part;
6840 : :
6841 : : /* We might have generated new SSA names in
6842 : : update_alias_info_with_stack_vars. They will have a NULL
6843 : : defining statements, and won't be part of the partitioning,
6844 : : so ignore those. */
6845 : 47363103 : if (!SSA_NAME_DEF_STMT (name))
6846 : 65610 : continue;
6847 : 47297493 : part = var_to_partition (SA.map, name);
6848 : 47297493 : if (part == NO_PARTITION)
6849 : 16701983 : continue;
6850 : :
6851 : : /* If this decl was marked as living in multiple places, reset
6852 : : this now to NULL. */
6853 : 30595510 : tree var = SSA_NAME_VAR (name);
6854 : 10337587 : if (var && DECL_RTL_IF_SET (var) == pc_rtx)
6855 : 240606 : SET_DECL_RTL (var, NULL);
6856 : : /* Check that the pseudos chosen by assign_parms are those of
6857 : : the corresponding default defs. */
6858 : 30354904 : else if (SSA_NAME_IS_DEFAULT_DEF (name)
6859 : 30354904 : && (TREE_CODE (var) == PARM_DECL
6860 : 3576316 : || TREE_CODE (var) == RESULT_DECL))
6861 : : {
6862 : 3523695 : rtx in = DECL_RTL_IF_SET (var);
6863 : 3523695 : gcc_assert (in);
6864 : 3523695 : rtx out = SA.partition_to_pseudo[part];
6865 : 3523695 : gcc_assert (in == out);
6866 : :
6867 : : /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6868 : : those expected by debug backends for each parm and for
6869 : : the result. This is particularly important for stabs,
6870 : : whose register elimination from parm's DECL_RTL may cause
6871 : : -fcompare-debug differences as SET_DECL_RTL changes reg's
6872 : : attrs. So, make sure the RTL already has the parm as the
6873 : : EXPR, so that it won't change. */
6874 : 3523695 : SET_DECL_RTL (var, NULL_RTX);
6875 : 3523695 : if (MEM_P (in))
6876 : 760424 : set_mem_attributes (in, var, true);
6877 : 3523695 : SET_DECL_RTL (var, in);
6878 : : }
6879 : : }
6880 : :
6881 : : /* If this function is `main', emit a call to `__main'
6882 : : to run global initializers, etc. */
6883 : 1487281 : if (DECL_NAME (current_function_decl)
6884 : 1487281 : && MAIN_NAME_P (DECL_NAME (current_function_decl))
6885 : 1596288 : && DECL_FILE_SCOPE_P (current_function_decl))
6886 : 1487281 : expand_main_function ();
6887 : :
6888 : : /* Initialize the stack_protect_guard field. This must happen after the
6889 : : call to __main (if any) so that the external decl is initialized. */
6890 : 1487281 : if (crtl->stack_protect_guard && targetm.stack_protect_runtime_enabled_p ())
6891 : 221 : stack_protect_prologue ();
6892 : :
6893 : 1487281 : expand_phi_nodes (&SA);
6894 : :
6895 : : /* Release any stale SSA redirection data. */
6896 : 1487281 : redirect_edge_var_map_empty ();
6897 : :
6898 : : /* Register rtl specific functions for cfg. */
6899 : 1487281 : rtl_register_cfg_hooks ();
6900 : :
6901 : 1487281 : init_block = construct_init_block ();
6902 : :
6903 : : /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6904 : : remaining edges later. */
6905 : 2974562 : FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs)
6906 : 1487281 : e->flags &= ~EDGE_EXECUTABLE;
6907 : :
6908 : : /* If the function has too many markers, drop them while expanding. */
6909 : 1487281 : if (cfun->debug_marker_count
6910 : 1487281 : >= param_max_debug_marker_count)
6911 : 1 : cfun->debug_nonbind_markers = false;
6912 : :
6913 : 1487281 : lab_rtx_for_bb = new hash_map<basic_block, rtx_code_label *>;
6914 : 14096516 : FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR_FOR_FN (fun),
6915 : : next_bb)
6916 : 12609235 : bb = expand_gimple_basic_block (bb, var_ret_seq != NULL_RTX);
6917 : :
6918 : 1487281 : if (MAY_HAVE_DEBUG_BIND_INSNS)
6919 : 481111 : expand_debug_locations ();
6920 : :
6921 : 1487281 : if (deep_ter_debug_map)
6922 : : {
6923 : 359 : delete deep_ter_debug_map;
6924 : 359 : deep_ter_debug_map = NULL;
6925 : : }
6926 : :
6927 : : /* Free stuff we no longer need after GIMPLE optimizations. */
6928 : 1487281 : free_dominance_info (CDI_DOMINATORS);
6929 : 1487281 : free_dominance_info (CDI_POST_DOMINATORS);
6930 : 1487281 : delete_tree_cfg_annotations (fun);
6931 : :
6932 : 1487281 : timevar_push (TV_OUT_OF_SSA);
6933 : 1487281 : finish_out_of_ssa (&SA);
6934 : 1487281 : timevar_pop (TV_OUT_OF_SSA);
6935 : :
6936 : 1487281 : timevar_push (TV_POST_EXPAND);
6937 : : /* We are no longer in SSA form. */
6938 : 1487281 : fun->gimple_df->in_ssa_p = false;
6939 : 1487281 : loops_state_clear (LOOP_CLOSED_SSA);
6940 : :
6941 : : /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6942 : : conservatively to true until they are all profile aware. */
6943 : 2974562 : delete lab_rtx_for_bb;
6944 : 1487281 : free_histograms (fun);
6945 : :
6946 : 1487281 : construct_exit_block ();
6947 : 1487281 : insn_locations_finalize ();
6948 : :
6949 : 1487281 : if (var_ret_seq)
6950 : : {
6951 : 1627 : rtx_insn *after = return_label;
6952 : 1627 : rtx_insn *next = NEXT_INSN (after);
6953 : 1627 : if (next && NOTE_INSN_BASIC_BLOCK_P (next))
6954 : 1627 : after = next;
6955 : 1627 : emit_insn_after (var_ret_seq, after);
6956 : : }
6957 : :
6958 : 1487281 : if (hwasan_sanitize_stack_p ())
6959 : 446 : hwasan_maybe_emit_frame_base_init ();
6960 : :
6961 : : /* Zap the tree EH table. */
6962 : 1487281 : set_eh_throw_stmt_table (fun, NULL);
6963 : :
6964 : : /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6965 : : split edges which edge insertions might do. */
6966 : 1487281 : rebuild_jump_labels (get_insns ());
6967 : :
6968 : : /* If we have a single successor to the entry block, put the pending insns
6969 : : after parm birth, but before NOTE_INSNS_FUNCTION_BEG. */
6970 : 1487281 : if (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun)))
6971 : : {
6972 : 1487281 : edge e = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fun));
6973 : 1487281 : if (e->insns.r)
6974 : : {
6975 : 5 : rtx_insn *insns = e->insns.r;
6976 : 5 : e->insns.r = NULL;
6977 : 5 : rebuild_jump_labels_chain (insns);
6978 : 5 : if (NOTE_P (parm_birth_insn)
6979 : 5 : && NOTE_KIND (parm_birth_insn) == NOTE_INSN_FUNCTION_BEG)
6980 : 5 : emit_insn_before_noloc (insns, parm_birth_insn, e->dest);
6981 : : else
6982 : 0 : emit_insn_after_noloc (insns, parm_birth_insn, e->dest);
6983 : : }
6984 : : }
6985 : :
6986 : : /* Otherwise, as well as for other edges, take the usual way. */
6987 : 1487281 : commit_edge_insertions ();
6988 : :
6989 : : /* We're done expanding trees to RTL. */
6990 : 1487281 : currently_expanding_to_rtl = 0;
6991 : :
6992 : 1487281 : flush_mark_addressable_queue ();
6993 : :
6994 : 18238543 : FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun)->next_bb,
6995 : : EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)
6996 : : {
6997 : 16751262 : edge e;
6998 : 16751262 : edge_iterator ei;
6999 : 39076804 : for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
7000 : : {
7001 : : /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
7002 : 22325542 : e->flags &= ~EDGE_EXECUTABLE;
7003 : :
7004 : : /* At the moment not all abnormal edges match the RTL
7005 : : representation. It is safe to remove them here as
7006 : : find_many_sub_basic_blocks will rediscover them.
7007 : : In the future we should get this fixed properly. */
7008 : 22325542 : if ((e->flags & EDGE_ABNORMAL)
7009 : : && !(e->flags & EDGE_SIBCALL))
7010 : 9723 : remove_edge (e);
7011 : : else
7012 : 22315819 : ei_next (&ei);
7013 : : }
7014 : : }
7015 : :
7016 : 1487281 : auto_sbitmap blocks (last_basic_block_for_fn (fun));
7017 : 1487281 : bitmap_ones (blocks);
7018 : 1487281 : find_many_sub_basic_blocks (blocks);
7019 : 1487281 : purge_all_dead_edges ();
7020 : :
7021 : : /* After initial rtl generation, call back to finish generating
7022 : : exception support code. We need to do this before cleaning up
7023 : : the CFG as the code does not expect dead landing pads. */
7024 : 1487281 : if (fun->eh->region_tree != NULL)
7025 : 57156 : finish_eh_generation ();
7026 : :
7027 : : /* Call expand_stack_alignment after finishing all
7028 : : updates to crtl->preferred_stack_boundary. */
7029 : 1487281 : expand_stack_alignment ();
7030 : :
7031 : : /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
7032 : : function. */
7033 : 1487281 : if (crtl->tail_call_emit)
7034 : 104642 : fixup_tail_calls ();
7035 : :
7036 : 1487281 : HOST_WIDE_INT patch_area_size, patch_area_entry;
7037 : 1487281 : parse_and_check_patch_area (flag_patchable_function_entry, false,
7038 : : &patch_area_size, &patch_area_entry);
7039 : :
7040 : 1487281 : tree patchable_function_entry_attr
7041 : 1487281 : = lookup_attribute ("patchable_function_entry",
7042 : 1487281 : DECL_ATTRIBUTES (cfun->decl));
7043 : 1487281 : if (patchable_function_entry_attr)
7044 : : {
7045 : 16 : tree pp_val = TREE_VALUE (patchable_function_entry_attr);
7046 : 16 : tree patchable_function_entry_value1 = TREE_VALUE (pp_val);
7047 : :
7048 : 16 : patch_area_size = tree_to_uhwi (patchable_function_entry_value1);
7049 : 16 : patch_area_entry = 0;
7050 : 16 : if (TREE_CHAIN (pp_val) != NULL_TREE)
7051 : : {
7052 : 8 : tree patchable_function_entry_value2
7053 : 8 : = TREE_VALUE (TREE_CHAIN (pp_val));
7054 : 8 : patch_area_entry = tree_to_uhwi (patchable_function_entry_value2);
7055 : : }
7056 : : }
7057 : :
7058 : 1487281 : if (patch_area_entry > patch_area_size)
7059 : : {
7060 : 0 : if (patch_area_size > 0)
7061 : 0 : warning (OPT_Wattributes,
7062 : : "patchable function entry %wu exceeds size %wu",
7063 : : patch_area_entry, patch_area_size);
7064 : 0 : patch_area_entry = 0;
7065 : : }
7066 : :
7067 : 1487281 : crtl->patch_area_size = patch_area_size;
7068 : 1487281 : crtl->patch_area_entry = patch_area_entry;
7069 : :
7070 : : /* BB subdivision may have created basic blocks that are only reachable
7071 : : from unlikely bbs but not marked as such in the profile. */
7072 : 1487281 : if (optimize)
7073 : 1051523 : propagate_unlikely_bbs_forward ();
7074 : :
7075 : : /* Remove unreachable blocks, otherwise we cannot compute dominators
7076 : : which are needed for loop state verification. As a side-effect
7077 : : this also compacts blocks.
7078 : : ??? We cannot remove trivially dead insns here as for example
7079 : : the DRAP reg on i?86 is not magically live at this point.
7080 : : gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
7081 : 1487281 : cleanup_cfg (CLEANUP_NO_INSN_DEL);
7082 : :
7083 : 1487281 : checking_verify_flow_info ();
7084 : :
7085 : : /* Initialize pseudos allocated for hard registers. */
7086 : 1487281 : emit_initial_value_sets ();
7087 : :
7088 : : /* And finally unshare all RTL. */
7089 : 1487281 : unshare_all_rtl ();
7090 : :
7091 : : /* There's no need to defer outputting this function any more; we
7092 : : know we want to output it. */
7093 : 1487281 : DECL_DEFER_OUTPUT (current_function_decl) = 0;
7094 : :
7095 : : /* Now that we're done expanding trees to RTL, we shouldn't have any
7096 : : more CONCATs anywhere. */
7097 : 1487281 : generating_concat_p = 0;
7098 : :
7099 : 1487281 : if (dump_file)
7100 : : {
7101 : 296 : fprintf (dump_file,
7102 : : "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
7103 : : /* And the pass manager will dump RTL for us. */
7104 : : }
7105 : :
7106 : : /* If we're emitting a nested function, make sure its parent gets
7107 : : emitted as well. Doing otherwise confuses debug info. */
7108 : 1487281 : {
7109 : 1487281 : tree parent;
7110 : 1487281 : for (parent = DECL_CONTEXT (current_function_decl);
7111 : 3141946 : parent != NULL_TREE;
7112 : 1654665 : parent = get_containing_scope (parent))
7113 : 1654665 : if (TREE_CODE (parent) == FUNCTION_DECL)
7114 : 66429 : TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
7115 : : }
7116 : :
7117 : 1487281 : TREE_ASM_WRITTEN (current_function_decl) = 1;
7118 : :
7119 : : /* After expanding, the return labels are no longer needed. */
7120 : 1487281 : return_label = NULL;
7121 : 1487281 : naked_return_label = NULL;
7122 : :
7123 : : /* After expanding, the tm_restart map is no longer needed. */
7124 : 1487281 : if (fun->gimple_df->tm_restart)
7125 : 265 : fun->gimple_df->tm_restart = NULL;
7126 : :
7127 : : /* Tag the blocks with a depth number so that change_scope can find
7128 : : the common parent easily. */
7129 : 1487281 : set_block_levels (DECL_INITIAL (fun->decl), 0);
7130 : 1487281 : default_rtl_profile ();
7131 : :
7132 : : /* For -dx discard loops now, otherwise IL verify in clean_state will
7133 : : ICE. */
7134 : 1487281 : if (rtl_dump_and_exit)
7135 : : {
7136 : 79 : cfun->curr_properties &= ~PROP_loops;
7137 : 79 : loop_optimizer_finalize ();
7138 : : }
7139 : :
7140 : 1487281 : timevar_pop (TV_POST_EXPAND);
7141 : :
7142 : 1487281 : return 0;
7143 : 1487281 : }
7144 : :
7145 : : } // anon namespace
7146 : :
7147 : : rtl_opt_pass *
7148 : 281612 : make_pass_expand (gcc::context *ctxt)
7149 : : {
7150 : 281612 : return new pass_expand (ctxt);
7151 : : }
|
