OSDN Git Service

* lower-subreg.c: Include except.h.
[pf3gnuchains/gcc-fork.git] / gcc / lower-subreg.c
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>
5
6 This file is part of GCC.
7
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
11 version.
12
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
16 for more details.
17
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
21 02110-1301, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "machmode.h"
27 #include "tm.h"
28 #include "rtl.h"
29 #include "tm_p.h"
30 #include "timevar.h"
31 #include "flags.h"
32 #include "insn-config.h"
33 #include "obstack.h"
34 #include "basic-block.h"
35 #include "recog.h"
36 #include "bitmap.h"
37 #include "expr.h"
38 #include "except.h"
39 #include "regs.h"
40 #include "tree-pass.h"
41
42 #ifdef STACK_GROWS_DOWNWARD
43 # undef STACK_GROWS_DOWNWARD
44 # define STACK_GROWS_DOWNWARD 1
45 #else
46 # define STACK_GROWS_DOWNWARD 0
47 #endif
48
49 DEF_VEC_P (bitmap);
50 DEF_VEC_ALLOC_P (bitmap,heap);
51
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.  */
57
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;
61
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;
65
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;
69
70 /* Return whether X is a simple object which we can take a word_mode
71    subreg of.  */
72
73 static bool
74 simple_move_operand (rtx x)
75 {
76   if (GET_CODE (x) == SUBREG)
77     x = SUBREG_REG (x);
78
79   if (!OBJECT_P (x))
80     return false;
81
82   if (GET_CODE (x) == LABEL_REF
83       || GET_CODE (x) == SYMBOL_REF
84       || GET_CODE (x) == HIGH
85       || GET_CODE (x) == CONST)
86     return false;
87
88   if (MEM_P (x)
89       && (MEM_VOLATILE_P (x)
90           || mode_dependent_address_p (XEXP (x, 0))))
91     return false;
92
93   return true;
94 }
95
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.  */
99
100 static rtx
101 simple_move (rtx insn)
102 {
103   rtx x;
104   rtx set;
105   enum machine_mode mode;
106
107   if (recog_data.n_operands != 2)
108     return NULL_RTX;
109
110   set = single_set (insn);
111   if (!set)
112     return NULL_RTX;
113
114   x = SET_DEST (set);
115   if (x != recog_data.operand[0] && x != recog_data.operand[1])
116     return NULL_RTX;
117   if (!simple_move_operand (x))
118     return NULL_RTX;
119
120   x = SET_SRC (set);
121   if (x != recog_data.operand[0] && x != recog_data.operand[1])
122     return NULL_RTX;
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))
127     return NULL_RTX;
128
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
133      size.  */
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)
137           == BLKmode))
138     return NULL_RTX;
139
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)
143     return NULL_RTX;
144
145   return set;
146 }
147
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
150    copy.  */
151
152 static bool
153 find_pseudo_copy (rtx set)
154 {
155   rtx dest = SET_DEST (set);
156   rtx src = SET_SRC (set);
157   unsigned int rd, rs;
158   bitmap b;
159
160   if (!REG_P (dest) || !REG_P (src))
161     return false;
162
163   rd = REGNO (dest);
164   rs = REGNO (src);
165   if (HARD_REGISTER_NUM_P (rd) || HARD_REGISTER_NUM_P (rs))
166     return false;
167
168   if (GET_MODE_SIZE (GET_MODE (dest)) <= UNITS_PER_WORD)
169     return false;
170
171   b = VEC_index (bitmap, reg_copy_graph, rs);
172   if (b == NULL)
173     {
174       b = BITMAP_ALLOC (NULL);
175       VEC_replace (bitmap, reg_copy_graph, rs, b);
176     }
177
178   bitmap_set_bit (b, rd);
179
180   return true;
181 }
182
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.  */
188
189 static void
190 propagate_pseudo_copies (void)
191 {
192   bitmap queue, propagate;
193
194   queue = BITMAP_ALLOC (NULL);
195   propagate = BITMAP_ALLOC (NULL);
196
197   bitmap_copy (queue, decomposable_context);
198   do
199     {
200       bitmap_iterator iter;
201       unsigned int i;
202
203       bitmap_clear (propagate);
204
205       EXECUTE_IF_SET_IN_BITMAP (queue, 0, i, iter)
206         {
207           bitmap b = VEC_index (bitmap, reg_copy_graph, i);
208           if (b)
209             bitmap_ior_and_compl_into (propagate, b, non_decomposable_context);
210         }
211
212       bitmap_and_compl (queue, propagate, decomposable_context);
213       bitmap_ior_into (decomposable_context, propagate);
214     }
215   while (!bitmap_empty_p (queue));
216
217   BITMAP_FREE (queue);
218   BITMAP_FREE (propagate);
219 }
220
221 /* A pointer to one of these values is passed to
222    find_decomposable_subregs via for_each_rtx.  */
223
224 enum classify_move_insn
225 {
226   /* Not a simple move from one location to another.  */
227   NOT_SIMPLE_MOVE,
228   /* A simple move from one pseudo-register to another with no
229      REG_RETVAL note.  */
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.  */
233   SIMPLE_MOVE
234 };
235
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.  */
242
243 static int
244 find_decomposable_subregs (rtx *px, void *data)
245 {
246   enum classify_move_insn *pcmi = (enum classify_move_insn *) data;
247   rtx x = *px;
248
249   if (x == NULL_RTX)
250     return 0;
251
252   if (GET_CODE (x) == SUBREG)
253     {
254       rtx inner = SUBREG_REG (x);
255       unsigned int regno, outer_size, inner_size, outer_words, inner_words;
256
257       if (!REG_P (inner))
258         return 0;
259
260       regno = REGNO (inner);
261       if (HARD_REGISTER_NUM_P (regno))
262         return -1;
263
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;
268
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.
272
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.  */
278
279       if (outer_words == 1 && inner_words > 1)
280         {
281           bitmap_set_bit (decomposable_context, regno);
282           return -1;
283         }
284     }
285   else if (REG_P (x))
286     {
287       unsigned int regno;
288
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
291          the register.
292
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.
300
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.  */
304
305       regno = REGNO (x);
306       if (!HARD_REGISTER_NUM_P (regno)
307           && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
308         {
309           switch (*pcmi)
310             {
311             case NOT_SIMPLE_MOVE:
312               bitmap_set_bit (non_decomposable_context, regno);
313               break;
314             case SIMPLE_PSEUDO_REG_MOVE:
315               if (MODES_TIEABLE_P (GET_MODE (x), word_mode))
316                 bitmap_set_bit (decomposable_context, regno);
317               break;
318             case SIMPLE_MOVE:
319               break;
320             default:
321               gcc_unreachable ();
322             }
323         }
324     }
325   else if (MEM_P (x))
326     {
327       enum classify_move_insn cmi_mem = NOT_SIMPLE_MOVE;
328
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);
333       return -1;
334     }
335
336   return 0;
337 }
338
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.  */
343
344 static void
345 decompose_register (unsigned int regno)
346 {
347   rtx reg;
348   unsigned int words, i;
349   rtvec v;
350
351   reg = regno_reg_rtx[regno];
352
353   regno_reg_rtx[regno] = NULL_RTX;
354   clear_reg_info_regno (regno);
355
356   words = GET_MODE_SIZE (GET_MODE (reg));
357   words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
358
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);
362
363   PUT_CODE (reg, CONCATN);
364   XVEC (reg, 0) = v;
365
366   if (dump_file)
367     {
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);
372     }
373 }
374
375 /* Get a SUBREG of a CONCATN.  */
376
377 static rtx
378 simplify_subreg_concatn (enum machine_mode outermode, rtx op,
379                          unsigned int byte)
380 {
381   unsigned int inner_size;
382   enum machine_mode innermode;
383   rtx part;
384   unsigned int final_offset;
385
386   gcc_assert (GET_CODE (op) == CONCATN);
387   gcc_assert (byte % GET_MODE_SIZE (outermode) == 0);
388
389   innermode = GET_MODE (op);
390   gcc_assert (byte < GET_MODE_SIZE (innermode));
391   gcc_assert (GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (innermode));
392
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)
397     return NULL_RTX;
398
399   return simplify_gen_subreg (outermode, part, GET_MODE (part), final_offset);
400 }
401
402 /* Wrapper around simplify_gen_subreg which handles CONCATN.  */
403
404 static rtx
405 simplify_gen_subreg_concatn (enum machine_mode outermode, rtx op,
406                              enum machine_mode innermode, unsigned int byte)
407 {
408   rtx ret;
409
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)
415     {
416       rtx op2;
417
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);
423
424       op2 = simplify_subreg_concatn (GET_MODE (op), SUBREG_REG (op),
425                                      SUBREG_BYTE (op));
426       if (op2 == NULL_RTX)
427         {
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);
436           return op2;
437         }
438
439       op = op2;
440       gcc_assert (op != NULL_RTX);
441       gcc_assert (innermode == GET_MODE (op));
442     }
443
444   if (GET_CODE (op) == CONCATN)
445     return simplify_subreg_concatn (outermode, op, byte);
446
447   ret = simplify_gen_subreg (outermode, op, innermode, byte);
448
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.  */
452   if (ret == NULL_RTX
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);
458
459   gcc_assert (ret != NULL_RTX);
460   return ret;
461 }
462
463 /* Return whether we should resolve X into the registers into which it
464    was decomposed.  */
465
466 static bool
467 resolve_reg_p (rtx x)
468 {
469   return GET_CODE (x) == CONCATN;
470 }
471
472 /* Return whether X is a SUBREG of a register which we need to
473    resolve.  */
474
475 static bool
476 resolve_subreg_p (rtx x)
477 {
478   if (GET_CODE (x) != SUBREG)
479     return false;
480   return resolve_reg_p (SUBREG_REG (x));
481 }
482
483 /* This is called via for_each_rtx.  Look for SUBREGs which need to be
484    decomposed.  */
485
486 static int
487 resolve_subreg_use (rtx *px, void *data)
488 {
489   rtx insn = (rtx) data;
490   rtx x = *px;
491
492   if (x == NULL_RTX)
493     return 0;
494
495   if (resolve_subreg_p (x))
496     {
497       x = simplify_subreg_concatn (GET_MODE (x), SUBREG_REG (x),
498                                    SUBREG_BYTE (x));
499
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.  */
503       if (!x)
504         {
505           gcc_assert (!insn);
506           return 1;
507         }
508
509       validate_change (insn, px, x, 1);
510       return -1;
511     }
512
513   if (resolve_reg_p (x))
514     {
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.  */
518       gcc_assert (!insn);
519       return 1;
520     }
521
522   return 0;
523 }
524
525 /* We are deleting INSN.  Move any EH_REGION notes to INSNS.  */
526
527 static void
528 move_eh_region_note (rtx insn, rtx insns)
529 {
530   rtx note, p;
531
532   note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
533   if (note == NULL_RTX)
534     return;
535
536   gcc_assert (CALL_P (insn)
537               || (flag_non_call_exceptions && may_trap_p (PATTERN (insn))));
538
539   for (p = insns; p != NULL_RTX; p = NEXT_INSN (p))
540     {
541       if (CALL_P (p)
542           || (flag_non_call_exceptions
543               && INSN_P (p)
544               && may_trap_p (PATTERN (p))))
545         REG_NOTES (p) = gen_rtx_EXPR_LIST (REG_EH_REGION, XEXP (note, 0),
546                                            REG_NOTES (p));
547     }
548 }
549
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.  */
552
553 static void
554 move_libcall_note (rtx old_start, rtx new_start)
555 {
556   rtx note0, note1, end;
557
558   note0 = find_reg_note (old_start, REG_LIBCALL, NULL);
559   if (note0 == NULL_RTX)
560     return;
561
562   remove_note (old_start, note0);
563   end = XEXP (note0, 0);
564   note1 = find_reg_note (end, REG_RETVAL, NULL);
565
566   XEXP (note0, 1) = REG_NOTES (new_start);
567   REG_NOTES (new_start) = note0;
568   XEXP (note1, 0) = new_start;
569 }
570
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.  */
574
575 static void
576 remove_retval_note (rtx insn1)
577 {
578   rtx note0, insn0, note1, insn;
579
580   note1 = find_reg_note (insn1, REG_RETVAL, NULL);
581   if (note1 == NULL_RTX)
582     return;
583
584   insn0 = XEXP (note1, 0);
585   note0 = find_reg_note (insn0, REG_LIBCALL, NULL);
586
587   remove_note (insn0, note0);
588   remove_note (insn1, note1);
589
590   for (insn = insn0; insn != insn1; insn = NEXT_INSN (insn))
591     {
592       while (1)
593         {
594           rtx note;
595
596           note = find_reg_note (insn, REG_NO_CONFLICT, NULL);
597           if (note == NULL_RTX)
598             break;
599           remove_note (insn, note);
600         }
601     }
602 }
603
604 /* Resolve any decomposed registers which appear in register notes on
605    INSN.  */
606
607 static void
608 resolve_reg_notes (rtx insn)
609 {
610   rtx *pnote, note;
611
612   note = find_reg_equal_equiv_note (insn);
613   if (note)
614     {
615       if (for_each_rtx (&XEXP (note, 0), resolve_subreg_use, NULL))
616         {
617           remove_note (insn, note);
618           remove_retval_note (insn);
619         }
620     }
621
622   pnote = &REG_NOTES (insn);
623   while (*pnote != NULL_RTX)
624     {
625       bool delete = false;
626
627       note = *pnote;
628       switch (REG_NOTE_KIND (note))
629         {
630         case REG_NO_CONFLICT:
631           if (resolve_reg_p (XEXP (note, 0)))
632             delete = true;
633           break;
634
635         default:
636           break;
637         }
638
639       if (delete)
640         *pnote = XEXP (note, 1);
641       else
642         pnote = &XEXP (note, 1);
643     }
644 }
645
646 /* Return whether X can be decomposed into subwords.  */
647
648 static bool
649 can_decompose_p (rtx x)
650 {
651   if (REG_P (x))
652     {
653       unsigned int regno = REGNO (x);
654
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));
658       else
659         return !bitmap_bit_p (non_decomposable_context, regno);
660     }
661
662   return true;
663 }
664
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.  */
668
669 static rtx
670 resolve_simple_move (rtx set, rtx insn)
671 {
672   rtx src, dest, real_dest, insns;
673   enum machine_mode orig_mode, dest_mode;
674   unsigned int words;
675   bool pushing;
676
677   src = SET_SRC (set);
678   dest = SET_DEST (set);
679   orig_mode = GET_MODE (dest);
680
681   words = (GET_MODE_SIZE (orig_mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
682   if (words <= 1)
683     return insn;
684
685   start_sequence ();
686
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.  */
691
692   real_dest = NULL_RTX;
693
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))))))
699     {
700       real_dest = dest;
701       dest = gen_reg_rtx (orig_mode);
702       if (REG_P (real_dest))
703         REG_ATTRS (dest) = REG_ATTRS (real_dest);
704     }
705
706   /* Similarly if we are copying to a SUBREG of a decomposed reg where
707      the SUBREG is larger than word size.  */
708
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))))))
714     {
715       rtx reg, minsn, smove;
716
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);
722       src = reg;
723     }
724
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.  */
728
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))
735     {
736       end_sequence ();
737       return insn;
738     }
739
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
744      the insn yet.  */
745   if (MEM_P (src) || MEM_P (dest))
746     {
747       int acg;
748
749       if (MEM_P (src))
750         for_each_rtx (&XEXP (src, 0), resolve_subreg_use, NULL_RTX);
751       if (MEM_P (dest))
752         for_each_rtx (&XEXP (dest, 0), resolve_subreg_use, NULL_RTX);
753       acg = apply_change_group ();
754       gcc_assert (acg);
755     }
756
757   /* If SRC is a register which we can't decompose, or has side
758      effects, we need to move via a temporary register.  */
759
760   if (!can_decompose_p (src)
761       || side_effects_p (src)
762       || GET_CODE (src) == ASM_OPERANDS)
763     {
764       rtx reg;
765
766       reg = gen_reg_rtx (orig_mode);
767       emit_move_insn (reg, src);
768       src = reg;
769     }
770
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.  */
777
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)))
785     {
786       if (real_dest == NULL_RTX)
787         real_dest = dest;
788       if (!SCALAR_INT_MODE_P (dest_mode))
789         {
790           dest_mode = mode_for_size (GET_MODE_SIZE (dest_mode) * BITS_PER_UNIT,
791                                      MODE_INT, 0);
792           gcc_assert (dest_mode != BLKmode);
793         }
794       dest = gen_reg_rtx (dest_mode);
795       if (REG_P (real_dest))
796         REG_ATTRS (dest) = REG_ATTRS (real_dest);
797     }
798
799   if (pushing)
800     {
801       unsigned int i, j, jinc;
802
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);
806
807       if (WORDS_BIG_ENDIAN == STACK_GROWS_DOWNWARD)
808         {
809           j = 0;
810           jinc = 1;
811         }
812       else
813         {
814           j = words - 1;
815           jinc = -1;
816         }
817
818       for (i = 0; i < words; ++i, j += jinc)
819         {
820           rtx temp;
821
822           temp = copy_rtx (XEXP (dest, 0));
823           temp = adjust_automodify_address_nv (dest, word_mode, temp,
824                                                j * UNITS_PER_WORD);
825           emit_move_insn (temp,
826                           simplify_gen_subreg_concatn (word_mode, src,
827                                                        orig_mode,
828                                                        j * UNITS_PER_WORD));
829         }
830     }
831   else
832     {
833       unsigned int i;
834
835       if (REG_P (dest) && !HARD_REGISTER_NUM_P (REGNO (dest)))
836         emit_insn (gen_rtx_CLOBBER (VOIDmode, dest));
837
838       for (i = 0; i < words; ++i)
839         emit_move_insn (simplify_gen_subreg_concatn (word_mode, dest,
840                                                      dest_mode,
841                                                      i * UNITS_PER_WORD),
842                         simplify_gen_subreg_concatn (word_mode, src,
843                                                      orig_mode,
844                                                      i * UNITS_PER_WORD));
845     }
846
847   if (real_dest != NULL_RTX)
848     {
849       rtx mdest, minsn, smove;
850
851       if (dest_mode == orig_mode)
852         mdest = dest;
853       else
854         mdest = simplify_gen_subreg (orig_mode, dest, GET_MODE (dest), 0);
855       minsn = emit_move_insn (real_dest, mdest);
856
857       smove = single_set (minsn);
858       gcc_assert (smove != NULL_RTX);
859
860       resolve_simple_move (smove, minsn);
861     }
862
863   insns = get_insns ();
864   end_sequence ();
865
866   move_eh_region_note (insn, insns);
867
868   emit_insn_before (insns, insn);
869
870   move_libcall_note (insn, insns);
871   remove_retval_note (insn);
872   delete_insn (insn);
873
874   return insns;
875 }
876
877 /* Change a CLOBBER of a decomposed register into a CLOBBER of the
878    component registers.  Return whether we changed something.  */
879
880 static bool
881 resolve_clobber (rtx pat, rtx insn)
882 {
883   rtx reg;
884   enum machine_mode orig_mode;
885   unsigned int words, i;
886   int ret;
887
888   reg = XEXP (pat, 0);
889   if (!resolve_reg_p (reg) && !resolve_subreg_p (reg))
890     return false;
891
892   orig_mode = GET_MODE (reg);
893   words = GET_MODE_SIZE (orig_mode);
894   words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
895
896   ret = validate_change (NULL_RTX, &XEXP (pat, 0),
897                          simplify_gen_subreg_concatn (word_mode, reg,
898                                                       orig_mode, 0),
899                          0);
900   gcc_assert (ret != 0);
901
902   for (i = words - 1; i > 0; --i)
903     {
904       rtx x;
905
906       x = simplify_gen_subreg_concatn (word_mode, reg, orig_mode,
907                                        i * UNITS_PER_WORD);
908       x = gen_rtx_CLOBBER (VOIDmode, x);
909       emit_insn_after (x, insn);
910     }
911
912   return true;
913 }
914
915 /* A USE of a decomposed register is no longer meaningful.  Return
916    whether we changed something.  */
917
918 static bool
919 resolve_use (rtx pat, rtx insn)
920 {
921   if (resolve_reg_p (XEXP (pat, 0)) || resolve_subreg_p (XEXP (pat, 0)))
922     {
923       delete_insn (insn);
924       return true;
925     }
926   return false;
927 }
928
929 /* Look for registers which are always accessed via word-sized SUBREGs
930    or via copies.  Decompose these registers into several word-sized
931    pseudo-registers.  */
932
933 static void
934 decompose_multiword_subregs (bool update_life)
935 {
936   unsigned int max;
937   basic_block bb;
938
939   max = max_reg_num ();
940
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
944      all the insns.  */
945   {
946     unsigned int i;
947
948     for (i = FIRST_PSEUDO_REGISTER; i < max; ++i)
949       {
950         if (regno_reg_rtx[i] != NULL
951             && GET_MODE_SIZE (GET_MODE (regno_reg_rtx[i])) > UNITS_PER_WORD)
952           break;
953       }
954     if (i == max)
955       return;
956   }
957
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.  */
962
963   decomposable_context = BITMAP_ALLOC (NULL);
964   non_decomposable_context = BITMAP_ALLOC (NULL);
965
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);
969
970   FOR_EACH_BB (bb)
971     {
972       rtx insn;
973
974       FOR_BB_INSNS (bb, insn)
975         {
976           rtx set;
977           enum classify_move_insn cmi;
978           int i, n;
979
980           if (!INSN_P (insn)
981               || GET_CODE (PATTERN (insn)) == CLOBBER
982               || GET_CODE (PATTERN (insn)) == USE)
983             continue;
984
985           recog_memoized (insn);
986           extract_insn (insn);
987
988           set = simple_move (insn);
989
990           if (!set)
991             cmi = NOT_SIMPLE_MOVE;
992           else
993             {
994               bool retval;
995
996               retval = find_reg_note (insn, REG_RETVAL, NULL_RTX) != NULL_RTX;
997
998               if (find_pseudo_copy (set) && !retval)
999                 cmi = SIMPLE_PSEUDO_REG_MOVE;
1000               else if (retval
1001                        && REG_P (SET_SRC (set))
1002                        && HARD_REGISTER_P (SET_SRC (set)))
1003                 {
1004                   rtx note;
1005
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;
1011
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,
1020                                   &cmi);
1021                 }
1022               else
1023                 cmi = SIMPLE_MOVE;
1024             }
1025
1026           n = recog_data.n_operands;
1027           for (i = 0; i < n; ++i)
1028             {
1029               for_each_rtx (&recog_data.operand[i],
1030                             find_decomposable_subregs,
1031                             &cmi);
1032
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.  */
1037
1038               if (cmi == SIMPLE_MOVE
1039                   && GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1040                 {
1041                   gcc_assert (i == 0);
1042                   cmi = NOT_SIMPLE_MOVE;
1043                 }
1044             }
1045         }
1046     }
1047
1048   bitmap_and_compl_into (decomposable_context, non_decomposable_context);
1049   if (!bitmap_empty_p (decomposable_context))
1050     {
1051       int hold_no_new_pseudos = no_new_pseudos;
1052       int max_regno = max_reg_num ();
1053       sbitmap life_blocks;
1054       sbitmap sub_blocks;
1055       unsigned int i;
1056       sbitmap_iterator sbi;
1057       bitmap_iterator iter;
1058       unsigned int regno;
1059
1060       propagate_pseudo_copies ();
1061
1062       no_new_pseudos = 0;
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);
1067
1068       EXECUTE_IF_SET_IN_BITMAP (decomposable_context, 0, regno, iter)
1069         decompose_register (regno);
1070
1071       FOR_EACH_BB (bb)
1072         {
1073           rtx insn;
1074
1075           FOR_BB_INSNS (bb, insn)
1076             {
1077               rtx next, pat;
1078               bool changed;
1079
1080               if (!INSN_P (insn))
1081                 continue;
1082
1083               next = NEXT_INSN (insn);
1084               changed = false;
1085
1086               pat = PATTERN (insn);
1087               if (GET_CODE (pat) == CLOBBER)
1088                 {
1089                   if (resolve_clobber (pat, insn))
1090                     changed = true;
1091                 }
1092               else if (GET_CODE (pat) == USE)
1093                 {
1094                   if (resolve_use (pat, insn))
1095                     changed = true;
1096                 }
1097               else
1098                 {
1099                   rtx set;
1100                   int i;
1101
1102                   recog_memoized (insn);
1103                   extract_insn (insn);
1104
1105                   set = simple_move (insn);
1106                   if (set)
1107                     {
1108                       rtx orig_insn = insn;
1109                       bool cfi = control_flow_insn_p (insn);
1110
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.  */
1122                       gcc_assert (!cfi
1123                                   || (flag_non_call_exceptions
1124                                       && can_throw_internal (insn)));
1125
1126                       insn = resolve_simple_move (set, insn);
1127                       if (insn != orig_insn)
1128                         {
1129                           changed = true;
1130
1131                           recog_memoized (insn);
1132                           extract_insn (insn);
1133
1134                           if (cfi)
1135                             SET_BIT (sub_blocks, bb->index);
1136                         }
1137                     }
1138
1139                   for (i = recog_data.n_operands - 1; i >= 0; --i)
1140                     for_each_rtx (recog_data.operand_loc[i],
1141                                   resolve_subreg_use,
1142                                   insn);
1143
1144                   resolve_reg_notes (insn);
1145
1146                   if (num_validated_changes () > 0)
1147                     {
1148                       for (i = recog_data.n_dups - 1; i >= 0; --i)
1149                         {
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];
1153
1154                           validate_change (insn, pl, *px, 1);
1155                         }
1156
1157                       i = apply_change_group ();
1158                       gcc_assert (i);
1159
1160                       changed = true;
1161                     }
1162                 }
1163
1164               if (changed)
1165                 {
1166                   SET_BIT (life_blocks, bb->index);
1167                   reg_scan_update (insn, next, max_regno);
1168                 }
1169             }
1170         }
1171
1172       no_new_pseudos = hold_no_new_pseudos;
1173
1174       if (update_life)
1175         update_life_info (life_blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
1176                           PROP_DEATH_NOTES);
1177
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
1181          loads to appear.  */
1182       EXECUTE_IF_SET_IN_SBITMAP (sub_blocks, 0, i, sbi)
1183         {
1184           rtx insn, end;
1185           edge fallthru;
1186
1187           bb = BASIC_BLOCK (i);
1188           insn = BB_HEAD (bb);
1189           end = BB_END (bb);
1190
1191           while (insn != end)
1192             {
1193               if (control_flow_insn_p (insn))
1194                 {
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);
1202                 }
1203               else
1204                 insn = NEXT_INSN (insn);
1205             }
1206         }
1207
1208       sbitmap_free (life_blocks);
1209       sbitmap_free (sub_blocks);
1210     }
1211
1212   {
1213     unsigned int i;
1214     bitmap b;
1215
1216     for (i = 0; VEC_iterate (bitmap, reg_copy_graph, i, b); ++i)
1217       if (b)
1218         BITMAP_FREE (b);
1219   }
1220
1221   VEC_free (bitmap, heap, reg_copy_graph);  
1222
1223   BITMAP_FREE (decomposable_context);
1224   BITMAP_FREE (non_decomposable_context);
1225 }
1226 \f
1227 /* Gate function for lower subreg pass.  */
1228
1229 static bool
1230 gate_handle_lower_subreg (void)
1231 {
1232   return flag_split_wide_types != 0;
1233 }
1234
1235 /* Implement first lower subreg pass.  */
1236
1237 static unsigned int
1238 rest_of_handle_lower_subreg (void)
1239 {
1240   decompose_multiword_subregs (false);
1241   return 0;
1242 }
1243
1244 /* Implement second lower subreg pass.  */
1245
1246 static unsigned int
1247 rest_of_handle_lower_subreg2 (void)
1248 {
1249   decompose_multiword_subregs (true);
1250   return 0;
1251 }
1252
1253 struct tree_opt_pass pass_lower_subreg =
1254 {
1255   "subreg",                             /* name */
1256   gate_handle_lower_subreg,             /* gate */
1257   rest_of_handle_lower_subreg,          /* execute */
1258   NULL,                                 /* sub */
1259   NULL,                                 /* next */
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 */
1266   TODO_dump_func |
1267   TODO_ggc_collect |
1268   TODO_verify_flow,                     /* todo_flags_finish */
1269   'u'                                   /* letter */
1270 };
1271
1272 struct tree_opt_pass pass_lower_subreg2 =
1273 {
1274   "subreg2",                            /* name */
1275   gate_handle_lower_subreg,             /* gate */
1276   rest_of_handle_lower_subreg2,          /* execute */
1277   NULL,                                 /* sub */
1278   NULL,                                 /* next */
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 */
1285   TODO_dump_func |
1286   TODO_ggc_collect |
1287   TODO_verify_flow,                     /* todo_flags_finish */
1288   'U'                                   /* letter */
1289 };