1 /* Register renaming for the GNU compiler.
2 Copyright (C) 2000, 2001, 2002 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
27 #include "insn-config.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
39 #define obstack_chunk_alloc xmalloc
40 #define obstack_chunk_free free
42 #ifndef REGNO_MODE_OK_FOR_BASE_P
43 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
46 #ifndef REG_MODE_OK_FOR_BASE_P
47 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
50 static const char *const reg_class_names
[] = REG_CLASS_NAMES
;
54 struct du_chain
*next_chain
;
55 struct du_chain
*next_use
;
60 unsigned int need_caller_save_reg
:1;
61 unsigned int earlyclobber
:1;
67 terminate_overlapping_read
,
74 static const char * const scan_actions_name
[] =
77 "terminate_overlapping_read",
84 static struct obstack rename_obstack
;
86 static void do_replace
PARAMS ((struct du_chain
*, int));
87 static void scan_rtx_reg
PARAMS ((rtx
, rtx
*, enum reg_class
,
88 enum scan_actions
, enum op_type
, int));
89 static void scan_rtx_address
PARAMS ((rtx
, rtx
*, enum reg_class
,
90 enum scan_actions
, enum machine_mode
));
91 static void scan_rtx
PARAMS ((rtx
, rtx
*, enum reg_class
,
92 enum scan_actions
, enum op_type
, int));
93 static struct du_chain
*build_def_use
PARAMS ((basic_block
));
94 static void dump_def_use_chain
PARAMS ((struct du_chain
*));
95 static void note_sets
PARAMS ((rtx
, rtx
, void *));
96 static void clear_dead_regs
PARAMS ((HARD_REG_SET
*, enum machine_mode
, rtx
));
97 static void merge_overlapping_regs
PARAMS ((basic_block
, HARD_REG_SET
*,
100 /* Called through note_stores from update_life. Find sets of registers, and
101 record them in *DATA (which is actually a HARD_REG_SET *). */
104 note_sets (x
, set
, data
)
106 rtx set ATTRIBUTE_UNUSED
;
109 HARD_REG_SET
*pset
= (HARD_REG_SET
*) data
;
112 if (GET_CODE (x
) != REG
)
115 nregs
= HARD_REGNO_NREGS (regno
, GET_MODE (x
));
117 /* There must not be pseudos at this point. */
118 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
122 SET_HARD_REG_BIT (*pset
, regno
+ nregs
);
125 /* Clear all registers from *PSET for which a note of kind KIND can be found
126 in the list NOTES. */
129 clear_dead_regs (pset
, kind
, notes
)
131 enum machine_mode kind
;
135 for (note
= notes
; note
; note
= XEXP (note
, 1))
136 if (REG_NOTE_KIND (note
) == kind
&& REG_P (XEXP (note
, 0)))
138 rtx reg
= XEXP (note
, 0);
139 unsigned int regno
= REGNO (reg
);
140 int nregs
= HARD_REGNO_NREGS (regno
, GET_MODE (reg
));
142 /* There must not be pseudos at this point. */
143 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
147 CLEAR_HARD_REG_BIT (*pset
, regno
+ nregs
);
151 /* For a def-use chain CHAIN in basic block B, find which registers overlap
152 its lifetime and set the corresponding bits in *PSET. */
155 merge_overlapping_regs (b
, pset
, chain
)
158 struct du_chain
*chain
;
160 struct du_chain
*t
= chain
;
164 REG_SET_TO_HARD_REG_SET (live
, b
->global_live_at_start
);
168 /* Search forward until the next reference to the register to be
170 while (insn
!= t
->insn
)
174 clear_dead_regs (&live
, REG_DEAD
, REG_NOTES (insn
));
175 note_stores (PATTERN (insn
), note_sets
, (void *) &live
);
176 /* Only record currently live regs if we are inside the
179 IOR_HARD_REG_SET (*pset
, live
);
180 clear_dead_regs (&live
, REG_UNUSED
, REG_NOTES (insn
));
182 insn
= NEXT_INSN (insn
);
185 IOR_HARD_REG_SET (*pset
, live
);
187 /* For the last reference, also merge in all registers set in the
189 @@@ We only have take earlyclobbered sets into account. */
191 note_stores (PATTERN (insn
), note_sets
, (void *) pset
);
197 /* Perform register renaming on the current function. */
200 regrename_optimize ()
202 int tick
[FIRST_PSEUDO_REGISTER
];
207 memset (tick
, 0, sizeof tick
);
209 gcc_obstack_init (&rename_obstack
);
210 first_obj
= (char *) obstack_alloc (&rename_obstack
, 0);
212 for (b
= 0; b
< n_basic_blocks
; b
++)
214 basic_block bb
= BASIC_BLOCK (b
);
215 struct du_chain
*all_chains
= 0;
216 HARD_REG_SET unavailable
;
217 HARD_REG_SET regs_seen
;
219 CLEAR_HARD_REG_SET (unavailable
);
222 fprintf (rtl_dump_file
, "\nBasic block %d:\n", b
);
224 all_chains
= build_def_use (bb
);
227 dump_def_use_chain (all_chains
);
229 CLEAR_HARD_REG_SET (unavailable
);
230 /* Don't clobber traceback for noreturn functions. */
231 if (frame_pointer_needed
)
235 for (i
= HARD_REGNO_NREGS (FRAME_POINTER_REGNUM
, Pmode
); i
--;)
236 SET_HARD_REG_BIT (unavailable
, FRAME_POINTER_REGNUM
+ i
);
238 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
239 for (i
= HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM
, Pmode
); i
--;)
240 SET_HARD_REG_BIT (unavailable
, HARD_FRAME_POINTER_REGNUM
+ i
);
244 CLEAR_HARD_REG_SET (regs_seen
);
247 int new_reg
, best_new_reg
= -1;
249 struct du_chain
*this = all_chains
;
250 struct du_chain
*tmp
, *last
;
251 HARD_REG_SET this_unavailable
;
252 int reg
= REGNO (*this->loc
);
255 all_chains
= this->next_chain
;
257 #if 0 /* This just disables optimization opportunities. */
258 /* Only rename once we've seen the reg more than once. */
259 if (! TEST_HARD_REG_BIT (regs_seen
, reg
))
261 SET_HARD_REG_BIT (regs_seen
, reg
);
266 if (fixed_regs
[reg
] || global_regs
[reg
]
267 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
268 || (frame_pointer_needed
&& reg
== HARD_FRAME_POINTER_REGNUM
)
270 || (frame_pointer_needed
&& reg
== FRAME_POINTER_REGNUM
)
275 COPY_HARD_REG_SET (this_unavailable
, unavailable
);
277 /* Find last entry on chain (which has the need_caller_save bit),
278 count number of uses, and narrow the set of registers we can
281 for (last
= this; last
->next_use
; last
= last
->next_use
)
284 IOR_COMPL_HARD_REG_SET (this_unavailable
,
285 reg_class_contents
[last
->class]);
290 IOR_COMPL_HARD_REG_SET (this_unavailable
,
291 reg_class_contents
[last
->class]);
293 if (this->need_caller_save_reg
)
294 IOR_HARD_REG_SET (this_unavailable
, call_used_reg_set
);
296 merge_overlapping_regs (bb
, &this_unavailable
, this);
298 /* Now potential_regs is a reasonable approximation, let's
299 have a closer look at each register still in there. */
300 for (new_reg
= 0; new_reg
< FIRST_PSEUDO_REGISTER
; new_reg
++)
302 int nregs
= HARD_REGNO_NREGS (new_reg
, GET_MODE (*this->loc
));
304 for (i
= nregs
- 1; i
>= 0; --i
)
305 if (TEST_HARD_REG_BIT (this_unavailable
, new_reg
+ i
)
306 || fixed_regs
[new_reg
+ i
]
307 || global_regs
[new_reg
+ i
]
308 /* Can't use regs which aren't saved by the prologue. */
309 || (! regs_ever_live
[new_reg
+ i
]
310 && ! call_used_regs
[new_reg
+ i
])
311 #ifdef LEAF_REGISTERS
312 /* We can't use a non-leaf register if we're in a
314 || (current_function_is_leaf
315 && !LEAF_REGISTERS
[new_reg
+ i
])
317 #ifdef HARD_REGNO_RENAME_OK
318 || ! HARD_REGNO_RENAME_OK (reg
+ i
, new_reg
+ i
)
325 /* See whether it accepts all modes that occur in
326 definition and uses. */
327 for (tmp
= this; tmp
; tmp
= tmp
->next_use
)
328 if (! HARD_REGNO_MODE_OK (new_reg
, GET_MODE (*tmp
->loc
))
329 || (tmp
->need_caller_save_reg
330 && ! (HARD_REGNO_CALL_PART_CLOBBERED
331 (reg
, GET_MODE (*tmp
->loc
)))
332 && (HARD_REGNO_CALL_PART_CLOBBERED
333 (new_reg
, GET_MODE (*tmp
->loc
)))))
337 if (best_new_reg
== -1
338 || tick
[best_new_reg
] > tick
[new_reg
])
339 best_new_reg
= new_reg
;
345 fprintf (rtl_dump_file
, "Register %s in insn %d",
346 reg_names
[reg
], INSN_UID (last
->insn
));
347 if (last
->need_caller_save_reg
)
348 fprintf (rtl_dump_file
, " crosses a call");
351 if (best_new_reg
== -1)
354 fprintf (rtl_dump_file
, "; no available registers\n");
358 do_replace (this, best_new_reg
);
359 tick
[best_new_reg
] = this_tick
++;
362 fprintf (rtl_dump_file
, ", renamed as %s\n", reg_names
[best_new_reg
]);
365 obstack_free (&rename_obstack
, first_obj
);
368 obstack_free (&rename_obstack
, NULL
);
371 fputc ('\n', rtl_dump_file
);
373 count_or_remove_death_notes (NULL
, 1);
374 update_life_info (NULL
, UPDATE_LIFE_LOCAL
,
375 PROP_REG_INFO
| PROP_DEATH_NOTES
);
379 do_replace (chain
, reg
)
380 struct du_chain
*chain
;
385 unsigned int regno
= ORIGINAL_REGNO (*chain
->loc
);
386 *chain
->loc
= gen_raw_REG (GET_MODE (*chain
->loc
), reg
);
387 if (regno
>= FIRST_PSEUDO_REGISTER
)
388 ORIGINAL_REGNO (*chain
->loc
) = regno
;
389 chain
= chain
->next_use
;
394 static struct du_chain
*open_chains
;
395 static struct du_chain
*closed_chains
;
398 scan_rtx_reg (insn
, loc
, class, action
, type
, earlyclobber
)
401 enum reg_class
class;
402 enum scan_actions action
;
408 enum machine_mode mode
= GET_MODE (x
);
409 int this_regno
= REGNO (x
);
410 int this_nregs
= HARD_REGNO_NREGS (this_regno
, mode
);
412 if (action
== mark_write
)
416 struct du_chain
*this = (struct du_chain
*)
417 obstack_alloc (&rename_obstack
, sizeof (struct du_chain
));
419 this->next_chain
= open_chains
;
423 this->need_caller_save_reg
= 0;
424 this->earlyclobber
= earlyclobber
;
430 if ((type
== OP_OUT
&& action
!= terminate_write
)
431 || (type
!= OP_OUT
&& action
== terminate_write
))
434 for (p
= &open_chains
; *p
;)
436 struct du_chain
*this = *p
;
438 /* Check if the chain has been terminated if it has then skip to
441 This can happen when we've already appended the location to
442 the chain in Step 3, but are trying to hide in-out operands
443 from terminate_write in Step 5. */
445 if (*this->loc
== cc0_rtx
)
446 p
= &this->next_chain
;
449 int regno
= REGNO (*this->loc
);
450 int nregs
= HARD_REGNO_NREGS (regno
, GET_MODE (*this->loc
));
451 int exact_match
= (regno
== this_regno
&& nregs
== this_nregs
);
453 if (regno
+ nregs
<= this_regno
454 || this_regno
+ this_nregs
<= regno
)
456 p
= &this->next_chain
;
460 if (action
== mark_read
)
465 /* ??? Class NO_REGS can happen if the md file makes use of
466 EXTRA_CONSTRAINTS to match registers. Which is arguably
467 wrong, but there we are. Since we know not what this may
468 be replaced with, terminate the chain. */
469 if (class != NO_REGS
)
471 this = (struct du_chain
*)
472 obstack_alloc (&rename_obstack
, sizeof (struct du_chain
));
474 this->next_chain
= (*p
)->next_chain
;
478 this->need_caller_save_reg
= 0;
486 if (action
!= terminate_overlapping_read
|| ! exact_match
)
488 struct du_chain
*next
= this->next_chain
;
490 /* Whether the terminated chain can be used for renaming
491 depends on the action and this being an exact match.
492 In either case, we remove this element from open_chains. */
494 if ((action
== terminate_dead
|| action
== terminate_write
)
497 this->next_chain
= closed_chains
;
498 closed_chains
= this;
500 fprintf (rtl_dump_file
,
501 "Closing chain %s at insn %d (%s)\n",
502 reg_names
[REGNO (*this->loc
)], INSN_UID (insn
),
503 scan_actions_name
[(int) action
]);
508 fprintf (rtl_dump_file
,
509 "Discarding chain %s at insn %d (%s)\n",
510 reg_names
[REGNO (*this->loc
)], INSN_UID (insn
),
511 scan_actions_name
[(int) action
]);
516 p
= &this->next_chain
;
521 /* Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
522 BASE_REG_CLASS depending on how the register is being considered. */
525 scan_rtx_address (insn
, loc
, class, action
, mode
)
528 enum reg_class
class;
529 enum scan_actions action
;
530 enum machine_mode mode
;
533 RTX_CODE code
= GET_CODE (x
);
537 if (action
== mark_write
)
544 rtx orig_op0
= XEXP (x
, 0);
545 rtx orig_op1
= XEXP (x
, 1);
546 RTX_CODE code0
= GET_CODE (orig_op0
);
547 RTX_CODE code1
= GET_CODE (orig_op1
);
553 if (GET_CODE (op0
) == SUBREG
)
555 op0
= SUBREG_REG (op0
);
556 code0
= GET_CODE (op0
);
559 if (GET_CODE (op1
) == SUBREG
)
561 op1
= SUBREG_REG (op1
);
562 code1
= GET_CODE (op1
);
565 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
566 || code0
== ZERO_EXTEND
|| code1
== MEM
)
571 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
572 || code1
== ZERO_EXTEND
|| code0
== MEM
)
577 else if (code0
== CONST_INT
|| code0
== CONST
578 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
580 else if (code1
== CONST_INT
|| code1
== CONST
581 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
583 else if (code0
== REG
&& code1
== REG
)
587 if (REG_OK_FOR_INDEX_P (op0
)
588 && REG_MODE_OK_FOR_BASE_P (op1
, mode
))
590 else if (REG_OK_FOR_INDEX_P (op1
)
591 && REG_MODE_OK_FOR_BASE_P (op0
, mode
))
593 else if (REG_MODE_OK_FOR_BASE_P (op1
, mode
))
595 else if (REG_MODE_OK_FOR_BASE_P (op0
, mode
))
597 else if (REG_OK_FOR_INDEX_P (op1
))
602 locI
= &XEXP (x
, index_op
);
603 locB
= &XEXP (x
, !index_op
);
605 else if (code0
== REG
)
610 else if (code1
== REG
)
617 scan_rtx_address (insn
, locI
, INDEX_REG_CLASS
, action
, mode
);
619 scan_rtx_address (insn
, locB
, MODE_BASE_REG_CLASS (mode
), action
, mode
);
630 /* If the target doesn't claim to handle autoinc, this must be
631 something special, like a stack push. Kill this chain. */
632 action
= terminate_all_read
;
637 scan_rtx_address (insn
, &XEXP (x
, 0),
638 MODE_BASE_REG_CLASS (GET_MODE (x
)), action
,
643 scan_rtx_reg (insn
, loc
, class, action
, OP_IN
, 0);
650 fmt
= GET_RTX_FORMAT (code
);
651 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
654 scan_rtx_address (insn
, &XEXP (x
, i
), class, action
, mode
);
655 else if (fmt
[i
] == 'E')
656 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
657 scan_rtx_address (insn
, &XVECEXP (x
, i
, j
), class, action
, mode
);
662 scan_rtx (insn
, loc
, class, action
, type
, earlyclobber
)
665 enum reg_class
class;
666 enum scan_actions action
;
672 enum rtx_code code
= GET_CODE (x
);
689 scan_rtx_reg (insn
, loc
, class, action
, type
, earlyclobber
);
693 scan_rtx_address (insn
, &XEXP (x
, 0),
694 MODE_BASE_REG_CLASS (GET_MODE (x
)), action
,
699 scan_rtx (insn
, &SET_SRC (x
), class, action
, OP_IN
, 0);
700 scan_rtx (insn
, &SET_DEST (x
), class, action
, OP_OUT
, 0);
703 case STRICT_LOW_PART
:
704 scan_rtx (insn
, &XEXP (x
, 0), class, action
, OP_INOUT
, earlyclobber
);
709 scan_rtx (insn
, &XEXP (x
, 0), class, action
,
710 type
== OP_IN
? OP_IN
: OP_INOUT
, earlyclobber
);
711 scan_rtx (insn
, &XEXP (x
, 1), class, action
, OP_IN
, 0);
712 scan_rtx (insn
, &XEXP (x
, 2), class, action
, OP_IN
, 0);
721 /* Should only happen inside MEM. */
725 scan_rtx (insn
, &SET_DEST (x
), class, action
, OP_OUT
, 1);
729 scan_rtx (insn
, &XEXP (x
, 0), class, action
, type
, 0);
731 scan_rtx (insn
, &XEXP (x
, 1), class, action
, type
, 0);
738 fmt
= GET_RTX_FORMAT (code
);
739 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
742 scan_rtx (insn
, &XEXP (x
, i
), class, action
, type
, 0);
743 else if (fmt
[i
] == 'E')
744 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
745 scan_rtx (insn
, &XVECEXP (x
, i
, j
), class, action
, type
, 0);
749 /* Build def/use chain */
751 static struct du_chain
*
757 open_chains
= closed_chains
= NULL
;
759 for (insn
= bb
->head
; ; insn
= NEXT_INSN (insn
))
765 rtx old_operands
[MAX_RECOG_OPERANDS
];
766 rtx old_dups
[MAX_DUP_OPERANDS
];
771 /* Process the insn, determining its effect on the def-use
772 chains. We perform the following steps with the register
773 references in the insn:
774 (1) Any read that overlaps an open chain, but doesn't exactly
775 match, causes that chain to be closed. We can't deal
777 (2) Any read outside an operand causes any chain it overlaps
778 with to be closed, since we can't replace it.
779 (3) Any read inside an operand is added if there's already
780 an open chain for it.
781 (4) For any REG_DEAD note we find, close open chains that
783 (5) For any write we find, close open chains that overlap it.
784 (6) For any write we find in an operand, make a new chain.
785 (7) For any REG_UNUSED, close any chains we just opened. */
787 icode
= recog_memoized (insn
);
789 constrain_operands (1);
790 preprocess_constraints ();
791 alt
= which_alternative
;
792 n_ops
= recog_data
.n_operands
;
794 /* Simplify the code below by rewriting things to reflect
795 matching constraints. Also promote OP_OUT to OP_INOUT
796 in predicated instructions. */
798 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
799 for (i
= 0; i
< n_ops
; ++i
)
801 int matches
= recog_op_alt
[i
][alt
].matches
;
803 recog_op_alt
[i
][alt
].class = recog_op_alt
[matches
][alt
].class;
804 if (matches
>= 0 || recog_op_alt
[i
][alt
].matched
>= 0
805 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
806 recog_data
.operand_type
[i
] = OP_INOUT
;
809 /* Step 1: Close chains for which we have overlapping reads. */
810 for (i
= 0; i
< n_ops
; i
++)
811 scan_rtx (insn
, recog_data
.operand_loc
[i
],
812 NO_REGS
, terminate_overlapping_read
,
813 recog_data
.operand_type
[i
], 0);
815 /* Step 2: Close chains for which we have reads outside operands.
816 We do this by munging all operands into CC0, and closing
817 everything remaining. */
819 for (i
= 0; i
< n_ops
; i
++)
821 old_operands
[i
] = recog_data
.operand
[i
];
822 /* Don't squash match_operator or match_parallel here, since
823 we don't know that all of the contained registers are
824 reachable by proper operands. */
825 if (recog_data
.constraints
[i
][0] == '\0')
827 *recog_data
.operand_loc
[i
] = cc0_rtx
;
829 for (i
= 0; i
< recog_data
.n_dups
; i
++)
831 int dup_num
= recog_data
.dup_num
[i
];
833 old_dups
[i
] = *recog_data
.dup_loc
[i
];
834 *recog_data
.dup_loc
[i
] = cc0_rtx
;
836 /* For match_dup of match_operator or match_parallel, share
837 them, so that we don't miss changes in the dup. */
839 && insn_data
[icode
].operand
[dup_num
].eliminable
== 0)
840 old_dups
[i
] = recog_data
.operand
[dup_num
];
843 scan_rtx (insn
, &PATTERN (insn
), NO_REGS
, terminate_all_read
,
846 for (i
= 0; i
< recog_data
.n_dups
; i
++)
847 *recog_data
.dup_loc
[i
] = old_dups
[i
];
848 for (i
= 0; i
< n_ops
; i
++)
849 *recog_data
.operand_loc
[i
] = old_operands
[i
];
851 /* Step 2B: Can't rename function call argument registers. */
852 if (GET_CODE (insn
) == CALL_INSN
&& CALL_INSN_FUNCTION_USAGE (insn
))
853 scan_rtx (insn
, &CALL_INSN_FUNCTION_USAGE (insn
),
854 NO_REGS
, terminate_all_read
, OP_IN
, 0);
856 /* Step 2C: Can't rename asm operands that were originally
858 if (asm_noperands (PATTERN (insn
)) > 0)
859 for (i
= 0; i
< n_ops
; i
++)
861 rtx
*loc
= recog_data
.operand_loc
[i
];
864 if (GET_CODE (op
) == REG
865 && REGNO (op
) == ORIGINAL_REGNO (op
)
866 && (recog_data
.operand_type
[i
] == OP_IN
867 || recog_data
.operand_type
[i
] == OP_INOUT
))
868 scan_rtx (insn
, loc
, NO_REGS
, terminate_all_read
, OP_IN
, 0);
871 /* Step 3: Append to chains for reads inside operands. */
872 for (i
= 0; i
< n_ops
+ recog_data
.n_dups
; i
++)
874 int opn
= i
< n_ops
? i
: recog_data
.dup_num
[i
- n_ops
];
875 rtx
*loc
= (i
< n_ops
876 ? recog_data
.operand_loc
[opn
]
877 : recog_data
.dup_loc
[i
- n_ops
]);
878 enum reg_class
class = recog_op_alt
[opn
][alt
].class;
879 enum op_type type
= recog_data
.operand_type
[opn
];
881 /* Don't scan match_operand here, since we've no reg class
882 information to pass down. Any operands that we could
883 substitute in will be represented elsewhere. */
884 if (recog_data
.constraints
[opn
][0] == '\0')
887 if (recog_op_alt
[opn
][alt
].is_address
)
888 scan_rtx_address (insn
, loc
, class, mark_read
, VOIDmode
);
890 scan_rtx (insn
, loc
, class, mark_read
, type
, 0);
893 /* Step 4: Close chains for registers that die here.
894 Also record updates for REG_INC notes. */
895 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
897 if (REG_NOTE_KIND (note
) == REG_DEAD
)
898 scan_rtx (insn
, &XEXP (note
, 0), NO_REGS
, terminate_dead
,
900 else if (REG_NOTE_KIND (note
) == REG_INC
)
901 scan_rtx (insn
, &XEXP (note
, 0), ALL_REGS
, mark_read
,
905 /* Step 4B: If this is a call, any chain live at this point
906 requires a caller-saved reg. */
907 if (GET_CODE (insn
) == CALL_INSN
)
910 for (p
= open_chains
; p
; p
= p
->next_chain
)
911 p
->need_caller_save_reg
= 1;
914 /* Step 5: Close open chains that overlap writes. Similar to
915 step 2, we hide in-out operands, since we do not want to
916 close these chains. */
918 for (i
= 0; i
< n_ops
; i
++)
920 old_operands
[i
] = recog_data
.operand
[i
];
921 if (recog_data
.operand_type
[i
] == OP_INOUT
)
922 *recog_data
.operand_loc
[i
] = cc0_rtx
;
924 for (i
= 0; i
< recog_data
.n_dups
; i
++)
926 int opn
= recog_data
.dup_num
[i
];
927 old_dups
[i
] = *recog_data
.dup_loc
[i
];
928 if (recog_data
.operand_type
[opn
] == OP_INOUT
)
929 *recog_data
.dup_loc
[i
] = cc0_rtx
;
932 scan_rtx (insn
, &PATTERN (insn
), NO_REGS
, terminate_write
, OP_IN
, 0);
934 for (i
= 0; i
< recog_data
.n_dups
; i
++)
935 *recog_data
.dup_loc
[i
] = old_dups
[i
];
936 for (i
= 0; i
< n_ops
; i
++)
937 *recog_data
.operand_loc
[i
] = old_operands
[i
];
939 /* Step 6: Begin new chains for writes inside operands. */
940 /* ??? Many targets have output constraints on the SET_DEST
941 of a call insn, which is stupid, since these are certainly
942 ABI defined hard registers. Don't change calls at all.
943 Similarly take special care for asm statement that originally
944 referenced hard registers. */
945 if (asm_noperands (PATTERN (insn
)) > 0)
947 for (i
= 0; i
< n_ops
; i
++)
948 if (recog_data
.operand_type
[i
] == OP_OUT
)
950 rtx
*loc
= recog_data
.operand_loc
[i
];
952 enum reg_class
class = recog_op_alt
[i
][alt
].class;
954 if (GET_CODE (op
) == REG
955 && REGNO (op
) == ORIGINAL_REGNO (op
))
958 scan_rtx (insn
, loc
, class, mark_write
, OP_OUT
,
959 recog_op_alt
[i
][alt
].earlyclobber
);
962 else if (GET_CODE (insn
) != CALL_INSN
)
963 for (i
= 0; i
< n_ops
+ recog_data
.n_dups
; i
++)
965 int opn
= i
< n_ops
? i
: recog_data
.dup_num
[i
- n_ops
];
966 rtx
*loc
= (i
< n_ops
967 ? recog_data
.operand_loc
[opn
]
968 : recog_data
.dup_loc
[i
- n_ops
]);
969 enum reg_class
class = recog_op_alt
[opn
][alt
].class;
971 if (recog_data
.operand_type
[opn
] == OP_OUT
)
972 scan_rtx (insn
, loc
, class, mark_write
, OP_OUT
,
973 recog_op_alt
[opn
][alt
].earlyclobber
);
976 /* Step 7: Close chains for registers that were never
978 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
979 if (REG_NOTE_KIND (note
) == REG_UNUSED
)
980 scan_rtx (insn
, &XEXP (note
, 0), NO_REGS
, terminate_dead
,
987 /* Since we close every chain when we find a REG_DEAD note, anything that
988 is still open lives past the basic block, so it can't be renamed. */
989 return closed_chains
;
992 /* Dump all def/use chains in CHAINS to RTL_DUMP_FILE. They are
993 printed in reverse order as that's how we build them. */
996 dump_def_use_chain (chains
)
997 struct du_chain
*chains
;
1001 struct du_chain
*this = chains
;
1002 int r
= REGNO (*this->loc
);
1003 int nregs
= HARD_REGNO_NREGS (r
, GET_MODE (*this->loc
));
1004 fprintf (rtl_dump_file
, "Register %s (%d):", reg_names
[r
], nregs
);
1007 fprintf (rtl_dump_file
, " %d [%s]", INSN_UID (this->insn
),
1008 reg_class_names
[this->class]);
1009 this = this->next_use
;
1011 fprintf (rtl_dump_file
, "\n");
1012 chains
= chains
->next_chain
;
1016 /* The following code does forward propagation of hard register copies.
1017 The object is to eliminate as many dependencies as possible, so that
1018 we have the most scheduling freedom. As a side effect, we also clean
1019 up some silly register allocation decisions made by reload. This
1020 code may be obsoleted by a new register allocator. */
1022 /* For each register, we have a list of registers that contain the same
1023 value. The OLDEST_REGNO field points to the head of the list, and
1024 the NEXT_REGNO field runs through the list. The MODE field indicates
1025 what mode the data is known to be in; this field is VOIDmode when the
1026 register is not known to contain valid data. */
1028 struct value_data_entry
1030 enum machine_mode mode
;
1031 unsigned int oldest_regno
;
1032 unsigned int next_regno
;
1037 struct value_data_entry e
[FIRST_PSEUDO_REGISTER
];
1038 unsigned int max_value_regs
;
1041 static void kill_value_regno
PARAMS ((unsigned, struct value_data
*));
1042 static void kill_value
PARAMS ((rtx
, struct value_data
*));
1043 static void set_value_regno
PARAMS ((unsigned, enum machine_mode
,
1044 struct value_data
*));
1045 static void init_value_data
PARAMS ((struct value_data
*));
1046 static void kill_clobbered_value
PARAMS ((rtx
, rtx
, void *));
1047 static void kill_set_value
PARAMS ((rtx
, rtx
, void *));
1048 static int kill_autoinc_value
PARAMS ((rtx
*, void *));
1049 static void copy_value
PARAMS ((rtx
, rtx
, struct value_data
*));
1050 static bool mode_change_ok
PARAMS ((enum machine_mode
, enum machine_mode
,
1052 static rtx find_oldest_value_reg
PARAMS ((enum reg_class
, rtx
,
1053 struct value_data
*));
1054 static bool replace_oldest_value_reg
PARAMS ((rtx
*, enum reg_class
, rtx
,
1055 struct value_data
*));
1056 static bool replace_oldest_value_addr
PARAMS ((rtx
*, enum reg_class
,
1057 enum machine_mode
, rtx
,
1058 struct value_data
*));
1059 static bool replace_oldest_value_mem
PARAMS ((rtx
, rtx
, struct value_data
*));
1060 static bool copyprop_hardreg_forward_1
PARAMS ((basic_block
,
1061 struct value_data
*));
1062 extern void debug_value_data
PARAMS ((struct value_data
*));
1063 #ifdef ENABLE_CHECKING
1064 static void validate_value_data
PARAMS ((struct value_data
*));
1067 /* Kill register REGNO. This involves removing it from any value lists,
1068 and resetting the value mode to VOIDmode. */
1071 kill_value_regno (regno
, vd
)
1073 struct value_data
*vd
;
1075 unsigned int i
, next
;
1077 if (vd
->e
[regno
].oldest_regno
!= regno
)
1079 for (i
= vd
->e
[regno
].oldest_regno
;
1080 vd
->e
[i
].next_regno
!= regno
;
1081 i
= vd
->e
[i
].next_regno
)
1083 vd
->e
[i
].next_regno
= vd
->e
[regno
].next_regno
;
1085 else if ((next
= vd
->e
[regno
].next_regno
) != INVALID_REGNUM
)
1087 for (i
= next
; i
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
1088 vd
->e
[i
].oldest_regno
= next
;
1091 vd
->e
[regno
].mode
= VOIDmode
;
1092 vd
->e
[regno
].oldest_regno
= regno
;
1093 vd
->e
[regno
].next_regno
= INVALID_REGNUM
;
1095 #ifdef ENABLE_CHECKING
1096 validate_value_data (vd
);
1100 /* Kill X. This is a convenience function for kill_value_regno
1101 so that we mind the mode the register is in. */
1106 struct value_data
*vd
;
1108 /* SUBREGS are supposed to have been eliminated by now. But some
1109 ports, e.g. i386 sse, use them to smuggle vector type information
1110 through to instruction selection. Each such SUBREG should simplify,
1111 so if we get a NULL we've done something wrong elsewhere. */
1113 if (GET_CODE (x
) == SUBREG
)
1114 x
= simplify_subreg (GET_MODE (x
), SUBREG_REG (x
),
1115 GET_MODE (SUBREG_REG (x
)), SUBREG_BYTE (x
));
1118 unsigned int regno
= REGNO (x
);
1119 unsigned int n
= HARD_REGNO_NREGS (regno
, GET_MODE (x
));
1122 /* Kill the value we're told to kill. */
1123 for (i
= 0; i
< n
; ++i
)
1124 kill_value_regno (regno
+ i
, vd
);
1126 /* Kill everything that overlapped what we're told to kill. */
1127 if (regno
< vd
->max_value_regs
)
1130 j
= regno
- vd
->max_value_regs
;
1131 for (; j
< regno
; ++j
)
1133 if (vd
->e
[j
].mode
== VOIDmode
)
1135 n
= HARD_REGNO_NREGS (j
, vd
->e
[j
].mode
);
1137 for (i
= 0; i
< n
; ++i
)
1138 kill_value_regno (j
+ i
, vd
);
1143 /* Remember that REGNO is valid in MODE. */
1146 set_value_regno (regno
, mode
, vd
)
1148 enum machine_mode mode
;
1149 struct value_data
*vd
;
1153 vd
->e
[regno
].mode
= mode
;
1155 nregs
= HARD_REGNO_NREGS (regno
, mode
);
1156 if (nregs
> vd
->max_value_regs
)
1157 vd
->max_value_regs
= nregs
;
1160 /* Initialize VD such that there are no known relationships between regs. */
1163 init_value_data (vd
)
1164 struct value_data
*vd
;
1167 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1169 vd
->e
[i
].mode
= VOIDmode
;
1170 vd
->e
[i
].oldest_regno
= i
;
1171 vd
->e
[i
].next_regno
= INVALID_REGNUM
;
1173 vd
->max_value_regs
= 0;
1176 /* Called through note_stores. If X is clobbered, kill its value. */
1179 kill_clobbered_value (x
, set
, data
)
1184 struct value_data
*vd
= data
;
1185 if (GET_CODE (set
) == CLOBBER
)
1189 /* Called through note_stores. If X is set, not clobbered, kill its
1190 current value and install it as the root of its own value list. */
1193 kill_set_value (x
, set
, data
)
1198 struct value_data
*vd
= data
;
1199 if (GET_CODE (set
) != CLOBBER
)
1203 set_value_regno (REGNO (x
), GET_MODE (x
), vd
);
1207 /* Called through for_each_rtx. Kill any register used as the base of an
1208 auto-increment expression, and install that register as the root of its
1212 kill_autoinc_value (px
, data
)
1217 struct value_data
*vd
= data
;
1219 if (GET_RTX_CLASS (GET_CODE (x
)) == 'a')
1223 set_value_regno (REGNO (x
), Pmode
, vd
);
1230 /* Assert that SRC has been copied to DEST. Adjust the data structures
1231 to reflect that SRC contains an older copy of the shared value. */
1234 copy_value (dest
, src
, vd
)
1237 struct value_data
*vd
;
1239 unsigned int dr
= REGNO (dest
);
1240 unsigned int sr
= REGNO (src
);
1241 unsigned int dn
, sn
;
1244 /* ??? At present, it's possible to see noop sets. It'd be nice if
1245 this were cleaned up beforehand... */
1249 /* Do not propagate copies to the stack pointer, as that can leave
1250 memory accesses with no scheduling dependancy on the stack update. */
1251 if (dr
== STACK_POINTER_REGNUM
)
1254 /* Likewise with the frame pointer, if we're using one. */
1255 if (frame_pointer_needed
&& dr
== HARD_FRAME_POINTER_REGNUM
)
1258 /* If SRC and DEST overlap, don't record anything. */
1259 dn
= HARD_REGNO_NREGS (dr
, GET_MODE (dest
));
1260 sn
= HARD_REGNO_NREGS (sr
, GET_MODE (dest
));
1261 if ((dr
> sr
&& dr
< sr
+ sn
)
1262 || (sr
> dr
&& sr
< dr
+ dn
))
1265 /* If SRC had no assigned mode (i.e. we didn't know it was live)
1266 assign it now and assume the value came from an input argument
1268 if (vd
->e
[sr
].mode
== VOIDmode
)
1269 set_value_regno (sr
, vd
->e
[dr
].mode
, vd
);
1271 /* If SRC had been assigned a mode narrower than the copy, we can't
1272 link DEST into the chain, because not all of the pieces of the
1273 copy came from oldest_regno. */
1274 else if (sn
> (unsigned int) HARD_REGNO_NREGS (sr
, vd
->e
[sr
].mode
))
1277 /* Link DR at the end of the value chain used by SR. */
1279 vd
->e
[dr
].oldest_regno
= vd
->e
[sr
].oldest_regno
;
1281 for (i
= sr
; vd
->e
[i
].next_regno
!= INVALID_REGNUM
; i
= vd
->e
[i
].next_regno
)
1283 vd
->e
[i
].next_regno
= dr
;
1285 #ifdef ENABLE_CHECKING
1286 validate_value_data (vd
);
1290 /* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
1293 mode_change_ok (orig_mode
, new_mode
, regno
)
1294 enum machine_mode orig_mode
, new_mode
;
1295 unsigned int regno ATTRIBUTE_UNUSED
;
1297 if (GET_MODE_SIZE (orig_mode
) < GET_MODE_SIZE (new_mode
))
1300 #ifdef CLASS_CANNOT_CHANGE_MODE
1301 if (TEST_HARD_REG_BIT (reg_class_contents
[CLASS_CANNOT_CHANGE_MODE
], regno
)
1302 && CLASS_CANNOT_CHANGE_MODE_P (orig_mode
, new_mode
))
1309 /* Find the oldest copy of the value contained in REGNO that is in
1310 register class CLASS and has mode MODE. If found, return an rtx
1311 of that oldest register, otherwise return NULL. */
1314 find_oldest_value_reg (class, reg
, vd
)
1315 enum reg_class
class;
1317 struct value_data
*vd
;
1319 unsigned int regno
= REGNO (reg
);
1320 enum machine_mode mode
= GET_MODE (reg
);
1323 /* If we are accessing REG in some mode other that what we set it in,
1324 make sure that the replacement is valid. In particular, consider
1325 (set (reg:DI r11) (...))
1326 (set (reg:SI r9) (reg:SI r11))
1327 (set (reg:SI r10) (...))
1328 (set (...) (reg:DI r9))
1329 Replacing r9 with r11 is invalid. */
1330 if (mode
!= vd
->e
[regno
].mode
)
1332 if (HARD_REGNO_NREGS (regno
, mode
)
1333 > HARD_REGNO_NREGS (regno
, vd
->e
[regno
].mode
))
1337 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
; i
= vd
->e
[i
].next_regno
)
1338 if (TEST_HARD_REG_BIT (reg_class_contents
[class], i
)
1339 && (vd
->e
[i
].mode
== mode
1340 || mode_change_ok (vd
->e
[i
].mode
, mode
, i
)))
1342 rtx
new = gen_rtx_raw_REG (mode
, i
);
1343 ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg
);
1350 /* If possible, replace the register at *LOC with the oldest register
1351 in register class CLASS. Return true if successfully replaced. */
1354 replace_oldest_value_reg (loc
, class, insn
, vd
)
1356 enum reg_class
class;
1358 struct value_data
*vd
;
1360 rtx
new = find_oldest_value_reg (class, *loc
, vd
);
1364 fprintf (rtl_dump_file
, "insn %u: replaced reg %u with %u\n",
1365 INSN_UID (insn
), REGNO (*loc
), REGNO (new));
1373 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
1374 Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
1375 BASE_REG_CLASS depending on how the register is being considered. */
1378 replace_oldest_value_addr (loc
, class, mode
, insn
, vd
)
1380 enum reg_class
class;
1381 enum machine_mode mode
;
1383 struct value_data
*vd
;
1386 RTX_CODE code
= GET_CODE (x
);
1389 bool changed
= false;
1395 rtx orig_op0
= XEXP (x
, 0);
1396 rtx orig_op1
= XEXP (x
, 1);
1397 RTX_CODE code0
= GET_CODE (orig_op0
);
1398 RTX_CODE code1
= GET_CODE (orig_op1
);
1404 if (GET_CODE (op0
) == SUBREG
)
1406 op0
= SUBREG_REG (op0
);
1407 code0
= GET_CODE (op0
);
1410 if (GET_CODE (op1
) == SUBREG
)
1412 op1
= SUBREG_REG (op1
);
1413 code1
= GET_CODE (op1
);
1416 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
1417 || code0
== ZERO_EXTEND
|| code1
== MEM
)
1419 locI
= &XEXP (x
, 0);
1420 locB
= &XEXP (x
, 1);
1422 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
1423 || code1
== ZERO_EXTEND
|| code0
== MEM
)
1425 locI
= &XEXP (x
, 1);
1426 locB
= &XEXP (x
, 0);
1428 else if (code0
== CONST_INT
|| code0
== CONST
1429 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
1430 locB
= &XEXP (x
, 1);
1431 else if (code1
== CONST_INT
|| code1
== CONST
1432 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
1433 locB
= &XEXP (x
, 0);
1434 else if (code0
== REG
&& code1
== REG
)
1438 if (REG_OK_FOR_INDEX_P (op0
)
1439 && REG_MODE_OK_FOR_BASE_P (op1
, mode
))
1441 else if (REG_OK_FOR_INDEX_P (op1
)
1442 && REG_MODE_OK_FOR_BASE_P (op0
, mode
))
1444 else if (REG_MODE_OK_FOR_BASE_P (op1
, mode
))
1446 else if (REG_MODE_OK_FOR_BASE_P (op0
, mode
))
1448 else if (REG_OK_FOR_INDEX_P (op1
))
1453 locI
= &XEXP (x
, index_op
);
1454 locB
= &XEXP (x
, !index_op
);
1456 else if (code0
== REG
)
1458 locI
= &XEXP (x
, 0);
1459 locB
= &XEXP (x
, 1);
1461 else if (code1
== REG
)
1463 locI
= &XEXP (x
, 1);
1464 locB
= &XEXP (x
, 0);
1468 changed
|= replace_oldest_value_addr (locI
, INDEX_REG_CLASS
, mode
,
1471 changed
|= replace_oldest_value_addr (locB
,
1472 MODE_BASE_REG_CLASS (mode
),
1486 return replace_oldest_value_mem (x
, insn
, vd
);
1489 return replace_oldest_value_reg (loc
, class, insn
, vd
);
1495 fmt
= GET_RTX_FORMAT (code
);
1496 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1499 changed
|= replace_oldest_value_addr (&XEXP (x
, i
), class, mode
,
1501 else if (fmt
[i
] == 'E')
1502 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1503 changed
|= replace_oldest_value_addr (&XVECEXP (x
, i
, j
), class,
1510 /* Similar to replace_oldest_value_reg, but X contains a memory. */
1513 replace_oldest_value_mem (x
, insn
, vd
)
1516 struct value_data
*vd
;
1518 return replace_oldest_value_addr (&XEXP (x
, 0),
1519 MODE_BASE_REG_CLASS (GET_MODE (x
)),
1520 GET_MODE (x
), insn
, vd
);
1523 /* Perform the forward copy propagation on basic block BB. */
1526 copyprop_hardreg_forward_1 (bb
, vd
)
1528 struct value_data
*vd
;
1530 bool changed
= false;
1533 for (insn
= bb
->head
; ; insn
= NEXT_INSN (insn
))
1535 int n_ops
, i
, alt
, predicated
;
1539 if (! INSN_P (insn
))
1541 if (insn
== bb
->end
)
1547 set
= single_set (insn
);
1548 extract_insn (insn
);
1549 constrain_operands (1);
1550 preprocess_constraints ();
1551 alt
= which_alternative
;
1552 n_ops
= recog_data
.n_operands
;
1553 is_asm
= asm_noperands (PATTERN (insn
)) >= 0;
1555 /* Simplify the code below by rewriting things to reflect
1556 matching constraints. Also promote OP_OUT to OP_INOUT
1557 in predicated instructions. */
1559 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
1560 for (i
= 0; i
< n_ops
; ++i
)
1562 int matches
= recog_op_alt
[i
][alt
].matches
;
1564 recog_op_alt
[i
][alt
].class = recog_op_alt
[matches
][alt
].class;
1565 if (matches
>= 0 || recog_op_alt
[i
][alt
].matched
>= 0
1566 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
1567 recog_data
.operand_type
[i
] = OP_INOUT
;
1570 /* For each earlyclobber operand, zap the value data. */
1571 for (i
= 0; i
< n_ops
; i
++)
1572 if (recog_op_alt
[i
][alt
].earlyclobber
)
1573 kill_value (recog_data
.operand
[i
], vd
);
1575 /* Within asms, a clobber cannot overlap inputs or outputs.
1576 I wouldn't think this were true for regular insns, but
1577 scan_rtx treats them like that... */
1578 note_stores (PATTERN (insn
), kill_clobbered_value
, vd
);
1580 /* Kill all auto-incremented values. */
1581 /* ??? REG_INC is useless, since stack pushes aren't done that way. */
1582 for_each_rtx (&PATTERN (insn
), kill_autoinc_value
, vd
);
1584 /* Kill all early-clobbered operands. */
1585 for (i
= 0; i
< n_ops
; i
++)
1586 if (recog_op_alt
[i
][alt
].earlyclobber
)
1587 kill_value (recog_data
.operand
[i
], vd
);
1589 /* Special-case plain move instructions, since we may well
1590 be able to do the move from a different register class. */
1591 if (set
&& REG_P (SET_SRC (set
)))
1593 rtx src
= SET_SRC (set
);
1594 unsigned int regno
= REGNO (src
);
1595 enum machine_mode mode
= GET_MODE (src
);
1599 /* If we are accessing SRC in some mode other that what we
1600 set it in, make sure that the replacement is valid. */
1601 if (mode
!= vd
->e
[regno
].mode
)
1603 if (HARD_REGNO_NREGS (regno
, mode
)
1604 > HARD_REGNO_NREGS (regno
, vd
->e
[regno
].mode
))
1605 goto no_move_special_case
;
1608 /* If the destination is also a register, try to find a source
1609 register in the same class. */
1610 if (REG_P (SET_DEST (set
)))
1612 new = find_oldest_value_reg (REGNO_REG_CLASS (regno
), src
, vd
);
1613 if (new && validate_change (insn
, &SET_SRC (set
), new, 0))
1616 fprintf (rtl_dump_file
,
1617 "insn %u: replaced reg %u with %u\n",
1618 INSN_UID (insn
), regno
, REGNO (new));
1620 goto did_replacement
;
1624 /* Otherwise, try all valid registers and see if its valid. */
1625 for (i
= vd
->e
[regno
].oldest_regno
; i
!= regno
;
1626 i
= vd
->e
[i
].next_regno
)
1627 if (vd
->e
[i
].mode
== mode
1628 || mode_change_ok (vd
->e
[i
].mode
, mode
, i
))
1630 new = gen_rtx_raw_REG (mode
, i
);
1631 if (validate_change (insn
, &SET_SRC (set
), new, 0))
1633 ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src
);
1635 fprintf (rtl_dump_file
,
1636 "insn %u: replaced reg %u with %u\n",
1637 INSN_UID (insn
), regno
, REGNO (new));
1639 goto did_replacement
;
1643 no_move_special_case
:
1645 /* For each input operand, replace a hard register with the
1646 eldest live copy that's in an appropriate register class. */
1647 for (i
= 0; i
< n_ops
; i
++)
1649 bool replaced
= false;
1651 /* Don't scan match_operand here, since we've no reg class
1652 information to pass down. Any operands that we could
1653 substitute in will be represented elsewhere. */
1654 if (recog_data
.constraints
[i
][0] == '\0')
1657 /* Don't replace in asms intentionally referencing hard regs. */
1658 if (is_asm
&& GET_CODE (recog_data
.operand
[i
]) == REG
1659 && (REGNO (recog_data
.operand
[i
])
1660 == ORIGINAL_REGNO (recog_data
.operand
[i
])))
1663 if (recog_data
.operand_type
[i
] == OP_IN
)
1665 if (recog_op_alt
[i
][alt
].is_address
)
1667 = replace_oldest_value_addr (recog_data
.operand_loc
[i
],
1668 recog_op_alt
[i
][alt
].class,
1669 VOIDmode
, insn
, vd
);
1670 else if (REG_P (recog_data
.operand
[i
]))
1672 = replace_oldest_value_reg (recog_data
.operand_loc
[i
],
1673 recog_op_alt
[i
][alt
].class,
1675 else if (GET_CODE (recog_data
.operand
[i
]) == MEM
)
1676 replaced
= replace_oldest_value_mem (recog_data
.operand
[i
],
1679 else if (GET_CODE (recog_data
.operand
[i
]) == MEM
)
1680 replaced
= replace_oldest_value_mem (recog_data
.operand
[i
],
1683 /* If we performed any replacement, update match_dups. */
1691 new = *recog_data
.operand_loc
[i
];
1692 recog_data
.operand
[i
] = new;
1693 for (j
= 0; j
< recog_data
.n_dups
; j
++)
1694 if (recog_data
.dup_num
[j
] == i
)
1695 *recog_data
.dup_loc
[j
] = new;
1700 /* Clobber call-clobbered registers. */
1701 if (GET_CODE (insn
) == CALL_INSN
)
1702 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1703 if (TEST_HARD_REG_BIT (regs_invalidated_by_call
, i
))
1704 kill_value_regno (i
, vd
);
1706 /* Notice stores. */
1707 note_stores (PATTERN (insn
), kill_set_value
, vd
);
1709 /* Notice copies. */
1710 if (set
&& REG_P (SET_DEST (set
)) && REG_P (SET_SRC (set
)))
1711 copy_value (SET_DEST (set
), SET_SRC (set
), vd
);
1713 if (insn
== bb
->end
)
1720 /* Main entry point for the forward copy propagation optimization. */
1723 copyprop_hardreg_forward ()
1725 struct value_data
*all_vd
;
1729 need_refresh
= false;
1731 all_vd
= xmalloc (sizeof (struct value_data
) * n_basic_blocks
);
1733 for (b
= 0; b
< n_basic_blocks
; b
++)
1735 basic_block bb
= BASIC_BLOCK (b
);
1737 /* If a block has a single predecessor, that we've already
1738 processed, begin with the value data that was live at
1739 the end of the predecessor block. */
1740 /* ??? Ought to use more intelligent queueing of blocks. */
1742 && ! bb
->pred
->pred_next
1743 && ! (bb
->pred
->flags
& (EDGE_ABNORMAL_CALL
| EDGE_EH
))
1744 && bb
->pred
->src
->index
!= ENTRY_BLOCK
1745 && bb
->pred
->src
->index
< b
)
1746 all_vd
[b
] = all_vd
[bb
->pred
->src
->index
];
1748 init_value_data (all_vd
+ b
);
1750 if (copyprop_hardreg_forward_1 (bb
, all_vd
+ b
))
1751 need_refresh
= true;
1757 fputs ("\n\n", rtl_dump_file
);
1759 /* ??? Irritatingly, delete_noop_moves does not take a set of blocks
1760 to scan, so we have to do a life update with no initial set of
1761 blocks Just In Case. */
1762 delete_noop_moves (get_insns ());
1763 update_life_info (NULL
, UPDATE_LIFE_GLOBAL_RM_NOTES
,
1765 | PROP_SCAN_DEAD_CODE
1766 | PROP_KILL_DEAD_CODE
);
1772 /* Dump the value chain data to stderr. */
1775 debug_value_data (vd
)
1776 struct value_data
*vd
;
1781 CLEAR_HARD_REG_SET (set
);
1783 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1784 if (vd
->e
[i
].oldest_regno
== i
)
1786 if (vd
->e
[i
].mode
== VOIDmode
)
1788 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1789 fprintf (stderr
, "[%u] Bad next_regno for empty chain (%u)\n",
1790 i
, vd
->e
[i
].next_regno
);
1794 SET_HARD_REG_BIT (set
, i
);
1795 fprintf (stderr
, "[%u %s] ", i
, GET_MODE_NAME (vd
->e
[i
].mode
));
1797 for (j
= vd
->e
[i
].next_regno
;
1798 j
!= INVALID_REGNUM
;
1799 j
= vd
->e
[j
].next_regno
)
1801 if (TEST_HARD_REG_BIT (set
, j
))
1803 fprintf (stderr
, "[%u] Loop in regno chain\n", j
);
1807 if (vd
->e
[j
].oldest_regno
!= i
)
1809 fprintf (stderr
, "[%u] Bad oldest_regno (%u)\n",
1810 j
, vd
->e
[j
].oldest_regno
);
1813 SET_HARD_REG_BIT (set
, j
);
1814 fprintf (stderr
, "[%u %s] ", j
, GET_MODE_NAME (vd
->e
[j
].mode
));
1816 fputc ('\n', stderr
);
1819 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1820 if (! TEST_HARD_REG_BIT (set
, i
)
1821 && (vd
->e
[i
].mode
!= VOIDmode
1822 || vd
->e
[i
].oldest_regno
!= i
1823 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1824 fprintf (stderr
, "[%u] Non-empty reg in chain (%s %u %i)\n",
1825 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1826 vd
->e
[i
].next_regno
);
1829 #ifdef ENABLE_CHECKING
1831 validate_value_data (vd
)
1832 struct value_data
*vd
;
1837 CLEAR_HARD_REG_SET (set
);
1839 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1840 if (vd
->e
[i
].oldest_regno
== i
)
1842 if (vd
->e
[i
].mode
== VOIDmode
)
1844 if (vd
->e
[i
].next_regno
!= INVALID_REGNUM
)
1845 internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
1846 i
, vd
->e
[i
].next_regno
);
1850 SET_HARD_REG_BIT (set
, i
);
1852 for (j
= vd
->e
[i
].next_regno
;
1853 j
!= INVALID_REGNUM
;
1854 j
= vd
->e
[j
].next_regno
)
1856 if (TEST_HARD_REG_BIT (set
, j
))
1857 internal_error ("validate_value_data: Loop in regno chain (%u)",
1859 if (vd
->e
[j
].oldest_regno
!= i
)
1860 internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
1861 j
, vd
->e
[j
].oldest_regno
);
1863 SET_HARD_REG_BIT (set
, j
);
1867 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
1868 if (! TEST_HARD_REG_BIT (set
, i
)
1869 && (vd
->e
[i
].mode
!= VOIDmode
1870 || vd
->e
[i
].oldest_regno
!= i
1871 || vd
->e
[i
].next_regno
!= INVALID_REGNUM
))
1872 internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
1873 i
, GET_MODE_NAME (vd
->e
[i
].mode
), vd
->e
[i
].oldest_regno
,
1874 vd
->e
[i
].next_regno
);