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"
43 #ifdef STACK_GROWS_DOWNWARD
44 # undef STACK_GROWS_DOWNWARD
45 # define STACK_GROWS_DOWNWARD 1
47 # define STACK_GROWS_DOWNWARD 0
51 DEF_VEC_ALLOC_P (bitmap
,heap
);
53 /* Decompose multi-word pseudo-registers into individual
54 pseudo-registers when possible. This is possible when all the uses
55 of a multi-word register are via SUBREG, or are copies of the
56 register to another location. Breaking apart the register permits
57 more CSE and permits better register allocation. */
59 /* Bit N in this bitmap is set if regno N is used in a context in
60 which we can decompose it. */
61 static bitmap decomposable_context
;
63 /* Bit N in this bitmap is set if regno N is used in a context in
64 which it can not be decomposed. */
65 static bitmap non_decomposable_context
;
67 /* Bit N in the bitmap in element M of this array is set if there is a
68 copy from reg M to reg N. */
69 static VEC(bitmap
,heap
) *reg_copy_graph
;
71 /* Return whether X is a simple object which we can take a word_mode
75 simple_move_operand (rtx x
)
77 if (GET_CODE (x
) == SUBREG
)
83 if (GET_CODE (x
) == LABEL_REF
84 || GET_CODE (x
) == SYMBOL_REF
85 || GET_CODE (x
) == HIGH
86 || GET_CODE (x
) == CONST
)
90 && (MEM_VOLATILE_P (x
)
91 || mode_dependent_address_p (XEXP (x
, 0))))
97 /* If INSN is a single set between two objects, return the single set.
98 Such an insn can always be decomposed. INSN should have been
99 passed to recog and extract_insn before this is called. */
102 simple_move (rtx insn
)
106 enum machine_mode mode
;
108 if (recog_data
.n_operands
!= 2)
111 set
= single_set (insn
);
116 if (x
!= recog_data
.operand
[0] && x
!= recog_data
.operand
[1])
118 if (!simple_move_operand (x
))
122 if (x
!= recog_data
.operand
[0] && x
!= recog_data
.operand
[1])
124 /* For the src we can handle ASM_OPERANDS, and it is beneficial for
125 things like x86 rdtsc which returns a DImode value. */
126 if (GET_CODE (x
) != ASM_OPERANDS
127 && !simple_move_operand (x
))
130 /* We try to decompose in integer modes, to avoid generating
131 inefficient code copying between integer and floating point
132 registers. That means that we can't decompose if this is a
133 non-integer mode for which there is no integer mode of the same
135 mode
= GET_MODE (SET_SRC (set
));
136 if (!SCALAR_INT_MODE_P (mode
)
137 && (mode_for_size (GET_MODE_SIZE (mode
) * BITS_PER_UNIT
, MODE_INT
, 0)
141 /* Reject PARTIAL_INT modes. They are used for processor specific
142 purposes and it's probably best not to tamper with them. */
143 if (GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
149 /* If SET is a copy from one multi-word pseudo-register to another,
150 record that in reg_copy_graph. Return whether it is such a
154 find_pseudo_copy (rtx set
)
156 rtx dest
= SET_DEST (set
);
157 rtx src
= SET_SRC (set
);
161 if (!REG_P (dest
) || !REG_P (src
))
166 if (HARD_REGISTER_NUM_P (rd
) || HARD_REGISTER_NUM_P (rs
))
169 if (GET_MODE_SIZE (GET_MODE (dest
)) <= UNITS_PER_WORD
)
172 b
= VEC_index (bitmap
, reg_copy_graph
, rs
);
175 b
= BITMAP_ALLOC (NULL
);
176 VEC_replace (bitmap
, reg_copy_graph
, rs
, b
);
179 bitmap_set_bit (b
, rd
);
184 /* Look through the registers in DECOMPOSABLE_CONTEXT. For each case
185 where they are copied to another register, add the register to
186 which they are copied to DECOMPOSABLE_CONTEXT. Use
187 NON_DECOMPOSABLE_CONTEXT to limit this--we don't bother to track
188 copies of registers which are in NON_DECOMPOSABLE_CONTEXT. */
191 propagate_pseudo_copies (void)
193 bitmap queue
, propagate
;
195 queue
= BITMAP_ALLOC (NULL
);
196 propagate
= BITMAP_ALLOC (NULL
);
198 bitmap_copy (queue
, decomposable_context
);
201 bitmap_iterator iter
;
204 bitmap_clear (propagate
);
206 EXECUTE_IF_SET_IN_BITMAP (queue
, 0, i
, iter
)
208 bitmap b
= VEC_index (bitmap
, reg_copy_graph
, i
);
210 bitmap_ior_and_compl_into (propagate
, b
, non_decomposable_context
);
213 bitmap_and_compl (queue
, propagate
, decomposable_context
);
214 bitmap_ior_into (decomposable_context
, propagate
);
216 while (!bitmap_empty_p (queue
));
219 BITMAP_FREE (propagate
);
222 /* A pointer to one of these values is passed to
223 find_decomposable_subregs via for_each_rtx. */
225 enum classify_move_insn
227 /* Not a simple move from one location to another. */
229 /* A simple move from one pseudo-register to another with no
231 SIMPLE_PSEUDO_REG_MOVE
,
232 /* A simple move involving a non-pseudo-register, or from one
233 pseudo-register to another with a REG_RETVAL note. */
237 /* This is called via for_each_rtx. If we find a SUBREG which we
238 could use to decompose a pseudo-register, set a bit in
239 DECOMPOSABLE_CONTEXT. If we find an unadorned register which is
240 not a simple pseudo-register copy, DATA will point at the type of
241 move, and we set a bit in DECOMPOSABLE_CONTEXT or
242 NON_DECOMPOSABLE_CONTEXT as appropriate. */
245 find_decomposable_subregs (rtx
*px
, void *data
)
247 enum classify_move_insn
*pcmi
= (enum classify_move_insn
*) data
;
253 if (GET_CODE (x
) == SUBREG
)
255 rtx inner
= SUBREG_REG (x
);
256 unsigned int regno
, outer_size
, inner_size
, outer_words
, inner_words
;
261 regno
= REGNO (inner
);
262 if (HARD_REGISTER_NUM_P (regno
))
265 outer_size
= GET_MODE_SIZE (GET_MODE (x
));
266 inner_size
= GET_MODE_SIZE (GET_MODE (inner
));
267 outer_words
= (outer_size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
268 inner_words
= (inner_size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
270 /* We only try to decompose single word subregs of multi-word
271 registers. When we find one, we return -1 to avoid iterating
272 over the inner register.
274 ??? This doesn't allow, e.g., DImode subregs of TImode values
275 on 32-bit targets. We would need to record the way the
276 pseudo-register was used, and only decompose if all the uses
277 were the same number and size of pieces. Hopefully this
278 doesn't happen much. */
280 if (outer_words
== 1 && inner_words
> 1)
282 bitmap_set_bit (decomposable_context
, regno
);
286 /* If this is a cast from one mode to another, where the modes
287 have the same size, and they are not tieable, then mark this
288 register as non-decomposable. If we decompose it we are
289 likely to mess up whatever the backend is trying to do. */
291 && outer_size
== inner_size
292 && !MODES_TIEABLE_P (GET_MODE (x
), GET_MODE (inner
)))
294 bitmap_set_bit (non_decomposable_context
, regno
);
302 /* We will see an outer SUBREG before we see the inner REG, so
303 when we see a plain REG here it means a direct reference to
306 If this is not a simple copy from one location to another,
307 then we can not decompose this register. If this is a simple
308 copy from one pseudo-register to another, with no REG_RETVAL
309 note, and the mode is right, then we mark the register as
310 decomposable. Otherwise we don't say anything about this
311 register--it could be decomposed, but whether that would be
312 profitable depends upon how it is used elsewhere.
314 We only set bits in the bitmap for multi-word
315 pseudo-registers, since those are the only ones we care about
316 and it keeps the size of the bitmaps down. */
319 if (!HARD_REGISTER_NUM_P (regno
)
320 && GET_MODE_SIZE (GET_MODE (x
)) > UNITS_PER_WORD
)
324 case NOT_SIMPLE_MOVE
:
325 bitmap_set_bit (non_decomposable_context
, regno
);
327 case SIMPLE_PSEUDO_REG_MOVE
:
328 if (MODES_TIEABLE_P (GET_MODE (x
), word_mode
))
329 bitmap_set_bit (decomposable_context
, regno
);
340 enum classify_move_insn cmi_mem
= NOT_SIMPLE_MOVE
;
342 /* Any registers used in a MEM do not participate in a
343 SIMPLE_MOVE or SIMPLE_PSEUDO_REG_MOVE. Do our own recursion
344 here, and return -1 to block the parent's recursion. */
345 for_each_rtx (&XEXP (x
, 0), find_decomposable_subregs
, &cmi_mem
);
352 /* Decompose REGNO into word-sized components. We smash the REG node
353 in place. This ensures that (1) something goes wrong quickly if we
354 fail to make some replacement, and (2) the debug information inside
355 the symbol table is automatically kept up to date. */
358 decompose_register (unsigned int regno
)
361 unsigned int words
, i
;
364 reg
= regno_reg_rtx
[regno
];
366 regno_reg_rtx
[regno
] = NULL_RTX
;
368 words
= GET_MODE_SIZE (GET_MODE (reg
));
369 words
= (words
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
371 v
= rtvec_alloc (words
);
372 for (i
= 0; i
< words
; ++i
)
373 RTVEC_ELT (v
, i
) = gen_reg_rtx_offset (reg
, word_mode
, i
* UNITS_PER_WORD
);
375 PUT_CODE (reg
, CONCATN
);
380 fprintf (dump_file
, "; Splitting reg %u ->", regno
);
381 for (i
= 0; i
< words
; ++i
)
382 fprintf (dump_file
, " %u", REGNO (XVECEXP (reg
, 0, i
)));
383 fputc ('\n', dump_file
);
387 /* Get a SUBREG of a CONCATN. */
390 simplify_subreg_concatn (enum machine_mode outermode
, rtx op
,
393 unsigned int inner_size
;
394 enum machine_mode innermode
;
396 unsigned int final_offset
;
398 gcc_assert (GET_CODE (op
) == CONCATN
);
399 gcc_assert (byte
% GET_MODE_SIZE (outermode
) == 0);
401 innermode
= GET_MODE (op
);
402 gcc_assert (byte
< GET_MODE_SIZE (innermode
));
403 gcc_assert (GET_MODE_SIZE (outermode
) <= GET_MODE_SIZE (innermode
));
405 inner_size
= GET_MODE_SIZE (innermode
) / XVECLEN (op
, 0);
406 part
= XVECEXP (op
, 0, byte
/ inner_size
);
407 final_offset
= byte
% inner_size
;
408 if (final_offset
+ GET_MODE_SIZE (outermode
) > inner_size
)
411 return simplify_gen_subreg (outermode
, part
, GET_MODE (part
), final_offset
);
414 /* Wrapper around simplify_gen_subreg which handles CONCATN. */
417 simplify_gen_subreg_concatn (enum machine_mode outermode
, rtx op
,
418 enum machine_mode innermode
, unsigned int byte
)
422 /* We have to handle generating a SUBREG of a SUBREG of a CONCATN.
423 If OP is a SUBREG of a CONCATN, then it must be a simple mode
424 change with the same size and offset 0, or it must extract a
425 part. We shouldn't see anything else here. */
426 if (GET_CODE (op
) == SUBREG
&& GET_CODE (SUBREG_REG (op
)) == CONCATN
)
430 if ((GET_MODE_SIZE (GET_MODE (op
))
431 == GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))))
432 && SUBREG_BYTE (op
) == 0)
433 return simplify_gen_subreg_concatn (outermode
, SUBREG_REG (op
),
434 GET_MODE (SUBREG_REG (op
)), byte
);
436 op2
= simplify_subreg_concatn (GET_MODE (op
), SUBREG_REG (op
),
440 /* We don't handle paradoxical subregs here. */
441 gcc_assert (GET_MODE_SIZE (outermode
)
442 <= GET_MODE_SIZE (GET_MODE (op
)));
443 gcc_assert (GET_MODE_SIZE (GET_MODE (op
))
444 <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
))));
445 op2
= simplify_subreg_concatn (outermode
, SUBREG_REG (op
),
446 byte
+ SUBREG_BYTE (op
));
447 gcc_assert (op2
!= NULL_RTX
);
452 gcc_assert (op
!= NULL_RTX
);
453 gcc_assert (innermode
== GET_MODE (op
));
456 if (GET_CODE (op
) == CONCATN
)
457 return simplify_subreg_concatn (outermode
, op
, byte
);
459 ret
= simplify_gen_subreg (outermode
, op
, innermode
, byte
);
461 /* If we see an insn like (set (reg:DI) (subreg:DI (reg:SI) 0)) then
462 resolve_simple_move will ask for the high part of the paradoxical
463 subreg, which does not have a value. Just return a zero. */
465 && GET_CODE (op
) == SUBREG
466 && SUBREG_BYTE (op
) == 0
467 && (GET_MODE_SIZE (innermode
)
468 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op
)))))
469 return CONST0_RTX (outermode
);
471 gcc_assert (ret
!= NULL_RTX
);
475 /* Return whether we should resolve X into the registers into which it
479 resolve_reg_p (rtx x
)
481 return GET_CODE (x
) == CONCATN
;
484 /* Return whether X is a SUBREG of a register which we need to
488 resolve_subreg_p (rtx x
)
490 if (GET_CODE (x
) != SUBREG
)
492 return resolve_reg_p (SUBREG_REG (x
));
495 /* This is called via for_each_rtx. Look for SUBREGs which need to be
499 resolve_subreg_use (rtx
*px
, void *data
)
501 rtx insn
= (rtx
) data
;
507 if (resolve_subreg_p (x
))
509 x
= simplify_subreg_concatn (GET_MODE (x
), SUBREG_REG (x
),
512 /* It is possible for a note to contain a reference which we can
513 decompose. In this case, return 1 to the caller to indicate
514 that the note must be removed. */
521 validate_change (insn
, px
, x
, 1);
525 if (resolve_reg_p (x
))
527 /* Return 1 to the caller to indicate that we found a direct
528 reference to a register which is being decomposed. This can
529 happen inside notes. */
537 /* We are deleting INSN. Move any EH_REGION notes to INSNS. */
540 move_eh_region_note (rtx insn
, rtx insns
)
544 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
545 if (note
== NULL_RTX
)
548 gcc_assert (CALL_P (insn
)
549 || (flag_non_call_exceptions
&& may_trap_p (PATTERN (insn
))));
551 for (p
= insns
; p
!= NULL_RTX
; p
= NEXT_INSN (p
))
554 || (flag_non_call_exceptions
556 && may_trap_p (PATTERN (p
))))
557 REG_NOTES (p
) = gen_rtx_EXPR_LIST (REG_EH_REGION
, XEXP (note
, 0),
562 /* If there is a REG_LIBCALL note on OLD_START, move it to NEW_START,
563 and link the corresponding REG_RETVAL note to NEW_START. */
566 move_libcall_note (rtx old_start
, rtx new_start
)
568 rtx note0
, note1
, end
;
570 note0
= find_reg_note (old_start
, REG_LIBCALL
, NULL
);
571 if (note0
== NULL_RTX
)
574 remove_note (old_start
, note0
);
575 end
= XEXP (note0
, 0);
576 note1
= find_reg_note (end
, REG_RETVAL
, NULL
);
578 XEXP (note0
, 1) = REG_NOTES (new_start
);
579 REG_NOTES (new_start
) = note0
;
580 XEXP (note1
, 0) = new_start
;
583 /* Remove any REG_RETVAL note, the corresponding REG_LIBCALL note, and
584 any markers for a no-conflict block. We have decomposed the
585 registers so the non-conflict is now obvious. */
588 remove_retval_note (rtx insn1
)
590 rtx note0
, insn0
, note1
, insn
;
592 note1
= find_reg_note (insn1
, REG_RETVAL
, NULL
);
593 if (note1
== NULL_RTX
)
596 insn0
= XEXP (note1
, 0);
597 note0
= find_reg_note (insn0
, REG_LIBCALL
, NULL
);
599 remove_note (insn0
, note0
);
600 remove_note (insn1
, note1
);
602 for (insn
= insn0
; insn
!= insn1
; insn
= NEXT_INSN (insn
))
608 note
= find_reg_note (insn
, REG_NO_CONFLICT
, NULL
);
609 if (note
== NULL_RTX
)
611 remove_note (insn
, note
);
616 /* Resolve any decomposed registers which appear in register notes on
620 resolve_reg_notes (rtx insn
)
624 note
= find_reg_equal_equiv_note (insn
);
627 int old_count
= num_validated_changes ();
628 if (for_each_rtx (&XEXP (note
, 0), resolve_subreg_use
, NULL
))
630 remove_note (insn
, note
);
631 remove_retval_note (insn
);
634 if (old_count
!= num_validated_changes ())
635 df_notes_rescan (insn
);
638 pnote
= ®_NOTES (insn
);
639 while (*pnote
!= NULL_RTX
)
644 switch (REG_NOTE_KIND (note
))
646 case REG_NO_CONFLICT
:
649 if (resolve_reg_p (XEXP (note
, 0)))
658 *pnote
= XEXP (note
, 1);
660 pnote
= &XEXP (note
, 1);
664 /* Return whether X can be decomposed into subwords. */
667 can_decompose_p (rtx x
)
671 unsigned int regno
= REGNO (x
);
673 if (HARD_REGISTER_NUM_P (regno
))
674 return (validate_subreg (word_mode
, GET_MODE (x
), x
, UNITS_PER_WORD
)
675 && HARD_REGNO_MODE_OK (regno
, word_mode
));
677 return !bitmap_bit_p (non_decomposable_context
, regno
);
683 /* Decompose the registers used in a simple move SET within INSN. If
684 we don't change anything, return INSN, otherwise return the start
685 of the sequence of moves. */
688 resolve_simple_move (rtx set
, rtx insn
)
690 rtx src
, dest
, real_dest
, insns
;
691 enum machine_mode orig_mode
, dest_mode
;
696 dest
= SET_DEST (set
);
697 orig_mode
= GET_MODE (dest
);
699 words
= (GET_MODE_SIZE (orig_mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
705 /* We have to handle copying from a SUBREG of a decomposed reg where
706 the SUBREG is larger than word size. Rather than assume that we
707 can take a word_mode SUBREG of the destination, we copy to a new
708 register and then copy that to the destination. */
710 real_dest
= NULL_RTX
;
712 if (GET_CODE (src
) == SUBREG
713 && resolve_reg_p (SUBREG_REG (src
))
714 && (SUBREG_BYTE (src
) != 0
715 || (GET_MODE_SIZE (orig_mode
)
716 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (src
))))))
719 dest
= gen_reg_rtx (orig_mode
);
720 if (REG_P (real_dest
))
721 REG_ATTRS (dest
) = REG_ATTRS (real_dest
);
724 /* Similarly if we are copying to a SUBREG of a decomposed reg where
725 the SUBREG is larger than word size. */
727 if (GET_CODE (dest
) == SUBREG
728 && resolve_reg_p (SUBREG_REG (dest
))
729 && (SUBREG_BYTE (dest
) != 0
730 || (GET_MODE_SIZE (orig_mode
)
731 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
))))))
733 rtx reg
, minsn
, smove
;
735 reg
= gen_reg_rtx (orig_mode
);
736 minsn
= emit_move_insn (reg
, src
);
737 smove
= single_set (minsn
);
738 gcc_assert (smove
!= NULL_RTX
);
739 resolve_simple_move (smove
, minsn
);
743 /* If we didn't have any big SUBREGS of decomposed registers, and
744 neither side of the move is a register we are decomposing, then
745 we don't have to do anything here. */
747 if (src
== SET_SRC (set
)
748 && dest
== SET_DEST (set
)
749 && !resolve_reg_p (src
)
750 && !resolve_subreg_p (src
)
751 && !resolve_reg_p (dest
)
752 && !resolve_subreg_p (dest
))
758 /* It's possible for the code to use a subreg of a decomposed
759 register while forming an address. We need to handle that before
760 passing the address to emit_move_insn. We pass NULL_RTX as the
761 insn parameter to resolve_subreg_use because we can not validate
763 if (MEM_P (src
) || MEM_P (dest
))
768 for_each_rtx (&XEXP (src
, 0), resolve_subreg_use
, NULL_RTX
);
770 for_each_rtx (&XEXP (dest
, 0), resolve_subreg_use
, NULL_RTX
);
771 acg
= apply_change_group ();
775 /* If SRC is a register which we can't decompose, or has side
776 effects, we need to move via a temporary register. */
778 if (!can_decompose_p (src
)
779 || side_effects_p (src
)
780 || GET_CODE (src
) == ASM_OPERANDS
)
784 reg
= gen_reg_rtx (orig_mode
);
785 emit_move_insn (reg
, src
);
789 /* If DEST is a register which we can't decompose, or has side
790 effects, we need to first move to a temporary register. We
791 handle the common case of pushing an operand directly. We also
792 go through a temporary register if it holds a floating point
793 value. This gives us better code on systems which can't move
794 data easily between integer and floating point registers. */
796 dest_mode
= orig_mode
;
797 pushing
= push_operand (dest
, dest_mode
);
798 if (!can_decompose_p (dest
)
799 || (side_effects_p (dest
) && !pushing
)
800 || (!SCALAR_INT_MODE_P (dest_mode
)
801 && !resolve_reg_p (dest
)
802 && !resolve_subreg_p (dest
)))
804 if (real_dest
== NULL_RTX
)
806 if (!SCALAR_INT_MODE_P (dest_mode
))
808 dest_mode
= mode_for_size (GET_MODE_SIZE (dest_mode
) * BITS_PER_UNIT
,
810 gcc_assert (dest_mode
!= BLKmode
);
812 dest
= gen_reg_rtx (dest_mode
);
813 if (REG_P (real_dest
))
814 REG_ATTRS (dest
) = REG_ATTRS (real_dest
);
819 unsigned int i
, j
, jinc
;
821 gcc_assert (GET_MODE_SIZE (orig_mode
) % UNITS_PER_WORD
== 0);
822 gcc_assert (GET_CODE (XEXP (dest
, 0)) != PRE_MODIFY
);
823 gcc_assert (GET_CODE (XEXP (dest
, 0)) != POST_MODIFY
);
825 if (WORDS_BIG_ENDIAN
== STACK_GROWS_DOWNWARD
)
836 for (i
= 0; i
< words
; ++i
, j
+= jinc
)
840 temp
= copy_rtx (XEXP (dest
, 0));
841 temp
= adjust_automodify_address_nv (dest
, word_mode
, temp
,
843 emit_move_insn (temp
,
844 simplify_gen_subreg_concatn (word_mode
, src
,
846 j
* UNITS_PER_WORD
));
853 if (REG_P (dest
) && !HARD_REGISTER_NUM_P (REGNO (dest
)))
854 emit_insn (gen_rtx_CLOBBER (VOIDmode
, dest
));
856 for (i
= 0; i
< words
; ++i
)
857 emit_move_insn (simplify_gen_subreg_concatn (word_mode
, dest
,
860 simplify_gen_subreg_concatn (word_mode
, src
,
862 i
* UNITS_PER_WORD
));
865 if (real_dest
!= NULL_RTX
)
867 rtx mdest
, minsn
, smove
;
869 if (dest_mode
== orig_mode
)
872 mdest
= simplify_gen_subreg (orig_mode
, dest
, GET_MODE (dest
), 0);
873 minsn
= emit_move_insn (real_dest
, mdest
);
875 smove
= single_set (minsn
);
876 gcc_assert (smove
!= NULL_RTX
);
878 resolve_simple_move (smove
, minsn
);
881 insns
= get_insns ();
884 move_eh_region_note (insn
, insns
);
886 emit_insn_before (insns
, insn
);
888 move_libcall_note (insn
, insns
);
889 remove_retval_note (insn
);
895 /* Change a CLOBBER of a decomposed register into a CLOBBER of the
896 component registers. Return whether we changed something. */
899 resolve_clobber (rtx pat
, rtx insn
)
902 enum machine_mode orig_mode
;
903 unsigned int words
, i
;
907 if (!resolve_reg_p (reg
) && !resolve_subreg_p (reg
))
910 orig_mode
= GET_MODE (reg
);
911 words
= GET_MODE_SIZE (orig_mode
);
912 words
= (words
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
914 ret
= validate_change (NULL_RTX
, &XEXP (pat
, 0),
915 simplify_gen_subreg_concatn (word_mode
, reg
,
918 df_insn_rescan (insn
);
919 gcc_assert (ret
!= 0);
921 for (i
= words
- 1; i
> 0; --i
)
925 x
= simplify_gen_subreg_concatn (word_mode
, reg
, orig_mode
,
927 x
= gen_rtx_CLOBBER (VOIDmode
, x
);
928 emit_insn_after (x
, insn
);
934 /* A USE of a decomposed register is no longer meaningful. Return
935 whether we changed something. */
938 resolve_use (rtx pat
, rtx insn
)
940 if (resolve_reg_p (XEXP (pat
, 0)) || resolve_subreg_p (XEXP (pat
, 0)))
948 /* Look for registers which are always accessed via word-sized SUBREGs
949 or via copies. Decompose these registers into several word-sized
953 decompose_multiword_subregs (void)
959 df_set_flags (DF_DEFER_INSN_RESCAN
);
961 max
= max_reg_num ();
963 /* First see if there are any multi-word pseudo-registers. If there
964 aren't, there is nothing we can do. This should speed up this
965 pass in the normal case, since it should be faster than scanning
970 for (i
= FIRST_PSEUDO_REGISTER
; i
< max
; ++i
)
972 if (regno_reg_rtx
[i
] != NULL
973 && GET_MODE_SIZE (GET_MODE (regno_reg_rtx
[i
])) > UNITS_PER_WORD
)
980 /* FIXME: When the dataflow branch is merged, we can change this
981 code to look for each multi-word pseudo-register and to find each
982 insn which sets or uses that register. That should be faster
983 than scanning all the insns. */
985 decomposable_context
= BITMAP_ALLOC (NULL
);
986 non_decomposable_context
= BITMAP_ALLOC (NULL
);
988 reg_copy_graph
= VEC_alloc (bitmap
, heap
, max
);
989 VEC_safe_grow (bitmap
, heap
, reg_copy_graph
, max
);
990 memset (VEC_address (bitmap
, reg_copy_graph
), 0, sizeof (bitmap
) * max
);
996 FOR_BB_INSNS (bb
, insn
)
999 enum classify_move_insn cmi
;
1003 || GET_CODE (PATTERN (insn
)) == CLOBBER
1004 || GET_CODE (PATTERN (insn
)) == USE
)
1007 recog_memoized (insn
);
1008 extract_insn (insn
);
1010 set
= simple_move (insn
);
1013 cmi
= NOT_SIMPLE_MOVE
;
1018 retval
= find_reg_note (insn
, REG_RETVAL
, NULL_RTX
) != NULL_RTX
;
1020 if (find_pseudo_copy (set
) && !retval
)
1021 cmi
= SIMPLE_PSEUDO_REG_MOVE
;
1023 && REG_P (SET_SRC (set
))
1024 && HARD_REGISTER_P (SET_SRC (set
)))
1028 /* We don't want to decompose an assignment which
1029 copies the value returned by a libcall to a
1030 pseudo-register. Doing that will lose the RETVAL
1031 note with no real gain. */
1032 cmi
= NOT_SIMPLE_MOVE
;
1034 /* If we have a RETVAL note, there should be an
1035 EQUAL note. We don't want to decompose any
1036 registers which that EQUAL note refers to
1037 directly. If we do, we will no longer know the
1038 value of the libcall. */
1039 note
= find_reg_equal_equiv_note (insn
);
1040 if (note
!= NULL_RTX
)
1041 for_each_rtx (&XEXP (note
, 0), find_decomposable_subregs
,
1048 n
= recog_data
.n_operands
;
1049 for (i
= 0; i
< n
; ++i
)
1051 for_each_rtx (&recog_data
.operand
[i
],
1052 find_decomposable_subregs
,
1055 /* We handle ASM_OPERANDS as a special case to support
1056 things like x86 rdtsc which returns a DImode value.
1057 We can decompose the output, which will certainly be
1058 operand 0, but not the inputs. */
1060 if (cmi
== SIMPLE_MOVE
1061 && GET_CODE (SET_SRC (set
)) == ASM_OPERANDS
)
1063 gcc_assert (i
== 0);
1064 cmi
= NOT_SIMPLE_MOVE
;
1070 bitmap_and_compl_into (decomposable_context
, non_decomposable_context
);
1071 if (!bitmap_empty_p (decomposable_context
))
1073 int hold_no_new_pseudos
= no_new_pseudos
;
1076 sbitmap_iterator sbi
;
1077 bitmap_iterator iter
;
1080 propagate_pseudo_copies ();
1083 sub_blocks
= sbitmap_alloc (last_basic_block
);
1084 sbitmap_zero (sub_blocks
);
1086 EXECUTE_IF_SET_IN_BITMAP (decomposable_context
, 0, regno
, iter
)
1087 decompose_register (regno
);
1093 FOR_BB_INSNS (bb
, insn
)
1101 next
= NEXT_INSN (insn
);
1104 pat
= PATTERN (insn
);
1105 if (GET_CODE (pat
) == CLOBBER
)
1107 if (resolve_clobber (pat
, insn
))
1110 else if (GET_CODE (pat
) == USE
)
1112 if (resolve_use (pat
, insn
))
1120 recog_memoized (insn
);
1121 extract_insn (insn
);
1123 set
= simple_move (insn
);
1126 rtx orig_insn
= insn
;
1127 bool cfi
= control_flow_insn_p (insn
);
1129 /* We can end up splitting loads to multi-word pseudos
1130 into separate loads to machine word size pseudos.
1131 When this happens, we first had one load that can
1132 throw, and after resolve_simple_move we'll have a
1133 bunch of loads (at least two). All those loads may
1134 trap if we can have non-call exceptions, so they
1135 all will end the current basic block. We split the
1136 block after the outer loop over all insns, but we
1137 make sure here that we will be able to split the
1138 basic block and still produce the correct control
1139 flow graph for it. */
1141 || (flag_non_call_exceptions
1142 && can_throw_internal (insn
)));
1144 insn
= resolve_simple_move (set
, insn
);
1145 if (insn
!= orig_insn
)
1149 remove_retval_note (insn
);
1151 recog_memoized (insn
);
1152 extract_insn (insn
);
1155 SET_BIT (sub_blocks
, bb
->index
);
1159 for (i
= recog_data
.n_operands
- 1; i
>= 0; --i
)
1160 for_each_rtx (recog_data
.operand_loc
[i
],
1164 resolve_reg_notes (insn
);
1166 if (num_validated_changes () > 0)
1168 for (i
= recog_data
.n_dups
- 1; i
>= 0; --i
)
1170 rtx
*pl
= recog_data
.dup_loc
[i
];
1171 int dup_num
= recog_data
.dup_num
[i
];
1172 rtx
*px
= recog_data
.operand_loc
[dup_num
];
1174 validate_change (insn
, pl
, *px
, 1);
1177 i
= apply_change_group ();
1180 remove_retval_note (insn
);
1188 no_new_pseudos
= hold_no_new_pseudos
;
1190 /* If we had insns to split that caused control flow insns in the middle
1191 of a basic block, split those blocks now. Note that we only handle
1192 the case where splitting a load has caused multiple possibly trapping
1194 EXECUTE_IF_SET_IN_SBITMAP (sub_blocks
, 0, i
, sbi
)
1199 bb
= BASIC_BLOCK (i
);
1200 insn
= BB_HEAD (bb
);
1205 if (control_flow_insn_p (insn
))
1207 /* Split the block after insn. There will be a fallthru
1208 edge, which is OK so we keep it. We have to create the
1209 exception edges ourselves. */
1210 fallthru
= split_block (bb
, insn
);
1211 rtl_make_eh_edge (NULL
, bb
, BB_END (bb
));
1212 bb
= fallthru
->dest
;
1213 insn
= BB_HEAD (bb
);
1216 insn
= NEXT_INSN (insn
);
1220 sbitmap_free (sub_blocks
);
1227 for (i
= 0; VEC_iterate (bitmap
, reg_copy_graph
, i
, b
); ++i
)
1232 VEC_free (bitmap
, heap
, reg_copy_graph
);
1234 BITMAP_FREE (decomposable_context
);
1235 BITMAP_FREE (non_decomposable_context
);
1238 /* Gate function for lower subreg pass. */
1241 gate_handle_lower_subreg (void)
1243 return flag_split_wide_types
!= 0;
1246 /* Implement first lower subreg pass. */
1249 rest_of_handle_lower_subreg (void)
1251 decompose_multiword_subregs ();
1255 /* Implement second lower subreg pass. */
1258 rest_of_handle_lower_subreg2 (void)
1260 decompose_multiword_subregs ();
1264 struct tree_opt_pass pass_lower_subreg
=
1266 "subreg", /* name */
1267 gate_handle_lower_subreg
, /* gate */
1268 rest_of_handle_lower_subreg
, /* execute */
1271 0, /* static_pass_number */
1272 TV_LOWER_SUBREG
, /* tv_id */
1273 0, /* properties_required */
1274 0, /* properties_provided */
1275 0, /* properties_destroyed */
1276 0, /* todo_flags_start */
1279 TODO_verify_flow
, /* todo_flags_finish */
1283 struct tree_opt_pass pass_lower_subreg2
=
1285 "subreg2", /* name */
1286 gate_handle_lower_subreg
, /* gate */
1287 rest_of_handle_lower_subreg2
, /* execute */
1290 0, /* static_pass_number */
1291 TV_LOWER_SUBREG
, /* tv_id */
1292 0, /* properties_required */
1293 0, /* properties_provided */
1294 0, /* properties_destroyed */
1295 0, /* todo_flags_start */
1299 TODO_verify_flow
, /* todo_flags_finish */