1 /* Register renaming for the GNU compiler.
2 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it 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 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
27 #include "insn-config.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
38 #define obstack_chunk_alloc xmalloc
39 #define obstack_chunk_free free
41 #ifndef REGNO_MODE_OK_FOR_BASE_P
42 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
45 #ifndef REG_MODE_OK_FOR_BASE_P
46 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
49 static const char *const reg_class_names
[] = REG_CLASS_NAMES
;
53 struct du_chain
*next_chain
;
54 struct du_chain
*next_use
;
59 unsigned int need_caller_save_reg
:1;
60 unsigned int earlyclobber
:1;
66 terminate_overlapping_read
,
73 static const char * const scan_actions_name
[] =
76 "terminate_overlapping_read",
83 static struct obstack rename_obstack
;
85 static void do_replace
PARAMS ((struct du_chain
*, int));
86 static void scan_rtx_reg
PARAMS ((rtx
, rtx
*, enum reg_class
,
87 enum scan_actions
, enum op_type
, int));
88 static void scan_rtx_address
PARAMS ((rtx
, rtx
*, enum reg_class
,
89 enum scan_actions
, enum machine_mode
));
90 static void scan_rtx
PARAMS ((rtx
, rtx
*, enum reg_class
,
91 enum scan_actions
, enum op_type
, int));
92 static struct du_chain
*build_def_use
PARAMS ((basic_block
));
93 static void dump_def_use_chain
PARAMS ((struct du_chain
*));
94 static void note_sets
PARAMS ((rtx
, rtx
, void *));
95 static void clear_dead_regs
PARAMS ((HARD_REG_SET
*, enum machine_mode
, rtx
));
96 static void merge_overlapping_regs
PARAMS ((basic_block
, HARD_REG_SET
*,
99 /* Called through note_stores from update_life. Find sets of registers, and
100 record them in *DATA (which is actually a HARD_REG_SET *). */
103 note_sets (x
, set
, data
)
105 rtx set ATTRIBUTE_UNUSED
;
108 HARD_REG_SET
*pset
= (HARD_REG_SET
*) data
;
111 if (GET_CODE (x
) != REG
)
114 nregs
= HARD_REGNO_NREGS (regno
, GET_MODE (x
));
116 /* There must not be pseudos at this point. */
117 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
121 SET_HARD_REG_BIT (*pset
, regno
+ nregs
);
124 /* Clear all registers from *PSET for which a note of kind KIND can be found
125 in the list NOTES. */
128 clear_dead_regs (pset
, kind
, notes
)
130 enum machine_mode kind
;
134 for (note
= notes
; note
; note
= XEXP (note
, 1))
135 if (REG_NOTE_KIND (note
) == kind
&& REG_P (XEXP (note
, 0)))
137 rtx reg
= XEXP (note
, 0);
138 unsigned int regno
= REGNO (reg
);
139 int nregs
= HARD_REGNO_NREGS (regno
, GET_MODE (reg
));
141 /* There must not be pseudos at this point. */
142 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
146 CLEAR_HARD_REG_BIT (*pset
, regno
+ nregs
);
150 /* For a def-use chain CHAIN in basic block B, find which registers overlap
151 its lifetime and set the corresponding bits in *PSET. */
154 merge_overlapping_regs (b
, pset
, chain
)
157 struct du_chain
*chain
;
159 struct du_chain
*t
= chain
;
163 REG_SET_TO_HARD_REG_SET (live
, b
->global_live_at_start
);
167 /* Search forward until the next reference to the register to be
169 while (insn
!= t
->insn
)
173 clear_dead_regs (&live
, REG_DEAD
, REG_NOTES (insn
));
174 note_stores (PATTERN (insn
), note_sets
, (void *) &live
);
175 /* Only record currently live regs if we are inside the
178 IOR_HARD_REG_SET (*pset
, live
);
179 clear_dead_regs (&live
, REG_UNUSED
, REG_NOTES (insn
));
181 insn
= NEXT_INSN (insn
);
184 IOR_HARD_REG_SET (*pset
, live
);
186 /* For the last reference, also merge in all registers set in the
188 @@@ We only have take earlyclobbered sets into account. */
190 note_stores (PATTERN (insn
), note_sets
, (void *) pset
);
196 /* Perform register renaming on the current function. */
199 regrename_optimize ()
201 int tick
[FIRST_PSEUDO_REGISTER
];
206 memset (tick
, 0, sizeof tick
);
208 gcc_obstack_init (&rename_obstack
);
209 first_obj
= (char *) obstack_alloc (&rename_obstack
, 0);
211 for (b
= 0; b
< n_basic_blocks
; b
++)
213 basic_block bb
= BASIC_BLOCK (b
);
214 struct du_chain
*all_chains
= 0;
215 HARD_REG_SET unavailable
;
216 HARD_REG_SET regs_seen
;
218 CLEAR_HARD_REG_SET (unavailable
);
221 fprintf (rtl_dump_file
, "\nBasic block %d:\n", b
);
223 all_chains
= build_def_use (bb
);
226 dump_def_use_chain (all_chains
);
228 CLEAR_HARD_REG_SET (unavailable
);
229 /* Don't clobber traceback for noreturn functions. */
230 if (frame_pointer_needed
)
234 for (i
= HARD_REGNO_NREGS (FRAME_POINTER_REGNUM
, Pmode
); i
--;)
235 SET_HARD_REG_BIT (unavailable
, FRAME_POINTER_REGNUM
+ i
);
237 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
238 for (i
= HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM
, Pmode
); i
--;)
239 SET_HARD_REG_BIT (unavailable
, HARD_FRAME_POINTER_REGNUM
+ i
);
243 CLEAR_HARD_REG_SET (regs_seen
);
246 int new_reg
, best_new_reg
= -1;
248 struct du_chain
*this = all_chains
;
249 struct du_chain
*tmp
, *last
;
250 HARD_REG_SET this_unavailable
;
251 int reg
= REGNO (*this->loc
);
254 all_chains
= this->next_chain
;
256 #if 0 /* This just disables optimization opportunities. */
257 /* Only rename once we've seen the reg more than once. */
258 if (! TEST_HARD_REG_BIT (regs_seen
, reg
))
260 SET_HARD_REG_BIT (regs_seen
, reg
);
265 if (fixed_regs
[reg
] || global_regs
[reg
]
266 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
267 || (frame_pointer_needed
&& reg
== HARD_FRAME_POINTER_REGNUM
)
269 || (frame_pointer_needed
&& reg
== FRAME_POINTER_REGNUM
)
274 COPY_HARD_REG_SET (this_unavailable
, unavailable
);
276 /* Find last entry on chain (which has the need_caller_save bit),
277 count number of uses, and narrow the set of registers we can
280 for (last
= this; last
->next_use
; last
= last
->next_use
)
283 IOR_COMPL_HARD_REG_SET (this_unavailable
,
284 reg_class_contents
[last
->class]);
289 IOR_COMPL_HARD_REG_SET (this_unavailable
,
290 reg_class_contents
[last
->class]);
292 if (this->need_caller_save_reg
)
293 IOR_HARD_REG_SET (this_unavailable
, call_used_reg_set
);
295 merge_overlapping_regs (bb
, &this_unavailable
, this);
297 /* Now potential_regs is a reasonable approximation, let's
298 have a closer look at each register still in there. */
299 for (new_reg
= 0; new_reg
< FIRST_PSEUDO_REGISTER
; new_reg
++)
301 int nregs
= HARD_REGNO_NREGS (new_reg
, GET_MODE (*this->loc
));
303 for (i
= nregs
- 1; i
>= 0; --i
)
304 if (TEST_HARD_REG_BIT (this_unavailable
, new_reg
+ i
)
305 || fixed_regs
[new_reg
+ i
]
306 || global_regs
[new_reg
+ i
]
307 /* Can't use regs which aren't saved by the prologue. */
308 || (! regs_ever_live
[new_reg
+ i
]
309 && ! call_used_regs
[new_reg
+ i
])
310 #ifdef LEAF_REGISTERS
311 /* We can't use a non-leaf register if we're in a
313 || (current_function_is_leaf
314 && !LEAF_REGISTERS
[new_reg
+ i
])
316 #ifdef HARD_REGNO_RENAME_OK
317 || ! HARD_REGNO_RENAME_OK (reg
+ i
, new_reg
+ i
)
324 /* See whether it accepts all modes that occur in
325 definition and uses. */
326 for (tmp
= this; tmp
; tmp
= tmp
->next_use
)
327 if (! HARD_REGNO_MODE_OK (new_reg
, GET_MODE (*tmp
->loc
)))
331 if (best_new_reg
== -1
332 || tick
[best_new_reg
] > tick
[new_reg
])
333 best_new_reg
= new_reg
;
339 fprintf (rtl_dump_file
, "Register %s in insn %d",
340 reg_names
[reg
], INSN_UID (last
->insn
));
341 if (last
->need_caller_save_reg
)
342 fprintf (rtl_dump_file
, " crosses a call");
345 if (best_new_reg
== -1)
348 fprintf (rtl_dump_file
, "; no available registers\n");
352 do_replace (this, best_new_reg
);
353 tick
[best_new_reg
] = this_tick
++;
356 fprintf (rtl_dump_file
, ", renamed as %s\n", reg_names
[best_new_reg
]);
359 obstack_free (&rename_obstack
, first_obj
);
362 obstack_free (&rename_obstack
, NULL
);
365 fputc ('\n', rtl_dump_file
);
367 count_or_remove_death_notes (NULL
, 1);
368 update_life_info (NULL
, UPDATE_LIFE_LOCAL
,
369 PROP_REG_INFO
| PROP_DEATH_NOTES
);
373 do_replace (chain
, reg
)
374 struct du_chain
*chain
;
379 unsigned int regno
= ORIGINAL_REGNO (*chain
->loc
);
380 *chain
->loc
= gen_raw_REG (GET_MODE (*chain
->loc
), reg
);
381 if (regno
>= FIRST_PSEUDO_REGISTER
)
382 ORIGINAL_REGNO (*chain
->loc
) = regno
;
383 chain
= chain
->next_use
;
388 static struct du_chain
*open_chains
;
389 static struct du_chain
*closed_chains
;
392 scan_rtx_reg (insn
, loc
, class, action
, type
, earlyclobber
)
395 enum reg_class
class;
396 enum scan_actions action
;
402 enum machine_mode mode
= GET_MODE (x
);
403 int this_regno
= REGNO (x
);
404 int this_nregs
= HARD_REGNO_NREGS (this_regno
, mode
);
406 if (action
== mark_write
)
410 struct du_chain
*this = (struct du_chain
*)
411 obstack_alloc (&rename_obstack
, sizeof (struct du_chain
));
413 this->next_chain
= open_chains
;
417 this->need_caller_save_reg
= 0;
418 this->earlyclobber
= earlyclobber
;
424 if ((type
== OP_OUT
&& action
!= terminate_write
)
425 || (type
!= OP_OUT
&& action
== terminate_write
))
428 for (p
= &open_chains
; *p
;)
430 struct du_chain
*this = *p
;
432 /* Check if the chain has been terminated if it has then skip to
435 This can happen when we've already appended the location to
436 the chain in Step 3, but are trying to hide in-out operands
437 from terminate_write in Step 5. */
439 if (*this->loc
== cc0_rtx
)
440 p
= &this->next_chain
;
443 int regno
= REGNO (*this->loc
);
444 int nregs
= HARD_REGNO_NREGS (regno
, GET_MODE (*this->loc
));
445 int exact_match
= (regno
== this_regno
&& nregs
== this_nregs
);
447 if (regno
+ nregs
<= this_regno
448 || this_regno
+ this_nregs
<= regno
)
450 p
= &this->next_chain
;
454 if (action
== mark_read
)
459 /* ??? Class NO_REGS can happen if the md file makes use of
460 EXTRA_CONSTRAINTS to match registers. Which is arguably
461 wrong, but there we are. Since we know not what this may
462 be replaced with, terminate the chain. */
463 if (class != NO_REGS
)
465 this = (struct du_chain
*)
466 obstack_alloc (&rename_obstack
, sizeof (struct du_chain
));
468 this->next_chain
= (*p
)->next_chain
;
472 this->need_caller_save_reg
= 0;
480 if (action
!= terminate_overlapping_read
|| ! exact_match
)
482 struct du_chain
*next
= this->next_chain
;
484 /* Whether the terminated chain can be used for renaming
485 depends on the action and this being an exact match.
486 In either case, we remove this element from open_chains. */
488 if ((action
== terminate_dead
|| action
== terminate_write
)
491 this->next_chain
= closed_chains
;
492 closed_chains
= this;
494 fprintf (rtl_dump_file
,
495 "Closing chain %s at insn %d (%s)\n",
496 reg_names
[REGNO (*this->loc
)], INSN_UID (insn
),
497 scan_actions_name
[(int) action
]);
502 fprintf (rtl_dump_file
,
503 "Discarding chain %s at insn %d (%s)\n",
504 reg_names
[REGNO (*this->loc
)], INSN_UID (insn
),
505 scan_actions_name
[(int) action
]);
510 p
= &this->next_chain
;
515 /* Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
516 BASE_REG_CLASS depending on how the register is being considered. */
519 scan_rtx_address (insn
, loc
, class, action
, mode
)
522 enum reg_class
class;
523 enum scan_actions action
;
524 enum machine_mode mode
;
527 RTX_CODE code
= GET_CODE (x
);
531 if (action
== mark_write
)
538 rtx orig_op0
= XEXP (x
, 0);
539 rtx orig_op1
= XEXP (x
, 1);
540 RTX_CODE code0
= GET_CODE (orig_op0
);
541 RTX_CODE code1
= GET_CODE (orig_op1
);
547 if (GET_CODE (op0
) == SUBREG
)
549 op0
= SUBREG_REG (op0
);
550 code0
= GET_CODE (op0
);
553 if (GET_CODE (op1
) == SUBREG
)
555 op1
= SUBREG_REG (op1
);
556 code1
= GET_CODE (op1
);
559 if (code0
== MULT
|| code0
== SIGN_EXTEND
|| code0
== TRUNCATE
560 || code0
== ZERO_EXTEND
|| code1
== MEM
)
565 else if (code1
== MULT
|| code1
== SIGN_EXTEND
|| code1
== TRUNCATE
566 || code1
== ZERO_EXTEND
|| code0
== MEM
)
571 else if (code0
== CONST_INT
|| code0
== CONST
572 || code0
== SYMBOL_REF
|| code0
== LABEL_REF
)
574 else if (code1
== CONST_INT
|| code1
== CONST
575 || code1
== SYMBOL_REF
|| code1
== LABEL_REF
)
577 else if (code0
== REG
&& code1
== REG
)
581 if (REG_OK_FOR_INDEX_P (op0
)
582 && REG_MODE_OK_FOR_BASE_P (op1
, mode
))
584 else if (REG_OK_FOR_INDEX_P (op1
)
585 && REG_MODE_OK_FOR_BASE_P (op0
, mode
))
587 else if (REG_MODE_OK_FOR_BASE_P (op1
, mode
))
589 else if (REG_MODE_OK_FOR_BASE_P (op0
, mode
))
591 else if (REG_OK_FOR_INDEX_P (op1
))
596 locI
= &XEXP (x
, index_op
);
597 locB
= &XEXP (x
, !index_op
);
599 else if (code0
== REG
)
604 else if (code1
== REG
)
611 scan_rtx_address (insn
, locI
, INDEX_REG_CLASS
, action
, mode
);
613 scan_rtx_address (insn
, locB
, BASE_REG_CLASS
, action
, mode
);
624 /* If the target doesn't claim to handle autoinc, this must be
625 something special, like a stack push. Kill this chain. */
626 action
= terminate_all_read
;
631 scan_rtx_address (insn
, &XEXP (x
, 0), BASE_REG_CLASS
, action
,
636 scan_rtx_reg (insn
, loc
, class, action
, OP_IN
, 0);
643 fmt
= GET_RTX_FORMAT (code
);
644 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
647 scan_rtx_address (insn
, &XEXP (x
, i
), class, action
, mode
);
648 else if (fmt
[i
] == 'E')
649 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
650 scan_rtx_address (insn
, &XVECEXP (x
, i
, j
), class, action
, mode
);
655 scan_rtx (insn
, loc
, class, action
, type
, earlyclobber
)
658 enum reg_class
class;
659 enum scan_actions action
;
665 enum rtx_code code
= GET_CODE (x
);
681 scan_rtx_reg (insn
, loc
, class, action
, type
, earlyclobber
);
685 scan_rtx_address (insn
, &XEXP (x
, 0), BASE_REG_CLASS
, action
,
690 scan_rtx (insn
, &SET_SRC (x
), class, action
, OP_IN
, 0);
691 scan_rtx (insn
, &SET_DEST (x
), class, action
, OP_OUT
, 0);
694 case STRICT_LOW_PART
:
695 scan_rtx (insn
, &XEXP (x
, 0), class, action
, OP_INOUT
, earlyclobber
);
700 scan_rtx (insn
, &XEXP (x
, 0), class, action
,
701 type
== OP_IN
? OP_IN
: OP_INOUT
, earlyclobber
);
702 scan_rtx (insn
, &XEXP (x
, 1), class, action
, OP_IN
, 0);
703 scan_rtx (insn
, &XEXP (x
, 2), class, action
, OP_IN
, 0);
712 /* Should only happen inside MEM. */
716 scan_rtx (insn
, &SET_DEST (x
), class, action
, OP_OUT
, 1);
720 scan_rtx (insn
, &XEXP (x
, 0), class, action
, type
, 0);
722 scan_rtx (insn
, &XEXP (x
, 1), class, action
, type
, 0);
729 fmt
= GET_RTX_FORMAT (code
);
730 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
733 scan_rtx (insn
, &XEXP (x
, i
), class, action
, type
, 0);
734 else if (fmt
[i
] == 'E')
735 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
736 scan_rtx (insn
, &XVECEXP (x
, i
, j
), class, action
, type
, 0);
740 /* Build def/use chain */
742 static struct du_chain
*
748 open_chains
= closed_chains
= NULL
;
750 for (insn
= bb
->head
; ; insn
= NEXT_INSN (insn
))
756 rtx old_operands
[MAX_RECOG_OPERANDS
];
757 rtx old_dups
[MAX_DUP_OPERANDS
];
762 /* Process the insn, determining its effect on the def-use
763 chains. We perform the following steps with the register
764 references in the insn:
765 (1) Any read that overlaps an open chain, but doesn't exactly
766 match, causes that chain to be closed. We can't deal
768 (2) Any read outside an operand causes any chain it overlaps
769 with to be closed, since we can't replace it.
770 (3) Any read inside an operand is added if there's already
771 an open chain for it.
772 (4) For any REG_DEAD note we find, close open chains that
774 (5) For any write we find, close open chains that overlap it.
775 (6) For any write we find in an operand, make a new chain.
776 (7) For any REG_UNUSED, close any chains we just opened. */
779 constrain_operands (1);
780 preprocess_constraints ();
781 alt
= which_alternative
;
782 n_ops
= recog_data
.n_operands
;
784 /* Simplify the code below by rewriting things to reflect
785 matching constraints. Also promote OP_OUT to OP_INOUT
786 in predicated instructions. */
788 predicated
= GET_CODE (PATTERN (insn
)) == COND_EXEC
;
789 for (i
= 0; i
< n_ops
; ++i
)
791 int matches
= recog_op_alt
[i
][alt
].matches
;
793 recog_op_alt
[i
][alt
].class = recog_op_alt
[matches
][alt
].class;
794 if (matches
>= 0 || recog_op_alt
[i
][alt
].matched
>= 0
795 || (predicated
&& recog_data
.operand_type
[i
] == OP_OUT
))
796 recog_data
.operand_type
[i
] = OP_INOUT
;
799 /* Step 1: Close chains for which we have overlapping reads. */
800 for (i
= 0; i
< n_ops
; i
++)
801 scan_rtx (insn
, recog_data
.operand_loc
[i
],
802 NO_REGS
, terminate_overlapping_read
,
803 recog_data
.operand_type
[i
], 0);
805 /* Step 2: Close chains for which we have reads outside operands.
806 We do this by munging all operands into CC0, and closing
807 everything remaining. */
809 for (i
= 0; i
< n_ops
; i
++)
811 old_operands
[i
] = recog_data
.operand
[i
];
812 /* Don't squash match_operator or match_parallel here, since
813 we don't know that all of the contained registers are
814 reachable by proper operands. */
815 if (recog_data
.constraints
[i
][0] == '\0')
817 *recog_data
.operand_loc
[i
] = cc0_rtx
;
819 for (i
= 0; i
< recog_data
.n_dups
; i
++)
821 old_dups
[i
] = *recog_data
.dup_loc
[i
];
822 *recog_data
.dup_loc
[i
] = cc0_rtx
;
825 scan_rtx (insn
, &PATTERN (insn
), NO_REGS
, terminate_all_read
,
828 for (i
= 0; i
< recog_data
.n_dups
; i
++)
829 *recog_data
.dup_loc
[i
] = old_dups
[i
];
830 for (i
= 0; i
< n_ops
; i
++)
831 *recog_data
.operand_loc
[i
] = old_operands
[i
];
833 /* Step 2B: Can't rename function call argument registers. */
834 if (GET_CODE (insn
) == CALL_INSN
&& CALL_INSN_FUNCTION_USAGE (insn
))
835 scan_rtx (insn
, &CALL_INSN_FUNCTION_USAGE (insn
),
836 NO_REGS
, terminate_all_read
, OP_IN
, 0);
838 /* Step 3: Append to chains for reads inside operands. */
839 for (i
= 0; i
< n_ops
+ recog_data
.n_dups
; i
++)
841 int opn
= i
< n_ops
? i
: recog_data
.dup_num
[i
- n_ops
];
842 rtx
*loc
= (i
< n_ops
843 ? recog_data
.operand_loc
[opn
]
844 : recog_data
.dup_loc
[i
- n_ops
]);
845 enum reg_class
class = recog_op_alt
[opn
][alt
].class;
846 enum op_type type
= recog_data
.operand_type
[opn
];
848 /* Don't scan match_operand here, since we've no reg class
849 information to pass down. Any operands that we could
850 substitute in will be represented elsewhere. */
851 if (recog_data
.constraints
[opn
][0] == '\0')
854 if (recog_op_alt
[opn
][alt
].is_address
)
855 scan_rtx_address (insn
, loc
, class, mark_read
, VOIDmode
);
857 scan_rtx (insn
, loc
, class, mark_read
, type
, 0);
860 /* Step 4: Close chains for registers that die here.
861 Also record updates for REG_INC notes. */
862 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
864 if (REG_NOTE_KIND (note
) == REG_DEAD
)
865 scan_rtx (insn
, &XEXP (note
, 0), NO_REGS
, terminate_dead
,
867 else if (REG_NOTE_KIND (note
) == REG_INC
)
868 scan_rtx (insn
, &XEXP (note
, 0), ALL_REGS
, mark_read
,
872 /* Step 4B: If this is a call, any chain live at this point
873 requires a caller-saved reg. */
874 if (GET_CODE (insn
) == CALL_INSN
)
877 for (p
= open_chains
; p
; p
= p
->next_chain
)
878 p
->need_caller_save_reg
= 1;
881 /* Step 5: Close open chains that overlap writes. Similar to
882 step 2, we hide in-out operands, since we do not want to
883 close these chains. */
885 for (i
= 0; i
< n_ops
; i
++)
887 old_operands
[i
] = recog_data
.operand
[i
];
888 if (recog_data
.operand_type
[i
] == OP_INOUT
)
889 *recog_data
.operand_loc
[i
] = cc0_rtx
;
891 for (i
= 0; i
< recog_data
.n_dups
; i
++)
893 int opn
= recog_data
.dup_num
[i
];
894 old_dups
[i
] = *recog_data
.dup_loc
[i
];
895 if (recog_data
.operand_type
[opn
] == OP_INOUT
)
896 *recog_data
.dup_loc
[i
] = cc0_rtx
;
899 scan_rtx (insn
, &PATTERN (insn
), NO_REGS
, terminate_write
, OP_IN
, 0);
901 for (i
= 0; i
< recog_data
.n_dups
; i
++)
902 *recog_data
.dup_loc
[i
] = old_dups
[i
];
903 for (i
= 0; i
< n_ops
; i
++)
904 *recog_data
.operand_loc
[i
] = old_operands
[i
];
906 /* Step 6: Begin new chains for writes inside operands. */
907 /* ??? Many targets have output constraints on the SET_DEST
908 of a call insn, which is stupid, since these are certainly
909 ABI defined hard registers. Don't change calls at all. */
910 if (GET_CODE (insn
) != CALL_INSN
)
911 for (i
= 0; i
< n_ops
+ recog_data
.n_dups
; i
++)
913 int opn
= i
< n_ops
? i
: recog_data
.dup_num
[i
- n_ops
];
914 rtx
*loc
= (i
< n_ops
915 ? recog_data
.operand_loc
[opn
]
916 : recog_data
.dup_loc
[i
- n_ops
]);
917 enum reg_class
class = recog_op_alt
[opn
][alt
].class;
919 if (recog_data
.operand_type
[opn
] == OP_OUT
)
920 scan_rtx (insn
, loc
, class, mark_write
, OP_OUT
,
921 recog_op_alt
[opn
][alt
].earlyclobber
);
924 /* Step 7: Close chains for registers that were never
926 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
927 if (REG_NOTE_KIND (note
) == REG_UNUSED
)
928 scan_rtx (insn
, &XEXP (note
, 0), NO_REGS
, terminate_dead
,
935 /* Since we close every chain when we find a REG_DEAD note, anything that
936 is still open lives past the basic block, so it can't be renamed. */
937 return closed_chains
;
940 /* Dump all def/use chains in CHAINS to RTL_DUMP_FILE. They are
941 printed in reverse order as that's how we build them. */
944 dump_def_use_chain (chains
)
945 struct du_chain
*chains
;
949 struct du_chain
*this = chains
;
950 int r
= REGNO (*this->loc
);
951 int nregs
= HARD_REGNO_NREGS (r
, GET_MODE (*this->loc
));
952 fprintf (rtl_dump_file
, "Register %s (%d):", reg_names
[r
], nregs
);
955 fprintf (rtl_dump_file
, " %d [%s]", INSN_UID (this->insn
),
956 reg_class_names
[this->class]);
957 this = this->next_use
;
959 fprintf (rtl_dump_file
, "\n");
960 chains
= chains
->next_chain
;