1 /* Copy propagation on hard registers for the GNU compiler.
2 Copyright (C) 2000-2017 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)
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/>. */
22 #include "coretypes.h"
28 #include "insn-config.h"
32 #include "diagnostic-core.h"
33 #include "addresses.h"
34 #include "tree-pass.h"
39 /* The following code does forward propagation of hard register copies.
40 The object is to eliminate as many dependencies as possible, so that
41 we have the most scheduling freedom. As a side effect, we also clean
42 up some silly register allocation decisions made by reload. This
43 code may be obsoleted by a new register allocator. */
45 /* DEBUG_INSNs aren't changed right away, as doing so might extend the
46 lifetime of a register and get the DEBUG_INSN subsequently reset.
47 So they are queued instead, and updated only when the register is
48 used in some subsequent real insn before it is set. */
49 struct queued_debug_insn_change
51 struct queued_debug_insn_change
*next
;
57 /* For each register, we have a list of registers that contain the same
58 value. The OLDEST_REGNO field points to the head of the list, and
59 the NEXT_REGNO field runs through the list. The MODE field indicates
60 what mode the data is known to be in; this field is VOIDmode when the
61 register is not known to contain valid data. */
63 struct value_data_entry
66 unsigned int oldest_regno
;
67 unsigned int next_regno
;
68 struct queued_debug_insn_change
*debug_insn_changes
;
73 struct value_data_entry e
[FIRST_PSEUDO_REGISTER
];
74 unsigned int max_value_regs
;
75 unsigned int n_debug_insn_changes
;
78 static object_allocator
<queued_debug_insn_change
> queued_debug_insn_change_pool
79 ("debug insn changes pool");
81 static bool skip_debug_insn_p
;
83 static void kill_value_one_regno (unsigned, struct value_data
*);
84 static void kill_value_regno (unsigned, unsigned, struct value_data
*);
85 static void kill_value (const_rtx
, struct value_data
*);
86 static void set_value_regno (unsigned, machine_mode
, struct value_data
*);
87 static void init_value_data (struct value_data
*);
88 static void kill_clobbered_value (rtx
, const_rtx
, void *);
89 static void kill_set_value (rtx
, const_rtx
, void *);
90 static void copy_value (rtx
, rtx
, struct value_data
*);
91 static bool mode_change_ok (machine_mode
, machine_mode
,
93 static rtx
maybe_mode_change (machine_mode
, machine_mode
,
94 machine_mode
, unsigned int, unsigned int);
95 static rtx
find_oldest_value_reg (enum reg_class
, rtx
, struct value_data
*);
96 static bool replace_oldest_value_reg (rtx
*, enum reg_class
, rtx_insn
*,
98 static bool replace_oldest_value_addr (rtx
*, enum reg_class
,
99 machine_mode
, addr_space_t
,
100 rtx_insn
*, struct value_data
*);
101 static bool replace_oldest_value_mem (rtx
, rtx_insn
*, struct value_data
*);
102 static bool copyprop_hardreg_forward_1 (basic_block
, struct value_data
*);
103 extern void debug_value_data (struct value_data
*);
104 static void validate_value_data (struct value_data
*);
106 /* Free all queued updates for DEBUG_INSNs that change some reg to
110 free_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
112 struct queued_debug_insn_change
*cur
, *next
;
113 for (cur
= vd
->e
[regno
].debug_insn_changes
; cur
; cur
= next
)
116 --vd
->n_debug_insn_changes
;
117 queued_debug_insn_change_pool
.remove (cur
);
119 vd
->e
[regno
].debug_insn_changes
= NULL
;
122 /* Kill register REGNO. This involves removing it from any value
123 lists, and resetting the value mode to VOIDmode. This is only a
124 helper function; it does not handle any hard registers overlapping
128 kill_value_one_regno (unsigned int regno
, struct value_data
*vd
)
130 unsigned int i
, next
;
132 if (vd
->e
[regno
].oldest_regno
!= regno
)
134 for (i
= vd
->e
[regno
].oldest_regno
;
135 vd
->e
[i
].next_regno
!= regno
;
136 i
= vd
->e
[i
].next_regno
)
138 vd
->e
[i
].next_regno
= vd
->e
[regno
].next_regno
;
140 else if ((next
= vd
->e
[regno
].next_regno
) != INVALID_REGNUM
)
142 for (i
= next
; i
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
143 vd
->e
[i
].oldest_regno
= next
;
146 vd
->e
[regno
].mode
= VOIDmode
;
147 vd
->e
[regno
].oldest_regno
= regno
;
148 vd
->e
[regno
].next_regno
= INVALID_REGNUM
;
149 if (vd
->e
[regno
].debug_insn_changes
)
150 free_debug_insn_changes (vd
, regno
);
153 validate_value_data (vd
);
156 /* Kill the value in register REGNO for NREGS, and any other registers
157 whose values overlap. */
160 kill_value_regno (unsigned int regno
, unsigned int nregs
,
161 struct value_data
*vd
)
165 /* Kill the value we're told to kill. */
166 for (j
= 0; j
< nregs
; ++j
)
167 kill_value_one_regno (regno
+ j
, vd
);
169 /* Kill everything that overlapped what we're told to kill. */
170 if (regno
< vd
->max_value_regs
)
173 j
= regno
- vd
->max_value_regs
;
174 for (; j
< regno
; ++j
)
177 if (vd
->e
[j
].mode
== VOIDmode
)
179 n
= hard_regno_nregs (j
, vd
->e
[j
].mode
);
181 for (i
= 0; i
< n
; ++i
)
182 kill_value_one_regno (j
+ i
, vd
);
186 /* Kill X. This is a convenience function wrapping kill_value_regno
187 so that we mind the mode the register is in. */
190 kill_value (const_rtx x
, struct value_data
*vd
)
192 if (GET_CODE (x
) == SUBREG
)
194 rtx tmp
= simplify_subreg (GET_MODE (x
), SUBREG_REG (x
),
195 GET_MODE (SUBREG_REG (x
)), SUBREG_BYTE (x
));
196 x
= tmp
? tmp
: SUBREG_REG (x
);
199 kill_value_regno (REGNO (x
), REG_NREGS (x
), vd
);
202 /* Remember that REGNO is valid in MODE. */
205 set_value_regno (unsigned int regno
, machine_mode mode
,
206 struct value_data
*vd
)
210 vd
->e
[regno
].mode
= mode
;
212 nregs
= hard_regno_nregs (regno
, mode
);
213 if (nregs
> vd
->max_value_regs
)
214 vd
->max_value_regs
= nregs
;
217 /* Initialize VD such that there are no known relationships between regs. */
220 init_value_data (struct value_data
*vd
)
223 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
225 vd
->e
[i
].mode
= VOIDmode
;
226 vd
->e
[i
].oldest_regno
= i
;
227 vd
->e
[i
].next_regno
= INVALID_REGNUM
;
228 vd
->e
[i
].debug_insn_changes
= NULL
;
230 vd
->max_value_regs
= 0;
231 vd
->n_debug_insn_changes
= 0;
234 /* Called through note_stores. If X is clobbered, kill its value. */
237 kill_clobbered_value (rtx x
, const_rtx set
, void *data
)
239 struct value_data
*const vd
= (struct value_data
*) data
;
240 if (GET_CODE (set
) == CLOBBER
)
244 /* A structure passed as data to kill_set_value through note_stores. */
245 struct kill_set_value_data
247 struct value_data
*vd
;
251 /* Called through note_stores. If X is set, not clobbered, kill its
252 current value and install it as the root of its own value list. */
255 kill_set_value (rtx x
, const_rtx set
, void *data
)
257 struct kill_set_value_data
*ksvd
= (struct kill_set_value_data
*) data
;
258 if (rtx_equal_p (x
, ksvd
->ignore_set_reg
))
260 if (GET_CODE (set
) != CLOBBER
)
262 kill_value (x
, ksvd
->vd
);
264 set_value_regno (REGNO (x
), GET_MODE (x
), ksvd
->vd
);
268 /* Kill any register used in X as the base of an auto-increment expression,
269 and install that register as the root of its own value list. */
272 kill_autoinc_value (rtx_insn
*insn
, struct value_data
*vd
)
274 subrtx_iterator::array_type array
;
275 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), NONCONST
)
278 if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_AUTOINC
)
282 set_value_regno (REGNO (x
), GET_MODE (x
), vd
);
283 iter
.skip_subrtxes ();
288 /* Assert that SRC has been copied to DEST. Adjust the data structures
289 to reflect that SRC contains an older copy of the shared value. */
292 copy_value (rtx dest
, rtx src
, struct value_data
*vd
)
294 unsigned int dr
= REGNO (dest
);
295 unsigned int sr
= REGNO (src
);
299 /* ??? At present, it's possible to see noop sets. It'd be nice if
300 this were cleaned up beforehand... */
304 /* Do not propagate copies to the stack pointer, as that can leave
305 memory accesses with no scheduling dependency on the stack update. */
306 if (dr
== STACK_POINTER_REGNUM
)
309 /* Likewise with the frame pointer, if we're using one. */
310 if (frame_pointer_needed
&& dr
== HARD_FRAME_POINTER_REGNUM
)
313 /* Do not propagate copies to fixed or global registers, patterns
314 can be relying to see particular fixed register or users can
315 expect the chosen global register in asm. */
316 if (fixed_regs
[dr
] || global_regs
[dr
])
319 /* If SRC and DEST overlap, don't record anything. */
320 dn
= REG_NREGS (dest
);
321 sn
= REG_NREGS (src
);
322 if ((dr
> sr
&& dr
< sr
+ sn
)
323 || (sr
> dr
&& sr
< dr
+ dn
))
326 /* If SRC had no assigned mode (i.e. we didn't know it was live)
327 assign it now and assume the value came from an input argument
329 if (vd
->e
[sr
].mode
== VOIDmode
)
330 set_value_regno (sr
, vd
->e
[dr
].mode
, vd
);
332 /* If we are narrowing the input to a smaller number of hard regs,
333 and it is in big endian, we are really extracting a high part.
334 Since we generally associate a low part of a value with the value itself,
335 we must not do the same for the high part.
336 Note we can still get low parts for the same mode combination through
337 a two-step copy involving differently sized hard regs.
338 Assume hard regs fr* are 32 bits each, while r* are 64 bits each:
339 (set (reg:DI r0) (reg:DI fr0))
340 (set (reg:SI fr2) (reg:SI r0))
341 loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
342 (set (reg:SI fr2) (reg:SI fr0))
343 loads the high part of (reg:DI fr0) into fr2.
345 We can't properly represent the latter case in our tables, so don't
346 record anything then. */
347 else if (sn
< hard_regno_nregs (sr
, vd
->e
[sr
].mode
)
348 && subreg_lowpart_offset (GET_MODE (dest
), vd
->e
[sr
].mode
) != 0)
351 /* If SRC had been assigned a mode narrower than the copy, we can't
352 link DEST into the chain, because not all of the pieces of the
353 copy came from oldest_regno. */
354 else if (sn
> hard_regno_nregs (sr
, vd
->e
[sr
].mode
))
357 /* Link DR at the end of the value chain used by SR. */
359 vd
->e
[dr
].oldest_regno
= vd
->e
[sr
].oldest_regno
;
361 for (i
= sr
; vd
->e
[i
].next_regno
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
363 vd
->e
[i
].next_regno
= dr
;
366 validate_value_data (vd
);
369 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
372 mode_change_ok (machine_mode orig_mode
, machine_mode new_mode
,
373 unsigned int regno ATTRIBUTE_UNUSED
)
375 if (partial_subreg_p (orig_mode
, new_mode
))
378 return REG_CAN_CHANGE_MODE_P (regno
, orig_mode
, new_mode
);
381 /* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
382 was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
384 Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
387 maybe_mode_change (machine_mode orig_mode
, machine_mode copy_mode
,
388 machine_mode new_mode
, unsigned int regno
,
389 unsigned int copy_regno ATTRIBUTE_UNUSED
)
391 if (partial_subreg_p (copy_mode
, orig_mode
)
392 && partial_subreg_p (copy_mode
, new_mode
))
395 /* Avoid creating multiple copies of the stack pointer. Some ports
396 assume there is one and only one stack pointer.
398 It's unclear if we need to do the same for other special registers. */
399 if (regno
== STACK_POINTER_REGNUM
)
402 if (orig_mode
== new_mode
)
403 return gen_raw_REG (new_mode
, regno
);
404 else if (mode_change_ok (orig_mode
, new_mode
, regno
))
406 int copy_nregs
= hard_regno_nregs (copy_regno
, copy_mode
);
407 int use_nregs
= hard_regno_nregs (copy_regno
, new_mode
);
409 = GET_MODE_SIZE (copy_mode
) / copy_nregs
* (copy_nregs
- use_nregs
);
411 = GET_MODE_SIZE (orig_mode
) - GET_MODE_SIZE (new_mode
) - copy_offset
;
412 int byteoffset
= offset
% UNITS_PER_WORD
;
413 int wordoffset
= offset
- byteoffset
;
415 offset
= ((WORDS_BIG_ENDIAN
? wordoffset
: 0)
416 + (BYTES_BIG_ENDIAN
? byteoffset
: 0));
417 regno
+= subreg_regno_offset (regno
, orig_mode
, offset
, new_mode
);
418 if (targetm
.hard_regno_mode_ok (regno
, new_mode
))
419 return gen_raw_REG (new_mode
, regno
);
424 /* Find the oldest copy of the value contained in REGNO that is in
425 register class CL and has mode MODE. If found, return an rtx
426 of that oldest register, otherwise return NULL. */
429 find_oldest_value_reg (enum reg_class cl
, rtx reg
, struct value_data
*vd
)
431 unsigned int regno
= REGNO (reg
);
432 machine_mode mode
= GET_MODE (reg
);
435 /* If we are accessing REG in some mode other that what we set it in,
436 make sure that the replacement is valid. In particular, consider
437 (set (reg:DI r11) (...))
438 (set (reg:SI r9) (reg:SI r11))
439 (set (reg:SI r10) (...))
440 (set (...) (reg:DI r9))
441 Replacing r9 with r11 is invalid. */
442 if (mode
!= vd
->e
[regno
].mode
443 && REG_NREGS (reg
) > hard_regno_nregs (regno
, vd
->e
[regno
].mode
))
446 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
; i
= vd
->e
[i
].next_regno
)
448 machine_mode oldmode
= vd
->e
[i
].mode
;
451 if (!in_hard_reg_set_p (reg_class_contents
[cl
], mode
, i
))
454 new_rtx
= maybe_mode_change (oldmode
, vd
->e
[regno
].mode
, mode
, i
, regno
);
457 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (reg
);
458 REG_ATTRS (new_rtx
) = REG_ATTRS (reg
);
459 REG_POINTER (new_rtx
) = REG_POINTER (reg
);
467 /* If possible, replace the register at *LOC with the oldest register
468 in register class CL. Return true if successfully replaced. */
471 replace_oldest_value_reg (rtx
*loc
, enum reg_class cl
, rtx_insn
*insn
,
472 struct value_data
*vd
)
474 rtx new_rtx
= find_oldest_value_reg (cl
, *loc
, vd
);
475 if (new_rtx
&& (!DEBUG_INSN_P (insn
) || !skip_debug_insn_p
))
477 if (DEBUG_INSN_P (insn
))
479 struct queued_debug_insn_change
*change
;
482 fprintf (dump_file
, "debug_insn %u: queued replacing reg %u with %u\n",
483 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
485 change
= queued_debug_insn_change_pool
.allocate ();
486 change
->next
= vd
->e
[REGNO (new_rtx
)].debug_insn_changes
;
489 change
->new_rtx
= new_rtx
;
490 vd
->e
[REGNO (new_rtx
)].debug_insn_changes
= change
;
491 ++vd
->n_debug_insn_changes
;
495 fprintf (dump_file
, "insn %u: replaced reg %u with %u\n",
496 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
498 validate_change (insn
, loc
, new_rtx
, 1);
504 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
505 Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
506 BASE_REG_CLASS depending on how the register is being considered. */
509 replace_oldest_value_addr (rtx
*loc
, enum reg_class cl
,
510 machine_mode mode
, addr_space_t as
,
511 rtx_insn
*insn
, struct value_data
*vd
)
514 RTX_CODE code
= GET_CODE (x
);
517 bool changed
= false;
522 if (DEBUG_INSN_P (insn
))
526 rtx orig_op0
= XEXP (x
, 0);
527 rtx orig_op1
= XEXP (x
, 1);
528 RTX_CODE code0
= GET_CODE (orig_op0
);
529 RTX_CODE code1
= GET_CODE (orig_op1
);
534 enum rtx_code index_code
= SCRATCH
;
536 if (GET_CODE (op0
) == SUBREG
)
538 op0
= SUBREG_REG (op0
);
539 code0
= GET_CODE (op0
);
542 if (GET_CODE (op1
) == SUBREG
)
544 op1
= SUBREG_REG (op1
);
545 code1
= GET_CODE (op1
);
548 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
549 || code0
== ZERO_EXTEND
|| code1
== MEM
)
553 index_code
= GET_CODE (*locI
);
555 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
556 || code1
== ZERO_EXTEND
|| code0
== MEM
)
560 index_code
= GET_CODE (*locI
);
562 else if (code0
== CONST_INT
|| code0
== CONST
563 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
566 index_code
= GET_CODE (XEXP (x
, 0));
568 else if (code1
== CONST_INT
|| code1
== CONST
569 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
572 index_code
= GET_CODE (XEXP (x
, 1));
574 else if (code0
== REG
&& code1
== REG
)
577 unsigned regno0
= REGNO (op0
), regno1
= REGNO (op1
);
579 if (REGNO_OK_FOR_INDEX_P (regno1
)
580 && regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
))
582 else if (REGNO_OK_FOR_INDEX_P (regno0
)
583 && regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
585 else if (regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
)
586 || REGNO_OK_FOR_INDEX_P (regno1
))
588 else if (regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
593 locI
= &XEXP (x
, index_op
);
594 locB
= &XEXP (x
, !index_op
);
595 index_code
= GET_CODE (*locI
);
597 else if (code0
== REG
)
601 index_code
= GET_CODE (*locI
);
603 else if (code1
== REG
)
607 index_code
= GET_CODE (*locI
);
611 changed
|= replace_oldest_value_addr (locI
, INDEX_REG_CLASS
,
614 changed
|= replace_oldest_value_addr (locB
,
615 base_reg_class (mode
, as
, PLUS
,
630 return replace_oldest_value_mem (x
, insn
, vd
);
633 return replace_oldest_value_reg (loc
, cl
, insn
, vd
);
639 fmt
= GET_RTX_FORMAT (code
);
640 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
643 changed
|= replace_oldest_value_addr (&XEXP (x
, i
), cl
, mode
, as
,
645 else if (fmt
[i
] == 'E')
646 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
647 changed
|= replace_oldest_value_addr (&XVECEXP (x
, i
, j
), cl
,
654 /* Similar to replace_oldest_value_reg, but X contains a memory. */
657 replace_oldest_value_mem (rtx x
, rtx_insn
*insn
, struct value_data
*vd
)
661 if (DEBUG_INSN_P (insn
))
664 cl
= base_reg_class (GET_MODE (x
), MEM_ADDR_SPACE (x
), MEM
, SCRATCH
);
666 return replace_oldest_value_addr (&XEXP (x
, 0), cl
,
667 GET_MODE (x
), MEM_ADDR_SPACE (x
),
671 /* Apply all queued updates for DEBUG_INSNs that change some reg to
675 apply_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
677 struct queued_debug_insn_change
*change
;
678 rtx_insn
*last_insn
= vd
->e
[regno
].debug_insn_changes
->insn
;
680 for (change
= vd
->e
[regno
].debug_insn_changes
;
682 change
= change
->next
)
684 if (last_insn
!= change
->insn
)
686 apply_change_group ();
687 last_insn
= change
->insn
;
689 validate_change (change
->insn
, change
->loc
, change
->new_rtx
, 1);
691 apply_change_group ();
694 /* Called via note_uses, for all used registers in a real insn
695 apply DEBUG_INSN changes that change registers to the used
699 cprop_find_used_regs (rtx
*loc
, void *data
)
701 struct value_data
*const vd
= (struct value_data
*) data
;
702 subrtx_iterator::array_type array
;
703 FOR_EACH_SUBRTX (iter
, array
, *loc
, NONCONST
)
708 unsigned int regno
= REGNO (x
);
709 if (vd
->e
[regno
].debug_insn_changes
)
711 apply_debug_insn_changes (vd
, regno
);
712 free_debug_insn_changes (vd
, regno
);
718 /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD. */
721 kill_clobbered_values (rtx_insn
*insn
, struct value_data
*vd
)
723 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
729 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
731 rtx x
= XEXP (exp
, 0);
732 if (GET_CODE (x
) == CLOBBER
)
733 kill_value (SET_DEST (x
), vd
);
738 /* Perform the forward copy propagation on basic block BB. */
741 copyprop_hardreg_forward_1 (basic_block bb
, struct value_data
*vd
)
743 bool anything_changed
= false;
744 rtx_insn
*insn
, *next
;
746 for (insn
= BB_HEAD (bb
); ; insn
= next
)
748 int n_ops
, i
, predicated
;
749 bool is_asm
, any_replacements
;
752 bool replaced
[MAX_RECOG_OPERANDS
];
753 bool changed
= false;
754 struct kill_set_value_data ksvd
;
756 next
= NEXT_INSN (insn
);
757 if (!NONDEBUG_INSN_P (insn
))
759 if (DEBUG_INSN_P (insn
))
761 rtx loc
= INSN_VAR_LOCATION_LOC (insn
);
762 if (!VAR_LOC_UNKNOWN_P (loc
))
763 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn
),
764 ALL_REGS
, GET_MODE (loc
),
765 ADDR_SPACE_GENERIC
, insn
, vd
);
768 if (insn
== BB_END (bb
))
774 set
= single_set (insn
);
776 /* Detect noop sets and remove them before processing side effects. */
777 if (set
&& REG_P (SET_DEST (set
)) && REG_P (SET_SRC (set
)))
779 unsigned int regno
= REGNO (SET_SRC (set
));
780 rtx r1
= find_oldest_value_reg (REGNO_REG_CLASS (regno
),
782 rtx r2
= find_oldest_value_reg (REGNO_REG_CLASS (regno
),
784 if (rtx_equal_p (r1
? r1
: SET_DEST (set
), r2
? r2
: SET_SRC (set
)))
786 bool last
= insn
== BB_END (bb
);
794 extract_constrain_insn (insn
);
795 preprocess_constraints (insn
);
796 const operand_alternative
*op_alt
= which_op_alt ();
797 n_ops
= recog_data
.n_operands
;
798 is_asm
= asm_noperands (PATTERN (insn
)) >= 0;
800 /* Simplify the code below by promoting OP_OUT to OP_INOUT
801 in predicated instructions. */
803 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
804 for (i
= 0; i
< n_ops
; ++i
)
806 int matches
= op_alt
[i
].matches
;
807 if (matches
>= 0 || op_alt
[i
].matched
>= 0
808 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
809 recog_data
.operand_type
[i
] = OP_INOUT
;
812 /* Apply changes to earlier DEBUG_INSNs if possible. */
813 if (vd
->n_debug_insn_changes
)
814 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
816 /* For each earlyclobber operand, zap the value data. */
817 for (i
= 0; i
< n_ops
; i
++)
818 if (op_alt
[i
].earlyclobber
)
819 kill_value (recog_data
.operand
[i
], vd
);
821 /* Within asms, a clobber cannot overlap inputs or outputs.
822 I wouldn't think this were true for regular insns, but
823 scan_rtx treats them like that... */
824 kill_clobbered_values (insn
, vd
);
826 /* Kill all auto-incremented values. */
827 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
828 kill_autoinc_value (insn
, vd
);
830 /* Kill all early-clobbered operands. */
831 for (i
= 0; i
< n_ops
; i
++)
832 if (op_alt
[i
].earlyclobber
)
833 kill_value (recog_data
.operand
[i
], vd
);
835 /* If we have dead sets in the insn, then we need to note these as we
837 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
839 if (REG_NOTE_KIND (link
) == REG_UNUSED
)
841 kill_value (XEXP (link
, 0), vd
);
842 /* Furthermore, if the insn looked like a single-set,
843 but the dead store kills the source value of that
844 set, then we can no-longer use the plain move
845 special case below. */
847 && reg_overlap_mentioned_p (XEXP (link
, 0), SET_SRC (set
)))
852 /* Special-case plain move instructions, since we may well
853 be able to do the move from a different register class. */
854 if (set
&& REG_P (SET_SRC (set
)))
856 rtx src
= SET_SRC (set
);
857 unsigned int regno
= REGNO (src
);
858 machine_mode mode
= GET_MODE (src
);
862 /* If we are accessing SRC in some mode other that what we
863 set it in, make sure that the replacement is valid. */
864 if (mode
!= vd
->e
[regno
].mode
)
867 > hard_regno_nregs (regno
, vd
->e
[regno
].mode
))
868 goto no_move_special_case
;
870 /* And likewise, if we are narrowing on big endian the transformation
872 if (REG_NREGS (src
) < hard_regno_nregs (regno
, vd
->e
[regno
].mode
)
873 && subreg_lowpart_offset (mode
, vd
->e
[regno
].mode
) != 0)
874 goto no_move_special_case
;
877 /* If the destination is also a register, try to find a source
878 register in the same class. */
879 if (REG_P (SET_DEST (set
)))
881 new_rtx
= find_oldest_value_reg (REGNO_REG_CLASS (regno
),
884 if (new_rtx
&& validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
888 "insn %u: replaced reg %u with %u\n",
889 INSN_UID (insn
), regno
, REGNO (new_rtx
));
891 goto did_replacement
;
893 /* We need to re-extract as validate_change clobbers
895 extract_constrain_insn (insn
);
896 preprocess_constraints (insn
);
899 /* Otherwise, try all valid registers and see if its valid. */
900 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
;
901 i
= vd
->e
[i
].next_regno
)
903 new_rtx
= maybe_mode_change (vd
->e
[i
].mode
, vd
->e
[regno
].mode
,
905 if (new_rtx
!= NULL_RTX
)
907 if (validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
909 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (src
);
910 REG_ATTRS (new_rtx
) = REG_ATTRS (src
);
911 REG_POINTER (new_rtx
) = REG_POINTER (src
);
914 "insn %u: replaced reg %u with %u\n",
915 INSN_UID (insn
), regno
, REGNO (new_rtx
));
917 goto did_replacement
;
919 /* We need to re-extract as validate_change clobbers
921 extract_constrain_insn (insn
);
922 preprocess_constraints (insn
);
926 no_move_special_case
:
928 any_replacements
= false;
930 /* For each input operand, replace a hard register with the
931 eldest live copy that's in an appropriate register class. */
932 for (i
= 0; i
< n_ops
; i
++)
936 /* Don't scan match_operand here, since we've no reg class
937 information to pass down. Any operands that we could
938 substitute in will be represented elsewhere. */
939 if (recog_data
.constraints
[i
][0] == '\0')
942 /* Don't replace in asms intentionally referencing hard regs. */
943 if (is_asm
&& REG_P (recog_data
.operand
[i
])
944 && (REGNO (recog_data
.operand
[i
])
945 == ORIGINAL_REGNO (recog_data
.operand
[i
])))
948 if (recog_data
.operand_type
[i
] == OP_IN
)
950 if (op_alt
[i
].is_address
)
952 = replace_oldest_value_addr (recog_data
.operand_loc
[i
],
953 alternative_class (op_alt
, i
),
954 VOIDmode
, ADDR_SPACE_GENERIC
,
956 else if (REG_P (recog_data
.operand
[i
]))
958 = replace_oldest_value_reg (recog_data
.operand_loc
[i
],
959 alternative_class (op_alt
, i
),
961 else if (MEM_P (recog_data
.operand
[i
]))
962 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
965 else if (MEM_P (recog_data
.operand
[i
]))
966 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
969 /* If we performed any replacement, update match_dups. */
975 new_rtx
= *recog_data
.operand_loc
[i
];
976 recog_data
.operand
[i
] = new_rtx
;
977 for (j
= 0; j
< recog_data
.n_dups
; j
++)
978 if (recog_data
.dup_num
[j
] == i
)
979 validate_unshare_change (insn
, recog_data
.dup_loc
[j
], new_rtx
, 1);
981 any_replacements
= true;
985 if (any_replacements
)
987 if (! apply_change_group ())
989 for (i
= 0; i
< n_ops
; i
++)
992 rtx old
= *recog_data
.operand_loc
[i
];
993 recog_data
.operand
[i
] = old
;
998 "insn %u: reg replacements not verified\n",
1008 anything_changed
= true;
1010 /* If something changed, perhaps further changes to earlier
1011 DEBUG_INSNs can be applied. */
1012 if (vd
->n_debug_insn_changes
)
1013 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
1017 ksvd
.ignore_set_reg
= NULL_RTX
;
1019 /* Clobber call-clobbered registers. */
1022 unsigned int set_regno
= INVALID_REGNUM
;
1023 unsigned int set_nregs
= 0;
1026 HARD_REG_SET regs_invalidated_by_this_call
;
1028 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
1030 rtx x
= XEXP (exp
, 0);
1031 if (GET_CODE (x
) == SET
)
1033 rtx dest
= SET_DEST (x
);
1034 kill_value (dest
, vd
);
1035 set_value_regno (REGNO (dest
), GET_MODE (dest
), vd
);
1036 copy_value (dest
, SET_SRC (x
), vd
);
1037 ksvd
.ignore_set_reg
= dest
;
1038 set_regno
= REGNO (dest
);
1039 set_nregs
= REG_NREGS (dest
);
1044 get_call_reg_set_usage (insn
,
1045 ®s_invalidated_by_this_call
,
1046 regs_invalidated_by_call
);
1047 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1048 if ((TEST_HARD_REG_BIT (regs_invalidated_by_this_call
, regno
)
1049 || (targetm
.hard_regno_call_part_clobbered
1050 (regno
, vd
->e
[regno
].mode
)))
1051 && (regno
< set_regno
|| regno
>= set_regno
+ set_nregs
))
1052 kill_value_regno (regno
, 1, vd
);
1054 /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
1055 of the SET isn't in regs_invalidated_by_call hard reg set,
1056 but instead among CLOBBERs on the CALL_INSN, we could wrongly
1057 assume the value in it is still live. */
1058 if (ksvd
.ignore_set_reg
)
1059 kill_clobbered_values (insn
, vd
);
1063 && REG_P (SET_DEST (set
))
1064 && REG_P (SET_SRC (set
)));
1065 bool noop_p
= (copy_p
1066 && rtx_equal_p (SET_DEST (set
), SET_SRC (set
)));
1068 /* If a noop move is using narrower mode than we have recorded,
1069 we need to either remove the noop move, or kill_set_value. */
1071 && partial_subreg_p (GET_MODE (SET_DEST (set
)),
1072 vd
->e
[REGNO (SET_DEST (set
))].mode
))
1074 if (noop_move_p (insn
))
1076 bool last
= insn
== BB_END (bb
);
1087 /* Notice stores. */
1088 note_stores (PATTERN (insn
), kill_set_value
, &ksvd
);
1090 /* Notice copies. */
1092 copy_value (SET_DEST (set
), SET_SRC (set
), vd
);
1095 if (insn
== BB_END (bb
))
1099 return anything_changed
;
1102 /* Dump the value chain data to stderr. */
1105 debug_value_data (struct value_data
*vd
)
1110 CLEAR_HARD_REG_SET (set
);
1112 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1113 if (vd
->e
[i
].oldest_regno
== i
)
1115 if (vd
->e
[i
].mode
== VOIDmode
)
1117 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1118 fprintf (stderr
, "[%u] Bad next_regno for empty chain (%u)\n",
1119 i
, vd
->e
[i
].next_regno
);
1123 SET_HARD_REG_BIT (set
, i
);
1124 fprintf (stderr
, "[%u %s] ", i
, GET_MODE_NAME (vd
->e
[i
].mode
));
1126 for (j
= vd
->e
[i
].next_regno
;
1127 j
!= INVALID_REGNUM
;
1128 j
= vd
->e
[j
].next_regno
)
1130 if (TEST_HARD_REG_BIT (set
, j
))
1132 fprintf (stderr
, "[%u] Loop in regno chain\n", j
);
1136 if (vd
->e
[j
].oldest_regno
!= i
)
1138 fprintf (stderr
, "[%u] Bad oldest_regno (%u)\n",
1139 j
, vd
->e
[j
].oldest_regno
);
1142 SET_HARD_REG_BIT (set
, j
);
1143 fprintf (stderr
, "[%u %s] ", j
, GET_MODE_NAME (vd
->e
[j
].mode
));
1145 fputc ('\n', stderr
);
1148 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1149 if (! TEST_HARD_REG_BIT (set
, i
)
1150 && (vd
->e
[i
].mode
!= VOIDmode
1151 || vd
->e
[i
].oldest_regno
!= i
1152 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1153 fprintf (stderr
, "[%u] Non-empty reg in chain (%s %u %i)\n",
1154 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1155 vd
->e
[i
].next_regno
);
1158 /* Do copyprop_hardreg_forward_1 for a single basic block BB.
1159 DEBUG_INSN is skipped since we do not want to involve DF related
1160 staff as how it is handled in function pass_cprop_hardreg::execute.
1162 NOTE: Currently it is only used for shrink-wrap. Maybe extend it
1163 to handle DEBUG_INSN for other uses. */
1166 copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb
)
1168 struct value_data
*vd
;
1169 vd
= XNEWVEC (struct value_data
, 1);
1170 init_value_data (vd
);
1172 skip_debug_insn_p
= true;
1173 copyprop_hardreg_forward_1 (bb
, vd
);
1175 skip_debug_insn_p
= false;
1179 validate_value_data (struct value_data
*vd
)
1184 CLEAR_HARD_REG_SET (set
);
1186 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1187 if (vd
->e
[i
].oldest_regno
== i
)
1189 if (vd
->e
[i
].mode
== VOIDmode
)
1191 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1192 internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1193 i
, vd
->e
[i
].next_regno
);
1197 SET_HARD_REG_BIT (set
, i
);
1199 for (j
= vd
->e
[i
].next_regno
;
1200 j
!= INVALID_REGNUM
;
1201 j
= vd
->e
[j
].next_regno
)
1203 if (TEST_HARD_REG_BIT (set
, j
))
1204 internal_error ("validate_value_data: Loop in regno chain (%u)",
1206 if (vd
->e
[j
].oldest_regno
!= i
)
1207 internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1208 j
, vd
->e
[j
].oldest_regno
);
1210 SET_HARD_REG_BIT (set
, j
);
1214 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1215 if (! TEST_HARD_REG_BIT (set
, i
)
1216 && (vd
->e
[i
].mode
!= VOIDmode
1217 || vd
->e
[i
].oldest_regno
!= i
1218 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1219 internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1220 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1221 vd
->e
[i
].next_regno
);
1227 const pass_data pass_data_cprop_hardreg
=
1229 RTL_PASS
, /* type */
1230 "cprop_hardreg", /* name */
1231 OPTGROUP_NONE
, /* optinfo_flags */
1232 TV_CPROP_REGISTERS
, /* tv_id */
1233 0, /* properties_required */
1234 0, /* properties_provided */
1235 0, /* properties_destroyed */
1236 0, /* todo_flags_start */
1237 TODO_df_finish
, /* todo_flags_finish */
1240 class pass_cprop_hardreg
: public rtl_opt_pass
1243 pass_cprop_hardreg (gcc::context
*ctxt
)
1244 : rtl_opt_pass (pass_data_cprop_hardreg
, ctxt
)
1247 /* opt_pass methods: */
1248 virtual bool gate (function
*)
1250 return (optimize
> 0 && (flag_cprop_registers
));
1253 virtual unsigned int execute (function
*);
1255 }; // class pass_cprop_hardreg
1258 pass_cprop_hardreg::execute (function
*fun
)
1260 struct value_data
*all_vd
;
1262 bool analyze_called
= false;
1264 all_vd
= XNEWVEC (struct value_data
, last_basic_block_for_fn (fun
));
1266 auto_sbitmap
visited (last_basic_block_for_fn (fun
));
1267 bitmap_clear (visited
);
1269 FOR_EACH_BB_FN (bb
, fun
)
1271 bitmap_set_bit (visited
, bb
->index
);
1273 /* If a block has a single predecessor, that we've already
1274 processed, begin with the value data that was live at
1275 the end of the predecessor block. */
1276 /* ??? Ought to use more intelligent queuing of blocks. */
1277 if (single_pred_p (bb
)
1278 && bitmap_bit_p (visited
, single_pred (bb
)->index
)
1279 && ! (single_pred_edge (bb
)->flags
& (EDGE_ABNORMAL_CALL
| EDGE_EH
)))
1281 all_vd
[bb
->index
] = all_vd
[single_pred (bb
)->index
];
1282 if (all_vd
[bb
->index
].n_debug_insn_changes
)
1286 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1288 if (all_vd
[bb
->index
].e
[regno
].debug_insn_changes
)
1290 all_vd
[bb
->index
].e
[regno
].debug_insn_changes
= NULL
;
1291 if (--all_vd
[bb
->index
].n_debug_insn_changes
== 0)
1298 init_value_data (all_vd
+ bb
->index
);
1300 copyprop_hardreg_forward_1 (bb
, all_vd
+ bb
->index
);
1303 if (MAY_HAVE_DEBUG_INSNS
)
1305 FOR_EACH_BB_FN (bb
, fun
)
1306 if (bitmap_bit_p (visited
, bb
->index
)
1307 && all_vd
[bb
->index
].n_debug_insn_changes
)
1312 if (!analyze_called
)
1315 analyze_called
= true;
1317 live
= df_get_live_out (bb
);
1318 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1319 if (all_vd
[bb
->index
].e
[regno
].debug_insn_changes
)
1321 if (REGNO_REG_SET_P (live
, regno
))
1322 apply_debug_insn_changes (all_vd
+ bb
->index
, regno
);
1323 if (all_vd
[bb
->index
].n_debug_insn_changes
== 0)
1328 queued_debug_insn_change_pool
.release ();
1338 make_pass_cprop_hardreg (gcc::context
*ctxt
)
1340 return new pass_cprop_hardreg (ctxt
);