ada: Fix minor glitch in finish_record_type
[official-gcc.git] / gcc / regcprop.cc
bloba75af2ba7e3c8dcd75a904503e1fe540ac72bef3
1 /* Copy propagation on hard registers for the GNU compiler.
2 Copyright (C) 2000-2023 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "backend.h"
24 #include "rtl.h"
25 #include "df.h"
26 #include "memmodel.h"
27 #include "tm_p.h"
28 #include "insn-config.h"
29 #include "regs.h"
30 #include "emit-rtl.h"
31 #include "recog.h"
32 #include "diagnostic-core.h"
33 #include "addresses.h"
34 #include "tree-pass.h"
35 #include "rtl-iter.h"
36 #include "cfgrtl.h"
37 #include "target.h"
38 #include "function-abi.h"
40 /* The following code does forward propagation of hard register copies.
41 The object is to eliminate as many dependencies as possible, so that
42 we have the most scheduling freedom. As a side effect, we also clean
43 up some silly register allocation decisions made by reload. This
44 code may be obsoleted by a new register allocator. */
46 /* DEBUG_INSNs aren't changed right away, as doing so might extend the
47 lifetime of a register and get the DEBUG_INSN subsequently reset.
48 So they are queued instead, and updated only when the register is
49 used in some subsequent real insn before it is set. */
50 struct queued_debug_insn_change
52 struct queued_debug_insn_change *next;
53 rtx_insn *insn;
54 rtx *loc;
55 rtx new_rtx;
58 /* For each register, we have a list of registers that contain the same
59 value. The OLDEST_REGNO field points to the head of the list, and
60 the NEXT_REGNO field runs through the list. The MODE field indicates
61 what mode the data is known to be in; this field is VOIDmode when the
62 register is not known to contain valid data. */
64 struct value_data_entry
66 machine_mode mode;
67 unsigned int oldest_regno;
68 unsigned int next_regno;
69 struct queued_debug_insn_change *debug_insn_changes;
72 struct value_data
74 struct value_data_entry e[FIRST_PSEUDO_REGISTER];
75 unsigned int max_value_regs;
76 unsigned int n_debug_insn_changes;
79 static object_allocator<queued_debug_insn_change> queued_debug_insn_change_pool
80 ("debug insn changes pool");
82 static bool skip_debug_insn_p;
84 static void kill_value_one_regno (unsigned, struct value_data *);
85 static void kill_value_regno (unsigned, unsigned, struct value_data *);
86 static void kill_value (const_rtx, struct value_data *);
87 static void set_value_regno (unsigned, machine_mode, struct value_data *);
88 static void init_value_data (struct value_data *);
89 static void kill_clobbered_value (rtx, const_rtx, void *);
90 static void kill_set_value (rtx, const_rtx, void *);
91 static void copy_value (rtx, rtx, struct value_data *);
92 static bool mode_change_ok (machine_mode, machine_mode,
93 unsigned int);
94 static rtx maybe_mode_change (machine_mode, machine_mode,
95 machine_mode, unsigned int, unsigned int);
96 static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
97 static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx_insn *,
98 struct value_data *);
99 static bool replace_oldest_value_addr (rtx *, enum reg_class,
100 machine_mode, addr_space_t,
101 rtx_insn *, struct value_data *);
102 static bool replace_oldest_value_mem (rtx, rtx_insn *, struct value_data *);
103 static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
104 extern void debug_value_data (struct value_data *);
105 static void validate_value_data (struct value_data *);
107 /* Free all queued updates for DEBUG_INSNs that change some reg to
108 register REGNO. */
110 static void
111 free_debug_insn_changes (struct value_data *vd, unsigned int regno)
113 struct queued_debug_insn_change *cur, *next;
114 for (cur = vd->e[regno].debug_insn_changes; cur; cur = next)
116 next = cur->next;
117 --vd->n_debug_insn_changes;
118 queued_debug_insn_change_pool.remove (cur);
120 vd->e[regno].debug_insn_changes = NULL;
123 /* Kill register REGNO. This involves removing it from any value
124 lists, and resetting the value mode to VOIDmode. This is only a
125 helper function; it does not handle any hard registers overlapping
126 with REGNO. */
128 static void
129 kill_value_one_regno (unsigned int regno, struct value_data *vd)
131 unsigned int i, next;
133 if (vd->e[regno].oldest_regno != regno)
135 for (i = vd->e[regno].oldest_regno;
136 vd->e[i].next_regno != regno;
137 i = vd->e[i].next_regno)
138 continue;
139 vd->e[i].next_regno = vd->e[regno].next_regno;
141 else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
143 for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
144 vd->e[i].oldest_regno = next;
147 vd->e[regno].mode = VOIDmode;
148 vd->e[regno].oldest_regno = regno;
149 vd->e[regno].next_regno = INVALID_REGNUM;
150 if (vd->e[regno].debug_insn_changes)
151 free_debug_insn_changes (vd, regno);
153 if (flag_checking)
154 validate_value_data (vd);
157 /* Kill the value in register REGNO for NREGS, and any other registers
158 whose values overlap. */
160 static void
161 kill_value_regno (unsigned int regno, unsigned int nregs,
162 struct value_data *vd)
164 unsigned int j;
166 /* Kill the value we're told to kill. */
167 for (j = 0; j < nregs; ++j)
168 kill_value_one_regno (regno + j, vd);
170 /* Kill everything that overlapped what we're told to kill. */
171 if (regno < vd->max_value_regs)
172 j = 0;
173 else
174 j = regno - vd->max_value_regs;
175 for (; j < regno; ++j)
177 unsigned int i, n;
178 if (vd->e[j].mode == VOIDmode)
179 continue;
180 n = hard_regno_nregs (j, vd->e[j].mode);
181 if (j + n > regno)
182 for (i = 0; i < n; ++i)
183 kill_value_one_regno (j + i, vd);
187 /* Kill X. This is a convenience function wrapping kill_value_regno
188 so that we mind the mode the register is in. */
190 static void
191 kill_value (const_rtx x, struct value_data *vd)
193 if (GET_CODE (x) == SUBREG)
195 rtx tmp = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
196 GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
197 x = tmp ? tmp : SUBREG_REG (x);
199 if (REG_P (x))
200 kill_value_regno (REGNO (x), REG_NREGS (x), vd);
203 /* Remember that REGNO is valid in MODE. */
205 static void
206 set_value_regno (unsigned int regno, machine_mode mode,
207 struct value_data *vd)
209 unsigned int nregs;
211 vd->e[regno].mode = mode;
213 nregs = hard_regno_nregs (regno, mode);
214 if (nregs > vd->max_value_regs)
215 vd->max_value_regs = nregs;
218 /* Initialize VD such that there are no known relationships between regs. */
220 static void
221 init_value_data (struct value_data *vd)
223 int i;
224 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
226 vd->e[i].mode = VOIDmode;
227 vd->e[i].oldest_regno = i;
228 vd->e[i].next_regno = INVALID_REGNUM;
229 vd->e[i].debug_insn_changes = NULL;
231 vd->max_value_regs = 0;
232 vd->n_debug_insn_changes = 0;
235 /* Called through note_stores. If X is clobbered, kill its value. */
237 static void
238 kill_clobbered_value (rtx x, const_rtx set, void *data)
240 struct value_data *const vd = (struct value_data *) data;
242 if (GET_CODE (set) == CLOBBER)
243 kill_value (x, vd);
246 /* A structure passed as data to kill_set_value through note_stores. */
247 struct kill_set_value_data
249 struct value_data *vd;
250 rtx ignore_set_reg;
253 /* Called through note_stores. If X is set, not clobbered, kill its
254 current value and install it as the root of its own value list. */
256 static void
257 kill_set_value (rtx x, const_rtx set, void *data)
259 struct kill_set_value_data *ksvd = (struct kill_set_value_data *) data;
260 if (rtx_equal_p (x, ksvd->ignore_set_reg))
261 return;
263 if (GET_CODE (set) != CLOBBER)
265 kill_value (x, ksvd->vd);
266 if (REG_P (x))
267 set_value_regno (REGNO (x), GET_MODE (x), ksvd->vd);
271 /* Kill any register used in X as the base of an auto-increment expression,
272 and install that register as the root of its own value list. */
274 static void
275 kill_autoinc_value (rtx_insn *insn, struct value_data *vd)
277 subrtx_iterator::array_type array;
278 FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
280 const_rtx x = *iter;
281 if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
283 x = XEXP (x, 0);
284 kill_value (x, vd);
285 set_value_regno (REGNO (x), GET_MODE (x), vd);
286 iter.skip_subrtxes ();
291 /* Assert that SRC has been copied to DEST. Adjust the data structures
292 to reflect that SRC contains an older copy of the shared value. */
294 static void
295 copy_value (rtx dest, rtx src, struct value_data *vd)
297 unsigned int dr = REGNO (dest);
298 unsigned int sr = REGNO (src);
299 unsigned int dn, sn;
300 unsigned int i;
302 /* ??? At present, it's possible to see noop sets. It'd be nice if
303 this were cleaned up beforehand... */
304 if (sr == dr)
305 return;
307 /* Do not propagate copies to the stack pointer, as that can leave
308 memory accesses with no scheduling dependency on the stack update. */
309 if (dr == STACK_POINTER_REGNUM)
310 return;
312 /* Likewise with the frame pointer, if we're using one. */
313 if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
314 return;
316 /* Do not propagate copies to fixed or global registers, patterns
317 can be relying to see particular fixed register or users can
318 expect the chosen global register in asm. */
319 if (fixed_regs[dr] || global_regs[dr])
320 return;
322 /* If SRC and DEST overlap, don't record anything. */
323 dn = REG_NREGS (dest);
324 sn = REG_NREGS (src);
325 if ((dr > sr && dr < sr + sn)
326 || (sr > dr && sr < dr + dn))
327 return;
329 /* If SRC had no assigned mode (i.e. we didn't know it was live)
330 assign it now and assume the value came from an input argument
331 or somesuch. */
332 if (vd->e[sr].mode == VOIDmode)
333 set_value_regno (sr, vd->e[dr].mode, vd);
335 /* If we are narrowing the input to a smaller number of hard regs,
336 and it is in big endian, we are really extracting a high part.
337 Since we generally associate a low part of a value with the value itself,
338 we must not do the same for the high part.
339 Note we can still get low parts for the same mode combination through
340 a two-step copy involving differently sized hard regs.
341 Assume hard regs fr* are 32 bits each, while r* are 64 bits each:
342 (set (reg:DI r0) (reg:DI fr0))
343 (set (reg:SI fr2) (reg:SI r0))
344 loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
345 (set (reg:SI fr2) (reg:SI fr0))
346 loads the high part of (reg:DI fr0) into fr2.
348 We can't properly represent the latter case in our tables, so don't
349 record anything then. */
350 else if (sn < hard_regno_nregs (sr, vd->e[sr].mode)
351 && maybe_ne (subreg_lowpart_offset (GET_MODE (dest),
352 vd->e[sr].mode), 0U))
353 return;
355 /* If SRC had been assigned a mode narrower than the copy, we can't
356 link DEST into the chain, because not all of the pieces of the
357 copy came from oldest_regno. */
358 else if (sn > hard_regno_nregs (sr, vd->e[sr].mode))
359 return;
361 /* If a narrower value is copied using wider mode, the upper bits
362 are undefined (could be e.g. a former paradoxical subreg). Signal
363 in that case we've only copied value using the narrower mode.
364 Consider:
365 (set (reg:DI r14) (mem:DI ...))
366 (set (reg:QI si) (reg:QI r14))
367 (set (reg:DI bp) (reg:DI r14))
368 (set (reg:DI r14) (const_int ...))
369 (set (reg:DI dx) (reg:DI si))
370 (set (reg:DI si) (const_int ...))
371 (set (reg:DI dx) (reg:DI bp))
372 The last set is not redundant, while the low 8 bits of dx are already
373 equal to low 8 bits of bp, the other bits are undefined. */
374 else if (partial_subreg_p (vd->e[sr].mode, GET_MODE (src)))
376 if (!REG_CAN_CHANGE_MODE_P (sr, GET_MODE (src), vd->e[sr].mode)
377 || !REG_CAN_CHANGE_MODE_P (dr, vd->e[sr].mode, GET_MODE (dest)))
378 return;
379 set_value_regno (dr, vd->e[sr].mode, vd);
382 /* Link DR at the end of the value chain used by SR. */
384 vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
386 for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
387 continue;
388 vd->e[i].next_regno = dr;
390 if (flag_checking)
391 validate_value_data (vd);
394 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
396 static bool
397 mode_change_ok (machine_mode orig_mode, machine_mode new_mode,
398 unsigned int regno ATTRIBUTE_UNUSED)
400 if (partial_subreg_p (orig_mode, new_mode))
401 return false;
403 return REG_CAN_CHANGE_MODE_P (regno, orig_mode, new_mode);
406 /* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
407 was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
408 in NEW_MODE.
409 Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
411 static rtx
412 maybe_mode_change (machine_mode orig_mode, machine_mode copy_mode,
413 machine_mode new_mode, unsigned int regno,
414 unsigned int copy_regno ATTRIBUTE_UNUSED)
416 if (partial_subreg_p (copy_mode, orig_mode)
417 && partial_subreg_p (copy_mode, new_mode))
418 return NULL_RTX;
420 /* Avoid creating multiple copies of the stack pointer. Some ports
421 assume there is one and only one stack pointer.
423 It's unclear if we need to do the same for other special registers. */
424 if (regno == STACK_POINTER_REGNUM)
426 if (orig_mode == new_mode && new_mode == GET_MODE (stack_pointer_rtx))
427 return stack_pointer_rtx;
428 else
429 return NULL_RTX;
432 if (orig_mode == new_mode)
433 return gen_raw_REG (new_mode, regno);
434 else if (mode_change_ok (orig_mode, new_mode, regno)
435 && mode_change_ok (copy_mode, new_mode, copy_regno))
437 int copy_nregs = hard_regno_nregs (copy_regno, copy_mode);
438 int use_nregs = hard_regno_nregs (copy_regno, new_mode);
439 poly_uint64 bytes_per_reg;
440 if (!can_div_trunc_p (GET_MODE_SIZE (copy_mode),
441 copy_nregs, &bytes_per_reg))
442 return NULL_RTX;
443 poly_uint64 copy_offset = bytes_per_reg * (copy_nregs - use_nregs);
444 poly_uint64 offset
445 = subreg_size_lowpart_offset (GET_MODE_SIZE (new_mode) + copy_offset,
446 GET_MODE_SIZE (orig_mode));
447 regno += subreg_regno_offset (regno, orig_mode, offset, new_mode);
448 if (targetm.hard_regno_mode_ok (regno, new_mode))
449 return gen_raw_REG (new_mode, regno);
451 return NULL_RTX;
454 /* Find the oldest copy of the value contained in REGNO that is in
455 register class CL and has mode MODE. If found, return an rtx
456 of that oldest register, otherwise return NULL. */
458 static rtx
459 find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
461 unsigned int regno = REGNO (reg);
462 machine_mode mode = GET_MODE (reg);
463 unsigned int i;
465 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
467 /* If we are accessing REG in some mode other that what we set it in,
468 make sure that the replacement is valid. In particular, consider
469 (set (reg:DI r11) (...))
470 (set (reg:SI r9) (reg:SI r11))
471 (set (reg:SI r10) (...))
472 (set (...) (reg:DI r9))
473 Replacing r9 with r11 is invalid. */
474 if (mode != vd->e[regno].mode
475 && (REG_NREGS (reg) > hard_regno_nregs (regno, vd->e[regno].mode)
476 || !REG_CAN_CHANGE_MODE_P (regno, mode, vd->e[regno].mode)))
477 return NULL_RTX;
479 for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
481 machine_mode oldmode = vd->e[i].mode;
482 rtx new_rtx;
484 if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i))
485 continue;
487 new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
488 if (new_rtx)
490 /* NEW_RTX may be the global stack pointer rtx, in which case we
491 must not modify it's attributes. */
492 if (new_rtx != stack_pointer_rtx)
494 ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg);
495 REG_ATTRS (new_rtx) = REG_ATTRS (reg);
496 REG_POINTER (new_rtx) = REG_POINTER (reg);
498 return new_rtx;
502 return NULL_RTX;
505 /* If possible, replace the register at *LOC with the oldest register
506 in register class CL. Return true if successfully replaced. */
508 static bool
509 replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx_insn *insn,
510 struct value_data *vd)
512 rtx new_rtx = find_oldest_value_reg (cl, *loc, vd);
513 if (new_rtx && (!DEBUG_INSN_P (insn) || !skip_debug_insn_p))
515 if (DEBUG_INSN_P (insn))
517 struct queued_debug_insn_change *change;
519 if (dump_file)
520 fprintf (dump_file, "debug_insn %u: queued replacing reg %u with %u\n",
521 INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
523 change = queued_debug_insn_change_pool.allocate ();
524 change->next = vd->e[REGNO (new_rtx)].debug_insn_changes;
525 change->insn = insn;
526 change->loc = loc;
527 change->new_rtx = new_rtx;
528 vd->e[REGNO (new_rtx)].debug_insn_changes = change;
529 ++vd->n_debug_insn_changes;
530 return true;
532 if (dump_file)
533 fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
534 INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
536 validate_change (insn, loc, new_rtx, 1);
537 return true;
539 return false;
542 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
543 Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
544 BASE_REG_CLASS depending on how the register is being considered. */
546 static bool
547 replace_oldest_value_addr (rtx *loc, enum reg_class cl,
548 machine_mode mode, addr_space_t as,
549 rtx_insn *insn, struct value_data *vd)
551 rtx x = *loc;
552 RTX_CODE code = GET_CODE (x);
553 const char *fmt;
554 int i, j;
555 bool changed = false;
557 switch (code)
559 case PLUS:
560 if (DEBUG_INSN_P (insn))
561 break;
564 rtx orig_op0 = XEXP (x, 0);
565 rtx orig_op1 = XEXP (x, 1);
566 RTX_CODE code0 = GET_CODE (orig_op0);
567 RTX_CODE code1 = GET_CODE (orig_op1);
568 rtx op0 = orig_op0;
569 rtx op1 = orig_op1;
570 rtx *locI = NULL;
571 rtx *locB = NULL;
572 enum rtx_code index_code = SCRATCH;
574 if (GET_CODE (op0) == SUBREG)
576 op0 = SUBREG_REG (op0);
577 code0 = GET_CODE (op0);
580 if (GET_CODE (op1) == SUBREG)
582 op1 = SUBREG_REG (op1);
583 code1 = GET_CODE (op1);
586 if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
587 || code0 == ZERO_EXTEND || code1 == MEM)
589 locI = &XEXP (x, 0);
590 locB = &XEXP (x, 1);
591 index_code = GET_CODE (*locI);
593 else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
594 || code1 == ZERO_EXTEND || code0 == MEM)
596 locI = &XEXP (x, 1);
597 locB = &XEXP (x, 0);
598 index_code = GET_CODE (*locI);
600 else if (code0 == CONST_INT || code0 == CONST
601 || code0 == SYMBOL_REF || code0 == LABEL_REF)
603 locB = &XEXP (x, 1);
604 index_code = GET_CODE (XEXP (x, 0));
606 else if (code1 == CONST_INT || code1 == CONST
607 || code1 == SYMBOL_REF || code1 == LABEL_REF)
609 locB = &XEXP (x, 0);
610 index_code = GET_CODE (XEXP (x, 1));
612 else if (code0 == REG && code1 == REG)
614 int index_op;
615 unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
617 if (REGNO_OK_FOR_INDEX_P (regno1)
618 && regno_ok_for_base_p (regno0, mode, as, PLUS, REG))
619 index_op = 1;
620 else if (REGNO_OK_FOR_INDEX_P (regno0)
621 && regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
622 index_op = 0;
623 else if (regno_ok_for_base_p (regno0, mode, as, PLUS, REG)
624 || REGNO_OK_FOR_INDEX_P (regno1))
625 index_op = 1;
626 else if (regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
627 index_op = 0;
628 else
629 index_op = 1;
631 locI = &XEXP (x, index_op);
632 locB = &XEXP (x, !index_op);
633 index_code = GET_CODE (*locI);
635 else if (code0 == REG)
637 locI = &XEXP (x, 0);
638 locB = &XEXP (x, 1);
639 index_code = GET_CODE (*locI);
641 else if (code1 == REG)
643 locI = &XEXP (x, 1);
644 locB = &XEXP (x, 0);
645 index_code = GET_CODE (*locI);
648 if (locI)
649 changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS,
650 mode, as, insn, vd);
651 if (locB)
652 changed |= replace_oldest_value_addr (locB,
653 base_reg_class (mode, as, PLUS,
654 index_code),
655 mode, as, insn, vd);
656 return changed;
659 case POST_INC:
660 case POST_DEC:
661 case POST_MODIFY:
662 case PRE_INC:
663 case PRE_DEC:
664 case PRE_MODIFY:
665 return false;
667 case MEM:
668 return replace_oldest_value_mem (x, insn, vd);
670 case REG:
671 return replace_oldest_value_reg (loc, cl, insn, vd);
673 default:
674 break;
677 fmt = GET_RTX_FORMAT (code);
678 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
680 if (fmt[i] == 'e')
681 changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode, as,
682 insn, vd);
683 else if (fmt[i] == 'E')
684 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
685 changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
686 mode, as, insn, vd);
689 return changed;
692 /* Similar to replace_oldest_value_reg, but X contains a memory. */
694 static bool
695 replace_oldest_value_mem (rtx x, rtx_insn *insn, struct value_data *vd)
697 enum reg_class cl;
699 if (DEBUG_INSN_P (insn))
700 cl = ALL_REGS;
701 else
702 cl = base_reg_class (GET_MODE (x), MEM_ADDR_SPACE (x), MEM, SCRATCH);
704 return replace_oldest_value_addr (&XEXP (x, 0), cl,
705 GET_MODE (x), MEM_ADDR_SPACE (x),
706 insn, vd);
709 /* Apply all queued updates for DEBUG_INSNs that change some reg to
710 register REGNO. */
712 static void
713 apply_debug_insn_changes (struct value_data *vd, unsigned int regno)
715 struct queued_debug_insn_change *change;
716 rtx_insn *last_insn = vd->e[regno].debug_insn_changes->insn;
718 for (change = vd->e[regno].debug_insn_changes;
719 change;
720 change = change->next)
722 if (last_insn != change->insn)
724 apply_change_group ();
725 last_insn = change->insn;
727 validate_change (change->insn, change->loc, change->new_rtx, 1);
729 apply_change_group ();
732 /* Called via note_uses, for all used registers in a real insn
733 apply DEBUG_INSN changes that change registers to the used
734 registers. */
736 static void
737 cprop_find_used_regs (rtx *loc, void *data)
739 struct value_data *const vd = (struct value_data *) data;
740 subrtx_iterator::array_type array;
741 FOR_EACH_SUBRTX (iter, array, *loc, NONCONST)
743 const_rtx x = *iter;
744 if (REG_P (x))
746 unsigned int regno = REGNO (x);
747 if (vd->e[regno].debug_insn_changes)
749 apply_debug_insn_changes (vd, regno);
750 free_debug_insn_changes (vd, regno);
756 /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD. */
758 static void
759 kill_clobbered_values (rtx_insn *insn, struct value_data *vd)
761 note_stores (insn, kill_clobbered_value, vd);
764 /* Perform the forward copy propagation on basic block BB. */
766 static bool
767 copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
769 bool anything_changed = false;
770 rtx_insn *insn, *next;
772 for (insn = BB_HEAD (bb); ; insn = next)
774 int n_ops, i, predicated;
775 bool is_asm, any_replacements;
776 rtx set;
777 rtx link;
778 bool changed = false;
779 struct kill_set_value_data ksvd;
781 next = NEXT_INSN (insn);
782 if (!NONDEBUG_INSN_P (insn))
784 if (DEBUG_BIND_INSN_P (insn))
786 rtx loc = INSN_VAR_LOCATION_LOC (insn);
787 if (!VAR_LOC_UNKNOWN_P (loc))
788 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn),
789 ALL_REGS, GET_MODE (loc),
790 ADDR_SPACE_GENERIC, insn, vd);
793 if (insn == BB_END (bb))
794 break;
795 else
796 continue;
799 set = single_set (insn);
801 /* Detect noop sets and remove them before processing side effects. */
802 if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
804 unsigned int regno = REGNO (SET_SRC (set));
805 rtx r1 = find_oldest_value_reg (REGNO_REG_CLASS (regno),
806 SET_DEST (set), vd);
807 rtx r2 = find_oldest_value_reg (REGNO_REG_CLASS (regno),
808 SET_SRC (set), vd);
809 if (rtx_equal_p (r1 ? r1 : SET_DEST (set), r2 ? r2 : SET_SRC (set)))
811 bool last = insn == BB_END (bb);
812 delete_insn (insn);
813 if (last)
814 break;
815 continue;
819 /* Detect obviously dead sets (via REG_UNUSED notes) and remove them. */
820 if (set
821 && !RTX_FRAME_RELATED_P (insn)
822 && NONJUMP_INSN_P (insn)
823 && !may_trap_p (set)
824 && find_reg_note (insn, REG_UNUSED, SET_DEST (set))
825 && !side_effects_p (SET_SRC (set))
826 && !side_effects_p (SET_DEST (set)))
828 bool last = insn == BB_END (bb);
829 delete_insn (insn);
830 if (last)
831 break;
832 continue;
836 extract_constrain_insn (insn);
837 preprocess_constraints (insn);
838 const operand_alternative *op_alt = which_op_alt ();
839 n_ops = recog_data.n_operands;
840 is_asm = asm_noperands (PATTERN (insn)) >= 0;
842 /* Simplify the code below by promoting OP_OUT to OP_INOUT
843 in predicated instructions. */
845 predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
846 for (i = 0; i < n_ops; ++i)
848 int matches = op_alt[i].matches;
849 if (matches >= 0 || op_alt[i].matched >= 0
850 || (predicated && recog_data.operand_type[i] == OP_OUT))
851 recog_data.operand_type[i] = OP_INOUT;
854 /* Apply changes to earlier DEBUG_INSNs if possible. */
855 if (vd->n_debug_insn_changes)
856 note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
858 /* For each earlyclobber operand, zap the value data. */
859 for (i = 0; i < n_ops; i++)
860 if (op_alt[i].earlyclobber)
861 kill_value (recog_data.operand[i], vd);
863 /* Within asms, a clobber cannot overlap inputs or outputs.
864 I wouldn't think this were true for regular insns, but
865 scan_rtx treats them like that... */
866 kill_clobbered_values (insn, vd);
868 /* Kill all auto-incremented values. */
869 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
870 kill_autoinc_value (insn, vd);
872 /* Kill all early-clobbered operands. */
873 for (i = 0; i < n_ops; i++)
874 if (op_alt[i].earlyclobber)
875 kill_value (recog_data.operand[i], vd);
877 /* If we have dead sets in the insn, then we need to note these as we
878 would clobbers. */
879 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
881 if (REG_NOTE_KIND (link) == REG_UNUSED)
883 kill_value (XEXP (link, 0), vd);
884 /* Furthermore, if the insn looked like a single-set,
885 but the dead store kills the source value of that
886 set, then we can no-longer use the plain move
887 special case below. */
888 if (set
889 && reg_overlap_mentioned_p (XEXP (link, 0), SET_SRC (set)))
890 set = NULL;
893 /* We need to keep CFI info correct, and the same on all paths,
894 so we cannot normally replace the registers REG_CFA_REGISTER
895 refers to. Bail. */
896 if (REG_NOTE_KIND (link) == REG_CFA_REGISTER)
897 goto did_replacement;
900 /* Special-case plain move instructions, since we may well
901 be able to do the move from a different register class. */
902 if (set && REG_P (SET_SRC (set)))
904 rtx src = SET_SRC (set);
905 rtx dest = SET_DEST (set);
906 unsigned int regno = REGNO (src);
907 machine_mode mode = GET_MODE (src);
908 unsigned int i;
909 rtx new_rtx;
911 /* If we are accessing SRC in some mode other that what we
912 set it in, make sure that the replacement is valid. */
913 if (mode != vd->e[regno].mode)
915 if (REG_NREGS (src)
916 > hard_regno_nregs (regno, vd->e[regno].mode))
917 goto no_move_special_case;
919 /* And likewise, if we are narrowing on big endian the transformation
920 is also invalid. */
921 if (REG_NREGS (src) < hard_regno_nregs (regno, vd->e[regno].mode)
922 && maybe_ne (subreg_lowpart_offset (mode,
923 vd->e[regno].mode), 0U))
924 goto no_move_special_case;
927 /* If the destination is also a register, try to find a source
928 register in the same class. */
929 if (REG_P (dest))
931 new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno),
932 src, vd);
934 if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
936 if (dump_file)
937 fprintf (dump_file,
938 "insn %u: replaced reg %u with %u\n",
939 INSN_UID (insn), regno, REGNO (new_rtx));
940 changed = true;
941 goto did_replacement;
943 /* We need to re-extract as validate_change clobbers
944 recog_data. */
945 extract_constrain_insn (insn);
946 preprocess_constraints (insn);
949 /* Otherwise, try all valid registers and see if its valid. */
950 for (i = vd->e[regno].oldest_regno; i != regno;
951 i = vd->e[i].next_regno)
953 new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
954 mode, i, regno);
955 if (new_rtx != NULL_RTX)
957 /* Don't propagate for a more expensive reg-reg move. */
958 if (REG_P (dest))
960 enum reg_class from = REGNO_REG_CLASS (regno);
961 enum reg_class to = REGNO_REG_CLASS (REGNO (dest));
962 enum reg_class new_from = REGNO_REG_CLASS (i);
963 unsigned int original_cost
964 = targetm.register_move_cost (mode, from, to);
965 unsigned int after_cost
966 = targetm.register_move_cost (mode, new_from, to);
967 if (after_cost > original_cost)
968 continue;
971 if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
973 /* NEW_RTX may be the global stack pointer rtx, in which
974 case we must not modify it's attributes. */
975 if (new_rtx != stack_pointer_rtx)
977 ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
978 REG_ATTRS (new_rtx) = REG_ATTRS (src);
979 REG_POINTER (new_rtx) = REG_POINTER (src);
981 if (dump_file)
982 fprintf (dump_file,
983 "insn %u: replaced reg %u with %u\n",
984 INSN_UID (insn), regno, REGNO (new_rtx));
985 changed = true;
986 goto did_replacement;
988 /* We need to re-extract as validate_change clobbers
989 recog_data. */
990 extract_constrain_insn (insn);
991 preprocess_constraints (insn);
995 no_move_special_case:
997 any_replacements = false;
999 /* For each input operand, replace a hard register with the
1000 eldest live copy that's in an appropriate register class. */
1001 for (i = 0; i < n_ops; i++)
1003 bool replaced = false;
1005 /* Don't scan match_operand here, since we've no reg class
1006 information to pass down. Any operands that we could
1007 substitute in will be represented elsewhere. */
1008 if (recog_data.constraints[i][0] == '\0')
1009 continue;
1011 /* Don't replace in asms intentionally referencing hard regs. */
1012 if (is_asm && REG_P (recog_data.operand[i])
1013 && (REGNO (recog_data.operand[i])
1014 == ORIGINAL_REGNO (recog_data.operand[i])))
1015 continue;
1017 if (recog_data.operand_type[i] == OP_IN)
1019 if (op_alt[i].is_address)
1020 replaced
1021 = replace_oldest_value_addr (recog_data.operand_loc[i],
1022 alternative_class (op_alt, i),
1023 VOIDmode, ADDR_SPACE_GENERIC,
1024 insn, vd);
1025 else if (REG_P (recog_data.operand[i]))
1026 replaced
1027 = replace_oldest_value_reg (recog_data.operand_loc[i],
1028 alternative_class (op_alt, i),
1029 insn, vd);
1030 else if (MEM_P (recog_data.operand[i]))
1031 replaced = replace_oldest_value_mem (recog_data.operand[i],
1032 insn, vd);
1034 else if (MEM_P (recog_data.operand[i]))
1035 replaced = replace_oldest_value_mem (recog_data.operand[i],
1036 insn, vd);
1038 /* If we performed any replacement, update match_dups. */
1039 if (replaced)
1041 int j;
1042 rtx new_rtx;
1044 new_rtx = *recog_data.operand_loc[i];
1045 recog_data.operand[i] = new_rtx;
1046 for (j = 0; j < recog_data.n_dups; j++)
1047 if (recog_data.dup_num[j] == i)
1048 validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1);
1050 any_replacements = true;
1054 if (any_replacements)
1056 if (! apply_change_group ())
1058 if (dump_file)
1059 fprintf (dump_file,
1060 "insn %u: reg replacements not verified\n",
1061 INSN_UID (insn));
1063 else
1064 changed = true;
1067 did_replacement:
1068 if (changed)
1070 anything_changed = true;
1072 /* If something changed, perhaps further changes to earlier
1073 DEBUG_INSNs can be applied. */
1074 if (vd->n_debug_insn_changes)
1075 note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
1076 df_insn_rescan (insn);
1079 ksvd.vd = vd;
1080 ksvd.ignore_set_reg = NULL_RTX;
1082 /* Clobber call-clobbered registers. */
1083 if (CALL_P (insn))
1085 unsigned int set_regno = INVALID_REGNUM;
1086 unsigned int set_nregs = 0;
1087 unsigned int regno;
1088 rtx exp;
1090 for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1))
1092 rtx x = XEXP (exp, 0);
1093 if (GET_CODE (x) == SET)
1095 rtx dest = SET_DEST (x);
1096 kill_value (dest, vd);
1097 set_value_regno (REGNO (dest), GET_MODE (dest), vd);
1098 copy_value (dest, SET_SRC (x), vd);
1099 ksvd.ignore_set_reg = dest;
1100 set_regno = REGNO (dest);
1101 set_nregs = REG_NREGS (dest);
1102 break;
1106 function_abi callee_abi = insn_callee_abi (insn);
1107 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1108 if (vd->e[regno].mode != VOIDmode
1109 && callee_abi.clobbers_reg_p (vd->e[regno].mode, regno)
1110 && (regno < set_regno || regno >= set_regno + set_nregs))
1111 kill_value_regno (regno, 1, vd);
1113 /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
1114 of the SET isn't clobbered by CALLEE_ABI, but instead among
1115 CLOBBERs on the CALL_INSN, we could wrongly assume the
1116 value in it is still live. */
1117 if (ksvd.ignore_set_reg)
1118 kill_clobbered_values (insn, vd);
1121 bool copy_p = (set
1122 && REG_P (SET_DEST (set))
1123 && REG_P (SET_SRC (set)));
1124 bool noop_p = (copy_p
1125 && rtx_equal_p (SET_DEST (set), SET_SRC (set)));
1127 /* If a noop move is using narrower mode than we have recorded,
1128 we need to either remove the noop move, or kill_set_value. */
1129 if (noop_p
1130 && partial_subreg_p (GET_MODE (SET_DEST (set)),
1131 vd->e[REGNO (SET_DEST (set))].mode))
1133 if (noop_move_p (insn))
1135 bool last = insn == BB_END (bb);
1136 delete_insn (insn);
1137 if (last)
1138 break;
1140 else
1141 noop_p = false;
1144 if (!noop_p)
1146 /* Notice stores. */
1147 note_stores (insn, kill_set_value, &ksvd);
1149 /* Notice copies. */
1150 if (copy_p)
1152 df_insn_rescan (insn);
1153 copy_value (SET_DEST (set), SET_SRC (set), vd);
1157 if (insn == BB_END (bb))
1158 break;
1161 return anything_changed;
1164 /* Dump the value chain data to stderr. */
1166 DEBUG_FUNCTION void
1167 debug_value_data (struct value_data *vd)
1169 HARD_REG_SET set;
1170 unsigned int i, j;
1172 CLEAR_HARD_REG_SET (set);
1174 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1175 if (vd->e[i].oldest_regno == i)
1177 if (vd->e[i].mode == VOIDmode)
1179 if (vd->e[i].next_regno != INVALID_REGNUM)
1180 fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
1181 i, vd->e[i].next_regno);
1182 continue;
1185 SET_HARD_REG_BIT (set, i);
1186 fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
1188 for (j = vd->e[i].next_regno;
1189 j != INVALID_REGNUM;
1190 j = vd->e[j].next_regno)
1192 if (TEST_HARD_REG_BIT (set, j))
1194 fprintf (stderr, "[%u] Loop in regno chain\n", j);
1195 return;
1198 if (vd->e[j].oldest_regno != i)
1200 fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
1201 j, vd->e[j].oldest_regno);
1202 return;
1204 SET_HARD_REG_BIT (set, j);
1205 fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
1207 fputc ('\n', stderr);
1210 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1211 if (! TEST_HARD_REG_BIT (set, i)
1212 && (vd->e[i].mode != VOIDmode
1213 || vd->e[i].oldest_regno != i
1214 || vd->e[i].next_regno != INVALID_REGNUM))
1215 fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
1216 i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
1217 vd->e[i].next_regno);
1220 /* Do copyprop_hardreg_forward_1 for a single basic block BB.
1221 DEBUG_INSN is skipped since we do not want to involve DF related
1222 staff as how it is handled in function pass_cprop_hardreg::execute.
1224 NOTE: Currently it is only used for shrink-wrap. Maybe extend it
1225 to handle DEBUG_INSN for other uses. */
1227 void
1228 copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb)
1230 struct value_data *vd;
1231 vd = XNEWVEC (struct value_data, 1);
1232 init_value_data (vd);
1234 skip_debug_insn_p = true;
1235 copyprop_hardreg_forward_1 (bb, vd);
1236 free (vd);
1237 skip_debug_insn_p = false;
1240 static void
1241 validate_value_data (struct value_data *vd)
1243 HARD_REG_SET set;
1244 unsigned int i, j;
1246 CLEAR_HARD_REG_SET (set);
1248 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1249 if (vd->e[i].oldest_regno == i)
1251 if (vd->e[i].mode == VOIDmode)
1253 if (vd->e[i].next_regno != INVALID_REGNUM)
1254 internal_error ("%qs: [%u] bad %<next_regno%> for empty chain (%u)",
1255 __func__, i, vd->e[i].next_regno);
1256 continue;
1259 SET_HARD_REG_BIT (set, i);
1261 for (j = vd->e[i].next_regno;
1262 j != INVALID_REGNUM;
1263 j = vd->e[j].next_regno)
1265 if (TEST_HARD_REG_BIT (set, j))
1266 internal_error ("%qs: loop in %<next_regno%> chain (%u)",
1267 __func__, j);
1268 if (vd->e[j].oldest_regno != i)
1269 internal_error ("%qs: [%u] bad %<oldest_regno%> (%u)",
1270 __func__, j, vd->e[j].oldest_regno);
1272 SET_HARD_REG_BIT (set, j);
1276 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
1277 if (! TEST_HARD_REG_BIT (set, i)
1278 && (vd->e[i].mode != VOIDmode
1279 || vd->e[i].oldest_regno != i
1280 || vd->e[i].next_regno != INVALID_REGNUM))
1281 internal_error ("%qs: [%u] non-empty register in chain (%s %u %i)",
1282 __func__, i,
1283 GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
1284 vd->e[i].next_regno);
1288 namespace {
1290 const pass_data pass_data_cprop_hardreg =
1292 RTL_PASS, /* type */
1293 "cprop_hardreg", /* name */
1294 OPTGROUP_NONE, /* optinfo_flags */
1295 TV_CPROP_REGISTERS, /* tv_id */
1296 0, /* properties_required */
1297 0, /* properties_provided */
1298 0, /* properties_destroyed */
1299 0, /* todo_flags_start */
1300 TODO_df_finish, /* todo_flags_finish */
1303 class pass_cprop_hardreg : public rtl_opt_pass
1305 public:
1306 pass_cprop_hardreg (gcc::context *ctxt)
1307 : rtl_opt_pass (pass_data_cprop_hardreg, ctxt)
1310 /* opt_pass methods: */
1311 bool gate (function *) final override
1313 return (optimize > 0 && (flag_cprop_registers));
1316 unsigned int execute (function *) final override;
1318 }; // class pass_cprop_hardreg
1320 static bool
1321 cprop_hardreg_bb (basic_block bb, struct value_data *all_vd, sbitmap visited)
1323 bitmap_set_bit (visited, bb->index);
1325 /* If a block has a single predecessor, that we've already
1326 processed, begin with the value data that was live at
1327 the end of the predecessor block. */
1328 /* ??? Ought to use more intelligent queuing of blocks. */
1329 if (single_pred_p (bb)
1330 && bitmap_bit_p (visited, single_pred (bb)->index)
1331 && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
1333 all_vd[bb->index] = all_vd[single_pred (bb)->index];
1334 if (all_vd[bb->index].n_debug_insn_changes)
1336 unsigned int regno;
1338 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1340 if (all_vd[bb->index].e[regno].debug_insn_changes)
1342 struct queued_debug_insn_change *cur;
1343 for (cur = all_vd[bb->index].e[regno].debug_insn_changes;
1344 cur; cur = cur->next)
1345 --all_vd[bb->index].n_debug_insn_changes;
1346 all_vd[bb->index].e[regno].debug_insn_changes = NULL;
1347 if (all_vd[bb->index].n_debug_insn_changes == 0)
1348 break;
1353 else
1354 init_value_data (all_vd + bb->index);
1356 return copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
1359 static void
1360 cprop_hardreg_debug (function *fun, struct value_data *all_vd)
1362 basic_block bb;
1364 FOR_EACH_BB_FN (bb, fun)
1365 if (all_vd[bb->index].n_debug_insn_changes)
1367 unsigned int regno;
1368 bitmap live;
1370 live = df_get_live_out (bb);
1371 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1372 if (all_vd[bb->index].e[regno].debug_insn_changes)
1374 if (REGNO_REG_SET_P (live, regno))
1375 apply_debug_insn_changes (all_vd + bb->index, regno);
1377 struct queued_debug_insn_change *cur;
1378 for (cur = all_vd[bb->index].e[regno].debug_insn_changes;
1379 cur; cur = cur->next)
1380 --all_vd[bb->index].n_debug_insn_changes;
1381 all_vd[bb->index].e[regno].debug_insn_changes = NULL;
1382 if (all_vd[bb->index].n_debug_insn_changes == 0)
1383 break;
1387 queued_debug_insn_change_pool.release ();
1390 unsigned int
1391 pass_cprop_hardreg::execute (function *fun)
1393 struct value_data *all_vd;
1394 basic_block bb;
1396 all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (fun));
1398 auto_sbitmap visited (last_basic_block_for_fn (fun));
1399 bitmap_clear (visited);
1401 auto_vec<int> worklist1, worklist2;
1402 auto_vec<int> *curr = &worklist1;
1403 auto_vec<int> *next = &worklist2;
1404 bool any_debug_changes = false;
1406 /* We need accurate notes. Earlier passes such as if-conversion may
1407 leave notes in an inconsistent state. */
1408 df_note_add_problem ();
1409 df_analyze ();
1411 /* It is tempting to set DF_LR_RUN_DCE, but DCE may choose to delete
1412 an insn and this pass would not have visibility into the removal.
1413 This pass would then potentially use the source of that
1414 INSN for propagation purposes, generating invalid code.
1416 So we just ask for updated notes and handle trivial deletions
1417 within this pass where we can update this passes internal
1418 data structures appropriately. */
1419 df_set_flags (DF_DEFER_INSN_RESCAN);
1421 FOR_EACH_BB_FN (bb, fun)
1423 if (cprop_hardreg_bb (bb, all_vd, visited))
1424 curr->safe_push (bb->index);
1425 if (all_vd[bb->index].n_debug_insn_changes)
1426 any_debug_changes = true;
1429 /* We must call df_analyze here unconditionally to ensure that the
1430 REG_UNUSED and REG_DEAD notes are consistent with and without -g. */
1431 df_analyze ();
1433 if (MAY_HAVE_DEBUG_BIND_INSNS && any_debug_changes)
1434 cprop_hardreg_debug (fun, all_vd);
1436 /* Repeat pass up to PASSES times, but only processing basic blocks
1437 that have changed on the previous iteration. CURR points to the
1438 current worklist, and each iteration populates the NEXT worklist,
1439 swapping pointers after each cycle. */
1441 unsigned int passes = optimize > 1 ? 3 : 2;
1442 for (unsigned int pass = 2; pass <= passes && !curr->is_empty (); pass++)
1444 any_debug_changes = false;
1445 bitmap_clear (visited);
1446 next->truncate (0);
1447 for (int index : *curr)
1449 bb = BASIC_BLOCK_FOR_FN (fun, index);
1450 if (cprop_hardreg_bb (bb, all_vd, visited))
1451 next->safe_push (bb->index);
1452 if (all_vd[bb->index].n_debug_insn_changes)
1453 any_debug_changes = true;
1456 df_analyze ();
1457 if (MAY_HAVE_DEBUG_BIND_INSNS && any_debug_changes)
1458 cprop_hardreg_debug (fun, all_vd);
1459 std::swap (curr, next);
1462 free (all_vd);
1463 return 0;
1466 } // anon namespace
1468 rtl_opt_pass *
1469 make_pass_cprop_hardreg (gcc::context *ctxt)
1471 return new pass_cprop_hardreg (ctxt);