1 /* Copy propagation on hard registers for the GNU compiler.
2 Copyright (C) 2000-2015 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"
27 #include "insn-config.h"
29 #include "addresses.h"
33 #include "diagnostic-core.h"
34 #include "tree-pass.h"
38 /* The following code does forward propagation of hard register copies.
39 The object is to eliminate as many dependencies as possible, so that
40 we have the most scheduling freedom. As a side effect, we also clean
41 up some silly register allocation decisions made by reload. This
42 code may be obsoleted by a new register allocator. */
44 /* DEBUG_INSNs aren't changed right away, as doing so might extend the
45 lifetime of a register and get the DEBUG_INSN subsequently reset.
46 So they are queued instead, and updated only when the register is
47 used in some subsequent real insn before it is set. */
48 struct queued_debug_insn_change
50 struct queued_debug_insn_change
*next
;
56 /* For each register, we have a list of registers that contain the same
57 value. The OLDEST_REGNO field points to the head of the list, and
58 the NEXT_REGNO field runs through the list. The MODE field indicates
59 what mode the data is known to be in; this field is VOIDmode when the
60 register is not known to contain valid data. */
62 struct value_data_entry
65 unsigned int oldest_regno
;
66 unsigned int next_regno
;
67 struct queued_debug_insn_change
*debug_insn_changes
;
72 struct value_data_entry e
[FIRST_PSEUDO_REGISTER
];
73 unsigned int max_value_regs
;
74 unsigned int n_debug_insn_changes
;
77 static object_allocator
<queued_debug_insn_change
> queued_debug_insn_change_pool
78 ("debug insn changes pool");
80 static bool skip_debug_insn_p
;
82 static void kill_value_one_regno (unsigned, struct value_data
*);
83 static void kill_value_regno (unsigned, unsigned, struct value_data
*);
84 static void kill_value (const_rtx
, struct value_data
*);
85 static void set_value_regno (unsigned, machine_mode
, struct value_data
*);
86 static void init_value_data (struct value_data
*);
87 static void kill_clobbered_value (rtx
, const_rtx
, void *);
88 static void kill_set_value (rtx
, const_rtx
, void *);
89 static void copy_value (rtx
, rtx
, struct value_data
*);
90 static bool mode_change_ok (machine_mode
, machine_mode
,
92 static rtx
maybe_mode_change (machine_mode
, machine_mode
,
93 machine_mode
, unsigned int, unsigned int);
94 static rtx
find_oldest_value_reg (enum reg_class
, rtx
, struct value_data
*);
95 static bool replace_oldest_value_reg (rtx
*, enum reg_class
, rtx_insn
*,
97 static bool replace_oldest_value_addr (rtx
*, enum reg_class
,
98 machine_mode
, addr_space_t
,
99 rtx_insn
*, struct value_data
*);
100 static bool replace_oldest_value_mem (rtx
, rtx_insn
*, struct value_data
*);
101 static bool copyprop_hardreg_forward_1 (basic_block
, struct value_data
*);
102 extern void debug_value_data (struct value_data
*);
103 #ifdef ENABLE_CHECKING
104 static void validate_value_data (struct value_data
*);
107 /* Free all queued updates for DEBUG_INSNs that change some reg to
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
)
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
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
)
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 #ifdef ENABLE_CHECKING
154 validate_value_data (vd
);
158 /* Kill the value in register REGNO for NREGS, and any other registers
159 whose values overlap. */
162 kill_value_regno (unsigned int regno
, unsigned int nregs
,
163 struct value_data
*vd
)
167 /* Kill the value we're told to kill. */
168 for (j
= 0; j
< nregs
; ++j
)
169 kill_value_one_regno (regno
+ j
, vd
);
171 /* Kill everything that overlapped what we're told to kill. */
172 if (regno
< vd
->max_value_regs
)
175 j
= regno
- vd
->max_value_regs
;
176 for (; j
< regno
; ++j
)
179 if (vd
->e
[j
].mode
== VOIDmode
)
181 n
= hard_regno_nregs
[j
][vd
->e
[j
].mode
];
183 for (i
= 0; i
< n
; ++i
)
184 kill_value_one_regno (j
+ i
, vd
);
188 /* Kill X. This is a convenience function wrapping kill_value_regno
189 so that we mind the mode the register is in. */
192 kill_value (const_rtx x
, struct value_data
*vd
)
194 if (GET_CODE (x
) == SUBREG
)
196 rtx tmp
= simplify_subreg (GET_MODE (x
), SUBREG_REG (x
),
197 GET_MODE (SUBREG_REG (x
)), SUBREG_BYTE (x
));
198 x
= tmp
? tmp
: SUBREG_REG (x
);
201 kill_value_regno (REGNO (x
), REG_NREGS (x
), vd
);
204 /* Remember that REGNO is valid in MODE. */
207 set_value_regno (unsigned int regno
, machine_mode mode
,
208 struct value_data
*vd
)
212 vd
->e
[regno
].mode
= mode
;
214 nregs
= hard_regno_nregs
[regno
][mode
];
215 if (nregs
> vd
->max_value_regs
)
216 vd
->max_value_regs
= nregs
;
219 /* Initialize VD such that there are no known relationships between regs. */
222 init_value_data (struct value_data
*vd
)
225 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
227 vd
->e
[i
].mode
= VOIDmode
;
228 vd
->e
[i
].oldest_regno
= i
;
229 vd
->e
[i
].next_regno
= INVALID_REGNUM
;
230 vd
->e
[i
].debug_insn_changes
= NULL
;
232 vd
->max_value_regs
= 0;
233 vd
->n_debug_insn_changes
= 0;
236 /* Called through note_stores. If X is clobbered, kill its value. */
239 kill_clobbered_value (rtx x
, const_rtx set
, void *data
)
241 struct value_data
*const vd
= (struct value_data
*) data
;
242 if (GET_CODE (set
) == CLOBBER
)
246 /* A structure passed as data to kill_set_value through note_stores. */
247 struct kill_set_value_data
249 struct value_data
*vd
;
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. */
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
))
262 if (GET_CODE (set
) != CLOBBER
)
264 kill_value (x
, ksvd
->vd
);
266 set_value_regno (REGNO (x
), GET_MODE (x
), ksvd
->vd
);
270 /* Kill any register used in X as the base of an auto-increment expression,
271 and install that register as the root of its own value list. */
274 kill_autoinc_value (rtx_insn
*insn
, struct value_data
*vd
)
276 subrtx_iterator::array_type array
;
277 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), NONCONST
)
280 if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_AUTOINC
)
284 set_value_regno (REGNO (x
), GET_MODE (x
), vd
);
285 iter
.skip_subrtxes ();
290 /* Assert that SRC has been copied to DEST. Adjust the data structures
291 to reflect that SRC contains an older copy of the shared value. */
294 copy_value (rtx dest
, rtx src
, struct value_data
*vd
)
296 unsigned int dr
= REGNO (dest
);
297 unsigned int sr
= REGNO (src
);
301 /* ??? At present, it's possible to see noop sets. It'd be nice if
302 this were cleaned up beforehand... */
306 /* Do not propagate copies to the stack pointer, as that can leave
307 memory accesses with no scheduling dependency on the stack update. */
308 if (dr
== STACK_POINTER_REGNUM
)
311 /* Likewise with the frame pointer, if we're using one. */
312 if (frame_pointer_needed
&& dr
== HARD_FRAME_POINTER_REGNUM
)
315 /* Do not propagate copies to fixed or global registers, patterns
316 can be relying to see particular fixed register or users can
317 expect the chosen global register in asm. */
318 if (fixed_regs
[dr
] || global_regs
[dr
])
321 /* If SRC and DEST overlap, don't record anything. */
322 dn
= REG_NREGS (dest
);
323 sn
= REG_NREGS (src
);
324 if ((dr
> sr
&& dr
< sr
+ sn
)
325 || (sr
> dr
&& sr
< dr
+ dn
))
328 /* If SRC had no assigned mode (i.e. we didn't know it was live)
329 assign it now and assume the value came from an input argument
331 if (vd
->e
[sr
].mode
== VOIDmode
)
332 set_value_regno (sr
, vd
->e
[dr
].mode
, vd
);
334 /* If we are narrowing the input to a smaller number of hard regs,
335 and it is in big endian, we are really extracting a high part.
336 Since we generally associate a low part of a value with the value itself,
337 we must not do the same for the high part.
338 Note we can still get low parts for the same mode combination through
339 a two-step copy involving differently sized hard regs.
340 Assume hard regs fr* are 32 bits each, while r* are 64 bits each:
341 (set (reg:DI r0) (reg:DI fr0))
342 (set (reg:SI fr2) (reg:SI r0))
343 loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
344 (set (reg:SI fr2) (reg:SI fr0))
345 loads the high part of (reg:DI fr0) into fr2.
347 We can't properly represent the latter case in our tables, so don't
348 record anything then. */
349 else if (sn
< (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
]
350 && (GET_MODE_SIZE (vd
->e
[sr
].mode
) > UNITS_PER_WORD
351 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
354 /* If SRC had been assigned a mode narrower than the copy, we can't
355 link DEST into the chain, because not all of the pieces of the
356 copy came from oldest_regno. */
357 else if (sn
> (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
])
360 /* Link DR at the end of the value chain used by SR. */
362 vd
->e
[dr
].oldest_regno
= vd
->e
[sr
].oldest_regno
;
364 for (i
= sr
; vd
->e
[i
].next_regno
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
366 vd
->e
[i
].next_regno
= dr
;
368 #ifdef ENABLE_CHECKING
369 validate_value_data (vd
);
373 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
376 mode_change_ok (machine_mode orig_mode
, machine_mode new_mode
,
377 unsigned int regno ATTRIBUTE_UNUSED
)
379 if (GET_MODE_SIZE (orig_mode
) < GET_MODE_SIZE (new_mode
))
382 #ifdef CANNOT_CHANGE_MODE_CLASS
383 return !REG_CANNOT_CHANGE_MODE_P (regno
, orig_mode
, new_mode
);
389 /* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
390 was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
392 Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
395 maybe_mode_change (machine_mode orig_mode
, machine_mode copy_mode
,
396 machine_mode new_mode
, unsigned int regno
,
397 unsigned int copy_regno ATTRIBUTE_UNUSED
)
399 if (GET_MODE_SIZE (copy_mode
) < GET_MODE_SIZE (orig_mode
)
400 && GET_MODE_SIZE (copy_mode
) < GET_MODE_SIZE (new_mode
))
403 if (orig_mode
== new_mode
)
404 return gen_raw_REG (new_mode
, regno
);
405 else if (mode_change_ok (orig_mode
, new_mode
, regno
))
407 int copy_nregs
= hard_regno_nregs
[copy_regno
][copy_mode
];
408 int use_nregs
= hard_regno_nregs
[copy_regno
][new_mode
];
410 = GET_MODE_SIZE (copy_mode
) / copy_nregs
* (copy_nregs
- use_nregs
);
412 = GET_MODE_SIZE (orig_mode
) - GET_MODE_SIZE (new_mode
) - copy_offset
;
413 int byteoffset
= offset
% UNITS_PER_WORD
;
414 int wordoffset
= offset
- byteoffset
;
416 offset
= ((WORDS_BIG_ENDIAN
? wordoffset
: 0)
417 + (BYTES_BIG_ENDIAN
? byteoffset
: 0));
418 regno
+= subreg_regno_offset (regno
, orig_mode
, offset
, new_mode
);
419 if (HARD_REGNO_MODE_OK (regno
, new_mode
))
420 return gen_raw_REG (new_mode
, regno
);
425 /* Find the oldest copy of the value contained in REGNO that is in
426 register class CL and has mode MODE. If found, return an rtx
427 of that oldest register, otherwise return NULL. */
430 find_oldest_value_reg (enum reg_class cl
, rtx reg
, struct value_data
*vd
)
432 unsigned int regno
= REGNO (reg
);
433 machine_mode mode
= GET_MODE (reg
);
436 /* If we are accessing REG in some mode other that what we set it in,
437 make sure that the replacement is valid. In particular, consider
438 (set (reg:DI r11) (...))
439 (set (reg:SI r9) (reg:SI r11))
440 (set (reg:SI r10) (...))
441 (set (...) (reg:DI r9))
442 Replacing r9 with r11 is invalid. */
443 if (mode
!= vd
->e
[regno
].mode
)
445 if (hard_regno_nregs
[regno
][mode
]
446 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
450 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
; i
= vd
->e
[i
].next_regno
)
452 machine_mode oldmode
= vd
->e
[i
].mode
;
455 if (!in_hard_reg_set_p (reg_class_contents
[cl
], mode
, i
))
458 new_rtx
= maybe_mode_change (oldmode
, vd
->e
[regno
].mode
, mode
, i
, regno
);
461 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (reg
);
462 REG_ATTRS (new_rtx
) = REG_ATTRS (reg
);
463 REG_POINTER (new_rtx
) = REG_POINTER (reg
);
471 /* If possible, replace the register at *LOC with the oldest register
472 in register class CL. Return true if successfully replaced. */
475 replace_oldest_value_reg (rtx
*loc
, enum reg_class cl
, rtx_insn
*insn
,
476 struct value_data
*vd
)
478 rtx new_rtx
= find_oldest_value_reg (cl
, *loc
, vd
);
479 if (new_rtx
&& (!DEBUG_INSN_P (insn
) || !skip_debug_insn_p
))
481 if (DEBUG_INSN_P (insn
))
483 struct queued_debug_insn_change
*change
;
486 fprintf (dump_file
, "debug_insn %u: queued replacing reg %u with %u\n",
487 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
489 change
= queued_debug_insn_change_pool
.allocate ();
490 change
->next
= vd
->e
[REGNO (new_rtx
)].debug_insn_changes
;
493 change
->new_rtx
= new_rtx
;
494 vd
->e
[REGNO (new_rtx
)].debug_insn_changes
= change
;
495 ++vd
->n_debug_insn_changes
;
499 fprintf (dump_file
, "insn %u: replaced reg %u with %u\n",
500 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
502 validate_change (insn
, loc
, new_rtx
, 1);
508 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
509 Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
510 BASE_REG_CLASS depending on how the register is being considered. */
513 replace_oldest_value_addr (rtx
*loc
, enum reg_class cl
,
514 machine_mode mode
, addr_space_t as
,
515 rtx_insn
*insn
, struct value_data
*vd
)
518 RTX_CODE code
= GET_CODE (x
);
521 bool changed
= false;
526 if (DEBUG_INSN_P (insn
))
530 rtx orig_op0
= XEXP (x
, 0);
531 rtx orig_op1
= XEXP (x
, 1);
532 RTX_CODE code0
= GET_CODE (orig_op0
);
533 RTX_CODE code1
= GET_CODE (orig_op1
);
538 enum rtx_code index_code
= SCRATCH
;
540 if (GET_CODE (op0
) == SUBREG
)
542 op0
= SUBREG_REG (op0
);
543 code0
= GET_CODE (op0
);
546 if (GET_CODE (op1
) == SUBREG
)
548 op1
= SUBREG_REG (op1
);
549 code1
= GET_CODE (op1
);
552 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
553 || code0
== ZERO_EXTEND
|| code1
== MEM
)
557 index_code
= GET_CODE (*locI
);
559 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
560 || code1
== ZERO_EXTEND
|| code0
== MEM
)
564 index_code
= GET_CODE (*locI
);
566 else if (code0
== CONST_INT
|| code0
== CONST
567 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
570 index_code
= GET_CODE (XEXP (x
, 0));
572 else if (code1
== CONST_INT
|| code1
== CONST
573 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
576 index_code
= GET_CODE (XEXP (x
, 1));
578 else if (code0
== REG
&& code1
== REG
)
581 unsigned regno0
= REGNO (op0
), regno1
= REGNO (op1
);
583 if (REGNO_OK_FOR_INDEX_P (regno1
)
584 && regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
))
586 else if (REGNO_OK_FOR_INDEX_P (regno0
)
587 && regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
589 else if (regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
)
590 || REGNO_OK_FOR_INDEX_P (regno1
))
592 else if (regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
597 locI
= &XEXP (x
, index_op
);
598 locB
= &XEXP (x
, !index_op
);
599 index_code
= GET_CODE (*locI
);
601 else if (code0
== REG
)
605 index_code
= GET_CODE (*locI
);
607 else if (code1
== REG
)
611 index_code
= GET_CODE (*locI
);
615 changed
|= replace_oldest_value_addr (locI
, INDEX_REG_CLASS
,
618 changed
|= replace_oldest_value_addr (locB
,
619 base_reg_class (mode
, as
, PLUS
,
634 return replace_oldest_value_mem (x
, insn
, vd
);
637 return replace_oldest_value_reg (loc
, cl
, insn
, vd
);
643 fmt
= GET_RTX_FORMAT (code
);
644 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
647 changed
|= replace_oldest_value_addr (&XEXP (x
, i
), cl
, mode
, as
,
649 else if (fmt
[i
] == 'E')
650 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
651 changed
|= replace_oldest_value_addr (&XVECEXP (x
, i
, j
), cl
,
658 /* Similar to replace_oldest_value_reg, but X contains a memory. */
661 replace_oldest_value_mem (rtx x
, rtx_insn
*insn
, struct value_data
*vd
)
665 if (DEBUG_INSN_P (insn
))
668 cl
= base_reg_class (GET_MODE (x
), MEM_ADDR_SPACE (x
), MEM
, SCRATCH
);
670 return replace_oldest_value_addr (&XEXP (x
, 0), cl
,
671 GET_MODE (x
), MEM_ADDR_SPACE (x
),
675 /* Apply all queued updates for DEBUG_INSNs that change some reg to
679 apply_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
681 struct queued_debug_insn_change
*change
;
682 rtx_insn
*last_insn
= vd
->e
[regno
].debug_insn_changes
->insn
;
684 for (change
= vd
->e
[regno
].debug_insn_changes
;
686 change
= change
->next
)
688 if (last_insn
!= change
->insn
)
690 apply_change_group ();
691 last_insn
= change
->insn
;
693 validate_change (change
->insn
, change
->loc
, change
->new_rtx
, 1);
695 apply_change_group ();
698 /* Called via note_uses, for all used registers in a real insn
699 apply DEBUG_INSN changes that change registers to the used
703 cprop_find_used_regs (rtx
*loc
, void *data
)
705 struct value_data
*const vd
= (struct value_data
*) data
;
706 subrtx_iterator::array_type array
;
707 FOR_EACH_SUBRTX (iter
, array
, *loc
, NONCONST
)
712 unsigned int regno
= REGNO (x
);
713 if (vd
->e
[regno
].debug_insn_changes
)
715 apply_debug_insn_changes (vd
, regno
);
716 free_debug_insn_changes (vd
, regno
);
722 /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD. */
725 kill_clobbered_values (rtx_insn
*insn
, struct value_data
*vd
)
727 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
733 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
735 rtx x
= XEXP (exp
, 0);
736 if (GET_CODE (x
) == CLOBBER
)
737 kill_value (SET_DEST (x
), vd
);
742 /* Perform the forward copy propagation on basic block BB. */
745 copyprop_hardreg_forward_1 (basic_block bb
, struct value_data
*vd
)
747 bool anything_changed
= false;
750 for (insn
= BB_HEAD (bb
); ; insn
= NEXT_INSN (insn
))
752 int n_ops
, i
, predicated
;
753 bool is_asm
, any_replacements
;
756 bool replaced
[MAX_RECOG_OPERANDS
];
757 bool changed
= false;
758 struct kill_set_value_data ksvd
;
760 if (!NONDEBUG_INSN_P (insn
))
762 if (DEBUG_INSN_P (insn
))
764 rtx loc
= INSN_VAR_LOCATION_LOC (insn
);
765 if (!VAR_LOC_UNKNOWN_P (loc
))
766 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn
),
767 ALL_REGS
, GET_MODE (loc
),
768 ADDR_SPACE_GENERIC
, insn
, vd
);
771 if (insn
== BB_END (bb
))
777 set
= single_set (insn
);
778 extract_constrain_insn (insn
);
779 preprocess_constraints (insn
);
780 const operand_alternative
*op_alt
= which_op_alt ();
781 n_ops
= recog_data
.n_operands
;
782 is_asm
= asm_noperands (PATTERN (insn
)) >= 0;
784 /* Simplify the code below by promoting OP_OUT to OP_INOUT
785 in predicated instructions. */
787 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
788 for (i
= 0; i
< n_ops
; ++i
)
790 int matches
= op_alt
[i
].matches
;
791 if (matches
>= 0 || op_alt
[i
].matched
>= 0
792 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
793 recog_data
.operand_type
[i
] = OP_INOUT
;
796 /* Apply changes to earlier DEBUG_INSNs if possible. */
797 if (vd
->n_debug_insn_changes
)
798 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
800 /* For each earlyclobber operand, zap the value data. */
801 for (i
= 0; i
< n_ops
; i
++)
802 if (op_alt
[i
].earlyclobber
)
803 kill_value (recog_data
.operand
[i
], vd
);
805 /* Within asms, a clobber cannot overlap inputs or outputs.
806 I wouldn't think this were true for regular insns, but
807 scan_rtx treats them like that... */
808 kill_clobbered_values (insn
, vd
);
810 /* Kill all auto-incremented values. */
811 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
812 kill_autoinc_value (insn
, vd
);
814 /* Kill all early-clobbered operands. */
815 for (i
= 0; i
< n_ops
; i
++)
816 if (op_alt
[i
].earlyclobber
)
817 kill_value (recog_data
.operand
[i
], vd
);
819 /* If we have dead sets in the insn, then we need to note these as we
821 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
823 if (REG_NOTE_KIND (link
) == REG_UNUSED
)
825 kill_value (XEXP (link
, 0), vd
);
826 /* Furthermore, if the insn looked like a single-set,
827 but the dead store kills the source value of that
828 set, then we can no-longer use the plain move
829 special case below. */
831 && reg_overlap_mentioned_p (XEXP (link
, 0), SET_SRC (set
)))
836 /* Special-case plain move instructions, since we may well
837 be able to do the move from a different register class. */
838 if (set
&& REG_P (SET_SRC (set
)))
840 rtx src
= SET_SRC (set
);
841 unsigned int regno
= REGNO (src
);
842 machine_mode mode
= GET_MODE (src
);
846 /* If we are accessing SRC in some mode other that what we
847 set it in, make sure that the replacement is valid. */
848 if (mode
!= vd
->e
[regno
].mode
)
850 if (hard_regno_nregs
[regno
][mode
]
851 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
852 goto no_move_special_case
;
854 /* And likewise, if we are narrowing on big endian the transformation
856 if (hard_regno_nregs
[regno
][mode
]
857 < hard_regno_nregs
[regno
][vd
->e
[regno
].mode
]
858 && (GET_MODE_SIZE (vd
->e
[regno
].mode
) > UNITS_PER_WORD
859 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
860 goto no_move_special_case
;
863 /* If the destination is also a register, try to find a source
864 register in the same class. */
865 if (REG_P (SET_DEST (set
)))
867 new_rtx
= find_oldest_value_reg (REGNO_REG_CLASS (regno
), src
, vd
);
868 if (new_rtx
&& validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
872 "insn %u: replaced reg %u with %u\n",
873 INSN_UID (insn
), regno
, REGNO (new_rtx
));
875 goto did_replacement
;
877 /* We need to re-extract as validate_change clobbers
879 extract_constrain_insn (insn
);
880 preprocess_constraints (insn
);
883 /* Otherwise, try all valid registers and see if its valid. */
884 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
;
885 i
= vd
->e
[i
].next_regno
)
887 new_rtx
= maybe_mode_change (vd
->e
[i
].mode
, vd
->e
[regno
].mode
,
889 if (new_rtx
!= NULL_RTX
)
891 if (validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
893 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (src
);
894 REG_ATTRS (new_rtx
) = REG_ATTRS (src
);
895 REG_POINTER (new_rtx
) = REG_POINTER (src
);
898 "insn %u: replaced reg %u with %u\n",
899 INSN_UID (insn
), regno
, REGNO (new_rtx
));
901 goto did_replacement
;
903 /* We need to re-extract as validate_change clobbers
905 extract_constrain_insn (insn
);
906 preprocess_constraints (insn
);
910 no_move_special_case
:
912 any_replacements
= false;
914 /* For each input operand, replace a hard register with the
915 eldest live copy that's in an appropriate register class. */
916 for (i
= 0; i
< n_ops
; i
++)
920 /* Don't scan match_operand here, since we've no reg class
921 information to pass down. Any operands that we could
922 substitute in will be represented elsewhere. */
923 if (recog_data
.constraints
[i
][0] == '\0')
926 /* Don't replace in asms intentionally referencing hard regs. */
927 if (is_asm
&& REG_P (recog_data
.operand
[i
])
928 && (REGNO (recog_data
.operand
[i
])
929 == ORIGINAL_REGNO (recog_data
.operand
[i
])))
932 if (recog_data
.operand_type
[i
] == OP_IN
)
934 if (op_alt
[i
].is_address
)
936 = replace_oldest_value_addr (recog_data
.operand_loc
[i
],
937 alternative_class (op_alt
, i
),
938 VOIDmode
, ADDR_SPACE_GENERIC
,
940 else if (REG_P (recog_data
.operand
[i
]))
942 = replace_oldest_value_reg (recog_data
.operand_loc
[i
],
943 alternative_class (op_alt
, i
),
945 else if (MEM_P (recog_data
.operand
[i
]))
946 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
949 else if (MEM_P (recog_data
.operand
[i
]))
950 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
953 /* If we performed any replacement, update match_dups. */
959 new_rtx
= *recog_data
.operand_loc
[i
];
960 recog_data
.operand
[i
] = new_rtx
;
961 for (j
= 0; j
< recog_data
.n_dups
; j
++)
962 if (recog_data
.dup_num
[j
] == i
)
963 validate_unshare_change (insn
, recog_data
.dup_loc
[j
], new_rtx
, 1);
965 any_replacements
= true;
969 if (any_replacements
)
971 if (! apply_change_group ())
973 for (i
= 0; i
< n_ops
; i
++)
976 rtx old
= *recog_data
.operand_loc
[i
];
977 recog_data
.operand
[i
] = old
;
982 "insn %u: reg replacements not verified\n",
992 anything_changed
= true;
994 /* If something changed, perhaps further changes to earlier
995 DEBUG_INSNs can be applied. */
996 if (vd
->n_debug_insn_changes
)
997 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
1001 ksvd
.ignore_set_reg
= NULL_RTX
;
1003 /* Clobber call-clobbered registers. */
1006 unsigned int set_regno
= INVALID_REGNUM
;
1007 unsigned int set_nregs
= 0;
1010 HARD_REG_SET regs_invalidated_by_this_call
;
1012 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
1014 rtx x
= XEXP (exp
, 0);
1015 if (GET_CODE (x
) == SET
)
1017 rtx dest
= SET_DEST (x
);
1018 kill_value (dest
, vd
);
1019 set_value_regno (REGNO (dest
), GET_MODE (dest
), vd
);
1020 copy_value (dest
, SET_SRC (x
), vd
);
1021 ksvd
.ignore_set_reg
= dest
;
1022 set_regno
= REGNO (dest
);
1023 set_nregs
= REG_NREGS (dest
);
1028 get_call_reg_set_usage (insn
,
1029 ®s_invalidated_by_this_call
,
1030 regs_invalidated_by_call
);
1031 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1032 if ((TEST_HARD_REG_BIT (regs_invalidated_by_this_call
, regno
)
1033 || HARD_REGNO_CALL_PART_CLOBBERED (regno
, vd
->e
[regno
].mode
))
1034 && (regno
< set_regno
|| regno
>= set_regno
+ set_nregs
))
1035 kill_value_regno (regno
, 1, vd
);
1037 /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
1038 of the SET isn't in regs_invalidated_by_call hard reg set,
1039 but instead among CLOBBERs on the CALL_INSN, we could wrongly
1040 assume the value in it is still live. */
1041 if (ksvd
.ignore_set_reg
)
1042 kill_clobbered_values (insn
, vd
);
1046 && REG_P (SET_DEST (set
))
1047 && REG_P (SET_SRC (set
)));
1048 bool noop_p
= (copy_p
1049 && rtx_equal_p (SET_DEST (set
), SET_SRC (set
)));
1053 /* Notice stores. */
1054 note_stores (PATTERN (insn
), kill_set_value
, &ksvd
);
1056 /* Notice copies. */
1058 copy_value (SET_DEST (set
), SET_SRC (set
), vd
);
1061 if (insn
== BB_END (bb
))
1065 return anything_changed
;
1068 /* Dump the value chain data to stderr. */
1071 debug_value_data (struct value_data
*vd
)
1076 CLEAR_HARD_REG_SET (set
);
1078 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1079 if (vd
->e
[i
].oldest_regno
== i
)
1081 if (vd
->e
[i
].mode
== VOIDmode
)
1083 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1084 fprintf (stderr
, "[%u] Bad next_regno for empty chain (%u)\n",
1085 i
, vd
->e
[i
].next_regno
);
1089 SET_HARD_REG_BIT (set
, i
);
1090 fprintf (stderr
, "[%u %s] ", i
, GET_MODE_NAME (vd
->e
[i
].mode
));
1092 for (j
= vd
->e
[i
].next_regno
;
1093 j
!= INVALID_REGNUM
;
1094 j
= vd
->e
[j
].next_regno
)
1096 if (TEST_HARD_REG_BIT (set
, j
))
1098 fprintf (stderr
, "[%u] Loop in regno chain\n", j
);
1102 if (vd
->e
[j
].oldest_regno
!= i
)
1104 fprintf (stderr
, "[%u] Bad oldest_regno (%u)\n",
1105 j
, vd
->e
[j
].oldest_regno
);
1108 SET_HARD_REG_BIT (set
, j
);
1109 fprintf (stderr
, "[%u %s] ", j
, GET_MODE_NAME (vd
->e
[j
].mode
));
1111 fputc ('\n', stderr
);
1114 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1115 if (! TEST_HARD_REG_BIT (set
, i
)
1116 && (vd
->e
[i
].mode
!= VOIDmode
1117 || vd
->e
[i
].oldest_regno
!= i
1118 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1119 fprintf (stderr
, "[%u] Non-empty reg in chain (%s %u %i)\n",
1120 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1121 vd
->e
[i
].next_regno
);
1124 /* Do copyprop_hardreg_forward_1 for a single basic block BB.
1125 DEBUG_INSN is skipped since we do not want to involve DF related
1126 staff as how it is handled in function pass_cprop_hardreg::execute.
1128 NOTE: Currently it is only used for shrink-wrap. Maybe extend it
1129 to handle DEBUG_INSN for other uses. */
1132 copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb
)
1134 struct value_data
*vd
;
1135 vd
= XNEWVEC (struct value_data
, 1);
1136 init_value_data (vd
);
1138 skip_debug_insn_p
= true;
1139 copyprop_hardreg_forward_1 (bb
, vd
);
1141 skip_debug_insn_p
= false;
1144 #ifdef ENABLE_CHECKING
1146 validate_value_data (struct value_data
*vd
)
1151 CLEAR_HARD_REG_SET (set
);
1153 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1154 if (vd
->e
[i
].oldest_regno
== i
)
1156 if (vd
->e
[i
].mode
== VOIDmode
)
1158 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1159 internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1160 i
, vd
->e
[i
].next_regno
);
1164 SET_HARD_REG_BIT (set
, i
);
1166 for (j
= vd
->e
[i
].next_regno
;
1167 j
!= INVALID_REGNUM
;
1168 j
= vd
->e
[j
].next_regno
)
1170 if (TEST_HARD_REG_BIT (set
, j
))
1171 internal_error ("validate_value_data: Loop in regno chain (%u)",
1173 if (vd
->e
[j
].oldest_regno
!= i
)
1174 internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1175 j
, vd
->e
[j
].oldest_regno
);
1177 SET_HARD_REG_BIT (set
, j
);
1181 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1182 if (! TEST_HARD_REG_BIT (set
, i
)
1183 && (vd
->e
[i
].mode
!= VOIDmode
1184 || vd
->e
[i
].oldest_regno
!= i
1185 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1186 internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1187 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1188 vd
->e
[i
].next_regno
);
1194 const pass_data pass_data_cprop_hardreg
=
1196 RTL_PASS
, /* type */
1197 "cprop_hardreg", /* name */
1198 OPTGROUP_NONE
, /* optinfo_flags */
1199 TV_CPROP_REGISTERS
, /* tv_id */
1200 0, /* properties_required */
1201 0, /* properties_provided */
1202 0, /* properties_destroyed */
1203 0, /* todo_flags_start */
1204 TODO_df_finish
, /* todo_flags_finish */
1207 class pass_cprop_hardreg
: public rtl_opt_pass
1210 pass_cprop_hardreg (gcc::context
*ctxt
)
1211 : rtl_opt_pass (pass_data_cprop_hardreg
, ctxt
)
1214 /* opt_pass methods: */
1215 virtual bool gate (function
*)
1217 return (optimize
> 0 && (flag_cprop_registers
));
1220 virtual unsigned int execute (function
*);
1222 }; // class pass_cprop_hardreg
1225 pass_cprop_hardreg::execute (function
*fun
)
1227 struct value_data
*all_vd
;
1230 bool analyze_called
= false;
1232 all_vd
= XNEWVEC (struct value_data
, last_basic_block_for_fn (fun
));
1234 visited
= sbitmap_alloc (last_basic_block_for_fn (fun
));
1235 bitmap_clear (visited
);
1237 FOR_EACH_BB_FN (bb
, fun
)
1239 bitmap_set_bit (visited
, bb
->index
);
1241 /* If a block has a single predecessor, that we've already
1242 processed, begin with the value data that was live at
1243 the end of the predecessor block. */
1244 /* ??? Ought to use more intelligent queuing of blocks. */
1245 if (single_pred_p (bb
)
1246 && bitmap_bit_p (visited
, single_pred (bb
)->index
)
1247 && ! (single_pred_edge (bb
)->flags
& (EDGE_ABNORMAL_CALL
| EDGE_EH
)))
1249 all_vd
[bb
->index
] = all_vd
[single_pred (bb
)->index
];
1250 if (all_vd
[bb
->index
].n_debug_insn_changes
)
1254 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1256 if (all_vd
[bb
->index
].e
[regno
].debug_insn_changes
)
1258 all_vd
[bb
->index
].e
[regno
].debug_insn_changes
= NULL
;
1259 if (--all_vd
[bb
->index
].n_debug_insn_changes
== 0)
1266 init_value_data (all_vd
+ bb
->index
);
1268 copyprop_hardreg_forward_1 (bb
, all_vd
+ bb
->index
);
1271 if (MAY_HAVE_DEBUG_INSNS
)
1273 FOR_EACH_BB_FN (bb
, fun
)
1274 if (bitmap_bit_p (visited
, bb
->index
)
1275 && all_vd
[bb
->index
].n_debug_insn_changes
)
1280 if (!analyze_called
)
1283 analyze_called
= true;
1285 live
= df_get_live_out (bb
);
1286 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1287 if (all_vd
[bb
->index
].e
[regno
].debug_insn_changes
)
1289 if (REGNO_REG_SET_P (live
, regno
))
1290 apply_debug_insn_changes (all_vd
+ bb
->index
, regno
);
1291 if (all_vd
[bb
->index
].n_debug_insn_changes
== 0)
1296 queued_debug_insn_change_pool
.release ();
1299 sbitmap_free (visited
);
1307 make_pass_cprop_hardreg (gcc::context
*ctxt
)
1309 return new pass_cprop_hardreg (ctxt
);