1 /* Copy propagation on hard registers for the GNU compiler.
2 Copyright (C) 2000-2014 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"
26 #include "insn-config.h"
28 #include "addresses.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
35 #include "diagnostic-core.h"
37 #include "tree-pass.h"
40 /* The following code does forward propagation of hard register copies.
41 The object is to eliminate as many dependencies as possible, so that
42 we have the most scheduling freedom. As a side effect, we also clean
43 up some silly register allocation decisions made by reload. This
44 code may be obsoleted by a new register allocator. */
46 /* DEBUG_INSNs aren't changed right away, as doing so might extend the
47 lifetime of a register and get the DEBUG_INSN subsequently reset.
48 So they are queued instead, and updated only when the register is
49 used in some subsequent real insn before it is set. */
50 struct queued_debug_insn_change
52 struct queued_debug_insn_change
*next
;
58 /* For each register, we have a list of registers that contain the same
59 value. The OLDEST_REGNO field points to the head of the list, and
60 the NEXT_REGNO field runs through the list. The MODE field indicates
61 what mode the data is known to be in; this field is VOIDmode when the
62 register is not known to contain valid data. */
64 struct value_data_entry
66 enum machine_mode mode
;
67 unsigned int oldest_regno
;
68 unsigned int next_regno
;
69 struct queued_debug_insn_change
*debug_insn_changes
;
74 struct value_data_entry e
[FIRST_PSEUDO_REGISTER
];
75 unsigned int max_value_regs
;
76 unsigned int n_debug_insn_changes
;
79 static alloc_pool 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 (rtx
, struct value_data
*);
85 static void set_value_regno (unsigned, enum 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 int kill_autoinc_value (rtx
*, void *);
90 static void copy_value (rtx
, rtx
, struct value_data
*);
91 static bool mode_change_ok (enum machine_mode
, enum machine_mode
,
93 static rtx
maybe_mode_change (enum machine_mode
, enum machine_mode
,
94 enum 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
,
98 static bool replace_oldest_value_addr (rtx
*, enum reg_class
,
99 enum machine_mode
, addr_space_t
, rtx
,
100 struct value_data
*);
101 static bool replace_oldest_value_mem (rtx
, rtx
, 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 #ifdef ENABLE_CHECKING
105 static void validate_value_data (struct value_data
*);
108 /* Free all queued updates for DEBUG_INSNs that change some reg to
112 free_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
114 struct queued_debug_insn_change
*cur
, *next
;
115 for (cur
= vd
->e
[regno
].debug_insn_changes
; cur
; cur
= next
)
118 --vd
->n_debug_insn_changes
;
119 pool_free (debug_insn_changes_pool
, cur
);
121 vd
->e
[regno
].debug_insn_changes
= NULL
;
124 /* Kill register REGNO. This involves removing it from any value
125 lists, and resetting the value mode to VOIDmode. This is only a
126 helper function; it does not handle any hard registers overlapping
130 kill_value_one_regno (unsigned int regno
, struct value_data
*vd
)
132 unsigned int i
, next
;
134 if (vd
->e
[regno
].oldest_regno
!= regno
)
136 for (i
= vd
->e
[regno
].oldest_regno
;
137 vd
->e
[i
].next_regno
!= regno
;
138 i
= vd
->e
[i
].next_regno
)
140 vd
->e
[i
].next_regno
= vd
->e
[regno
].next_regno
;
142 else if ((next
= vd
->e
[regno
].next_regno
) != INVALID_REGNUM
)
144 for (i
= next
; i
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
145 vd
->e
[i
].oldest_regno
= next
;
148 vd
->e
[regno
].mode
= VOIDmode
;
149 vd
->e
[regno
].oldest_regno
= regno
;
150 vd
->e
[regno
].next_regno
= INVALID_REGNUM
;
151 if (vd
->e
[regno
].debug_insn_changes
)
152 free_debug_insn_changes (vd
, regno
);
154 #ifdef ENABLE_CHECKING
155 validate_value_data (vd
);
159 /* Kill the value in register REGNO for NREGS, and any other registers
160 whose values overlap. */
163 kill_value_regno (unsigned int regno
, unsigned int nregs
,
164 struct value_data
*vd
)
168 /* Kill the value we're told to kill. */
169 for (j
= 0; j
< nregs
; ++j
)
170 kill_value_one_regno (regno
+ j
, vd
);
172 /* Kill everything that overlapped what we're told to kill. */
173 if (regno
< vd
->max_value_regs
)
176 j
= regno
- vd
->max_value_regs
;
177 for (; j
< regno
; ++j
)
180 if (vd
->e
[j
].mode
== VOIDmode
)
182 n
= hard_regno_nregs
[j
][vd
->e
[j
].mode
];
184 for (i
= 0; i
< n
; ++i
)
185 kill_value_one_regno (j
+ i
, vd
);
189 /* Kill X. This is a convenience function wrapping kill_value_regno
190 so that we mind the mode the register is in. */
193 kill_value (rtx x
, struct value_data
*vd
)
197 if (GET_CODE (x
) == SUBREG
)
199 x
= simplify_subreg (GET_MODE (x
), SUBREG_REG (x
),
200 GET_MODE (SUBREG_REG (x
)), SUBREG_BYTE (x
));
202 x
= SUBREG_REG (orig_rtx
);
206 unsigned int regno
= REGNO (x
);
207 unsigned int n
= hard_regno_nregs
[regno
][GET_MODE (x
)];
209 kill_value_regno (regno
, n
, vd
);
213 /* Remember that REGNO is valid in MODE. */
216 set_value_regno (unsigned int regno
, enum machine_mode mode
,
217 struct value_data
*vd
)
221 vd
->e
[regno
].mode
= mode
;
223 nregs
= hard_regno_nregs
[regno
][mode
];
224 if (nregs
> vd
->max_value_regs
)
225 vd
->max_value_regs
= nregs
;
228 /* Initialize VD such that there are no known relationships between regs. */
231 init_value_data (struct value_data
*vd
)
234 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
236 vd
->e
[i
].mode
= VOIDmode
;
237 vd
->e
[i
].oldest_regno
= i
;
238 vd
->e
[i
].next_regno
= INVALID_REGNUM
;
239 vd
->e
[i
].debug_insn_changes
= NULL
;
241 vd
->max_value_regs
= 0;
242 vd
->n_debug_insn_changes
= 0;
245 /* Called through note_stores. If X is clobbered, kill its value. */
248 kill_clobbered_value (rtx x
, const_rtx set
, void *data
)
250 struct value_data
*const vd
= (struct value_data
*) data
;
251 if (GET_CODE (set
) == CLOBBER
)
255 /* A structure passed as data to kill_set_value through note_stores. */
256 struct kill_set_value_data
258 struct value_data
*vd
;
262 /* Called through note_stores. If X is set, not clobbered, kill its
263 current value and install it as the root of its own value list. */
266 kill_set_value (rtx x
, const_rtx set
, void *data
)
268 struct kill_set_value_data
*ksvd
= (struct kill_set_value_data
*) data
;
269 if (rtx_equal_p (x
, ksvd
->ignore_set_reg
))
271 if (GET_CODE (set
) != CLOBBER
)
273 kill_value (x
, ksvd
->vd
);
275 set_value_regno (REGNO (x
), GET_MODE (x
), ksvd
->vd
);
279 /* Called through for_each_rtx. Kill any register used as the base of an
280 auto-increment expression, and install that register as the root of its
284 kill_autoinc_value (rtx
*px
, void *data
)
287 struct value_data
*const vd
= (struct value_data
*) data
;
289 if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_AUTOINC
)
293 set_value_regno (REGNO (x
), GET_MODE (x
), vd
);
300 /* Assert that SRC has been copied to DEST. Adjust the data structures
301 to reflect that SRC contains an older copy of the shared value. */
304 copy_value (rtx dest
, rtx src
, struct value_data
*vd
)
306 unsigned int dr
= REGNO (dest
);
307 unsigned int sr
= REGNO (src
);
311 /* ??? At present, it's possible to see noop sets. It'd be nice if
312 this were cleaned up beforehand... */
316 /* Do not propagate copies to the stack pointer, as that can leave
317 memory accesses with no scheduling dependency on the stack update. */
318 if (dr
== STACK_POINTER_REGNUM
)
321 /* Likewise with the frame pointer, if we're using one. */
322 if (frame_pointer_needed
&& dr
== HARD_FRAME_POINTER_REGNUM
)
325 /* Do not propagate copies to fixed or global registers, patterns
326 can be relying to see particular fixed register or users can
327 expect the chosen global register in asm. */
328 if (fixed_regs
[dr
] || global_regs
[dr
])
331 /* If SRC and DEST overlap, don't record anything. */
332 dn
= hard_regno_nregs
[dr
][GET_MODE (dest
)];
333 sn
= hard_regno_nregs
[sr
][GET_MODE (dest
)];
334 if ((dr
> sr
&& dr
< sr
+ sn
)
335 || (sr
> dr
&& sr
< dr
+ dn
))
338 /* If SRC had no assigned mode (i.e. we didn't know it was live)
339 assign it now and assume the value came from an input argument
341 if (vd
->e
[sr
].mode
== VOIDmode
)
342 set_value_regno (sr
, vd
->e
[dr
].mode
, vd
);
344 /* If we are narrowing the input to a smaller number of hard regs,
345 and it is in big endian, we are really extracting a high part.
346 Since we generally associate a low part of a value with the value itself,
347 we must not do the same for the high part.
348 Note we can still get low parts for the same mode combination through
349 a two-step copy involving differently sized hard regs.
350 Assume hard regs fr* are 32 bits bits each, while r* are 64 bits each:
351 (set (reg:DI r0) (reg:DI fr0))
352 (set (reg:SI fr2) (reg:SI r0))
353 loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
354 (set (reg:SI fr2) (reg:SI fr0))
355 loads the high part of (reg:DI fr0) into fr2.
357 We can't properly represent the latter case in our tables, so don't
358 record anything then. */
359 else if (sn
< (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
]
360 && (GET_MODE_SIZE (vd
->e
[sr
].mode
) > UNITS_PER_WORD
361 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
364 /* If SRC had been assigned a mode narrower than the copy, we can't
365 link DEST into the chain, because not all of the pieces of the
366 copy came from oldest_regno. */
367 else if (sn
> (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
])
370 /* Link DR at the end of the value chain used by SR. */
372 vd
->e
[dr
].oldest_regno
= vd
->e
[sr
].oldest_regno
;
374 for (i
= sr
; vd
->e
[i
].next_regno
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
376 vd
->e
[i
].next_regno
= dr
;
378 #ifdef ENABLE_CHECKING
379 validate_value_data (vd
);
383 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
386 mode_change_ok (enum machine_mode orig_mode
, enum machine_mode new_mode
,
387 unsigned int regno ATTRIBUTE_UNUSED
)
389 if (GET_MODE_SIZE (orig_mode
) < GET_MODE_SIZE (new_mode
))
392 #ifdef CANNOT_CHANGE_MODE_CLASS
393 return !REG_CANNOT_CHANGE_MODE_P (regno
, orig_mode
, new_mode
);
399 /* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
400 was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
402 Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
405 maybe_mode_change (enum machine_mode orig_mode
, enum machine_mode copy_mode
,
406 enum machine_mode new_mode
, unsigned int regno
,
407 unsigned int copy_regno ATTRIBUTE_UNUSED
)
409 if (GET_MODE_SIZE (copy_mode
) < GET_MODE_SIZE (orig_mode
)
410 && GET_MODE_SIZE (copy_mode
) < GET_MODE_SIZE (new_mode
))
413 if (orig_mode
== new_mode
)
414 return gen_rtx_raw_REG (new_mode
, regno
);
415 else if (mode_change_ok (orig_mode
, new_mode
, regno
))
417 int copy_nregs
= hard_regno_nregs
[copy_regno
][copy_mode
];
418 int use_nregs
= hard_regno_nregs
[copy_regno
][new_mode
];
420 = GET_MODE_SIZE (copy_mode
) / copy_nregs
* (copy_nregs
- use_nregs
);
422 = GET_MODE_SIZE (orig_mode
) - GET_MODE_SIZE (new_mode
) - copy_offset
;
423 int byteoffset
= offset
% UNITS_PER_WORD
;
424 int wordoffset
= offset
- byteoffset
;
426 offset
= ((WORDS_BIG_ENDIAN
? wordoffset
: 0)
427 + (BYTES_BIG_ENDIAN
? byteoffset
: 0));
428 regno
+= subreg_regno_offset (regno
, orig_mode
, offset
, new_mode
);
429 if (HARD_REGNO_MODE_OK (regno
, new_mode
))
430 return gen_rtx_raw_REG (new_mode
, regno
);
435 /* Find the oldest copy of the value contained in REGNO that is in
436 register class CL and has mode MODE. If found, return an rtx
437 of that oldest register, otherwise return NULL. */
440 find_oldest_value_reg (enum reg_class cl
, rtx reg
, struct value_data
*vd
)
442 unsigned int regno
= REGNO (reg
);
443 enum machine_mode mode
= GET_MODE (reg
);
446 /* If we are accessing REG in some mode other that what we set it in,
447 make sure that the replacement is valid. In particular, consider
448 (set (reg:DI r11) (...))
449 (set (reg:SI r9) (reg:SI r11))
450 (set (reg:SI r10) (...))
451 (set (...) (reg:DI r9))
452 Replacing r9 with r11 is invalid. */
453 if (mode
!= vd
->e
[regno
].mode
)
455 if (hard_regno_nregs
[regno
][mode
]
456 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
460 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
; i
= vd
->e
[i
].next_regno
)
462 enum machine_mode oldmode
= vd
->e
[i
].mode
;
465 if (!in_hard_reg_set_p (reg_class_contents
[cl
], mode
, i
))
468 new_rtx
= maybe_mode_change (oldmode
, vd
->e
[regno
].mode
, mode
, i
, regno
);
471 ORIGINAL_REGNO (new_rtx
) = ORIGINAL_REGNO (reg
);
472 REG_ATTRS (new_rtx
) = REG_ATTRS (reg
);
473 REG_POINTER (new_rtx
) = REG_POINTER (reg
);
481 /* If possible, replace the register at *LOC with the oldest register
482 in register class CL. Return true if successfully replaced. */
485 replace_oldest_value_reg (rtx
*loc
, enum reg_class cl
, rtx insn
,
486 struct value_data
*vd
)
488 rtx new_rtx
= find_oldest_value_reg (cl
, *loc
, vd
);
489 if (new_rtx
&& (!DEBUG_INSN_P (insn
) || !skip_debug_insn_p
))
491 if (DEBUG_INSN_P (insn
))
493 struct queued_debug_insn_change
*change
;
496 fprintf (dump_file
, "debug_insn %u: queued replacing reg %u with %u\n",
497 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
499 change
= (struct queued_debug_insn_change
*)
500 pool_alloc (debug_insn_changes_pool
);
501 change
->next
= vd
->e
[REGNO (new_rtx
)].debug_insn_changes
;
504 change
->new_rtx
= new_rtx
;
505 vd
->e
[REGNO (new_rtx
)].debug_insn_changes
= change
;
506 ++vd
->n_debug_insn_changes
;
510 fprintf (dump_file
, "insn %u: replaced reg %u with %u\n",
511 INSN_UID (insn
), REGNO (*loc
), REGNO (new_rtx
));
513 validate_change (insn
, loc
, new_rtx
, 1);
519 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
520 Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
521 BASE_REG_CLASS depending on how the register is being considered. */
524 replace_oldest_value_addr (rtx
*loc
, enum reg_class cl
,
525 enum machine_mode mode
, addr_space_t as
,
526 rtx insn
, struct value_data
*vd
)
529 RTX_CODE code
= GET_CODE (x
);
532 bool changed
= false;
537 if (DEBUG_INSN_P (insn
))
541 rtx orig_op0
= XEXP (x
, 0);
542 rtx orig_op1
= XEXP (x
, 1);
543 RTX_CODE code0
= GET_CODE (orig_op0
);
544 RTX_CODE code1
= GET_CODE (orig_op1
);
549 enum rtx_code index_code
= SCRATCH
;
551 if (GET_CODE (op0
) == SUBREG
)
553 op0
= SUBREG_REG (op0
);
554 code0
= GET_CODE (op0
);
557 if (GET_CODE (op1
) == SUBREG
)
559 op1
= SUBREG_REG (op1
);
560 code1
= GET_CODE (op1
);
563 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
564 || code0
== ZERO_EXTEND
|| code1
== MEM
)
568 index_code
= GET_CODE (*locI
);
570 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
571 || code1
== ZERO_EXTEND
|| code0
== MEM
)
575 index_code
= GET_CODE (*locI
);
577 else if (code0
== CONST_INT
|| code0
== CONST
578 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
581 index_code
= GET_CODE (XEXP (x
, 0));
583 else if (code1
== CONST_INT
|| code1
== CONST
584 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
587 index_code
= GET_CODE (XEXP (x
, 1));
589 else if (code0
== REG
&& code1
== REG
)
592 unsigned regno0
= REGNO (op0
), regno1
= REGNO (op1
);
594 if (REGNO_OK_FOR_INDEX_P (regno1
)
595 && regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
))
597 else if (REGNO_OK_FOR_INDEX_P (regno0
)
598 && regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
600 else if (regno_ok_for_base_p (regno0
, mode
, as
, PLUS
, REG
)
601 || REGNO_OK_FOR_INDEX_P (regno1
))
603 else if (regno_ok_for_base_p (regno1
, mode
, as
, PLUS
, REG
))
608 locI
= &XEXP (x
, index_op
);
609 locB
= &XEXP (x
, !index_op
);
610 index_code
= GET_CODE (*locI
);
612 else if (code0
== REG
)
616 index_code
= GET_CODE (*locI
);
618 else if (code1
== REG
)
622 index_code
= GET_CODE (*locI
);
626 changed
|= replace_oldest_value_addr (locI
, INDEX_REG_CLASS
,
629 changed
|= replace_oldest_value_addr (locB
,
630 base_reg_class (mode
, as
, PLUS
,
645 return replace_oldest_value_mem (x
, insn
, vd
);
648 return replace_oldest_value_reg (loc
, cl
, insn
, vd
);
654 fmt
= GET_RTX_FORMAT (code
);
655 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
658 changed
|= replace_oldest_value_addr (&XEXP (x
, i
), cl
, mode
, as
,
660 else if (fmt
[i
] == 'E')
661 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
662 changed
|= replace_oldest_value_addr (&XVECEXP (x
, i
, j
), cl
,
669 /* Similar to replace_oldest_value_reg, but X contains a memory. */
672 replace_oldest_value_mem (rtx x
, rtx insn
, struct value_data
*vd
)
676 if (DEBUG_INSN_P (insn
))
679 cl
= base_reg_class (GET_MODE (x
), MEM_ADDR_SPACE (x
), MEM
, SCRATCH
);
681 return replace_oldest_value_addr (&XEXP (x
, 0), cl
,
682 GET_MODE (x
), MEM_ADDR_SPACE (x
),
686 /* Apply all queued updates for DEBUG_INSNs that change some reg to
690 apply_debug_insn_changes (struct value_data
*vd
, unsigned int regno
)
692 struct queued_debug_insn_change
*change
;
693 rtx last_insn
= vd
->e
[regno
].debug_insn_changes
->insn
;
695 for (change
= vd
->e
[regno
].debug_insn_changes
;
697 change
= change
->next
)
699 if (last_insn
!= change
->insn
)
701 apply_change_group ();
702 last_insn
= change
->insn
;
704 validate_change (change
->insn
, change
->loc
, change
->new_rtx
, 1);
706 apply_change_group ();
709 /* Called via for_each_rtx, for all used registers in a real
710 insn apply DEBUG_INSN changes that change registers to the
714 cprop_find_used_regs_1 (rtx
*loc
, void *data
)
718 struct value_data
*vd
= (struct value_data
*) data
;
719 if (vd
->e
[REGNO (*loc
)].debug_insn_changes
)
721 apply_debug_insn_changes (vd
, REGNO (*loc
));
722 free_debug_insn_changes (vd
, REGNO (*loc
));
728 /* Called via note_uses, for all used registers in a real insn
729 apply DEBUG_INSN changes that change registers to the used
733 cprop_find_used_regs (rtx
*loc
, void *vd
)
735 for_each_rtx (loc
, cprop_find_used_regs_1
, 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;
746 for (insn
= BB_HEAD (bb
); ; insn
= NEXT_INSN (insn
))
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 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 if (! constrain_operands (1))
776 fatal_insn_not_found (insn
);
777 preprocess_constraints ();
778 const operand_alternative
*op_alt
= which_op_alt ();
779 n_ops
= recog_data
.n_operands
;
780 is_asm
= asm_noperands (PATTERN (insn
)) >= 0;
782 /* Simplify the code below by promoting OP_OUT to OP_INOUT
783 in predicated instructions. */
785 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
786 for (i
= 0; i
< n_ops
; ++i
)
788 int matches
= op_alt
[i
].matches
;
789 if (matches
>= 0 || op_alt
[i
].matched
>= 0
790 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
791 recog_data
.operand_type
[i
] = OP_INOUT
;
794 /* Apply changes to earlier DEBUG_INSNs if possible. */
795 if (vd
->n_debug_insn_changes
)
796 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
798 /* For each earlyclobber operand, zap the value data. */
799 for (i
= 0; i
< n_ops
; i
++)
800 if (op_alt
[i
].earlyclobber
)
801 kill_value (recog_data
.operand
[i
], vd
);
803 /* Within asms, a clobber cannot overlap inputs or outputs.
804 I wouldn't think this were true for regular insns, but
805 scan_rtx treats them like that... */
806 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
808 /* Kill all auto-incremented values. */
809 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
810 for_each_rtx (&PATTERN (insn
), kill_autoinc_value
, vd
);
812 /* Kill all early-clobbered operands. */
813 for (i
= 0; i
< n_ops
; i
++)
814 if (op_alt
[i
].earlyclobber
)
815 kill_value (recog_data
.operand
[i
], vd
);
817 /* If we have dead sets in the insn, then we need to note these as we
819 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
821 if (REG_NOTE_KIND (link
) == REG_UNUSED
)
823 kill_value (XEXP (link
, 0), vd
);
824 /* Furthermore, if the insn looked like a single-set,
825 but the dead store kills the source value of that
826 set, then we can no-longer use the plain move
827 special case below. */
829 && reg_overlap_mentioned_p (XEXP (link
, 0), SET_SRC (set
)))
834 /* Special-case plain move instructions, since we may well
835 be able to do the move from a different register class. */
836 if (set
&& REG_P (SET_SRC (set
)))
838 rtx src
= SET_SRC (set
);
839 unsigned int regno
= REGNO (src
);
840 enum machine_mode mode
= GET_MODE (src
);
844 /* If we are accessing SRC in some mode other that what we
845 set it in, make sure that the replacement is valid. */
846 if (mode
!= vd
->e
[regno
].mode
)
848 if (hard_regno_nregs
[regno
][mode
]
849 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
850 goto no_move_special_case
;
852 /* And likewise, if we are narrowing on big endian the transformation
854 if (hard_regno_nregs
[regno
][mode
]
855 < hard_regno_nregs
[regno
][vd
->e
[regno
].mode
]
856 && (GET_MODE_SIZE (vd
->e
[regno
].mode
) > UNITS_PER_WORD
857 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
858 goto no_move_special_case
;
861 /* If the destination is also a register, try to find a source
862 register in the same class. */
863 if (REG_P (SET_DEST (set
)))
865 new_rtx
= find_oldest_value_reg (REGNO_REG_CLASS (regno
), src
, vd
);
866 if (new_rtx
&& validate_change (insn
, &SET_SRC (set
), new_rtx
, 0))
870 "insn %u: replaced reg %u with %u\n",
871 INSN_UID (insn
), regno
, REGNO (new_rtx
));
873 goto did_replacement
;
875 /* We need to re-extract as validate_change clobbers
878 if (! constrain_operands (1))
879 fatal_insn_not_found (insn
);
880 preprocess_constraints ();
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
906 if (! constrain_operands (1))
907 fatal_insn_not_found (insn
);
908 preprocess_constraints ();
912 no_move_special_case
:
914 any_replacements
= false;
916 /* For each input operand, replace a hard register with the
917 eldest live copy that's in an appropriate register class. */
918 for (i
= 0; i
< n_ops
; i
++)
922 /* Don't scan match_operand here, since we've no reg class
923 information to pass down. Any operands that we could
924 substitute in will be represented elsewhere. */
925 if (recog_data
.constraints
[i
][0] == '\0')
928 /* Don't replace in asms intentionally referencing hard regs. */
929 if (is_asm
&& REG_P (recog_data
.operand
[i
])
930 && (REGNO (recog_data
.operand
[i
])
931 == ORIGINAL_REGNO (recog_data
.operand
[i
])))
934 if (recog_data
.operand_type
[i
] == OP_IN
)
936 if (op_alt
[i
].is_address
)
938 = replace_oldest_value_addr (recog_data
.operand_loc
[i
],
939 alternative_class (op_alt
, i
),
940 VOIDmode
, ADDR_SPACE_GENERIC
,
942 else if (REG_P (recog_data
.operand
[i
]))
944 = replace_oldest_value_reg (recog_data
.operand_loc
[i
],
945 alternative_class (op_alt
, i
),
947 else if (MEM_P (recog_data
.operand
[i
]))
948 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
951 else if (MEM_P (recog_data
.operand
[i
]))
952 replaced
[i
] = replace_oldest_value_mem (recog_data
.operand
[i
],
955 /* If we performed any replacement, update match_dups. */
961 new_rtx
= *recog_data
.operand_loc
[i
];
962 recog_data
.operand
[i
] = new_rtx
;
963 for (j
= 0; j
< recog_data
.n_dups
; j
++)
964 if (recog_data
.dup_num
[j
] == i
)
965 validate_unshare_change (insn
, recog_data
.dup_loc
[j
], new_rtx
, 1);
967 any_replacements
= true;
971 if (any_replacements
)
973 if (! apply_change_group ())
975 for (i
= 0; i
< n_ops
; i
++)
978 rtx old
= *recog_data
.operand_loc
[i
];
979 recog_data
.operand
[i
] = old
;
984 "insn %u: reg replacements not verified\n",
994 anything_changed
= true;
996 /* If something changed, perhaps further changes to earlier
997 DEBUG_INSNs can be applied. */
998 if (vd
->n_debug_insn_changes
)
999 note_uses (&PATTERN (insn
), cprop_find_used_regs
, vd
);
1003 ksvd
.ignore_set_reg
= NULL_RTX
;
1005 /* Clobber call-clobbered registers. */
1008 unsigned int set_regno
= INVALID_REGNUM
;
1009 unsigned int set_nregs
= 0;
1013 for (exp
= CALL_INSN_FUNCTION_USAGE (insn
); exp
; exp
= XEXP (exp
, 1))
1015 rtx x
= XEXP (exp
, 0);
1016 if (GET_CODE (x
) == SET
)
1018 rtx dest
= SET_DEST (x
);
1019 kill_value (dest
, vd
);
1020 set_value_regno (REGNO (dest
), GET_MODE (dest
), vd
);
1021 copy_value (dest
, SET_SRC (x
), vd
);
1022 ksvd
.ignore_set_reg
= dest
;
1023 set_regno
= REGNO (dest
);
1025 = hard_regno_nregs
[set_regno
][GET_MODE (dest
)];
1030 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1031 if ((TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
1032 || HARD_REGNO_CALL_PART_CLOBBERED (regno
, vd
->e
[regno
].mode
))
1033 && (regno
< set_regno
|| regno
>= set_regno
+ set_nregs
))
1034 kill_value_regno (regno
, 1, vd
);
1036 /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
1037 of the SET isn't in regs_invalidated_by_call hard reg set,
1038 but instead among CLOBBERs on the CALL_INSN, we could wrongly
1039 assume the value in it is still live. */
1040 if (ksvd
.ignore_set_reg
)
1041 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
1044 /* Notice stores. */
1045 note_stores (PATTERN (insn
), kill_set_value
, &ksvd
);
1047 /* Notice copies. */
1048 if (set
&& REG_P (SET_DEST (set
)) && REG_P (SET_SRC (set
)))
1049 copy_value (SET_DEST (set
), SET_SRC (set
), vd
);
1051 if (insn
== BB_END (bb
))
1055 return anything_changed
;
1058 /* Dump the value chain data to stderr. */
1061 debug_value_data (struct value_data
*vd
)
1066 CLEAR_HARD_REG_SET (set
);
1068 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1069 if (vd
->e
[i
].oldest_regno
== i
)
1071 if (vd
->e
[i
].mode
== VOIDmode
)
1073 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1074 fprintf (stderr
, "[%u] Bad next_regno for empty chain (%u)\n",
1075 i
, vd
->e
[i
].next_regno
);
1079 SET_HARD_REG_BIT (set
, i
);
1080 fprintf (stderr
, "[%u %s] ", i
, GET_MODE_NAME (vd
->e
[i
].mode
));
1082 for (j
= vd
->e
[i
].next_regno
;
1083 j
!= INVALID_REGNUM
;
1084 j
= vd
->e
[j
].next_regno
)
1086 if (TEST_HARD_REG_BIT (set
, j
))
1088 fprintf (stderr
, "[%u] Loop in regno chain\n", j
);
1092 if (vd
->e
[j
].oldest_regno
!= i
)
1094 fprintf (stderr
, "[%u] Bad oldest_regno (%u)\n",
1095 j
, vd
->e
[j
].oldest_regno
);
1098 SET_HARD_REG_BIT (set
, j
);
1099 fprintf (stderr
, "[%u %s] ", j
, GET_MODE_NAME (vd
->e
[j
].mode
));
1101 fputc ('\n', stderr
);
1104 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1105 if (! TEST_HARD_REG_BIT (set
, i
)
1106 && (vd
->e
[i
].mode
!= VOIDmode
1107 || vd
->e
[i
].oldest_regno
!= i
1108 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1109 fprintf (stderr
, "[%u] Non-empty reg in chain (%s %u %i)\n",
1110 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1111 vd
->e
[i
].next_regno
);
1114 /* Do copyprop_hardreg_forward_1 for a single basic block BB.
1115 DEBUG_INSN is skipped since we do not want to involve DF related
1116 staff as how it is handled in function pass_cprop_hardreg::execute.
1118 NOTE: Currently it is only used for shrink-wrap. Maybe extend it
1119 to handle DEBUG_INSN for other uses. */
1122 copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb
)
1124 struct value_data
*vd
;
1125 vd
= XNEWVEC (struct value_data
, 1);
1126 init_value_data (vd
);
1128 skip_debug_insn_p
= true;
1129 copyprop_hardreg_forward_1 (bb
, vd
);
1131 skip_debug_insn_p
= false;
1134 #ifdef ENABLE_CHECKING
1136 validate_value_data (struct value_data
*vd
)
1141 CLEAR_HARD_REG_SET (set
);
1143 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1144 if (vd
->e
[i
].oldest_regno
== i
)
1146 if (vd
->e
[i
].mode
== VOIDmode
)
1148 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1149 internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1150 i
, vd
->e
[i
].next_regno
);
1154 SET_HARD_REG_BIT (set
, i
);
1156 for (j
= vd
->e
[i
].next_regno
;
1157 j
!= INVALID_REGNUM
;
1158 j
= vd
->e
[j
].next_regno
)
1160 if (TEST_HARD_REG_BIT (set
, j
))
1161 internal_error ("validate_value_data: Loop in regno chain (%u)",
1163 if (vd
->e
[j
].oldest_regno
!= i
)
1164 internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1165 j
, vd
->e
[j
].oldest_regno
);
1167 SET_HARD_REG_BIT (set
, j
);
1171 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1172 if (! TEST_HARD_REG_BIT (set
, i
)
1173 && (vd
->e
[i
].mode
!= VOIDmode
1174 || vd
->e
[i
].oldest_regno
!= i
1175 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1176 internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1177 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1178 vd
->e
[i
].next_regno
);
1184 const pass_data pass_data_cprop_hardreg
=
1186 RTL_PASS
, /* type */
1187 "cprop_hardreg", /* name */
1188 OPTGROUP_NONE
, /* optinfo_flags */
1189 true, /* has_execute */
1190 TV_CPROP_REGISTERS
, /* tv_id */
1191 0, /* properties_required */
1192 0, /* properties_provided */
1193 0, /* properties_destroyed */
1194 0, /* todo_flags_start */
1195 TODO_df_finish
, /* todo_flags_finish */
1198 class pass_cprop_hardreg
: public rtl_opt_pass
1201 pass_cprop_hardreg (gcc::context
*ctxt
)
1202 : rtl_opt_pass (pass_data_cprop_hardreg
, ctxt
)
1205 /* opt_pass methods: */
1206 virtual bool gate (function
*)
1208 return (optimize
> 0 && (flag_cprop_registers
));
1211 virtual unsigned int execute (function
*);
1213 }; // class pass_cprop_hardreg
1216 pass_cprop_hardreg::execute (function
*fun
)
1218 struct value_data
*all_vd
;
1221 bool analyze_called
= false;
1223 all_vd
= XNEWVEC (struct value_data
, last_basic_block_for_fn (fun
));
1225 visited
= sbitmap_alloc (last_basic_block_for_fn (fun
));
1226 bitmap_clear (visited
);
1228 if (MAY_HAVE_DEBUG_INSNS
)
1229 debug_insn_changes_pool
1230 = create_alloc_pool ("debug insn changes pool",
1231 sizeof (struct queued_debug_insn_change
), 256);
1233 FOR_EACH_BB_FN (bb
, fun
)
1235 bitmap_set_bit (visited
, bb
->index
);
1237 /* If a block has a single predecessor, that we've already
1238 processed, begin with the value data that was live at
1239 the end of the predecessor block. */
1240 /* ??? Ought to use more intelligent queuing of blocks. */
1241 if (single_pred_p (bb
)
1242 && bitmap_bit_p (visited
, single_pred (bb
)->index
)
1243 && ! (single_pred_edge (bb
)->flags
& (EDGE_ABNORMAL_CALL
| EDGE_EH
)))
1245 all_vd
[bb
->index
] = all_vd
[single_pred (bb
)->index
];
1246 if (all_vd
[bb
->index
].n_debug_insn_changes
)
1250 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1252 if (all_vd
[bb
->index
].e
[regno
].debug_insn_changes
)
1254 all_vd
[bb
->index
].e
[regno
].debug_insn_changes
= NULL
;
1255 if (--all_vd
[bb
->index
].n_debug_insn_changes
== 0)
1262 init_value_data (all_vd
+ bb
->index
);
1264 copyprop_hardreg_forward_1 (bb
, all_vd
+ bb
->index
);
1267 if (MAY_HAVE_DEBUG_INSNS
)
1269 FOR_EACH_BB_FN (bb
, fun
)
1270 if (bitmap_bit_p (visited
, bb
->index
)
1271 && all_vd
[bb
->index
].n_debug_insn_changes
)
1276 if (!analyze_called
)
1279 analyze_called
= true;
1281 live
= df_get_live_out (bb
);
1282 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1283 if (all_vd
[bb
->index
].e
[regno
].debug_insn_changes
)
1285 if (REGNO_REG_SET_P (live
, regno
))
1286 apply_debug_insn_changes (all_vd
+ bb
->index
, regno
);
1287 if (all_vd
[bb
->index
].n_debug_insn_changes
== 0)
1292 free_alloc_pool (debug_insn_changes_pool
);
1295 sbitmap_free (visited
);
1303 make_pass_cprop_hardreg (gcc::context
*ctxt
)
1305 return new pass_cprop_hardreg (ctxt
);