1 /* Copy propagation on hard registers for the GNU compiler.
2 Copyright (C) 2000-2016 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"
31 #include "diagnostic-core.h"
32 #include "addresses.h"
33 #include "tree-pass.h"
37 /* The following code does forward propagation of hard register copies.
38 The object is to eliminate as many dependencies as possible, so that
39 we have the most scheduling freedom. As a side effect, we also clean
40 up some silly register allocation decisions made by reload. This
41 code may be obsoleted by a new register allocator. */
43 /* DEBUG_INSNs aren't changed right away, as doing so might extend the
44 lifetime of a register and get the DEBUG_INSN subsequently reset.
45 So they are queued instead, and updated only when the register is
46 used in some subsequent real insn before it is set. */
47 struct queued_debug_insn_change
49 struct queued_debug_insn_change
*next
;
55 /* For each register, we have a list of registers that contain the same
56 value. The OLDEST_REGNO field points to the head of the list, and
57 the NEXT_REGNO field runs through the list. The MODE field indicates
58 what mode the data is known to be in; this field is VOIDmode when the
59 register is not known to contain valid data. */
61 struct value_data_entry
64 unsigned int oldest_regno
;
65 unsigned int next_regno
;
66 struct queued_debug_insn_change
*debug_insn_changes
;
71 struct value_data_entry e
[FIRST_PSEUDO_REGISTER
];
72 unsigned int max_value_regs
;
73 unsigned int n_debug_insn_changes
;
76 static object_allocator
<queued_debug_insn_change
> queued_debug_insn_change_pool
77 ("debug insn changes pool");
79 static bool skip_debug_insn_p
;
81 static void kill_value_one_regno (unsigned, struct value_data
*);
82 static void kill_value_regno (unsigned, unsigned, struct value_data
*);
83 static void kill_value (const_rtx
, struct value_data
*);
84 static void set_value_regno (unsigned, machine_mode
, struct value_data
*);
85 static void init_value_data (struct value_data
*);
86 static void kill_clobbered_value (rtx
, const_rtx
, void *);
87 static void kill_set_value (rtx
, const_rtx
, void *);
88 static void copy_value (rtx
, rtx
, struct value_data
*);
89 static bool mode_change_ok (machine_mode
, machine_mode
,
91 static rtx
maybe_mode_change (machine_mode
, machine_mode
,
92 machine_mode
, unsigned int, unsigned int);
93 static rtx
find_oldest_value_reg (enum reg_class
, rtx
, struct value_data
*);
94 static bool replace_oldest_value_reg (rtx
*, enum reg_class
, rtx_insn
*,
96 static bool replace_oldest_value_addr (rtx
*, enum reg_class
,
97 machine_mode
, addr_space_t
,
98 rtx_insn
*, struct value_data
*);
99 static bool replace_oldest_value_mem (rtx
, rtx_insn
*, struct value_data
*);
100 static bool copyprop_hardreg_forward_1 (basic_block
, struct value_data
*);
101 extern void debug_value_data (struct value_data
*);
102 static void validate_value_data (struct value_data
*);
104 /* Free all queued updates for DEBUG_INSNs that change some reg to
108 free_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
110 struct queued_debug_insn_change
*cur
, *next
;
111 for (cur
= vd
->e
[regno
].debug_insn_changes
; cur
; cur
= next
)
114 --vd
->n_debug_insn_changes
;
115 queued_debug_insn_change_pool
.remove (cur
);
117 vd
->e
[regno
].debug_insn_changes
= NULL
;
120 /* Kill register REGNO. This involves removing it from any value
121 lists, and resetting the value mode to VOIDmode. This is only a
122 helper function; it does not handle any hard registers overlapping
126 kill_value_one_regno (unsigned int regno
, struct value_data
*vd
)
128 unsigned int i
, next
;
130 if (vd
->e
[regno
].oldest_regno
!= regno
)
132 for (i
= vd
->e
[regno
].oldest_regno
;
133 vd
->e
[i
].next_regno
!= regno
;
134 i
= vd
->e
[i
].next_regno
)
136 vd
->e
[i
].next_regno
= vd
->e
[regno
].next_regno
;
138 else if ((next
= vd
->e
[regno
].next_regno
) != INVALID_REGNUM
)
140 for (i
= next
; i
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
141 vd
->e
[i
].oldest_regno
= next
;
144 vd
->e
[regno
].mode
= VOIDmode
;
145 vd
->e
[regno
].oldest_regno
= regno
;
146 vd
->e
[regno
].next_regno
= INVALID_REGNUM
;
147 if (vd
->e
[regno
].debug_insn_changes
)
148 free_debug_insn_changes (vd
, regno
);
151 validate_value_data (vd
);
154 /* Kill the value in register REGNO for NREGS, and any other registers
155 whose values overlap. */
158 kill_value_regno (unsigned int regno
, unsigned int nregs
,
159 struct value_data
*vd
)
163 /* Kill the value we're told to kill. */
164 for (j
= 0; j
< nregs
; ++j
)
165 kill_value_one_regno (regno
+ j
, vd
);
167 /* Kill everything that overlapped what we're told to kill. */
168 if (regno
< vd
->max_value_regs
)
171 j
= regno
- vd
->max_value_regs
;
172 for (; j
< regno
; ++j
)
175 if (vd
->e
[j
].mode
== VOIDmode
)
177 n
= hard_regno_nregs
[j
][vd
->e
[j
].mode
];
179 for (i
= 0; i
< n
; ++i
)
180 kill_value_one_regno (j
+ i
, vd
);
184 /* Kill X. This is a convenience function wrapping kill_value_regno
185 so that we mind the mode the register is in. */
188 kill_value (const_rtx x
, struct value_data
*vd
)
190 if (GET_CODE (x
) == SUBREG
)
192 rtx tmp
= simplify_subreg (GET_MODE (x
), SUBREG_REG (x
),
193 GET_MODE (SUBREG_REG (x
)), SUBREG_BYTE (x
));
194 x
= tmp
? tmp
: SUBREG_REG (x
);
197 kill_value_regno (REGNO (x
), REG_NREGS (x
), vd
);
200 /* Remember that REGNO is valid in MODE. */
203 set_value_regno (unsigned int regno
, machine_mode mode
,
204 struct value_data
*vd
)
208 vd
->e
[regno
].mode
= mode
;
210 nregs
= hard_regno_nregs
[regno
][mode
];
211 if (nregs
> vd
->max_value_regs
)
212 vd
->max_value_regs
= nregs
;
215 /* Initialize VD such that there are no known relationships between regs. */
218 init_value_data (struct value_data
*vd
)
221 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
223 vd
->e
[i
].mode
= VOIDmode
;
224 vd
->e
[i
].oldest_regno
= i
;
225 vd
->e
[i
].next_regno
= INVALID_REGNUM
;
226 vd
->e
[i
].debug_insn_changes
= NULL
;
228 vd
->max_value_regs
= 0;
229 vd
->n_debug_insn_changes
= 0;
232 /* Called through note_stores. If X is clobbered, kill its value. */
235 kill_clobbered_value (rtx x
, const_rtx set
, void *data
)
237 struct value_data
*const vd
= (struct value_data
*) data
;
238 if (GET_CODE (set
) == CLOBBER
)
242 /* A structure passed as data to kill_set_value through note_stores. */
243 struct kill_set_value_data
245 struct value_data
*vd
;
249 /* Called through note_stores. If X is set, not clobbered, kill its
250 current value and install it as the root of its own value list. */
253 kill_set_value (rtx x
, const_rtx set
, void *data
)
255 struct kill_set_value_data
*ksvd
= (struct kill_set_value_data
*) data
;
256 if (rtx_equal_p (x
, ksvd
->ignore_set_reg
))
258 if (GET_CODE (set
) != CLOBBER
)
260 kill_value (x
, ksvd
->vd
);
262 set_value_regno (REGNO (x
), GET_MODE (x
), ksvd
->vd
);
266 /* Kill any register used in X as the base of an auto-increment expression,
267 and install that register as the root of its own value list. */
270 kill_autoinc_value (rtx_insn
*insn
, struct value_data
*vd
)
272 subrtx_iterator::array_type array
;
273 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), NONCONST
)
276 if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_AUTOINC
)
280 set_value_regno (REGNO (x
), GET_MODE (x
), vd
);
281 iter
.skip_subrtxes ();
286 /* Assert that SRC has been copied to DEST. Adjust the data structures
287 to reflect that SRC contains an older copy of the shared value. */
290 copy_value (rtx dest
, rtx src
, struct value_data
*vd
)
292 unsigned int dr
= REGNO (dest
);
293 unsigned int sr
= REGNO (src
);
297 /* ??? At present, it's possible to see noop sets. It'd be nice if
298 this were cleaned up beforehand... */
302 /* Do not propagate copies to the stack pointer, as that can leave
303 memory accesses with no scheduling dependency on the stack update. */
304 if (dr
== STACK_POINTER_REGNUM
)
307 /* Likewise with the frame pointer, if we're using one. */
308 if (frame_pointer_needed
&& dr
== HARD_FRAME_POINTER_REGNUM
)
311 /* Do not propagate copies to fixed or global registers, patterns
312 can be relying to see particular fixed register or users can
313 expect the chosen global register in asm. */
314 if (fixed_regs
[dr
] || global_regs
[dr
])
317 /* If SRC and DEST overlap, don't record anything. */
318 dn
= REG_NREGS (dest
);
319 sn
= REG_NREGS (src
);
320 if ((dr
> sr
&& dr
< sr
+ sn
)
321 || (sr
> dr
&& sr
< dr
+ dn
))
324 /* If SRC had no assigned mode (i.e. we didn't know it was live)
325 assign it now and assume the value came from an input argument
327 if (vd
->e
[sr
].mode
== VOIDmode
)
328 set_value_regno (sr
, vd
->e
[dr
].mode
, vd
);
330 /* If we are narrowing the input to a smaller number of hard regs,
331 and it is in big endian, we are really extracting a high part.
332 Since we generally associate a low part of a value with the value itself,
333 we must not do the same for the high part.
334 Note we can still get low parts for the same mode combination through
335 a two-step copy involving differently sized hard regs.
336 Assume hard regs fr* are 32 bits each, while r* are 64 bits each:
337 (set (reg:DI r0) (reg:DI fr0))
338 (set (reg:SI fr2) (reg:SI r0))
339 loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
340 (set (reg:SI fr2) (reg:SI fr0))
341 loads the high part of (reg:DI fr0) into fr2.
343 We can't properly represent the latter case in our tables, so don't
344 record anything then. */
345 else if (sn
< (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
]
346 && (GET_MODE_SIZE (vd
->e
[sr
].mode
) > UNITS_PER_WORD
347 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
350 /* If SRC had been assigned a mode narrower than the copy, we can't
351 link DEST into the chain, because not all of the pieces of the
352 copy came from oldest_regno. */
353 else if (sn
> (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
])
356 /* Link DR at the end of the value chain used by SR. */
358 vd
->e
[dr
].oldest_regno
= vd
->e
[sr
].oldest_regno
;
360 for (i
= sr
; vd
->e
[i
].next_regno
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
362 vd
->e
[i
].next_regno
= dr
;
365 validate_value_data (vd
);
368 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
371 mode_change_ok (machine_mode orig_mode
, machine_mode new_mode
,
372 unsigned int regno ATTRIBUTE_UNUSED
)
374 if (GET_MODE_SIZE (orig_mode
) < GET_MODE_SIZE (new_mode
))
377 #ifdef CANNOT_CHANGE_MODE_CLASS
378 return !REG_CANNOT_CHANGE_MODE_P (regno
, orig_mode
, new_mode
);
384 /* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
385 was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
387 Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
390 maybe_mode_change (machine_mode orig_mode
, machine_mode copy_mode
,
391 machine_mode new_mode
, unsigned int regno
,
392 unsigned int copy_regno ATTRIBUTE_UNUSED
)
394 if (GET_MODE_SIZE (copy_mode
) < GET_MODE_SIZE (orig_mode
)
395 && GET_MODE_SIZE (copy_mode
) < GET_MODE_SIZE (new_mode
))
398 if (orig_mode
== new_mode
)
399 return gen_raw_REG (new_mode
, regno
);
400 else if (mode_change_ok (orig_mode
, new_mode
, regno
))
402 int copy_nregs
= hard_regno_nregs
[copy_regno
][copy_mode
];
403 int use_nregs
= hard_regno_nregs
[copy_regno
][new_mode
];
405 = GET_MODE_SIZE (copy_mode
) / copy_nregs
* (copy_nregs
- use_nregs
);
407 = GET_MODE_SIZE (orig_mode
) - GET_MODE_SIZE (new_mode
) - copy_offset
;
408 int byteoffset
= offset
% UNITS_PER_WORD
;
409 int wordoffset
= offset
- byteoffset
;
411 offset
= ((WORDS_BIG_ENDIAN
? wordoffset
: 0)
412 + (BYTES_BIG_ENDIAN
? byteoffset
: 0));
413 regno
+= subreg_regno_offset (regno
, orig_mode
, offset
, new_mode
);
414 if (HARD_REGNO_MODE_OK (regno
, new_mode
))
415 return gen_raw_REG (new_mode
, regno
);
420 /* Find the oldest copy of the value contained in REGNO that is in
421 register class CL and has mode MODE. If found, return an rtx
422 of that oldest register, otherwise return NULL. */
425 find_oldest_value_reg (enum reg_class cl
, rtx reg
, struct value_data
*vd
)
427 unsigned int regno
= REGNO (reg
);
428 machine_mode mode
= GET_MODE (reg
);
431 /* If we are accessing REG in some mode other that what we set it in,
432 make sure that the replacement is valid. In particular, consider
433 (set (reg:DI r11) (...))
434 (set (reg:SI r9) (reg:SI r11))
435 (set (reg:SI r10) (...))
436 (set (...) (reg:DI r9))
437 Replacing r9 with r11 is invalid. */
438 if (mode
!= vd
->e
[regno
].mode
)
440 if (hard_regno_nregs
[regno
][mode
]
441 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
445 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
; i
= vd
->e
[i
].next_regno
)
447 machine_mode oldmode
= vd
->e
[i
].mode
;
450 if (!in_hard_reg_set_p (reg_class_contents
[cl
], mode
, i
))
453 new_rtx
= maybe_mode_change (oldmode
, vd
->e
[regno
].mode
, mode
, i
, regno
);
456 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (reg
);
457 REG_ATTRS (new_rtx
) = REG_ATTRS (reg
);
458 REG_POINTER (new_rtx
) = REG_POINTER (reg
);
466 /* If possible, replace the register at *LOC with the oldest register
467 in register class CL. Return true if successfully replaced. */
470 replace_oldest_value_reg (rtx
*loc
, enum reg_class cl
, rtx_insn
*insn
,
471 struct value_data
*vd
)
473 rtx new_rtx
= find_oldest_value_reg (cl
, *loc
, vd
);
474 if (new_rtx
&& (!DEBUG_INSN_P (insn
) || !skip_debug_insn_p
))
476 if (DEBUG_INSN_P (insn
))
478 struct queued_debug_insn_change
*change
;
481 fprintf (dump_file
, "debug_insn %u: queued replacing reg %u with %u\n",
482 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
484 change
= queued_debug_insn_change_pool
.allocate ();
485 change
->next
= vd
->e
[REGNO (new_rtx
)].debug_insn_changes
;
488 change
->new_rtx
= new_rtx
;
489 vd
->e
[REGNO (new_rtx
)].debug_insn_changes
= change
;
490 ++vd
->n_debug_insn_changes
;
494 fprintf (dump_file
, "insn %u: replaced reg %u with %u\n",
495 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
497 validate_change (insn
, loc
, new_rtx
, 1);
503 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
504 Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
505 BASE_REG_CLASS depending on how the register is being considered. */
508 replace_oldest_value_addr (rtx
*loc
, enum reg_class cl
,
509 machine_mode mode
, addr_space_t as
,
510 rtx_insn
*insn
, struct value_data
*vd
)
513 RTX_CODE code
= GET_CODE (x
);
516 bool changed
= false;
521 if (DEBUG_INSN_P (insn
))
525 rtx orig_op0
= XEXP (x
, 0);
526 rtx orig_op1
= XEXP (x
, 1);
527 RTX_CODE code0
= GET_CODE (orig_op0
);
528 RTX_CODE code1
= GET_CODE (orig_op1
);
533 enum rtx_code index_code
= SCRATCH
;
535 if (GET_CODE (op0
) == SUBREG
)
537 op0
= SUBREG_REG (op0
);
538 code0
= GET_CODE (op0
);
541 if (GET_CODE (op1
) == SUBREG
)
543 op1
= SUBREG_REG (op1
);
544 code1
= GET_CODE (op1
);
547 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
548 || code0
== ZERO_EXTEND
|| code1
== MEM
)
552 index_code
= GET_CODE (*locI
);
554 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
555 || code1
== ZERO_EXTEND
|| code0
== MEM
)
559 index_code
= GET_CODE (*locI
);
561 else if (code0
== CONST_INT
|| code0
== CONST
562 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
565 index_code
= GET_CODE (XEXP (x
, 0));
567 else if (code1
== CONST_INT
|| code1
== CONST
568 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
571 index_code
= GET_CODE (XEXP (x
, 1));
573 else if (code0
== REG
&& code1
== REG
)
576 unsigned regno0
= REGNO (op0
), regno1
= REGNO (op1
);
578 if (REGNO_OK_FOR_INDEX_P (regno1
)
579 && regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
))
581 else if (REGNO_OK_FOR_INDEX_P (regno0
)
582 && regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
584 else if (regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
)
585 || REGNO_OK_FOR_INDEX_P (regno1
))
587 else if (regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
592 locI
= &XEXP (x
, index_op
);
593 locB
= &XEXP (x
, !index_op
);
594 index_code
= GET_CODE (*locI
);
596 else if (code0
== REG
)
600 index_code
= GET_CODE (*locI
);
602 else if (code1
== REG
)
606 index_code
= GET_CODE (*locI
);
610 changed
|= replace_oldest_value_addr (locI
, INDEX_REG_CLASS
,
613 changed
|= replace_oldest_value_addr (locB
,
614 base_reg_class (mode
, as
, PLUS
,
629 return replace_oldest_value_mem (x
, insn
, vd
);
632 return replace_oldest_value_reg (loc
, cl
, insn
, vd
);
638 fmt
= GET_RTX_FORMAT (code
);
639 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
642 changed
|= replace_oldest_value_addr (&XEXP (x
, i
), cl
, mode
, as
,
644 else if (fmt
[i
] == 'E')
645 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
646 changed
|= replace_oldest_value_addr (&XVECEXP (x
, i
, j
), cl
,
653 /* Similar to replace_oldest_value_reg, but X contains a memory. */
656 replace_oldest_value_mem (rtx x
, rtx_insn
*insn
, struct value_data
*vd
)
660 if (DEBUG_INSN_P (insn
))
663 cl
= base_reg_class (GET_MODE (x
), MEM_ADDR_SPACE (x
), MEM
, SCRATCH
);
665 return replace_oldest_value_addr (&XEXP (x
, 0), cl
,
666 GET_MODE (x
), MEM_ADDR_SPACE (x
),
670 /* Apply all queued updates for DEBUG_INSNs that change some reg to
674 apply_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
676 struct queued_debug_insn_change
*change
;
677 rtx_insn
*last_insn
= vd
->e
[regno
].debug_insn_changes
->insn
;
679 for (change
= vd
->e
[regno
].debug_insn_changes
;
681 change
= change
->next
)
683 if (last_insn
!= change
->insn
)
685 apply_change_group ();
686 last_insn
= change
->insn
;
688 validate_change (change
->insn
, change
->loc
, change
->new_rtx
, 1);
690 apply_change_group ();
693 /* Called via note_uses, for all used registers in a real insn
694 apply DEBUG_INSN changes that change registers to the used
698 cprop_find_used_regs (rtx
*loc
, void *data
)
700 struct value_data
*const vd
= (struct value_data
*) data
;
701 subrtx_iterator::array_type array
;
702 FOR_EACH_SUBRTX (iter
, array
, *loc
, NONCONST
)
707 unsigned int regno
= REGNO (x
);
708 if (vd
->e
[regno
].debug_insn_changes
)
710 apply_debug_insn_changes (vd
, regno
);
711 free_debug_insn_changes (vd
, regno
);
717 /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD. */
720 kill_clobbered_values (rtx_insn
*insn
, struct value_data
*vd
)
722 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
728 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
730 rtx x
= XEXP (exp
, 0);
731 if (GET_CODE (x
) == CLOBBER
)
732 kill_value (SET_DEST (x
), vd
);
737 /* Perform the forward copy propagation on basic block BB. */
740 copyprop_hardreg_forward_1 (basic_block bb
, struct value_data
*vd
)
742 bool anything_changed
= false;
743 rtx_insn
*insn
, *next
;
745 for (insn
= BB_HEAD (bb
); ; insn
= next
)
747 int n_ops
, i
, predicated
;
748 bool is_asm
, any_replacements
;
751 bool replaced
[MAX_RECOG_OPERANDS
];
752 bool changed
= false;
753 struct kill_set_value_data ksvd
;
755 next
= NEXT_INSN (insn
);
756 if (!NONDEBUG_INSN_P (insn
))
758 if (DEBUG_INSN_P (insn
))
760 rtx loc
= INSN_VAR_LOCATION_LOC (insn
);
761 if (!VAR_LOC_UNKNOWN_P (loc
))
762 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn
),
763 ALL_REGS
, GET_MODE (loc
),
764 ADDR_SPACE_GENERIC
, insn
, vd
);
767 if (insn
== BB_END (bb
))
773 set
= single_set (insn
);
775 /* Detect noop sets and remove them before processing side effects. */
776 if (set
&& REG_P (SET_DEST (set
)) && REG_P (SET_SRC (set
)))
778 unsigned int regno
= REGNO (SET_SRC (set
));
779 rtx r1
= find_oldest_value_reg (REGNO_REG_CLASS (regno
),
781 rtx r2
= find_oldest_value_reg (REGNO_REG_CLASS (regno
),
783 if (rtx_equal_p (r1
? r1
: SET_DEST (set
), r2
? r2
: SET_SRC (set
)))
785 bool last
= insn
== BB_END (bb
);
793 extract_constrain_insn (insn
);
794 preprocess_constraints (insn
);
795 const operand_alternative
*op_alt
= which_op_alt ();
796 n_ops
= recog_data
.n_operands
;
797 is_asm
= asm_noperands (PATTERN (insn
)) >= 0;
799 /* Simplify the code below by promoting OP_OUT to OP_INOUT
800 in predicated instructions. */
802 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
803 for (i
= 0; i
< n_ops
; ++i
)
805 int matches
= op_alt
[i
].matches
;
806 if (matches
>= 0 || op_alt
[i
].matched
>= 0
807 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
808 recog_data
.operand_type
[i
] = OP_INOUT
;
811 /* Apply changes to earlier DEBUG_INSNs if possible. */
812 if (vd
->n_debug_insn_changes
)
813 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
815 /* For each earlyclobber operand, zap the value data. */
816 for (i
= 0; i
< n_ops
; i
++)
817 if (op_alt
[i
].earlyclobber
)
818 kill_value (recog_data
.operand
[i
], vd
);
820 /* Within asms, a clobber cannot overlap inputs or outputs.
821 I wouldn't think this were true for regular insns, but
822 scan_rtx treats them like that... */
823 kill_clobbered_values (insn
, vd
);
825 /* Kill all auto-incremented values. */
826 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
827 kill_autoinc_value (insn
, vd
);
829 /* Kill all early-clobbered operands. */
830 for (i
= 0; i
< n_ops
; i
++)
831 if (op_alt
[i
].earlyclobber
)
832 kill_value (recog_data
.operand
[i
], vd
);
834 /* If we have dead sets in the insn, then we need to note these as we
836 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
838 if (REG_NOTE_KIND (link
) == REG_UNUSED
)
840 kill_value (XEXP (link
, 0), vd
);
841 /* Furthermore, if the insn looked like a single-set,
842 but the dead store kills the source value of that
843 set, then we can no-longer use the plain move
844 special case below. */
846 && reg_overlap_mentioned_p (XEXP (link
, 0), SET_SRC (set
)))
851 /* Special-case plain move instructions, since we may well
852 be able to do the move from a different register class. */
853 if (set
&& REG_P (SET_SRC (set
)))
855 rtx src
= SET_SRC (set
);
856 unsigned int regno
= REGNO (src
);
857 machine_mode mode
= GET_MODE (src
);
861 /* If we are accessing SRC in some mode other that what we
862 set it in, make sure that the replacement is valid. */
863 if (mode
!= vd
->e
[regno
].mode
)
865 if (hard_regno_nregs
[regno
][mode
]
866 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
867 goto no_move_special_case
;
869 /* And likewise, if we are narrowing on big endian the transformation
871 if (hard_regno_nregs
[regno
][mode
]
872 < hard_regno_nregs
[regno
][vd
->e
[regno
].mode
]
873 && (GET_MODE_SIZE (vd
->e
[regno
].mode
) > UNITS_PER_WORD
874 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
875 goto no_move_special_case
;
878 /* If the destination is also a register, try to find a source
879 register in the same class. */
880 if (REG_P (SET_DEST (set
)))
882 new_rtx
= find_oldest_value_reg (REGNO_REG_CLASS (regno
),
885 if (new_rtx
&& validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
889 "insn %u: replaced reg %u with %u\n",
890 INSN_UID (insn
), regno
, REGNO (new_rtx
));
892 goto did_replacement
;
894 /* We need to re-extract as validate_change clobbers
896 extract_constrain_insn (insn
);
897 preprocess_constraints (insn
);
900 /* Otherwise, try all valid registers and see if its valid. */
901 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
;
902 i
= vd
->e
[i
].next_regno
)
904 new_rtx
= maybe_mode_change (vd
->e
[i
].mode
, vd
->e
[regno
].mode
,
906 if (new_rtx
!= NULL_RTX
)
908 if (validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
910 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (src
);
911 REG_ATTRS (new_rtx
) = REG_ATTRS (src
);
912 REG_POINTER (new_rtx
) = REG_POINTER (src
);
915 "insn %u: replaced reg %u with %u\n",
916 INSN_UID (insn
), regno
, REGNO (new_rtx
));
918 goto did_replacement
;
920 /* We need to re-extract as validate_change clobbers
922 extract_constrain_insn (insn
);
923 preprocess_constraints (insn
);
927 no_move_special_case
:
929 any_replacements
= false;
931 /* For each input operand, replace a hard register with the
932 eldest live copy that's in an appropriate register class. */
933 for (i
= 0; i
< n_ops
; i
++)
937 /* Don't scan match_operand here, since we've no reg class
938 information to pass down. Any operands that we could
939 substitute in will be represented elsewhere. */
940 if (recog_data
.constraints
[i
][0] == '\0')
943 /* Don't replace in asms intentionally referencing hard regs. */
944 if (is_asm
&& REG_P (recog_data
.operand
[i
])
945 && (REGNO (recog_data
.operand
[i
])
946 == ORIGINAL_REGNO (recog_data
.operand
[i
])))
949 if (recog_data
.operand_type
[i
] == OP_IN
)
951 if (op_alt
[i
].is_address
)
953 = replace_oldest_value_addr (recog_data
.operand_loc
[i
],
954 alternative_class (op_alt
, i
),
955 VOIDmode
, ADDR_SPACE_GENERIC
,
957 else if (REG_P (recog_data
.operand
[i
]))
959 = replace_oldest_value_reg (recog_data
.operand_loc
[i
],
960 alternative_class (op_alt
, i
),
962 else if (MEM_P (recog_data
.operand
[i
]))
963 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
966 else if (MEM_P (recog_data
.operand
[i
]))
967 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
970 /* If we performed any replacement, update match_dups. */
976 new_rtx
= *recog_data
.operand_loc
[i
];
977 recog_data
.operand
[i
] = new_rtx
;
978 for (j
= 0; j
< recog_data
.n_dups
; j
++)
979 if (recog_data
.dup_num
[j
] == i
)
980 validate_unshare_change (insn
, recog_data
.dup_loc
[j
], new_rtx
, 1);
982 any_replacements
= true;
986 if (any_replacements
)
988 if (! apply_change_group ())
990 for (i
= 0; i
< n_ops
; i
++)
993 rtx old
= *recog_data
.operand_loc
[i
];
994 recog_data
.operand
[i
] = old
;
999 "insn %u: reg replacements not verified\n",
1009 anything_changed
= true;
1011 /* If something changed, perhaps further changes to earlier
1012 DEBUG_INSNs can be applied. */
1013 if (vd
->n_debug_insn_changes
)
1014 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
1018 ksvd
.ignore_set_reg
= NULL_RTX
;
1020 /* Clobber call-clobbered registers. */
1023 unsigned int set_regno
= INVALID_REGNUM
;
1024 unsigned int set_nregs
= 0;
1027 HARD_REG_SET regs_invalidated_by_this_call
;
1029 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
1031 rtx x
= XEXP (exp
, 0);
1032 if (GET_CODE (x
) == SET
)
1034 rtx dest
= SET_DEST (x
);
1035 kill_value (dest
, vd
);
1036 set_value_regno (REGNO (dest
), GET_MODE (dest
), vd
);
1037 copy_value (dest
, SET_SRC (x
), vd
);
1038 ksvd
.ignore_set_reg
= dest
;
1039 set_regno
= REGNO (dest
);
1040 set_nregs
= REG_NREGS (dest
);
1045 get_call_reg_set_usage (insn
,
1046 ®s_invalidated_by_this_call
,
1047 regs_invalidated_by_call
);
1048 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1049 if ((TEST_HARD_REG_BIT (regs_invalidated_by_this_call
, regno
)
1050 || HARD_REGNO_CALL_PART_CLOBBERED (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 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
)))
1072 < GET_MODE_BITSIZE (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
);