1 /* Register renaming for the GNU compiler.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004 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 2, 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 COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #include "coretypes.h"
27 #include "insn-config.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
39 #ifndef REG_MODE_OK_FOR_BASE_P
40 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
43 static const char *const reg_class_names
[] = REG_CLASS_NAMES
;
47 struct du_chain
*next_chain
;
48 struct du_chain
*next_use
;
52 ENUM_BITFIELD(reg_class
) cl
: 16;
53 unsigned int need_caller_save_reg
:1;
54 unsigned int earlyclobber
:1;
60 terminate_overlapping_read
,
67 static const char * const scan_actions_name
[] =
70 "terminate_overlapping_read",
77 static struct obstack rename_obstack
;
79 static void do_replace (struct du_chain
*, int);
80 static void scan_rtx_reg (rtx
, rtx
*, enum reg_class
,
81 enum scan_actions
, enum op_type
, int);
82 static void scan_rtx_address (rtx
, rtx
*, enum reg_class
,
83 enum scan_actions
, enum machine_mode
);
84 static void scan_rtx (rtx
, rtx
*, enum reg_class
, enum scan_actions
,
86 static struct du_chain
*build_def_use (basic_block
);
87 static void dump_def_use_chain (struct du_chain
*);
88 static void note_sets (rtx
, rtx
, void *);
89 static void clear_dead_regs (HARD_REG_SET
*, enum machine_mode
, rtx
);
90 static void merge_overlapping_regs (basic_block
, HARD_REG_SET
*,
93 /* Called through note_stores from update_life. Find sets of registers, and
94 record them in *DATA (which is actually a HARD_REG_SET *). */
97 note_sets (rtx x
, rtx set ATTRIBUTE_UNUSED
, void *data
)
99 HARD_REG_SET
*pset
= (HARD_REG_SET
*) data
;
105 nregs
= hard_regno_nregs
[regno
][GET_MODE (x
)];
107 /* There must not be pseudos at this point. */
108 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
112 SET_HARD_REG_BIT (*pset
, regno
+ nregs
);
115 /* Clear all registers from *PSET for which a note of kind KIND can be found
116 in the list NOTES. */
119 clear_dead_regs (HARD_REG_SET
*pset
, enum machine_mode kind
, rtx notes
)
122 for (note
= notes
; note
; note
= XEXP (note
, 1))
123 if (REG_NOTE_KIND (note
) == kind
&& REG_P (XEXP (note
, 0)))
125 rtx reg
= XEXP (note
, 0);
126 unsigned int regno
= REGNO (reg
);
127 int nregs
= hard_regno_nregs
[regno
][GET_MODE (reg
)];
129 /* There must not be pseudos at this point. */
130 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
134 CLEAR_HARD_REG_BIT (*pset
, regno
+ nregs
);
138 /* For a def-use chain CHAIN in basic block B, find which registers overlap
139 its lifetime and set the corresponding bits in *PSET. */
142 merge_overlapping_regs (basic_block b
, HARD_REG_SET
*pset
,
143 struct du_chain
*chain
)
145 struct du_chain
*t
= chain
;
149 REG_SET_TO_HARD_REG_SET (live
, b
->global_live_at_start
);
153 /* Search forward until the next reference to the register to be
155 while (insn
!= t
->insn
)
159 clear_dead_regs (&live
, REG_DEAD
, REG_NOTES (insn
));
160 note_stores (PATTERN (insn
), note_sets
, (void *) &live
);
161 /* Only record currently live regs if we are inside the
164 IOR_HARD_REG_SET (*pset
, live
);
165 clear_dead_regs (&live
, REG_UNUSED
, REG_NOTES (insn
));
167 insn
= NEXT_INSN (insn
);
170 IOR_HARD_REG_SET (*pset
, live
);
172 /* For the last reference, also merge in all registers set in the
174 @@@ We only have take earlyclobbered sets into account. */
176 note_stores (PATTERN (insn
), note_sets
, (void *) pset
);
182 /* Perform register renaming on the current function. */
185 regrename_optimize (void)
187 int tick
[FIRST_PSEUDO_REGISTER
];
192 memset (tick
, 0, sizeof tick
);
194 gcc_obstack_init (&rename_obstack
);
195 first_obj
= obstack_alloc (&rename_obstack
, 0);
199 struct du_chain
*all_chains
= 0;
200 HARD_REG_SET unavailable
;
201 HARD_REG_SET regs_seen
;
203 CLEAR_HARD_REG_SET (unavailable
);
206 fprintf (dump_file
, "\nBasic block %d:\n", bb
->index
);
208 all_chains
= build_def_use (bb
);
211 dump_def_use_chain (all_chains
);
213 CLEAR_HARD_REG_SET (unavailable
);
214 /* Don't clobber traceback for noreturn functions. */
215 if (frame_pointer_needed
)
219 for (i
= hard_regno_nregs
[FRAME_POINTER_REGNUM
][Pmode
]; i
--;)
220 SET_HARD_REG_BIT (unavailable
, FRAME_POINTER_REGNUM
+ i
);
222 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
223 for (i
= hard_regno_nregs
[HARD_FRAME_POINTER_REGNUM
][Pmode
]; i
--;)
224 SET_HARD_REG_BIT (unavailable
, HARD_FRAME_POINTER_REGNUM
+ i
);
228 CLEAR_HARD_REG_SET (regs_seen
);
231 int new_reg
, best_new_reg
;
233 struct du_chain
*this = all_chains
;
234 struct du_chain
*tmp
, *last
;
235 HARD_REG_SET this_unavailable
;
236 int reg
= REGNO (*this->loc
);
239 all_chains
= this->next_chain
;
243 #if 0 /* This just disables optimization opportunities. */
244 /* Only rename once we've seen the reg more than once. */
245 if (! TEST_HARD_REG_BIT (regs_seen
, reg
))
247 SET_HARD_REG_BIT (regs_seen
, reg
);
252 if (fixed_regs
[reg
] || global_regs
[reg
]
253 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
254 || (frame_pointer_needed
&& reg
== HARD_FRAME_POINTER_REGNUM
)
256 || (frame_pointer_needed
&& reg
== FRAME_POINTER_REGNUM
)
261 COPY_HARD_REG_SET (this_unavailable
, unavailable
);
263 /* Find last entry on chain (which has the need_caller_save bit),
264 count number of uses, and narrow the set of registers we can
267 for (last
= this; last
->next_use
; last
= last
->next_use
)
270 IOR_COMPL_HARD_REG_SET (this_unavailable
,
271 reg_class_contents
[last
->cl
]);
276 IOR_COMPL_HARD_REG_SET (this_unavailable
,
277 reg_class_contents
[last
->cl
]);
279 if (this->need_caller_save_reg
)
280 IOR_HARD_REG_SET (this_unavailable
, call_used_reg_set
);
282 merge_overlapping_regs (bb
, &this_unavailable
, this);
284 /* Now potential_regs is a reasonable approximation, let's
285 have a closer look at each register still in there. */
286 for (new_reg
= 0; new_reg
< FIRST_PSEUDO_REGISTER
; new_reg
++)
288 int nregs
= hard_regno_nregs
[new_reg
][GET_MODE (*this->loc
)];
290 for (i
= nregs
- 1; i
>= 0; --i
)
291 if (TEST_HARD_REG_BIT (this_unavailable
, new_reg
+ i
)
292 || fixed_regs
[new_reg
+ i
]
293 || global_regs
[new_reg
+ i
]
294 /* Can't use regs which aren't saved by the prologue. */
295 || (! regs_ever_live
[new_reg
+ i
]
296 && ! call_used_regs
[new_reg
+ i
])
297 #ifdef LEAF_REGISTERS
298 /* We can't use a non-leaf register if we're in a
300 || (current_function_is_leaf
301 && !LEAF_REGISTERS
[new_reg
+ i
])
303 #ifdef HARD_REGNO_RENAME_OK
304 || ! HARD_REGNO_RENAME_OK (reg
+ i
, new_reg
+ i
)
311 /* See whether it accepts all modes that occur in
312 definition and uses. */
313 for (tmp
= this; tmp
; tmp
= tmp
->next_use
)
314 if (! HARD_REGNO_MODE_OK (new_reg
, GET_MODE (*tmp
->loc
))
315 || (tmp
->need_caller_save_reg
316 && ! (HARD_REGNO_CALL_PART_CLOBBERED
317 (reg
, GET_MODE (*tmp
->loc
)))
318 && (HARD_REGNO_CALL_PART_CLOBBERED
319 (new_reg
, GET_MODE (*tmp
->loc
)))))
323 if (tick
[best_new_reg
] > tick
[new_reg
])
324 best_new_reg
= new_reg
;
330 fprintf (dump_file
, "Register %s in insn %d",
331 reg_names
[reg
], INSN_UID (last
->insn
));
332 if (last
->need_caller_save_reg
)
333 fprintf (dump_file
, " crosses a call");
336 if (best_new_reg
== reg
)
338 tick
[reg
] = ++this_tick
;
340 fprintf (dump_file
, "; no available better choice\n");
344 do_replace (this, best_new_reg
);
345 tick
[best_new_reg
] = ++this_tick
;
346 regs_ever_live
[best_new_reg
] = 1;
349 fprintf (dump_file
, ", renamed as %s\n", reg_names
[best_new_reg
]);
352 obstack_free (&rename_obstack
, first_obj
);
355 obstack_free (&rename_obstack
, NULL
);
358 fputc ('\n', dump_file
);
360 count_or_remove_death_notes (NULL
, 1);
361 update_life_info (NULL
, UPDATE_LIFE_LOCAL
,
366 do_replace (struct du_chain
*chain
, int reg
)
370 unsigned int regno
= ORIGINAL_REGNO (*chain
->loc
);
371 struct reg_attrs
* attr
= REG_ATTRS (*chain
->loc
);
373 *chain
->loc
= gen_raw_REG (GET_MODE (*chain
->loc
), reg
);
374 if (regno
>= FIRST_PSEUDO_REGISTER
)
375 ORIGINAL_REGNO (*chain
->loc
) = regno
;
376 REG_ATTRS (*chain
->loc
) = attr
;
377 chain
= chain
->next_use
;
382 static struct du_chain
*open_chains
;
383 static struct du_chain
*closed_chains
;
386 scan_rtx_reg (rtx insn
, rtx
*loc
, enum reg_class cl
,
387 enum scan_actions action
, enum op_type type
, int earlyclobber
)
391 enum machine_mode mode
= GET_MODE (x
);
392 int this_regno
= REGNO (x
);
393 int this_nregs
= hard_regno_nregs
[this_regno
][mode
];
395 if (action
== mark_write
)
399 struct du_chain
*this
400 = obstack_alloc (&rename_obstack
, sizeof (struct du_chain
));
402 this->next_chain
= open_chains
;
406 this->need_caller_save_reg
= 0;
407 this->earlyclobber
= earlyclobber
;
413 if ((type
== OP_OUT
&& action
!= terminate_write
)
414 || (type
!= OP_OUT
&& action
== terminate_write
))
417 for (p
= &open_chains
; *p
;)
419 struct du_chain
*this = *p
;
421 /* Check if the chain has been terminated if it has then skip to
424 This can happen when we've already appended the location to
425 the chain in Step 3, but are trying to hide in-out operands
426 from terminate_write in Step 5. */
428 if (*this->loc
== cc0_rtx
)
429 p
= &this->next_chain
;
432 int regno
= REGNO (*this->loc
);
433 int nregs
= hard_regno_nregs
[regno
][GET_MODE (*this->loc
)];
434 int exact_match
= (regno
== this_regno
&& nregs
== this_nregs
);
436 if (regno
+ nregs
<= this_regno
437 || this_regno
+ this_nregs
<= regno
)
439 p
= &this->next_chain
;
443 if (action
== mark_read
)
448 /* ??? Class NO_REGS can happen if the md file makes use of
449 EXTRA_CONSTRAINTS to match registers. Which is arguably
450 wrong, but there we are. Since we know not what this may
451 be replaced with, terminate the chain. */
454 this = obstack_alloc (&rename_obstack
, sizeof (struct du_chain
));
456 this->next_chain
= (*p
)->next_chain
;
460 this->need_caller_save_reg
= 0;
468 if (action
!= terminate_overlapping_read
|| ! exact_match
)
470 struct du_chain
*next
= this->next_chain
;
472 /* Whether the terminated chain can be used for renaming
473 depends on the action and this being an exact match.
474 In either case, we remove this element from open_chains. */
476 if ((action
== terminate_dead
|| action
== terminate_write
)
479 this->next_chain
= closed_chains
;
480 closed_chains
= this;
483 "Closing chain %s at insn %d (%s)\n",
484 reg_names
[REGNO (*this->loc
)], INSN_UID (insn
),
485 scan_actions_name
[(int) action
]);
491 "Discarding chain %s at insn %d (%s)\n",
492 reg_names
[REGNO (*this->loc
)], INSN_UID (insn
),
493 scan_actions_name
[(int) action
]);
498 p
= &this->next_chain
;
503 /* Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
504 BASE_REG_CLASS depending on how the register is being considered. */
507 scan_rtx_address (rtx insn
, rtx
*loc
, enum reg_class cl
,
508 enum scan_actions action
, enum machine_mode mode
)
511 RTX_CODE code
= GET_CODE (x
);
515 if (action
== mark_write
)
522 rtx orig_op0
= XEXP (x
, 0);
523 rtx orig_op1
= XEXP (x
, 1);
524 RTX_CODE code0
= GET_CODE (orig_op0
);
525 RTX_CODE code1
= GET_CODE (orig_op1
);
531 if (GET_CODE (op0
) == SUBREG
)
533 op0
= SUBREG_REG (op0
);
534 code0
= GET_CODE (op0
);
537 if (GET_CODE (op1
) == SUBREG
)
539 op1
= SUBREG_REG (op1
);
540 code1
= GET_CODE (op1
);
543 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
544 || code0
== ZERO_EXTEND
|| code1
== MEM
)
549 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
550 || code1
== ZERO_EXTEND
|| code0
== MEM
)
555 else if (code0
== CONST_INT
|| code0
== CONST
556 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
558 else if (code1
== CONST_INT
|| code1
== CONST
559 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
561 else if (code0
== REG
&& code1
== REG
)
565 if (REG_OK_FOR_INDEX_P (op0
)
566 && REG_MODE_OK_FOR_BASE_P (op1
, mode
))
568 else if (REG_OK_FOR_INDEX_P (op1
)
569 && REG_MODE_OK_FOR_BASE_P (op0
, mode
))
571 else if (REG_MODE_OK_FOR_BASE_P (op1
, mode
))
573 else if (REG_MODE_OK_FOR_BASE_P (op0
, mode
))
575 else if (REG_OK_FOR_INDEX_P (op1
))
580 locI
= &XEXP (x
, index_op
);
581 locB
= &XEXP (x
, !index_op
);
583 else if (code0
== REG
)
588 else if (code1
== REG
)
595 scan_rtx_address (insn
, locI
, INDEX_REG_CLASS
, action
, mode
);
597 scan_rtx_address (insn
, locB
, MODE_BASE_REG_CLASS (mode
), action
, mode
);
608 /* If the target doesn't claim to handle autoinc, this must be
609 something special, like a stack push. Kill this chain. */
610 action
= terminate_all_read
;
615 scan_rtx_address (insn
, &XEXP (x
, 0),
616 MODE_BASE_REG_CLASS (GET_MODE (x
)), action
,
621 scan_rtx_reg (insn
, loc
, cl
, action
, OP_IN
, 0);
628 fmt
= GET_RTX_FORMAT (code
);
629 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
632 scan_rtx_address (insn
, &XEXP (x
, i
), cl
, action
, mode
);
633 else if (fmt
[i
] == 'E')
634 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
635 scan_rtx_address (insn
, &XVECEXP (x
, i
, j
), cl
, action
, mode
);
640 scan_rtx (rtx insn
, rtx
*loc
, enum reg_class cl
,
641 enum scan_actions action
, enum op_type type
, int earlyclobber
)
645 enum rtx_code code
= GET_CODE (x
);
662 scan_rtx_reg (insn
, loc
, cl
, action
, type
, earlyclobber
);
666 scan_rtx_address (insn
, &XEXP (x
, 0),
667 MODE_BASE_REG_CLASS (GET_MODE (x
)), action
,
672 scan_rtx (insn
, &SET_SRC (x
), cl
, action
, OP_IN
, 0);
673 scan_rtx (insn
, &SET_DEST (x
), cl
, action
, OP_OUT
, 0);
676 case STRICT_LOW_PART
:
677 scan_rtx (insn
, &XEXP (x
, 0), cl
, action
, OP_INOUT
, earlyclobber
);
682 scan_rtx (insn
, &XEXP (x
, 0), cl
, action
,
683 type
== OP_IN
? OP_IN
: OP_INOUT
, earlyclobber
);
684 scan_rtx (insn
, &XEXP (x
, 1), cl
, action
, OP_IN
, 0);
685 scan_rtx (insn
, &XEXP (x
, 2), cl
, action
, OP_IN
, 0);
694 /* Should only happen inside MEM. */
698 scan_rtx (insn
, &SET_DEST (x
), cl
, action
, OP_OUT
, 1);
702 scan_rtx (insn
, &XEXP (x
, 0), cl
, action
, type
, 0);
704 scan_rtx (insn
, &XEXP (x
, 1), cl
, action
, type
, 0);
711 fmt
= GET_RTX_FORMAT (code
);
712 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
715 scan_rtx (insn
, &XEXP (x
, i
), cl
, action
, type
, 0);
716 else if (fmt
[i
] == 'E')
717 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
718 scan_rtx (insn
, &XVECEXP (x
, i
, j
), cl
, action
, type
, 0);
722 /* Build def/use chain. */
724 static struct du_chain
*
725 build_def_use (basic_block bb
)
729 open_chains
= closed_chains
= NULL
;
731 for (insn
= BB_HEAD (bb
); ; insn
= NEXT_INSN (insn
))
737 rtx old_operands
[MAX_RECOG_OPERANDS
];
738 rtx old_dups
[MAX_DUP_OPERANDS
];
743 /* Process the insn, determining its effect on the def-use
744 chains. We perform the following steps with the register
745 references in the insn:
746 (1) Any read that overlaps an open chain, but doesn't exactly
747 match, causes that chain to be closed. We can't deal
749 (2) Any read outside an operand causes any chain it overlaps
750 with to be closed, since we can't replace it.
751 (3) Any read inside an operand is added if there's already
752 an open chain for it.
753 (4) For any REG_DEAD note we find, close open chains that
755 (5) For any write we find, close open chains that overlap it.
756 (6) For any write we find in an operand, make a new chain.
757 (7) For any REG_UNUSED, close any chains we just opened. */
759 icode
= recog_memoized (insn
);
761 if (! constrain_operands (1))
762 fatal_insn_not_found (insn
);
763 preprocess_constraints ();
764 alt
= which_alternative
;
765 n_ops
= recog_data
.n_operands
;
767 /* Simplify the code below by rewriting things to reflect
768 matching constraints. Also promote OP_OUT to OP_INOUT
769 in predicated instructions. */
771 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
772 for (i
= 0; i
< n_ops
; ++i
)
774 int matches
= recog_op_alt
[i
][alt
].matches
;
776 recog_op_alt
[i
][alt
].cl
= recog_op_alt
[matches
][alt
].cl
;
777 if (matches
>= 0 || recog_op_alt
[i
][alt
].matched
>= 0
778 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
779 recog_data
.operand_type
[i
] = OP_INOUT
;
782 /* Step 1: Close chains for which we have overlapping reads. */
783 for (i
= 0; i
< n_ops
; i
++)
784 scan_rtx (insn
, recog_data
.operand_loc
[i
],
785 NO_REGS
, terminate_overlapping_read
,
786 recog_data
.operand_type
[i
], 0);
788 /* Step 2: Close chains for which we have reads outside operands.
789 We do this by munging all operands into CC0, and closing
790 everything remaining. */
792 for (i
= 0; i
< n_ops
; i
++)
794 old_operands
[i
] = recog_data
.operand
[i
];
795 /* Don't squash match_operator or match_parallel here, since
796 we don't know that all of the contained registers are
797 reachable by proper operands. */
798 if (recog_data
.constraints
[i
][0] == '\0')
800 *recog_data
.operand_loc
[i
] = cc0_rtx
;
802 for (i
= 0; i
< recog_data
.n_dups
; i
++)
804 int dup_num
= recog_data
.dup_num
[i
];
806 old_dups
[i
] = *recog_data
.dup_loc
[i
];
807 *recog_data
.dup_loc
[i
] = cc0_rtx
;
809 /* For match_dup of match_operator or match_parallel, share
810 them, so that we don't miss changes in the dup. */
812 && insn_data
[icode
].operand
[dup_num
].eliminable
== 0)
813 old_dups
[i
] = recog_data
.operand
[dup_num
];
816 scan_rtx (insn
, &PATTERN (insn
), NO_REGS
, terminate_all_read
,
819 for (i
= 0; i
< recog_data
.n_dups
; i
++)
820 *recog_data
.dup_loc
[i
] = old_dups
[i
];
821 for (i
= 0; i
< n_ops
; i
++)
822 *recog_data
.operand_loc
[i
] = old_operands
[i
];
824 /* Step 2B: Can't rename function call argument registers. */
825 if (CALL_P (insn
) && CALL_INSN_FUNCTION_USAGE (insn
))
826 scan_rtx (insn
, &CALL_INSN_FUNCTION_USAGE (insn
),
827 NO_REGS
, terminate_all_read
, OP_IN
, 0);
829 /* Step 2C: Can't rename asm operands that were originally
831 if (asm_noperands (PATTERN (insn
)) > 0)
832 for (i
= 0; i
< n_ops
; i
++)
834 rtx
*loc
= recog_data
.operand_loc
[i
];
838 && REGNO (op
) == ORIGINAL_REGNO (op
)
839 && (recog_data
.operand_type
[i
] == OP_IN
840 || recog_data
.operand_type
[i
] == OP_INOUT
))
841 scan_rtx (insn
, loc
, NO_REGS
, terminate_all_read
, OP_IN
, 0);
844 /* Step 3: Append to chains for reads inside operands. */
845 for (i
= 0; i
< n_ops
+ recog_data
.n_dups
; i
++)
847 int opn
= i
< n_ops
? i
: recog_data
.dup_num
[i
- n_ops
];
848 rtx
*loc
= (i
< n_ops
849 ? recog_data
.operand_loc
[opn
]
850 : recog_data
.dup_loc
[i
- n_ops
]);
851 enum reg_class cl
= recog_op_alt
[opn
][alt
].cl
;
852 enum op_type type
= recog_data
.operand_type
[opn
];
854 /* Don't scan match_operand here, since we've no reg class
855 information to pass down. Any operands that we could
856 substitute in will be represented elsewhere. */
857 if (recog_data
.constraints
[opn
][0] == '\0')
860 if (recog_op_alt
[opn
][alt
].is_address
)
861 scan_rtx_address (insn
, loc
, cl
, mark_read
, VOIDmode
);
863 scan_rtx (insn
, loc
, cl
, mark_read
, type
, 0);
866 /* Step 4: Close chains for registers that die here.
867 Also record updates for REG_INC notes. */
868 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
870 if (REG_NOTE_KIND (note
) == REG_DEAD
)
871 scan_rtx (insn
, &XEXP (note
, 0), NO_REGS
, terminate_dead
,
873 else if (REG_NOTE_KIND (note
) == REG_INC
)
874 scan_rtx (insn
, &XEXP (note
, 0), ALL_REGS
, mark_read
,
878 /* Step 4B: If this is a call, any chain live at this point
879 requires a caller-saved reg. */
883 for (p
= open_chains
; p
; p
= p
->next_chain
)
884 p
->need_caller_save_reg
= 1;
887 /* Step 5: Close open chains that overlap writes. Similar to
888 step 2, we hide in-out operands, since we do not want to
889 close these chains. */
891 for (i
= 0; i
< n_ops
; i
++)
893 old_operands
[i
] = recog_data
.operand
[i
];
894 if (recog_data
.operand_type
[i
] == OP_INOUT
)
895 *recog_data
.operand_loc
[i
] = cc0_rtx
;
897 for (i
= 0; i
< recog_data
.n_dups
; i
++)
899 int opn
= recog_data
.dup_num
[i
];
900 old_dups
[i
] = *recog_data
.dup_loc
[i
];
901 if (recog_data
.operand_type
[opn
] == OP_INOUT
)
902 *recog_data
.dup_loc
[i
] = cc0_rtx
;
905 scan_rtx (insn
, &PATTERN (insn
), NO_REGS
, terminate_write
, OP_IN
, 0);
907 for (i
= 0; i
< recog_data
.n_dups
; i
++)
908 *recog_data
.dup_loc
[i
] = old_dups
[i
];
909 for (i
= 0; i
< n_ops
; i
++)
910 *recog_data
.operand_loc
[i
] = old_operands
[i
];
912 /* Step 6: Begin new chains for writes inside operands. */
913 /* ??? Many targets have output constraints on the SET_DEST
914 of a call insn, which is stupid, since these are certainly
915 ABI defined hard registers. Don't change calls at all.
916 Similarly take special care for asm statement that originally
917 referenced hard registers. */
918 if (asm_noperands (PATTERN (insn
)) > 0)
920 for (i
= 0; i
< n_ops
; i
++)
921 if (recog_data
.operand_type
[i
] == OP_OUT
)
923 rtx
*loc
= recog_data
.operand_loc
[i
];
925 enum reg_class cl
= recog_op_alt
[i
][alt
].cl
;
928 && REGNO (op
) == ORIGINAL_REGNO (op
))
931 scan_rtx (insn
, loc
, cl
, mark_write
, OP_OUT
,
932 recog_op_alt
[i
][alt
].earlyclobber
);
935 else if (!CALL_P (insn
))
936 for (i
= 0; i
< n_ops
+ recog_data
.n_dups
; i
++)
938 int opn
= i
< n_ops
? i
: recog_data
.dup_num
[i
- n_ops
];
939 rtx
*loc
= (i
< n_ops
940 ? recog_data
.operand_loc
[opn
]
941 : recog_data
.dup_loc
[i
- n_ops
]);
942 enum reg_class cl
= recog_op_alt
[opn
][alt
].cl
;
944 if (recog_data
.operand_type
[opn
] == OP_OUT
)
945 scan_rtx (insn
, loc
, cl
, mark_write
, OP_OUT
,
946 recog_op_alt
[opn
][alt
].earlyclobber
);
949 /* Step 7: Close chains for registers that were never
951 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
952 if (REG_NOTE_KIND (note
) == REG_UNUSED
)
953 scan_rtx (insn
, &XEXP (note
, 0), NO_REGS
, terminate_dead
,
956 if (insn
== BB_END (bb
))
960 /* Since we close every chain when we find a REG_DEAD note, anything that
961 is still open lives past the basic block, so it can't be renamed. */
962 return closed_chains
;
965 /* Dump all def/use chains in CHAINS to DUMP_FILE. They are
966 printed in reverse order as that's how we build them. */
969 dump_def_use_chain (struct du_chain
*chains
)
973 struct du_chain
*this = chains
;
974 int r
= REGNO (*this->loc
);
975 int nregs
= hard_regno_nregs
[r
][GET_MODE (*this->loc
)];
976 fprintf (dump_file
, "Register %s (%d):", reg_names
[r
], nregs
);
979 fprintf (dump_file
, " %d [%s]", INSN_UID (this->insn
),
980 reg_class_names
[this->cl
]);
981 this = this->next_use
;
983 fprintf (dump_file
, "\n");
984 chains
= chains
->next_chain
;
988 /* The following code does forward propagation of hard register copies.
989 The object is to eliminate as many dependencies as possible, so that
990 we have the most scheduling freedom. As a side effect, we also clean
991 up some silly register allocation decisions made by reload. This
992 code may be obsoleted by a new register allocator. */
994 /* For each register, we have a list of registers that contain the same
995 value. The OLDEST_REGNO field points to the head of the list, and
996 the NEXT_REGNO field runs through the list. The MODE field indicates
997 what mode the data is known to be in; this field is VOIDmode when the
998 register is not known to contain valid data. */
1000 struct value_data_entry
1002 enum machine_mode mode
;
1003 unsigned int oldest_regno
;
1004 unsigned int next_regno
;
1009 struct value_data_entry e
[FIRST_PSEUDO_REGISTER
];
1010 unsigned int max_value_regs
;
1013 static void kill_value_one_regno (unsigned, struct value_data
*);
1014 static void kill_value_regno (unsigned, unsigned, struct value_data
*);
1015 static void kill_value (rtx
, struct value_data
*);
1016 static void set_value_regno (unsigned, enum machine_mode
, struct value_data
*);
1017 static void init_value_data (struct value_data
*);
1018 static void kill_clobbered_value (rtx
, rtx
, void *);
1019 static void kill_set_value (rtx
, rtx
, void *);
1020 static int kill_autoinc_value (rtx
*, void *);
1021 static void copy_value (rtx
, rtx
, struct value_data
*);
1022 static bool mode_change_ok (enum machine_mode
, enum machine_mode
,
1024 static rtx
maybe_mode_change (enum machine_mode
, enum machine_mode
,
1025 enum machine_mode
, unsigned int, unsigned int);
1026 static rtx
find_oldest_value_reg (enum reg_class
, rtx
, struct value_data
*);
1027 static bool replace_oldest_value_reg (rtx
*, enum reg_class
, rtx
,
1028 struct value_data
*);
1029 static bool replace_oldest_value_addr (rtx
*, enum reg_class
,
1030 enum machine_mode
, rtx
,
1031 struct value_data
*);
1032 static bool replace_oldest_value_mem (rtx
, rtx
, struct value_data
*);
1033 static bool copyprop_hardreg_forward_1 (basic_block
, struct value_data
*);
1034 extern void debug_value_data (struct value_data
*);
1035 #ifdef ENABLE_CHECKING
1036 static void validate_value_data (struct value_data
*);
1039 /* Kill register REGNO. This involves removing it from any value
1040 lists, and resetting the value mode to VOIDmode. This is only a
1041 helper function; it does not handle any hard registers overlapping
1045 kill_value_one_regno (unsigned int regno
, struct value_data
*vd
)
1047 unsigned int i
, next
;
1049 if (vd
->e
[regno
].oldest_regno
!= regno
)
1051 for (i
= vd
->e
[regno
].oldest_regno
;
1052 vd
->e
[i
].next_regno
!= regno
;
1053 i
= vd
->e
[i
].next_regno
)
1055 vd
->e
[i
].next_regno
= vd
->e
[regno
].next_regno
;
1057 else if ((next
= vd
->e
[regno
].next_regno
) != INVALID_REGNUM
)
1059 for (i
= next
; i
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
1060 vd
->e
[i
].oldest_regno
= next
;
1063 vd
->e
[regno
].mode
= VOIDmode
;
1064 vd
->e
[regno
].oldest_regno
= regno
;
1065 vd
->e
[regno
].next_regno
= INVALID_REGNUM
;
1067 #ifdef ENABLE_CHECKING
1068 validate_value_data (vd
);
1072 /* Kill the value in register REGNO for NREGS, and any other registers
1073 whose values overlap. */
1076 kill_value_regno (regno
, nregs
, vd
)
1079 struct value_data
*vd
;
1083 /* Kill the value we're told to kill. */
1084 for (j
= 0; j
< nregs
; ++j
)
1085 kill_value_one_regno (regno
+ j
, vd
);
1087 /* Kill everything that overlapped what we're told to kill. */
1088 if (regno
< vd
->max_value_regs
)
1091 j
= regno
- vd
->max_value_regs
;
1092 for (; j
< regno
; ++j
)
1095 if (vd
->e
[j
].mode
== VOIDmode
)
1097 n
= hard_regno_nregs
[j
][vd
->e
[j
].mode
];
1099 for (i
= 0; i
< n
; ++i
)
1100 kill_value_one_regno (j
+ i
, vd
);
1104 /* Kill X. This is a convenience function wrapping kill_value_regno
1105 so that we mind the mode the register is in. */
1108 kill_value (rtx x
, struct value_data
*vd
)
1110 /* SUBREGS are supposed to have been eliminated by now. But some
1111 ports, e.g. i386 sse, use them to smuggle vector type information
1112 through to instruction selection. Each such SUBREG should simplify,
1113 so if we get a NULL we've done something wrong elsewhere. */
1115 if (GET_CODE (x
) == SUBREG
)
1116 x
= simplify_subreg (GET_MODE (x
), SUBREG_REG (x
),
1117 GET_MODE (SUBREG_REG (x
)), SUBREG_BYTE (x
));
1120 unsigned int regno
= REGNO (x
);
1121 unsigned int n
= hard_regno_nregs
[regno
][GET_MODE (x
)];
1123 kill_value_regno (regno
, n
, vd
);
1127 /* Remember that REGNO is valid in MODE. */
1130 set_value_regno (unsigned int regno
, enum machine_mode mode
,
1131 struct value_data
*vd
)
1135 vd
->e
[regno
].mode
= mode
;
1137 nregs
= hard_regno_nregs
[regno
][mode
];
1138 if (nregs
> vd
->max_value_regs
)
1139 vd
->max_value_regs
= nregs
;
1142 /* Initialize VD such that there are no known relationships between regs. */
1145 init_value_data (struct value_data
*vd
)
1148 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1150 vd
->e
[i
].mode
= VOIDmode
;
1151 vd
->e
[i
].oldest_regno
= i
;
1152 vd
->e
[i
].next_regno
= INVALID_REGNUM
;
1154 vd
->max_value_regs
= 0;
1157 /* Called through note_stores. If X is clobbered, kill its value. */
1160 kill_clobbered_value (rtx x
, rtx set
, void *data
)
1162 struct value_data
*vd
= data
;
1163 if (GET_CODE (set
) == CLOBBER
)
1167 /* Called through note_stores. If X is set, not clobbered, kill its
1168 current value and install it as the root of its own value list. */
1171 kill_set_value (rtx x
, rtx set
, void *data
)
1173 struct value_data
*vd
= data
;
1174 if (GET_CODE (set
) != CLOBBER
)
1178 set_value_regno (REGNO (x
), GET_MODE (x
), vd
);
1182 /* Called through for_each_rtx. Kill any register used as the base of an
1183 auto-increment expression, and install that register as the root of its
1187 kill_autoinc_value (rtx
*px
, void *data
)
1190 struct value_data
*vd
= data
;
1192 if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_AUTOINC
)
1196 set_value_regno (REGNO (x
), Pmode
, vd
);
1203 /* Assert that SRC has been copied to DEST. Adjust the data structures
1204 to reflect that SRC contains an older copy of the shared value. */
1207 copy_value (rtx dest
, rtx src
, struct value_data
*vd
)
1209 unsigned int dr
= REGNO (dest
);
1210 unsigned int sr
= REGNO (src
);
1211 unsigned int dn
, sn
;
1214 /* ??? At present, it's possible to see noop sets. It'd be nice if
1215 this were cleaned up beforehand... */
1219 /* Do not propagate copies to the stack pointer, as that can leave
1220 memory accesses with no scheduling dependency on the stack update. */
1221 if (dr
== STACK_POINTER_REGNUM
)
1224 /* Likewise with the frame pointer, if we're using one. */
1225 if (frame_pointer_needed
&& dr
== HARD_FRAME_POINTER_REGNUM
)
1228 /* If SRC and DEST overlap, don't record anything. */
1229 dn
= hard_regno_nregs
[dr
][GET_MODE (dest
)];
1230 sn
= hard_regno_nregs
[sr
][GET_MODE (dest
)];
1231 if ((dr
> sr
&& dr
< sr
+ sn
)
1232 || (sr
> dr
&& sr
< dr
+ dn
))
1235 /* If SRC had no assigned mode (i.e. we didn't know it was live)
1236 assign it now and assume the value came from an input argument
1238 if (vd
->e
[sr
].mode
== VOIDmode
)
1239 set_value_regno (sr
, vd
->e
[dr
].mode
, vd
);
1241 /* If we are narrowing the input to a smaller number of hard regs,
1242 and it is in big endian, we are really extracting a high part.
1243 Since we generally associate a low part of a value with the value itself,
1244 we must not do the same for the high part.
1245 Note we can still get low parts for the same mode combination through
1246 a two-step copy involving differently sized hard regs.
1247 Assume hard regs fr* are 32 bits bits each, while r* are 64 bits each:
1248 (set (reg:DI r0) (reg:DI fr0))
1249 (set (reg:SI fr2) (reg:SI r0))
1250 loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
1251 (set (reg:SI fr2) (reg:SI fr0))
1252 loads the high part of (reg:DI fr0) into fr2.
1254 We can't properly represent the latter case in our tables, so don't
1255 record anything then. */
1256 else if (sn
< (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
]
1257 && (GET_MODE_SIZE (vd
->e
[sr
].mode
) > UNITS_PER_WORD
1258 ? WORDS_BIG_ENDIAN
: BYTES_BIG_ENDIAN
))
1261 /* If SRC had been assigned a mode narrower than the copy, we can't
1262 link DEST into the chain, because not all of the pieces of the
1263 copy came from oldest_regno. */
1264 else if (sn
> (unsigned int) hard_regno_nregs
[sr
][vd
->e
[sr
].mode
])
1267 /* Link DR at the end of the value chain used by SR. */
1269 vd
->e
[dr
].oldest_regno
= vd
->e
[sr
].oldest_regno
;
1271 for (i
= sr
; vd
->e
[i
].next_regno
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
1273 vd
->e
[i
].next_regno
= dr
;
1275 #ifdef ENABLE_CHECKING
1276 validate_value_data (vd
);
1280 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
1283 mode_change_ok (enum machine_mode orig_mode
, enum machine_mode new_mode
,
1284 unsigned int regno ATTRIBUTE_UNUSED
)
1286 if (GET_MODE_SIZE (orig_mode
) < GET_MODE_SIZE (new_mode
))
1289 #ifdef CANNOT_CHANGE_MODE_CLASS
1290 return !REG_CANNOT_CHANGE_MODE_P (regno
, orig_mode
, new_mode
);
1296 /* Register REGNO was originally set in ORIG_MODE. It - or a copy of it -
1297 was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
1299 Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX. */
1302 maybe_mode_change (enum machine_mode orig_mode
, enum machine_mode copy_mode
,
1303 enum machine_mode new_mode
, unsigned int regno
,
1304 unsigned int copy_regno ATTRIBUTE_UNUSED
)
1306 if (orig_mode
== new_mode
)
1307 return gen_rtx_raw_REG (new_mode
, regno
);
1308 else if (mode_change_ok (orig_mode
, new_mode
, regno
))
1310 int copy_nregs
= hard_regno_nregs
[copy_regno
][copy_mode
];
1311 int use_nregs
= hard_regno_nregs
[copy_regno
][new_mode
];
1313 = GET_MODE_SIZE (copy_mode
) / copy_nregs
* (copy_nregs
- use_nregs
);
1315 = GET_MODE_SIZE (orig_mode
) - GET_MODE_SIZE (new_mode
) - copy_offset
;
1316 int byteoffset
= offset
% UNITS_PER_WORD
;
1317 int wordoffset
= offset
- byteoffset
;
1319 offset
= ((WORDS_BIG_ENDIAN
? wordoffset
: 0)
1320 + (BYTES_BIG_ENDIAN
? byteoffset
: 0));
1321 return gen_rtx_raw_REG (new_mode
,
1322 regno
+ subreg_regno_offset (regno
, orig_mode
,
1329 /* Find the oldest copy of the value contained in REGNO that is in
1330 register class CL and has mode MODE. If found, return an rtx
1331 of that oldest register, otherwise return NULL. */
1334 find_oldest_value_reg (enum reg_class cl
, rtx reg
, struct value_data
*vd
)
1336 unsigned int regno
= REGNO (reg
);
1337 enum machine_mode mode
= GET_MODE (reg
);
1340 /* If we are accessing REG in some mode other that what we set it in,
1341 make sure that the replacement is valid. In particular, consider
1342 (set (reg:DI r11) (...))
1343 (set (reg:SI r9) (reg:SI r11))
1344 (set (reg:SI r10) (...))
1345 (set (...) (reg:DI r9))
1346 Replacing r9 with r11 is invalid. */
1347 if (mode
!= vd
->e
[regno
].mode
)
1349 if (hard_regno_nregs
[regno
][mode
]
1350 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
1354 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
; i
= vd
->e
[i
].next_regno
)
1356 enum machine_mode oldmode
= vd
->e
[i
].mode
;
1360 for (last
= i
; last
< i
+ hard_regno_nregs
[i
][mode
]; last
++)
1361 if (!TEST_HARD_REG_BIT (reg_class_contents
[cl
], last
))
1364 new = maybe_mode_change (oldmode
, vd
->e
[regno
].mode
, mode
, i
, regno
);
1367 ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg
);
1368 REG_ATTRS (new) = REG_ATTRS (reg
);
1376 /* If possible, replace the register at *LOC with the oldest register
1377 in register class CL. Return true if successfully replaced. */
1380 replace_oldest_value_reg (rtx
*loc
, enum reg_class cl
, rtx insn
,
1381 struct value_data
*vd
)
1383 rtx
new = find_oldest_value_reg (cl
, *loc
, vd
);
1387 fprintf (dump_file
, "insn %u: replaced reg %u with %u\n",
1388 INSN_UID (insn
), REGNO (*loc
), REGNO (new));
1396 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
1397 Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or
1398 BASE_REG_CLASS depending on how the register is being considered. */
1401 replace_oldest_value_addr (rtx
*loc
, enum reg_class cl
,
1402 enum machine_mode mode
, rtx insn
,
1403 struct value_data
*vd
)
1406 RTX_CODE code
= GET_CODE (x
);
1409 bool changed
= false;
1415 rtx orig_op0
= XEXP (x
, 0);
1416 rtx orig_op1
= XEXP (x
, 1);
1417 RTX_CODE code0
= GET_CODE (orig_op0
);
1418 RTX_CODE code1
= GET_CODE (orig_op1
);
1424 if (GET_CODE (op0
) == SUBREG
)
1426 op0
= SUBREG_REG (op0
);
1427 code0
= GET_CODE (op0
);
1430 if (GET_CODE (op1
) == SUBREG
)
1432 op1
= SUBREG_REG (op1
);
1433 code1
= GET_CODE (op1
);
1436 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
1437 || code0
== ZERO_EXTEND
|| code1
== MEM
)
1439 locI
= &XEXP (x
, 0);
1440 locB
= &XEXP (x
, 1);
1442 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
1443 || code1
== ZERO_EXTEND
|| code0
== MEM
)
1445 locI
= &XEXP (x
, 1);
1446 locB
= &XEXP (x
, 0);
1448 else if (code0
== CONST_INT
|| code0
== CONST
1449 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
1450 locB
= &XEXP (x
, 1);
1451 else if (code1
== CONST_INT
|| code1
== CONST
1452 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
1453 locB
= &XEXP (x
, 0);
1454 else if (code0
== REG
&& code1
== REG
)
1458 if (REG_OK_FOR_INDEX_P (op0
)
1459 && REG_MODE_OK_FOR_BASE_P (op1
, mode
))
1461 else if (REG_OK_FOR_INDEX_P (op1
)
1462 && REG_MODE_OK_FOR_BASE_P (op0
, mode
))
1464 else if (REG_MODE_OK_FOR_BASE_P (op1
, mode
))
1466 else if (REG_MODE_OK_FOR_BASE_P (op0
, mode
))
1468 else if (REG_OK_FOR_INDEX_P (op1
))
1473 locI
= &XEXP (x
, index_op
);
1474 locB
= &XEXP (x
, !index_op
);
1476 else if (code0
== REG
)
1478 locI
= &XEXP (x
, 0);
1479 locB
= &XEXP (x
, 1);
1481 else if (code1
== REG
)
1483 locI
= &XEXP (x
, 1);
1484 locB
= &XEXP (x
, 0);
1488 changed
|= replace_oldest_value_addr (locI
, INDEX_REG_CLASS
, mode
,
1491 changed
|= replace_oldest_value_addr (locB
,
1492 MODE_BASE_REG_CLASS (mode
),
1506 return replace_oldest_value_mem (x
, insn
, vd
);
1509 return replace_oldest_value_reg (loc
, cl
, insn
, vd
);
1515 fmt
= GET_RTX_FORMAT (code
);
1516 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1519 changed
|= replace_oldest_value_addr (&XEXP (x
, i
), cl
, mode
,
1521 else if (fmt
[i
] == 'E')
1522 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1523 changed
|= replace_oldest_value_addr (&XVECEXP (x
, i
, j
), cl
,
1530 /* Similar to replace_oldest_value_reg, but X contains a memory. */
1533 replace_oldest_value_mem (rtx x
, rtx insn
, struct value_data
*vd
)
1535 return replace_oldest_value_addr (&XEXP (x
, 0),
1536 MODE_BASE_REG_CLASS (GET_MODE (x
)),
1537 GET_MODE (x
), insn
, vd
);
1540 /* Perform the forward copy propagation on basic block BB. */
1543 copyprop_hardreg_forward_1 (basic_block bb
, struct value_data
*vd
)
1545 bool changed
= false;
1548 for (insn
= BB_HEAD (bb
); ; insn
= NEXT_INSN (insn
))
1550 int n_ops
, i
, alt
, predicated
;
1554 if (! INSN_P (insn
))
1556 if (insn
== BB_END (bb
))
1562 set
= single_set (insn
);
1563 extract_insn (insn
);
1564 if (! constrain_operands (1))
1565 fatal_insn_not_found (insn
);
1566 preprocess_constraints ();
1567 alt
= which_alternative
;
1568 n_ops
= recog_data
.n_operands
;
1569 is_asm
= asm_noperands (PATTERN (insn
)) >= 0;
1571 /* Simplify the code below by rewriting things to reflect
1572 matching constraints. Also promote OP_OUT to OP_INOUT
1573 in predicated instructions. */
1575 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
1576 for (i
= 0; i
< n_ops
; ++i
)
1578 int matches
= recog_op_alt
[i
][alt
].matches
;
1580 recog_op_alt
[i
][alt
].cl
= recog_op_alt
[matches
][alt
].cl
;
1581 if (matches
>= 0 || recog_op_alt
[i
][alt
].matched
>= 0
1582 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
1583 recog_data
.operand_type
[i
] = OP_INOUT
;
1586 /* For each earlyclobber operand, zap the value data. */
1587 for (i
= 0; i
< n_ops
; i
++)
1588 if (recog_op_alt
[i
][alt
].earlyclobber
)
1589 kill_value (recog_data
.operand
[i
], vd
);
1591 /* Within asms, a clobber cannot overlap inputs or outputs.
1592 I wouldn't think this were true for regular insns, but
1593 scan_rtx treats them like that... */
1594 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
1596 /* Kill all auto-incremented values. */
1597 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
1598 for_each_rtx (&PATTERN (insn
), kill_autoinc_value
, vd
);
1600 /* Kill all early-clobbered operands. */
1601 for (i
= 0; i
< n_ops
; i
++)
1602 if (recog_op_alt
[i
][alt
].earlyclobber
)
1603 kill_value (recog_data
.operand
[i
], vd
);
1605 /* Special-case plain move instructions, since we may well
1606 be able to do the move from a different register class. */
1607 if (set
&& REG_P (SET_SRC (set
)))
1609 rtx src
= SET_SRC (set
);
1610 unsigned int regno
= REGNO (src
);
1611 enum machine_mode mode
= GET_MODE (src
);
1615 /* If we are accessing SRC in some mode other that what we
1616 set it in, make sure that the replacement is valid. */
1617 if (mode
!= vd
->e
[regno
].mode
)
1619 if (hard_regno_nregs
[regno
][mode
]
1620 > hard_regno_nregs
[regno
][vd
->e
[regno
].mode
])
1621 goto no_move_special_case
;
1624 /* If the destination is also a register, try to find a source
1625 register in the same class. */
1626 if (REG_P (SET_DEST (set
)))
1628 new = find_oldest_value_reg (REGNO_REG_CLASS (regno
), src
, vd
);
1629 if (new && validate_change (insn
, &SET_SRC (set
), new, 0))
1633 "insn %u: replaced reg %u with %u\n",
1634 INSN_UID (insn
), regno
, REGNO (new));
1636 goto did_replacement
;
1640 /* Otherwise, try all valid registers and see if its valid. */
1641 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
;
1642 i
= vd
->e
[i
].next_regno
)
1644 new = maybe_mode_change (vd
->e
[i
].mode
, vd
->e
[regno
].mode
,
1646 if (new != NULL_RTX
)
1648 if (validate_change (insn
, &SET_SRC (set
), new, 0))
1650 ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src
);
1651 REG_ATTRS (new) = REG_ATTRS (src
);
1654 "insn %u: replaced reg %u with %u\n",
1655 INSN_UID (insn
), regno
, REGNO (new));
1657 goto did_replacement
;
1662 no_move_special_case
:
1664 /* For each input operand, replace a hard register with the
1665 eldest live copy that's in an appropriate register class. */
1666 for (i
= 0; i
< n_ops
; i
++)
1668 bool replaced
= false;
1670 /* Don't scan match_operand here, since we've no reg class
1671 information to pass down. Any operands that we could
1672 substitute in will be represented elsewhere. */
1673 if (recog_data
.constraints
[i
][0] == '\0')
1676 /* Don't replace in asms intentionally referencing hard regs. */
1677 if (is_asm
&& REG_P (recog_data
.operand
[i
])
1678 && (REGNO (recog_data
.operand
[i
])
1679 == ORIGINAL_REGNO (recog_data
.operand
[i
])))
1682 if (recog_data
.operand_type
[i
] == OP_IN
)
1684 if (recog_op_alt
[i
][alt
].is_address
)
1686 = replace_oldest_value_addr (recog_data
.operand_loc
[i
],
1687 recog_op_alt
[i
][alt
].cl
,
1688 VOIDmode
, insn
, vd
);
1689 else if (REG_P (recog_data
.operand
[i
]))
1691 = replace_oldest_value_reg (recog_data
.operand_loc
[i
],
1692 recog_op_alt
[i
][alt
].cl
,
1694 else if (MEM_P (recog_data
.operand
[i
]))
1695 replaced
= replace_oldest_value_mem (recog_data
.operand
[i
],
1698 else if (MEM_P (recog_data
.operand
[i
]))
1699 replaced
= replace_oldest_value_mem (recog_data
.operand
[i
],
1702 /* If we performed any replacement, update match_dups. */
1710 new = *recog_data
.operand_loc
[i
];
1711 recog_data
.operand
[i
] = new;
1712 for (j
= 0; j
< recog_data
.n_dups
; j
++)
1713 if (recog_data
.dup_num
[j
] == i
)
1714 *recog_data
.dup_loc
[j
] = new;
1719 /* Clobber call-clobbered registers. */
1721 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1722 if (TEST_HARD_REG_BIT (regs_invalidated_by_call
, i
))
1723 kill_value_regno (i
, 1, vd
);
1725 /* Notice stores. */
1726 note_stores (PATTERN (insn
), kill_set_value
, vd
);
1728 /* Notice copies. */
1729 if (set
&& REG_P (SET_DEST (set
)) && REG_P (SET_SRC (set
)))
1730 copy_value (SET_DEST (set
), SET_SRC (set
), vd
);
1732 if (insn
== BB_END (bb
))
1739 /* Main entry point for the forward copy propagation optimization. */
1742 copyprop_hardreg_forward (void)
1744 struct value_data
*all_vd
;
1746 basic_block bb
, bbp
= 0;
1748 need_refresh
= false;
1750 all_vd
= xmalloc (sizeof (struct value_data
) * last_basic_block
);
1754 /* If a block has a single predecessor, that we've already
1755 processed, begin with the value data that was live at
1756 the end of the predecessor block. */
1757 /* ??? Ought to use more intelligent queuing of blocks. */
1759 for (bbp
= bb
; bbp
&& bbp
!= bb
->pred
->src
; bbp
= bbp
->prev_bb
);
1761 && ! bb
->pred
->pred_next
1762 && ! (bb
->pred
->flags
& (EDGE_ABNORMAL_CALL
| EDGE_EH
))
1763 && bb
->pred
->src
!= ENTRY_BLOCK_PTR
1765 all_vd
[bb
->index
] = all_vd
[bb
->pred
->src
->index
];
1767 init_value_data (all_vd
+ bb
->index
);
1769 if (copyprop_hardreg_forward_1 (bb
, all_vd
+ bb
->index
))
1770 need_refresh
= true;
1776 fputs ("\n\n", dump_file
);
1778 /* ??? Irritatingly, delete_noop_moves does not take a set of blocks
1779 to scan, so we have to do a life update with no initial set of
1780 blocks Just In Case. */
1781 delete_noop_moves ();
1782 update_life_info (NULL
, UPDATE_LIFE_GLOBAL_RM_NOTES
,
1784 | PROP_SCAN_DEAD_CODE
1785 | PROP_KILL_DEAD_CODE
);
1791 /* Dump the value chain data to stderr. */
1794 debug_value_data (struct value_data
*vd
)
1799 CLEAR_HARD_REG_SET (set
);
1801 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1802 if (vd
->e
[i
].oldest_regno
== i
)
1804 if (vd
->e
[i
].mode
== VOIDmode
)
1806 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1807 fprintf (stderr
, "[%u] Bad next_regno for empty chain (%u)\n",
1808 i
, vd
->e
[i
].next_regno
);
1812 SET_HARD_REG_BIT (set
, i
);
1813 fprintf (stderr
, "[%u %s] ", i
, GET_MODE_NAME (vd
->e
[i
].mode
));
1815 for (j
= vd
->e
[i
].next_regno
;
1816 j
!= INVALID_REGNUM
;
1817 j
= vd
->e
[j
].next_regno
)
1819 if (TEST_HARD_REG_BIT (set
, j
))
1821 fprintf (stderr
, "[%u] Loop in regno chain\n", j
);
1825 if (vd
->e
[j
].oldest_regno
!= i
)
1827 fprintf (stderr
, "[%u] Bad oldest_regno (%u)\n",
1828 j
, vd
->e
[j
].oldest_regno
);
1831 SET_HARD_REG_BIT (set
, j
);
1832 fprintf (stderr
, "[%u %s] ", j
, GET_MODE_NAME (vd
->e
[j
].mode
));
1834 fputc ('\n', stderr
);
1837 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1838 if (! TEST_HARD_REG_BIT (set
, i
)
1839 && (vd
->e
[i
].mode
!= VOIDmode
1840 || vd
->e
[i
].oldest_regno
!= i
1841 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1842 fprintf (stderr
, "[%u] Non-empty reg in chain (%s %u %i)\n",
1843 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1844 vd
->e
[i
].next_regno
);
1847 #ifdef ENABLE_CHECKING
1849 validate_value_data (struct value_data
*vd
)
1854 CLEAR_HARD_REG_SET (set
);
1856 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1857 if (vd
->e
[i
].oldest_regno
== i
)
1859 if (vd
->e
[i
].mode
== VOIDmode
)
1861 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1862 internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1863 i
, vd
->e
[i
].next_regno
);
1867 SET_HARD_REG_BIT (set
, i
);
1869 for (j
= vd
->e
[i
].next_regno
;
1870 j
!= INVALID_REGNUM
;
1871 j
= vd
->e
[j
].next_regno
)
1873 if (TEST_HARD_REG_BIT (set
, j
))
1874 internal_error ("validate_value_data: Loop in regno chain (%u)",
1876 if (vd
->e
[j
].oldest_regno
!= i
)
1877 internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1878 j
, vd
->e
[j
].oldest_regno
);
1880 SET_HARD_REG_BIT (set
, j
);
1884 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1885 if (! TEST_HARD_REG_BIT (set
, i
)
1886 && (vd
->e
[i
].mode
!= VOIDmode
1887 || vd
->e
[i
].oldest_regno
!= i
1888 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1889 internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1890 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1891 vd
->e
[i
].next_regno
);