1 /* Decompose multiword subregs.
2 Copyright (C) 2007 Free Software Foundation, Inc.
3 Contributed by Richard Henderson <rth@redhat.com>
4 Ian Lance Taylor <iant@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
32 #include "insn-config.h"
34 #include "basic-block.h"
40 #include "tree-pass.h"
42 #ifdef STACK_GROWS_DOWNWARD
43 # undef STACK_GROWS_DOWNWARD
44 # define STACK_GROWS_DOWNWARD 1
46 # define STACK_GROWS_DOWNWARD 0
50 DEF_VEC_ALLOC_P (bitmap
,heap
);
52 /* Decompose multi-word pseudo-registers into individual
53 pseudo-registers when possible. This is possible when all the uses
54 of a multi-word register are via SUBREG, or are copies of the
55 register to another location. Breaking apart the register permits
56 more CSE and permits better register allocation. */
58 /* Bit N in this bitmap is set if regno N is used in a context in
59 which we can decompose it. */
60 static bitmap decomposable_context
;
62 /* Bit N in this bitmap is set if regno N is used in a context in
63 which it can not be decomposed. */
64 static bitmap non_decomposable_context
;
66 /* Bit N in the bitmap in element M of this array is set if there is a
67 copy from reg M to reg N. */
68 static VEC(bitmap
,heap
) *reg_copy_graph
;
70 /* Return whether X is a simple object which we can take a word_mode
74 simple_move_operand (rtx x
)
76 if (GET_CODE (x
) == SUBREG
)
82 if (GET_CODE (x
) == LABEL_REF
83 || GET_CODE (x
) == SYMBOL_REF
84 || GET_CODE (x
) == HIGH
85 || GET_CODE (x
) == CONST
)
89 && (MEM_VOLATILE_P (x
)
90 || mode_dependent_address_p (XEXP (x
, 0))))
96 /* If INSN is a single set between two objects, return the single set.
97 Such an insn can always be decomposed. INSN should have been
98 passed to recog and extract_insn before this is called. */
101 simple_move (rtx insn
)
105 enum machine_mode mode
;
107 if (recog_data
.n_operands
!= 2)
110 set
= single_set (insn
);
115 if (x
!= recog_data
.operand
[0] && x
!= recog_data
.operand
[1])
117 if (!simple_move_operand (x
))
121 if (x
!= recog_data
.operand
[0] && x
!= recog_data
.operand
[1])
123 /* For the src we can handle ASM_OPERANDS, and it is beneficial for
124 things like x86 rdtsc which returns a DImode value. */
125 if (GET_CODE (x
) != ASM_OPERANDS
126 && !simple_move_operand (x
))
129 /* We try to decompose in integer modes, to avoid generating
130 inefficient code copying between integer and floating point
131 registers. That means that we can't decompose if this is a
132 non-integer mode for which there is no integer mode of the same
134 mode
= GET_MODE (SET_SRC (set
));
135 if (!SCALAR_INT_MODE_P (mode
)
136 && (mode_for_size (GET_MODE_SIZE (mode
) * BITS_PER_UNIT
, MODE_INT
, 0)
140 /* Reject PARTIAL_INT modes. They are used for processor specific
141 purposes and it's probably best not to tamper with them. */
142 if (GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
148 /* If SET is a copy from one multi-word pseudo-register to another,
149 record that in reg_copy_graph. Return whether it is such a
153 find_pseudo_copy (rtx set
)
155 rtx dest
= SET_DEST (set
);
156 rtx src
= SET_SRC (set
);
160 if (!REG_P (dest
) || !REG_P (src
))
165 if (HARD_REGISTER_NUM_P (rd
) || HARD_REGISTER_NUM_P (rs
))
168 if (GET_MODE_SIZE (GET_MODE (dest
)) <= UNITS_PER_WORD
)
171 b
= VEC_index (bitmap
, reg_copy_graph
, rs
);
174 b
= BITMAP_ALLOC (NULL
);
175 VEC_replace (bitmap
, reg_copy_graph
, rs
, b
);
178 bitmap_set_bit (b
, rd
);
183 /* Look through the registers in DECOMPOSABLE_CONTEXT. For each case
184 where they are copied to another register, add the register to
185 which they are copied to DECOMPOSABLE_CONTEXT. Use
186 NON_DECOMPOSABLE_CONTEXT to limit this--we don't bother to track
187 copies of registers which are in NON_DECOMPOSABLE_CONTEXT. */
190 propagate_pseudo_copies (void)
192 bitmap queue
, propagate
;
194 queue
= BITMAP_ALLOC (NULL
);
195 propagate
= BITMAP_ALLOC (NULL
);
197 bitmap_copy (queue
, decomposable_context
);
200 bitmap_iterator iter
;
203 bitmap_clear (propagate
);
205 EXECUTE_IF_SET_IN_BITMAP (queue
, 0, i
, iter
)
207 bitmap b
= VEC_index (bitmap
, reg_copy_graph
, i
);
209 bitmap_ior_and_compl_into (propagate
, b
, non_decomposable_context
);
212 bitmap_and_compl (queue
, propagate
, decomposable_context
);
213 bitmap_ior_into (decomposable_context
, propagate
);
215 while (!bitmap_empty_p (queue
));
218 BITMAP_FREE (propagate
);
221 /* A pointer to one of these values is passed to
222 find_decomposable_subregs via for_each_rtx. */
224 enum classify_move_insn
226 /* Not a simple move from one location to another. */
228 /* A simple move from one pseudo-register to another with no
230 SIMPLE_PSEUDO_REG_MOVE
,
231 /* A simple move involving a non-pseudo-register, or from one
232 pseudo-register to another with a REG_RETVAL note. */
236 /* This is called via for_each_rtx. If we find a SUBREG which we
237 could use to decompose a pseudo-register, set a bit in
238 DECOMPOSABLE_CONTEXT. If we find an unadorned register which is
239 not a simple pseudo-register copy, DATA will point at the type of
240 move, and we set a bit in DECOMPOSABLE_CONTEXT or
241 NON_DECOMPOSABLE_CONTEXT as appropriate. */
244 find_decomposable_subregs (rtx
*px
, void *data
)
246 enum classify_move_insn
*pcmi
= (enum classify_move_insn
*) data
;
252 if (GET_CODE (x
) == SUBREG
)
254 rtx inner
= SUBREG_REG (x
);
255 unsigned int regno
, outer_size
, inner_size
, outer_words
, inner_words
;
260 regno
= REGNO (inner
);
261 if (HARD_REGISTER_NUM_P (regno
))
264 outer_size
= GET_MODE_SIZE (GET_MODE (x
));
265 inner_size
= GET_MODE_SIZE (GET_MODE (inner
));
266 outer_words
= (outer_size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
267 inner_words
= (inner_size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
269 /* We only try to decompose single word subregs of multi-word
270 registers. When we find one, we return -1 to avoid iterating
271 over the inner register.
273 ??? This doesn't allow, e.g., DImode subregs of TImode values
274 on 32-bit targets. We would need to record the way the
275 pseudo-register was used, and only decompose if all the uses
276 were the same number and size of pieces. Hopefully this
277 doesn't happen much. */
279 if (outer_words
== 1 && inner_words
> 1)
281 bitmap_set_bit (decomposable_context
, regno
);
289 /* We will see an outer SUBREG before we see the inner REG, so
290 when we see a plain REG here it means a direct reference to
293 If this is not a simple copy from one location to another,
294 then we can not decompose this register. If this is a simple
295 copy from one pseudo-register to another, with no REG_RETVAL
296 note, and the mode is right, then we mark the register as
297 decomposable. Otherwise we don't say anything about this
298 register--it could be decomposed, but whether that would be
299 profitable depends upon how it is used elsewhere.
301 We only set bits in the bitmap for multi-word
302 pseudo-registers, since those are the only ones we care about
303 and it keeps the size of the bitmaps down. */
306 if (!HARD_REGISTER_NUM_P (regno
)
307 && GET_MODE_SIZE (GET_MODE (x
)) > UNITS_PER_WORD
)
311 case NOT_SIMPLE_MOVE
:
312 bitmap_set_bit (non_decomposable_context
, regno
);
314 case SIMPLE_PSEUDO_REG_MOVE
:
315 if (MODES_TIEABLE_P (GET_MODE (x
), word_mode
))
316 bitmap_set_bit (decomposable_context
, regno
);
327 enum classify_move_insn cmi_mem
= NOT_SIMPLE_MOVE
;
329 /* Any registers used in a MEM do not participate in a
330 SIMPLE_MOVE or SIMPLE_PSEUDO_REG_MOVE. Do our own recursion
331 here, and return -1 to block the parent's recursion. */
332 for_each_rtx (&XEXP (x
, 0), find_decomposable_subregs
, &cmi_mem
);
339 /* Decompose REGNO into word-sized components. We smash the REG node
340 in place. This ensures that (1) something goes wrong quickly if we
341 fail to make some replacement, and (2) the debug information inside
342 the symbol table is automatically kept up to date. */
345 decompose_register (unsigned int regno
)
348 unsigned int words
, i
;
351 reg
= regno_reg_rtx
[regno
];
353 regno_reg_rtx
[regno
] = NULL_RTX
;
354 clear_reg_info_regno (regno
);
356 words
= GET_MODE_SIZE (GET_MODE (reg
));
357 words
= (words
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
359 v
= rtvec_alloc (words
);
360 for (i
= 0; i
< words
; ++i
)
361 RTVEC_ELT (v
, i
) = gen_reg_rtx_offset (reg
, word_mode
, i
* UNITS_PER_WORD
);
363 PUT_CODE (reg
, CONCATN
);
368 fprintf (dump_file
, "; Splitting reg %u ->", regno
);
369 for (i
= 0; i
< words
; ++i
)
370 fprintf (dump_file
, " %u", REGNO (XVECEXP (reg
, 0, i
)));
371 fputc ('\n', dump_file
);
375 /* Get a SUBREG of a CONCATN. */
378 simplify_subreg_concatn (enum machine_mode outermode
, rtx op
,
381 unsigned int inner_size
;
382 enum machine_mode innermode
;
384 unsigned int final_offset
;
386 gcc_assert (GET_CODE (op
) == CONCATN
);
387 gcc_assert (byte
% GET_MODE_SIZE (outermode
) == 0);
389 innermode
= GET_MODE (op
);
390 gcc_assert (byte
< GET_MODE_SIZE (innermode
));
391 gcc_assert (GET_MODE_SIZE (outermode
) <= GET_MODE_SIZE (innermode
));
393 inner_size
= GET_MODE_SIZE (innermode
) / XVECLEN (op
, 0);
394 part
= XVECEXP (op
, 0, byte
/ inner_size
);
395 final_offset
= byte
% inner_size
;
396 if (final_offset
+ GET_MODE_SIZE (outermode
) > inner_size
)
399 return simplify_gen_subreg (outermode
, part
, GET_MODE (part
), final_offset
);
402 /* Wrapper around simplify_gen_subreg which handles CONCATN. */
405 simplify_gen_subreg_concatn (enum machine_mode outermode
, rtx op
,
406 enum machine_mode innermode
, unsigned int byte
)
410 /* We have to handle generating a SUBREG of a SUBREG of a CONCATN.
411 If OP is a SUBREG of a CONCATN, then it must be a simple mode
412 change with the same size and offset 0, or it must extract a
413 part. We shouldn't see anything else here. */
414 if (GET_CODE (op
) == SUBREG
&& GET_CODE (SUBREG_REG (op
)) == CONCATN
)
418 if ((GET_MODE_SIZE (GET_MODE (op
))
419 == GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))))
420 && SUBREG_BYTE (op
) == 0)
421 return simplify_gen_subreg_concatn (outermode
, SUBREG_REG (op
),
422 GET_MODE (SUBREG_REG (op
)), byte
);
424 op2
= simplify_subreg_concatn (GET_MODE (op
), SUBREG_REG (op
),
428 /* We don't handle paradoxical subregs here. */
429 gcc_assert (GET_MODE_SIZE (outermode
)
430 <= GET_MODE_SIZE (GET_MODE (op
)));
431 gcc_assert (GET_MODE_SIZE (GET_MODE (op
))
432 <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))));
433 op2
= simplify_subreg_concatn (outermode
, SUBREG_REG (op
),
434 byte
+ SUBREG_BYTE (op
));
435 gcc_assert (op2
!= NULL_RTX
);
440 gcc_assert (op
!= NULL_RTX
);
441 gcc_assert (innermode
== GET_MODE (op
));
444 if (GET_CODE (op
) == CONCATN
)
445 return simplify_subreg_concatn (outermode
, op
, byte
);
447 ret
= simplify_gen_subreg (outermode
, op
, innermode
, byte
);
449 /* If we see an insn like (set (reg:DI) (subreg:DI (reg:SI) 0)) then
450 resolve_simple_move will ask for the high part of the paradoxical
451 subreg, which does not have a value. Just return a zero. */
453 && GET_CODE (op
) == SUBREG
454 && SUBREG_BYTE (op
) == 0
455 && (GET_MODE_SIZE (innermode
)
456 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
)))))
457 return CONST0_RTX (outermode
);
459 gcc_assert (ret
!= NULL_RTX
);
463 /* Return whether we should resolve X into the registers into which it
467 resolve_reg_p (rtx x
)
469 return GET_CODE (x
) == CONCATN
;
472 /* Return whether X is a SUBREG of a register which we need to
476 resolve_subreg_p (rtx x
)
478 if (GET_CODE (x
) != SUBREG
)
480 return resolve_reg_p (SUBREG_REG (x
));
483 /* This is called via for_each_rtx. Look for SUBREGs which need to be
487 resolve_subreg_use (rtx
*px
, void *data
)
489 rtx insn
= (rtx
) data
;
495 if (resolve_subreg_p (x
))
497 x
= simplify_subreg_concatn (GET_MODE (x
), SUBREG_REG (x
),
500 /* It is possible for a note to contain a reference which we can
501 decompose. In this case, return 1 to the caller to indicate
502 that the note must be removed. */
509 validate_change (insn
, px
, x
, 1);
513 if (resolve_reg_p (x
))
515 /* Return 1 to the caller to indicate that we found a direct
516 reference to a register which is being decomposed. This can
517 happen inside notes. */
525 /* We are deleting INSN. Move any EH_REGION notes to INSNS. */
528 move_eh_region_note (rtx insn
, rtx insns
)
532 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
533 if (note
== NULL_RTX
)
536 gcc_assert (CALL_P (insn
)
537 || (flag_non_call_exceptions
&& may_trap_p (PATTERN (insn
))));
539 for (p
= insns
; p
!= NULL_RTX
; p
= NEXT_INSN (p
))
542 || (flag_non_call_exceptions
544 && may_trap_p (PATTERN (p
))))
545 REG_NOTES (p
) = gen_rtx_EXPR_LIST (REG_EH_REGION
, XEXP (note
, 0),
550 /* If there is a REG_LIBCALL note on OLD_START, move it to NEW_START,
551 and link the corresponding REG_RETVAL note to NEW_START. */
554 move_libcall_note (rtx old_start
, rtx new_start
)
556 rtx note0
, note1
, end
;
558 note0
= find_reg_note (old_start
, REG_LIBCALL
, NULL
);
559 if (note0
== NULL_RTX
)
562 remove_note (old_start
, note0
);
563 end
= XEXP (note0
, 0);
564 note1
= find_reg_note (end
, REG_RETVAL
, NULL
);
566 XEXP (note0
, 1) = REG_NOTES (new_start
);
567 REG_NOTES (new_start
) = note0
;
568 XEXP (note1
, 0) = new_start
;
571 /* Remove any REG_RETVAL note, the corresponding REG_LIBCALL note, and
572 any markers for a no-conflict block. We have decomposed the
573 registers so the non-conflict is now obvious. */
576 remove_retval_note (rtx insn1
)
578 rtx note0
, insn0
, note1
, insn
;
580 note1
= find_reg_note (insn1
, REG_RETVAL
, NULL
);
581 if (note1
== NULL_RTX
)
584 insn0
= XEXP (note1
, 0);
585 note0
= find_reg_note (insn0
, REG_LIBCALL
, NULL
);
587 remove_note (insn0
, note0
);
588 remove_note (insn1
, note1
);
590 for (insn
= insn0
; insn
!= insn1
; insn
= NEXT_INSN (insn
))
596 note
= find_reg_note (insn
, REG_NO_CONFLICT
, NULL
);
597 if (note
== NULL_RTX
)
599 remove_note (insn
, note
);
604 /* Resolve any decomposed registers which appear in register notes on
608 resolve_reg_notes (rtx insn
)
612 note
= find_reg_equal_equiv_note (insn
);
615 if (for_each_rtx (&XEXP (note
, 0), resolve_subreg_use
, NULL
))
617 remove_note (insn
, note
);
618 remove_retval_note (insn
);
622 pnote
= ®_NOTES (insn
);
623 while (*pnote
!= NULL_RTX
)
628 switch (REG_NOTE_KIND (note
))
630 case REG_NO_CONFLICT
:
631 if (resolve_reg_p (XEXP (note
, 0)))
640 *pnote
= XEXP (note
, 1);
642 pnote
= &XEXP (note
, 1);
646 /* Return whether X can be decomposed into subwords. */
649 can_decompose_p (rtx x
)
653 unsigned int regno
= REGNO (x
);
655 if (HARD_REGISTER_NUM_P (regno
))
656 return (validate_subreg (word_mode
, GET_MODE (x
), x
, UNITS_PER_WORD
)
657 && HARD_REGNO_MODE_OK (regno
, word_mode
));
659 return !bitmap_bit_p (non_decomposable_context
, regno
);
665 /* Decompose the registers used in a simple move SET within INSN. If
666 we don't change anything, return INSN, otherwise return the start
667 of the sequence of moves. */
670 resolve_simple_move (rtx set
, rtx insn
)
672 rtx src
, dest
, real_dest
, insns
;
673 enum machine_mode orig_mode
, dest_mode
;
678 dest
= SET_DEST (set
);
679 orig_mode
= GET_MODE (dest
);
681 words
= (GET_MODE_SIZE (orig_mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
687 /* We have to handle copying from a SUBREG of a decomposed reg where
688 the SUBREG is larger than word size. Rather than assume that we
689 can take a word_mode SUBREG of the destination, we copy to a new
690 register and then copy that to the destination. */
692 real_dest
= NULL_RTX
;
694 if (GET_CODE (src
) == SUBREG
695 && resolve_reg_p (SUBREG_REG (src
))
696 && (SUBREG_BYTE (src
) != 0
697 || (GET_MODE_SIZE (orig_mode
)
698 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (src
))))))
701 dest
= gen_reg_rtx (orig_mode
);
702 if (REG_P (real_dest
))
703 REG_ATTRS (dest
) = REG_ATTRS (real_dest
);
706 /* Similarly if we are copying to a SUBREG of a decomposed reg where
707 the SUBREG is larger than word size. */
709 if (GET_CODE (dest
) == SUBREG
710 && resolve_reg_p (SUBREG_REG (dest
))
711 && (SUBREG_BYTE (dest
) != 0
712 || (GET_MODE_SIZE (orig_mode
)
713 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
))))))
715 rtx reg
, minsn
, smove
;
717 reg
= gen_reg_rtx (orig_mode
);
718 minsn
= emit_move_insn (reg
, src
);
719 smove
= single_set (minsn
);
720 gcc_assert (smove
!= NULL_RTX
);
721 resolve_simple_move (smove
, minsn
);
725 /* If we didn't have any big SUBREGS of decomposed registers, and
726 neither side of the move is a register we are decomposing, then
727 we don't have to do anything here. */
729 if (src
== SET_SRC (set
)
730 && dest
== SET_DEST (set
)
731 && !resolve_reg_p (src
)
732 && !resolve_subreg_p (src
)
733 && !resolve_reg_p (dest
)
734 && !resolve_subreg_p (dest
))
740 /* It's possible for the code to use a subreg of a decomposed
741 register while forming an address. We need to handle that before
742 passing the address to emit_move_insn. We pass NULL_RTX as the
743 insn parameter to resolve_subreg_use because we can not validate
745 if (MEM_P (src
) || MEM_P (dest
))
750 for_each_rtx (&XEXP (src
, 0), resolve_subreg_use
, NULL_RTX
);
752 for_each_rtx (&XEXP (dest
, 0), resolve_subreg_use
, NULL_RTX
);
753 acg
= apply_change_group ();
757 /* If SRC is a register which we can't decompose, or has side
758 effects, we need to move via a temporary register. */
760 if (!can_decompose_p (src
)
761 || side_effects_p (src
)
762 || GET_CODE (src
) == ASM_OPERANDS
)
766 reg
= gen_reg_rtx (orig_mode
);
767 emit_move_insn (reg
, src
);
771 /* If DEST is a register which we can't decompose, or has side
772 effects, we need to first move to a temporary register. We
773 handle the common case of pushing an operand directly. We also
774 go through a temporary register if it holds a floating point
775 value. This gives us better code on systems which can't move
776 data easily between integer and floating point registers. */
778 dest_mode
= orig_mode
;
779 pushing
= push_operand (dest
, dest_mode
);
780 if (!can_decompose_p (dest
)
781 || (side_effects_p (dest
) && !pushing
)
782 || (!SCALAR_INT_MODE_P (dest_mode
)
783 && !resolve_reg_p (dest
)
784 && !resolve_subreg_p (dest
)))
786 if (real_dest
== NULL_RTX
)
788 if (!SCALAR_INT_MODE_P (dest_mode
))
790 dest_mode
= mode_for_size (GET_MODE_SIZE (dest_mode
) * BITS_PER_UNIT
,
792 gcc_assert (dest_mode
!= BLKmode
);
794 dest
= gen_reg_rtx (dest_mode
);
795 if (REG_P (real_dest
))
796 REG_ATTRS (dest
) = REG_ATTRS (real_dest
);
801 unsigned int i
, j
, jinc
;
803 gcc_assert (GET_MODE_SIZE (orig_mode
) % UNITS_PER_WORD
== 0);
804 gcc_assert (GET_CODE (XEXP (dest
, 0)) != PRE_MODIFY
);
805 gcc_assert (GET_CODE (XEXP (dest
, 0)) != POST_MODIFY
);
807 if (WORDS_BIG_ENDIAN
== STACK_GROWS_DOWNWARD
)
818 for (i
= 0; i
< words
; ++i
, j
+= jinc
)
822 temp
= copy_rtx (XEXP (dest
, 0));
823 temp
= adjust_automodify_address_nv (dest
, word_mode
, temp
,
825 emit_move_insn (temp
,
826 simplify_gen_subreg_concatn (word_mode
, src
,
828 j
* UNITS_PER_WORD
));
835 if (REG_P (dest
) && !HARD_REGISTER_NUM_P (REGNO (dest
)))
836 emit_insn (gen_rtx_CLOBBER (VOIDmode
, dest
));
838 for (i
= 0; i
< words
; ++i
)
839 emit_move_insn (simplify_gen_subreg_concatn (word_mode
, dest
,
842 simplify_gen_subreg_concatn (word_mode
, src
,
844 i
* UNITS_PER_WORD
));
847 if (real_dest
!= NULL_RTX
)
849 rtx mdest
, minsn
, smove
;
851 if (dest_mode
== orig_mode
)
854 mdest
= simplify_gen_subreg (orig_mode
, dest
, GET_MODE (dest
), 0);
855 minsn
= emit_move_insn (real_dest
, mdest
);
857 smove
= single_set (minsn
);
858 gcc_assert (smove
!= NULL_RTX
);
860 resolve_simple_move (smove
, minsn
);
863 insns
= get_insns ();
866 move_eh_region_note (insn
, insns
);
868 emit_insn_before (insns
, insn
);
870 move_libcall_note (insn
, insns
);
871 remove_retval_note (insn
);
877 /* Change a CLOBBER of a decomposed register into a CLOBBER of the
878 component registers. Return whether we changed something. */
881 resolve_clobber (rtx pat
, rtx insn
)
884 enum machine_mode orig_mode
;
885 unsigned int words
, i
;
889 if (!resolve_reg_p (reg
) && !resolve_subreg_p (reg
))
892 orig_mode
= GET_MODE (reg
);
893 words
= GET_MODE_SIZE (orig_mode
);
894 words
= (words
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
896 ret
= validate_change (NULL_RTX
, &XEXP (pat
, 0),
897 simplify_gen_subreg_concatn (word_mode
, reg
,
900 gcc_assert (ret
!= 0);
902 for (i
= words
- 1; i
> 0; --i
)
906 x
= simplify_gen_subreg_concatn (word_mode
, reg
, orig_mode
,
908 x
= gen_rtx_CLOBBER (VOIDmode
, x
);
909 emit_insn_after (x
, insn
);
915 /* A USE of a decomposed register is no longer meaningful. Return
916 whether we changed something. */
919 resolve_use (rtx pat
, rtx insn
)
921 if (resolve_reg_p (XEXP (pat
, 0)) || resolve_subreg_p (XEXP (pat
, 0)))
929 /* Look for registers which are always accessed via word-sized SUBREGs
930 or via copies. Decompose these registers into several word-sized
934 decompose_multiword_subregs (bool update_life
)
939 max
= max_reg_num ();
941 /* First see if there are any multi-word pseudo-registers. If there
942 aren't, there is nothing we can do. This should speed up this
943 pass in the normal case, since it should be faster than scanning
948 for (i
= FIRST_PSEUDO_REGISTER
; i
< max
; ++i
)
950 if (regno_reg_rtx
[i
] != NULL
951 && GET_MODE_SIZE (GET_MODE (regno_reg_rtx
[i
])) > UNITS_PER_WORD
)
958 /* FIXME: When the dataflow branch is merged, we can change this
959 code to look for each multi-word pseudo-register and to find each
960 insn which sets or uses that register. That should be faster
961 than scanning all the insns. */
963 decomposable_context
= BITMAP_ALLOC (NULL
);
964 non_decomposable_context
= BITMAP_ALLOC (NULL
);
966 reg_copy_graph
= VEC_alloc (bitmap
, heap
, max
);
967 VEC_safe_grow (bitmap
, heap
, reg_copy_graph
, max
);
968 memset (VEC_address (bitmap
, reg_copy_graph
), 0, sizeof (bitmap
) * max
);
974 FOR_BB_INSNS (bb
, insn
)
977 enum classify_move_insn cmi
;
981 || GET_CODE (PATTERN (insn
)) == CLOBBER
982 || GET_CODE (PATTERN (insn
)) == USE
)
985 recog_memoized (insn
);
988 set
= simple_move (insn
);
991 cmi
= NOT_SIMPLE_MOVE
;
996 retval
= find_reg_note (insn
, REG_RETVAL
, NULL_RTX
) != NULL_RTX
;
998 if (find_pseudo_copy (set
) && !retval
)
999 cmi
= SIMPLE_PSEUDO_REG_MOVE
;
1001 && REG_P (SET_SRC (set
))
1002 && HARD_REGISTER_P (SET_SRC (set
)))
1006 /* We don't want to decompose an assignment which
1007 copies the value returned by a libcall to a
1008 pseudo-register. Doing that will lose the RETVAL
1009 note with no real gain. */
1010 cmi
= NOT_SIMPLE_MOVE
;
1012 /* If we have a RETVAL note, there should be an
1013 EQUAL note. We don't want to decompose any
1014 registers which that EQUAL note refers to
1015 directly. If we do, we will no longer know the
1016 value of the libcall. */
1017 note
= find_reg_equal_equiv_note (insn
);
1018 if (note
!= NULL_RTX
)
1019 for_each_rtx (&XEXP (note
, 0), find_decomposable_subregs
,
1026 n
= recog_data
.n_operands
;
1027 for (i
= 0; i
< n
; ++i
)
1029 for_each_rtx (&recog_data
.operand
[i
],
1030 find_decomposable_subregs
,
1033 /* We handle ASM_OPERANDS as a special case to support
1034 things like x86 rdtsc which returns a DImode value.
1035 We can decompose the output, which will certainly be
1036 operand 0, but not the inputs. */
1038 if (cmi
== SIMPLE_MOVE
1039 && GET_CODE (SET_SRC (set
)) == ASM_OPERANDS
)
1041 gcc_assert (i
== 0);
1042 cmi
= NOT_SIMPLE_MOVE
;
1048 bitmap_and_compl_into (decomposable_context
, non_decomposable_context
);
1049 if (!bitmap_empty_p (decomposable_context
))
1051 int hold_no_new_pseudos
= no_new_pseudos
;
1052 int max_regno
= max_reg_num ();
1053 sbitmap life_blocks
;
1056 sbitmap_iterator sbi
;
1057 bitmap_iterator iter
;
1060 propagate_pseudo_copies ();
1063 life_blocks
= sbitmap_alloc (last_basic_block
);
1064 sbitmap_zero (life_blocks
);
1065 sub_blocks
= sbitmap_alloc (last_basic_block
);
1066 sbitmap_zero (sub_blocks
);
1068 EXECUTE_IF_SET_IN_BITMAP (decomposable_context
, 0, regno
, iter
)
1069 decompose_register (regno
);
1075 FOR_BB_INSNS (bb
, insn
)
1083 next
= NEXT_INSN (insn
);
1086 pat
= PATTERN (insn
);
1087 if (GET_CODE (pat
) == CLOBBER
)
1089 if (resolve_clobber (pat
, insn
))
1092 else if (GET_CODE (pat
) == USE
)
1094 if (resolve_use (pat
, insn
))
1102 recog_memoized (insn
);
1103 extract_insn (insn
);
1105 set
= simple_move (insn
);
1108 rtx orig_insn
= insn
;
1109 bool cfi
= control_flow_insn_p (insn
);
1111 /* We can end up splitting loads to multi-word pseudos
1112 into separate loads to machine word size pseudos.
1113 When this happens, we first had one load that can
1114 throw, and after resolve_simple_move we'll have a
1115 bunch of loads (at least two). All those loads may
1116 trap if we can have non-call exceptions, so they
1117 all will end the current basic block. We split the
1118 block after the outer loop over all insns, but we
1119 make sure here that we will be able to split the
1120 basic block and still produce the correct control
1121 flow graph for it. */
1123 || (flag_non_call_exceptions
1124 && can_throw_internal (insn
)));
1126 insn
= resolve_simple_move (set
, insn
);
1127 if (insn
!= orig_insn
)
1131 recog_memoized (insn
);
1132 extract_insn (insn
);
1135 SET_BIT (sub_blocks
, bb
->index
);
1139 for (i
= recog_data
.n_operands
- 1; i
>= 0; --i
)
1140 for_each_rtx (recog_data
.operand_loc
[i
],
1144 resolve_reg_notes (insn
);
1146 if (num_validated_changes () > 0)
1148 for (i
= recog_data
.n_dups
- 1; i
>= 0; --i
)
1150 rtx
*pl
= recog_data
.dup_loc
[i
];
1151 int dup_num
= recog_data
.dup_num
[i
];
1152 rtx
*px
= recog_data
.operand_loc
[dup_num
];
1154 validate_change (insn
, pl
, *px
, 1);
1157 i
= apply_change_group ();
1166 SET_BIT (life_blocks
, bb
->index
);
1167 reg_scan_update (insn
, next
, max_regno
);
1172 no_new_pseudos
= hold_no_new_pseudos
;
1175 update_life_info (life_blocks
, UPDATE_LIFE_GLOBAL_RM_NOTES
,
1178 /* If we had insns to split that caused control flow insns in the middle
1179 of a basic block, split those blocks now. Note that we only handle
1180 the case where splitting a load has caused multiple possibly trapping
1182 EXECUTE_IF_SET_IN_SBITMAP (sub_blocks
, 0, i
, sbi
)
1187 bb
= BASIC_BLOCK (i
);
1188 insn
= BB_HEAD (bb
);
1193 if (control_flow_insn_p (insn
))
1195 /* Split the block after insn. There will be a fallthru
1196 edge, which is OK so we keep it. We have to create the
1197 exception edges ourselves. */
1198 fallthru
= split_block (bb
, insn
);
1199 rtl_make_eh_edge (NULL
, bb
, BB_END (bb
));
1200 bb
= fallthru
->dest
;
1201 insn
= BB_HEAD (bb
);
1204 insn
= NEXT_INSN (insn
);
1208 sbitmap_free (life_blocks
);
1209 sbitmap_free (sub_blocks
);
1216 for (i
= 0; VEC_iterate (bitmap
, reg_copy_graph
, i
, b
); ++i
)
1221 VEC_free (bitmap
, heap
, reg_copy_graph
);
1223 BITMAP_FREE (decomposable_context
);
1224 BITMAP_FREE (non_decomposable_context
);
1227 /* Gate function for lower subreg pass. */
1230 gate_handle_lower_subreg (void)
1232 return flag_split_wide_types
!= 0;
1235 /* Implement first lower subreg pass. */
1238 rest_of_handle_lower_subreg (void)
1240 decompose_multiword_subregs (false);
1244 /* Implement second lower subreg pass. */
1247 rest_of_handle_lower_subreg2 (void)
1249 decompose_multiword_subregs (true);
1253 struct tree_opt_pass pass_lower_subreg
=
1255 "subreg", /* name */
1256 gate_handle_lower_subreg
, /* gate */
1257 rest_of_handle_lower_subreg
, /* execute */
1260 0, /* static_pass_number */
1261 TV_LOWER_SUBREG
, /* tv_id */
1262 0, /* properties_required */
1263 0, /* properties_provided */
1264 0, /* properties_destroyed */
1265 0, /* todo_flags_start */
1268 TODO_verify_flow
, /* todo_flags_finish */
1272 struct tree_opt_pass pass_lower_subreg2
=
1274 "subreg2", /* name */
1275 gate_handle_lower_subreg
, /* gate */
1276 rest_of_handle_lower_subreg2
, /* execute */
1279 0, /* static_pass_number */
1280 TV_LOWER_SUBREG
, /* tv_id */
1281 0, /* properties_required */
1282 0, /* properties_provided */
1283 0, /* properties_destroyed */
1284 0, /* todo_flags_start */
1287 TODO_verify_flow
, /* todo_flags_finish */