OSDN Git Service

Remove libcall notes.
[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 3, 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 COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "machmode.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "tm_p.h"
29 #include "timevar.h"
30 #include "flags.h"
31 #include "insn-config.h"
32 #include "obstack.h"
33 #include "basic-block.h"
34 #include "recog.h"
35 #include "bitmap.h"
36 #include "expr.h"
37 #include "except.h"
38 #include "regs.h"
39 #include "tree-pass.h"
40 #include "df.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.  */
229   SIMPLE_PSEUDO_REG_MOVE,
230   /* A simple move involving a non-pseudo-register.  */
231   SIMPLE_MOVE
232 };
233
234 /* This is called via for_each_rtx.  If we find a SUBREG which we
235    could use to decompose a pseudo-register, set a bit in
236    DECOMPOSABLE_CONTEXT.  If we find an unadorned register which is
237    not a simple pseudo-register copy, DATA will point at the type of
238    move, and we set a bit in DECOMPOSABLE_CONTEXT or
239    NON_DECOMPOSABLE_CONTEXT as appropriate.  */
240
241 static int
242 find_decomposable_subregs (rtx *px, void *data)
243 {
244   enum classify_move_insn *pcmi = (enum classify_move_insn *) data;
245   rtx x = *px;
246
247   if (x == NULL_RTX)
248     return 0;
249
250   if (GET_CODE (x) == SUBREG)
251     {
252       rtx inner = SUBREG_REG (x);
253       unsigned int regno, outer_size, inner_size, outer_words, inner_words;
254
255       if (!REG_P (inner))
256         return 0;
257
258       regno = REGNO (inner);
259       if (HARD_REGISTER_NUM_P (regno))
260         return -1;
261
262       outer_size = GET_MODE_SIZE (GET_MODE (x));
263       inner_size = GET_MODE_SIZE (GET_MODE (inner));
264       outer_words = (outer_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
265       inner_words = (inner_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
266
267       /* We only try to decompose single word subregs of multi-word
268          registers.  When we find one, we return -1 to avoid iterating
269          over the inner register.
270
271          ??? This doesn't allow, e.g., DImode subregs of TImode values
272          on 32-bit targets.  We would need to record the way the
273          pseudo-register was used, and only decompose if all the uses
274          were the same number and size of pieces.  Hopefully this
275          doesn't happen much.  */
276
277       if (outer_words == 1 && inner_words > 1)
278         {
279           bitmap_set_bit (decomposable_context, regno);
280           return -1;
281         }
282
283       /* If this is a cast from one mode to another, where the modes
284          have the same size, and they are not tieable, then mark this
285          register as non-decomposable.  If we decompose it we are
286          likely to mess up whatever the backend is trying to do.  */
287       if (outer_words > 1
288           && outer_size == inner_size
289           && !MODES_TIEABLE_P (GET_MODE (x), GET_MODE (inner)))
290         {
291           bitmap_set_bit (non_decomposable_context, regno);
292           return -1;
293         }
294     }
295   else if (REG_P (x))
296     {
297       unsigned int regno;
298
299       /* We will see an outer SUBREG before we see the inner REG, so
300          when we see a plain REG here it means a direct reference to
301          the register.
302
303          If this is not a simple copy from one location to another,
304          then we can not decompose this register.  If this is a simple
305          copy from one pseudo-register to another, and the mode is right
306          then we mark the register as decomposable.
307          Otherwise we don't say anything about this register --
308          it could be decomposed, but whether that would be
309          profitable depends upon how it is used elsewhere.
310
311          We only set bits in the bitmap for multi-word
312          pseudo-registers, since those are the only ones we care about
313          and it keeps the size of the bitmaps down.  */
314
315       regno = REGNO (x);
316       if (!HARD_REGISTER_NUM_P (regno)
317           && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
318         {
319           switch (*pcmi)
320             {
321             case NOT_SIMPLE_MOVE:
322               bitmap_set_bit (non_decomposable_context, regno);
323               break;
324             case SIMPLE_PSEUDO_REG_MOVE:
325               if (MODES_TIEABLE_P (GET_MODE (x), word_mode))
326                 bitmap_set_bit (decomposable_context, regno);
327               break;
328             case SIMPLE_MOVE:
329               break;
330             default:
331               gcc_unreachable ();
332             }
333         }
334     }
335   else if (MEM_P (x))
336     {
337       enum classify_move_insn cmi_mem = NOT_SIMPLE_MOVE;
338
339       /* Any registers used in a MEM do not participate in a
340          SIMPLE_MOVE or SIMPLE_PSEUDO_REG_MOVE.  Do our own recursion
341          here, and return -1 to block the parent's recursion.  */
342       for_each_rtx (&XEXP (x, 0), find_decomposable_subregs, &cmi_mem);
343       return -1;
344     }
345
346   return 0;
347 }
348
349 /* Decompose REGNO into word-sized components.  We smash the REG node
350    in place.  This ensures that (1) something goes wrong quickly if we
351    fail to make some replacement, and (2) the debug information inside
352    the symbol table is automatically kept up to date.  */
353
354 static void
355 decompose_register (unsigned int regno)
356 {
357   rtx reg;
358   unsigned int words, i;
359   rtvec v;
360
361   reg = regno_reg_rtx[regno];
362
363   regno_reg_rtx[regno] = NULL_RTX;
364
365   words = GET_MODE_SIZE (GET_MODE (reg));
366   words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
367
368   v = rtvec_alloc (words);
369   for (i = 0; i < words; ++i)
370     RTVEC_ELT (v, i) = gen_reg_rtx_offset (reg, word_mode, i * UNITS_PER_WORD);
371
372   PUT_CODE (reg, CONCATN);
373   XVEC (reg, 0) = v;
374
375   if (dump_file)
376     {
377       fprintf (dump_file, "; Splitting reg %u ->", regno);
378       for (i = 0; i < words; ++i)
379         fprintf (dump_file, " %u", REGNO (XVECEXP (reg, 0, i)));
380       fputc ('\n', dump_file);
381     }
382 }
383
384 /* Get a SUBREG of a CONCATN.  */
385
386 static rtx
387 simplify_subreg_concatn (enum machine_mode outermode, rtx op,
388                          unsigned int byte)
389 {
390   unsigned int inner_size;
391   enum machine_mode innermode;
392   rtx part;
393   unsigned int final_offset;
394
395   gcc_assert (GET_CODE (op) == CONCATN);
396   gcc_assert (byte % GET_MODE_SIZE (outermode) == 0);
397
398   innermode = GET_MODE (op);
399   gcc_assert (byte < GET_MODE_SIZE (innermode));
400   gcc_assert (GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (innermode));
401
402   inner_size = GET_MODE_SIZE (innermode) / XVECLEN (op, 0);
403   part = XVECEXP (op, 0, byte / inner_size);
404   final_offset = byte % inner_size;
405   if (final_offset + GET_MODE_SIZE (outermode) > inner_size)
406     return NULL_RTX;
407
408   return simplify_gen_subreg (outermode, part, GET_MODE (part), final_offset);
409 }
410
411 /* Wrapper around simplify_gen_subreg which handles CONCATN.  */
412
413 static rtx
414 simplify_gen_subreg_concatn (enum machine_mode outermode, rtx op,
415                              enum machine_mode innermode, unsigned int byte)
416 {
417   rtx ret;
418
419   /* We have to handle generating a SUBREG of a SUBREG of a CONCATN.
420      If OP is a SUBREG of a CONCATN, then it must be a simple mode
421      change with the same size and offset 0, or it must extract a
422      part.  We shouldn't see anything else here.  */
423   if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == CONCATN)
424     {
425       rtx op2;
426
427       if ((GET_MODE_SIZE (GET_MODE (op))
428            == GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
429           && SUBREG_BYTE (op) == 0)
430         return simplify_gen_subreg_concatn (outermode, SUBREG_REG (op),
431                                             GET_MODE (SUBREG_REG (op)), byte);
432
433       op2 = simplify_subreg_concatn (GET_MODE (op), SUBREG_REG (op),
434                                      SUBREG_BYTE (op));
435       if (op2 == NULL_RTX)
436         {
437           /* We don't handle paradoxical subregs here.  */
438           gcc_assert (GET_MODE_SIZE (outermode)
439                       <= GET_MODE_SIZE (GET_MODE (op)));
440           gcc_assert (GET_MODE_SIZE (GET_MODE (op))
441                       <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))));
442           op2 = simplify_subreg_concatn (outermode, SUBREG_REG (op),
443                                          byte + SUBREG_BYTE (op));
444           gcc_assert (op2 != NULL_RTX);
445           return op2;
446         }
447
448       op = op2;
449       gcc_assert (op != NULL_RTX);
450       gcc_assert (innermode == GET_MODE (op));
451     }
452
453   if (GET_CODE (op) == CONCATN)
454     return simplify_subreg_concatn (outermode, op, byte);
455
456   ret = simplify_gen_subreg (outermode, op, innermode, byte);
457
458   /* If we see an insn like (set (reg:DI) (subreg:DI (reg:SI) 0)) then
459      resolve_simple_move will ask for the high part of the paradoxical
460      subreg, which does not have a value.  Just return a zero.  */
461   if (ret == NULL_RTX
462       && GET_CODE (op) == SUBREG
463       && SUBREG_BYTE (op) == 0
464       && (GET_MODE_SIZE (innermode)
465           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op)))))
466     return CONST0_RTX (outermode);
467
468   gcc_assert (ret != NULL_RTX);
469   return ret;
470 }
471
472 /* Return whether we should resolve X into the registers into which it
473    was decomposed.  */
474
475 static bool
476 resolve_reg_p (rtx x)
477 {
478   return GET_CODE (x) == CONCATN;
479 }
480
481 /* Return whether X is a SUBREG of a register which we need to
482    resolve.  */
483
484 static bool
485 resolve_subreg_p (rtx x)
486 {
487   if (GET_CODE (x) != SUBREG)
488     return false;
489   return resolve_reg_p (SUBREG_REG (x));
490 }
491
492 /* This is called via for_each_rtx.  Look for SUBREGs which need to be
493    decomposed.  */
494
495 static int
496 resolve_subreg_use (rtx *px, void *data)
497 {
498   rtx insn = (rtx) data;
499   rtx x = *px;
500
501   if (x == NULL_RTX)
502     return 0;
503
504   if (resolve_subreg_p (x))
505     {
506       x = simplify_subreg_concatn (GET_MODE (x), SUBREG_REG (x),
507                                    SUBREG_BYTE (x));
508
509       /* It is possible for a note to contain a reference which we can
510          decompose.  In this case, return 1 to the caller to indicate
511          that the note must be removed.  */
512       if (!x)
513         {
514           gcc_assert (!insn);
515           return 1;
516         }
517
518       validate_change (insn, px, x, 1);
519       return -1;
520     }
521
522   if (resolve_reg_p (x))
523     {
524       /* Return 1 to the caller to indicate that we found a direct
525          reference to a register which is being decomposed.  This can
526          happen inside notes, multiword shift or zero-extend
527          instructions.  */
528       return 1;
529     }
530
531   return 0;
532 }
533
534 /* We are deleting INSN.  Move any EH_REGION notes to INSNS.  */
535
536 static void
537 move_eh_region_note (rtx insn, rtx insns)
538 {
539   rtx note, p;
540
541   note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
542   if (note == NULL_RTX)
543     return;
544
545   gcc_assert (CALL_P (insn)
546               || (flag_non_call_exceptions && may_trap_p (PATTERN (insn))));
547
548   for (p = insns; p != NULL_RTX; p = NEXT_INSN (p))
549     {
550       if (CALL_P (p)
551           || (flag_non_call_exceptions
552               && INSN_P (p)
553               && may_trap_p (PATTERN (p))))
554         REG_NOTES (p) = gen_rtx_EXPR_LIST (REG_EH_REGION, XEXP (note, 0),
555                                            REG_NOTES (p));
556     }
557 }
558
559 /* Resolve any decomposed registers which appear in register notes on
560    INSN.  */
561
562 static void
563 resolve_reg_notes (rtx insn)
564 {
565   rtx *pnote, note;
566
567   note = find_reg_equal_equiv_note (insn);
568   if (note)
569     {
570       int old_count = num_validated_changes ();
571       if (for_each_rtx (&XEXP (note, 0), resolve_subreg_use, NULL))
572         remove_note (insn, note);
573       else
574         if (old_count != num_validated_changes ())
575           df_notes_rescan (insn);
576     }
577
578   pnote = &REG_NOTES (insn);
579   while (*pnote != NULL_RTX)
580     {
581       bool delete = false;
582
583       note = *pnote;
584       switch (REG_NOTE_KIND (note))
585         {
586         case REG_DEAD:
587         case REG_UNUSED:
588           if (resolve_reg_p (XEXP (note, 0)))
589             delete = true;
590           break;
591
592         default:
593           break;
594         }
595
596       if (delete)
597         *pnote = XEXP (note, 1);
598       else
599         pnote = &XEXP (note, 1);
600     }
601 }
602
603 /* Return whether X can be decomposed into subwords.  */
604
605 static bool
606 can_decompose_p (rtx x)
607 {
608   if (REG_P (x))
609     {
610       unsigned int regno = REGNO (x);
611
612       if (HARD_REGISTER_NUM_P (regno))
613         return (validate_subreg (word_mode, GET_MODE (x), x, UNITS_PER_WORD)
614                 && HARD_REGNO_MODE_OK (regno, word_mode));
615       else
616         return !bitmap_bit_p (non_decomposable_context, regno);
617     }
618
619   return true;
620 }
621
622 /* Decompose the registers used in a simple move SET within INSN.  If
623    we don't change anything, return INSN, otherwise return the start
624    of the sequence of moves.  */
625
626 static rtx
627 resolve_simple_move (rtx set, rtx insn)
628 {
629   rtx src, dest, real_dest, insns;
630   enum machine_mode orig_mode, dest_mode;
631   unsigned int words;
632   bool pushing;
633
634   src = SET_SRC (set);
635   dest = SET_DEST (set);
636   orig_mode = GET_MODE (dest);
637
638   words = (GET_MODE_SIZE (orig_mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
639   if (words <= 1)
640     return insn;
641
642   start_sequence ();
643
644   /* We have to handle copying from a SUBREG of a decomposed reg where
645      the SUBREG is larger than word size.  Rather than assume that we
646      can take a word_mode SUBREG of the destination, we copy to a new
647      register and then copy that to the destination.  */
648
649   real_dest = NULL_RTX;
650
651   if (GET_CODE (src) == SUBREG
652       && resolve_reg_p (SUBREG_REG (src))
653       && (SUBREG_BYTE (src) != 0
654           || (GET_MODE_SIZE (orig_mode)
655               != GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))))
656     {
657       real_dest = dest;
658       dest = gen_reg_rtx (orig_mode);
659       if (REG_P (real_dest))
660         REG_ATTRS (dest) = REG_ATTRS (real_dest);
661     }
662
663   /* Similarly if we are copying to a SUBREG of a decomposed reg where
664      the SUBREG is larger than word size.  */
665
666   if (GET_CODE (dest) == SUBREG
667       && resolve_reg_p (SUBREG_REG (dest))
668       && (SUBREG_BYTE (dest) != 0
669           || (GET_MODE_SIZE (orig_mode)
670               != GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))))))
671     {
672       rtx reg, minsn, smove;
673
674       reg = gen_reg_rtx (orig_mode);
675       minsn = emit_move_insn (reg, src);
676       smove = single_set (minsn);
677       gcc_assert (smove != NULL_RTX);
678       resolve_simple_move (smove, minsn);
679       src = reg;
680     }
681
682   /* If we didn't have any big SUBREGS of decomposed registers, and
683      neither side of the move is a register we are decomposing, then
684      we don't have to do anything here.  */
685
686   if (src == SET_SRC (set)
687       && dest == SET_DEST (set)
688       && !resolve_reg_p (src)
689       && !resolve_subreg_p (src)
690       && !resolve_reg_p (dest)
691       && !resolve_subreg_p (dest))
692     {
693       end_sequence ();
694       return insn;
695     }
696
697   /* It's possible for the code to use a subreg of a decomposed
698      register while forming an address.  We need to handle that before
699      passing the address to emit_move_insn.  We pass NULL_RTX as the
700      insn parameter to resolve_subreg_use because we can not validate
701      the insn yet.  */
702   if (MEM_P (src) || MEM_P (dest))
703     {
704       int acg;
705
706       if (MEM_P (src))
707         for_each_rtx (&XEXP (src, 0), resolve_subreg_use, NULL_RTX);
708       if (MEM_P (dest))
709         for_each_rtx (&XEXP (dest, 0), resolve_subreg_use, NULL_RTX);
710       acg = apply_change_group ();
711       gcc_assert (acg);
712     }
713
714   /* If SRC is a register which we can't decompose, or has side
715      effects, we need to move via a temporary register.  */
716
717   if (!can_decompose_p (src)
718       || side_effects_p (src)
719       || GET_CODE (src) == ASM_OPERANDS)
720     {
721       rtx reg;
722
723       reg = gen_reg_rtx (orig_mode);
724       emit_move_insn (reg, src);
725       src = reg;
726     }
727
728   /* If DEST is a register which we can't decompose, or has side
729      effects, we need to first move to a temporary register.  We
730      handle the common case of pushing an operand directly.  We also
731      go through a temporary register if it holds a floating point
732      value.  This gives us better code on systems which can't move
733      data easily between integer and floating point registers.  */
734
735   dest_mode = orig_mode;
736   pushing = push_operand (dest, dest_mode);
737   if (!can_decompose_p (dest)
738       || (side_effects_p (dest) && !pushing)
739       || (!SCALAR_INT_MODE_P (dest_mode)
740           && !resolve_reg_p (dest)
741           && !resolve_subreg_p (dest)))
742     {
743       if (real_dest == NULL_RTX)
744         real_dest = dest;
745       if (!SCALAR_INT_MODE_P (dest_mode))
746         {
747           dest_mode = mode_for_size (GET_MODE_SIZE (dest_mode) * BITS_PER_UNIT,
748                                      MODE_INT, 0);
749           gcc_assert (dest_mode != BLKmode);
750         }
751       dest = gen_reg_rtx (dest_mode);
752       if (REG_P (real_dest))
753         REG_ATTRS (dest) = REG_ATTRS (real_dest);
754     }
755
756   if (pushing)
757     {
758       unsigned int i, j, jinc;
759
760       gcc_assert (GET_MODE_SIZE (orig_mode) % UNITS_PER_WORD == 0);
761       gcc_assert (GET_CODE (XEXP (dest, 0)) != PRE_MODIFY);
762       gcc_assert (GET_CODE (XEXP (dest, 0)) != POST_MODIFY);
763
764       if (WORDS_BIG_ENDIAN == STACK_GROWS_DOWNWARD)
765         {
766           j = 0;
767           jinc = 1;
768         }
769       else
770         {
771           j = words - 1;
772           jinc = -1;
773         }
774
775       for (i = 0; i < words; ++i, j += jinc)
776         {
777           rtx temp;
778
779           temp = copy_rtx (XEXP (dest, 0));
780           temp = adjust_automodify_address_nv (dest, word_mode, temp,
781                                                j * UNITS_PER_WORD);
782           emit_move_insn (temp,
783                           simplify_gen_subreg_concatn (word_mode, src,
784                                                        orig_mode,
785                                                        j * UNITS_PER_WORD));
786         }
787     }
788   else
789     {
790       unsigned int i;
791
792       if (REG_P (dest) && !HARD_REGISTER_NUM_P (REGNO (dest)))
793         emit_clobber (dest);
794
795       for (i = 0; i < words; ++i)
796         emit_move_insn (simplify_gen_subreg_concatn (word_mode, dest,
797                                                      dest_mode,
798                                                      i * UNITS_PER_WORD),
799                         simplify_gen_subreg_concatn (word_mode, src,
800                                                      orig_mode,
801                                                      i * UNITS_PER_WORD));
802     }
803
804   if (real_dest != NULL_RTX)
805     {
806       rtx mdest, minsn, smove;
807
808       if (dest_mode == orig_mode)
809         mdest = dest;
810       else
811         mdest = simplify_gen_subreg (orig_mode, dest, GET_MODE (dest), 0);
812       minsn = emit_move_insn (real_dest, mdest);
813
814       smove = single_set (minsn);
815       gcc_assert (smove != NULL_RTX);
816
817       resolve_simple_move (smove, minsn);
818     }
819
820   insns = get_insns ();
821   end_sequence ();
822
823   move_eh_region_note (insn, insns);
824
825   emit_insn_before (insns, insn);
826
827   delete_insn (insn);
828
829   return insns;
830 }
831
832 /* Change a CLOBBER of a decomposed register into a CLOBBER of the
833    component registers.  Return whether we changed something.  */
834
835 static bool
836 resolve_clobber (rtx pat, rtx insn)
837 {
838   rtx reg;
839   enum machine_mode orig_mode;
840   unsigned int words, i;
841   int ret;
842
843   reg = XEXP (pat, 0);
844   if (!resolve_reg_p (reg) && !resolve_subreg_p (reg))
845     return false;
846
847   orig_mode = GET_MODE (reg);
848   words = GET_MODE_SIZE (orig_mode);
849   words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
850
851   ret = validate_change (NULL_RTX, &XEXP (pat, 0),
852                          simplify_gen_subreg_concatn (word_mode, reg,
853                                                       orig_mode, 0),
854                          0);
855   df_insn_rescan (insn);
856   gcc_assert (ret != 0);
857
858   for (i = words - 1; i > 0; --i)
859     {
860       rtx x;
861
862       x = simplify_gen_subreg_concatn (word_mode, reg, orig_mode,
863                                        i * UNITS_PER_WORD);
864       x = gen_rtx_CLOBBER (VOIDmode, x);
865       emit_insn_after (x, insn);
866     }
867
868   resolve_reg_notes (insn);
869
870   return true;
871 }
872
873 /* A USE of a decomposed register is no longer meaningful.  Return
874    whether we changed something.  */
875
876 static bool
877 resolve_use (rtx pat, rtx insn)
878 {
879   if (resolve_reg_p (XEXP (pat, 0)) || resolve_subreg_p (XEXP (pat, 0)))
880     {
881       delete_insn (insn);
882       return true;
883     }
884
885   resolve_reg_notes (insn);
886
887   return false;
888 }
889
890 /* Checks if INSN is a decomposable multiword-shift or zero-extend and
891    sets the decomposable_context bitmap accordingly.  A non-zero value
892    is returned if a decomposable insn has been found.  */
893
894 static int
895 find_decomposable_shift_zext (rtx insn)
896 {
897   rtx set;
898   rtx op;
899   rtx op_operand;
900
901   set = single_set (insn);
902   if (!set)
903     return 0;
904
905   op = SET_SRC (set);
906   if (GET_CODE (op) != ASHIFT
907       && GET_CODE (op) != LSHIFTRT
908       && GET_CODE (op) != ZERO_EXTEND)
909     return 0;
910
911   op_operand = XEXP (op, 0);
912   if (!REG_P (SET_DEST (set)) || !REG_P (op_operand)
913       || HARD_REGISTER_NUM_P (REGNO (SET_DEST (set)))
914       || HARD_REGISTER_NUM_P (REGNO (op_operand))
915       || !SCALAR_INT_MODE_P (GET_MODE (op)))
916     return 0;
917
918   if (GET_CODE (op) == ZERO_EXTEND)
919     {
920       if (GET_MODE (op_operand) != word_mode
921           || GET_MODE_BITSIZE (GET_MODE (op)) != 2 * BITS_PER_WORD)
922         return 0;
923     }
924   else /* left or right shift */
925     {
926       if (GET_CODE (XEXP (op, 1)) != CONST_INT
927           || INTVAL (XEXP (op, 1)) < BITS_PER_WORD
928           || GET_MODE_BITSIZE (GET_MODE (op_operand)) != 2 * BITS_PER_WORD)
929         return 0;
930     }
931
932   bitmap_set_bit (decomposable_context, REGNO (SET_DEST (set)));
933
934   if (GET_CODE (op) != ZERO_EXTEND)
935     bitmap_set_bit (decomposable_context, REGNO (op_operand));
936
937   return 1;
938 }
939
940 /* Decompose a more than word wide shift (in INSN) of a multiword
941    pseudo or a multiword zero-extend of a wordmode pseudo into a move
942    and 'set to zero' insn.  Return a pointer to the new insn when a
943    replacement was done.  */
944
945 static rtx
946 resolve_shift_zext (rtx insn)
947 {
948   rtx set;
949   rtx op;
950   rtx op_operand;
951   rtx insns;
952   rtx src_reg, dest_reg, dest_zero;
953   int src_reg_num, dest_reg_num, offset1, offset2, src_offset;
954
955   set = single_set (insn);
956   if (!set)
957     return NULL_RTX;
958
959   op = SET_SRC (set);
960   if (GET_CODE (op) != ASHIFT
961       && GET_CODE (op) != LSHIFTRT
962       && GET_CODE (op) != ZERO_EXTEND)
963     return NULL_RTX;
964
965   op_operand = XEXP (op, 0);
966
967   if (!resolve_reg_p (SET_DEST (set)) && !resolve_reg_p (op_operand))
968     return NULL_RTX;
969
970   /* src_reg_num is the number of the word mode register which we
971      are operating on.  For a left shift and a zero_extend on little
972      endian machines this is register 0.  */
973   src_reg_num = GET_CODE (op) == LSHIFTRT ? 1 : 0;
974
975   if (WORDS_BIG_ENDIAN
976       && GET_MODE_SIZE (GET_MODE (op_operand)) > UNITS_PER_WORD)
977     src_reg_num = 1 - src_reg_num;
978
979   if (GET_CODE (op) == ZERO_EXTEND)
980     dest_reg_num = WORDS_BIG_ENDIAN ? 1 : 0;
981   else
982     dest_reg_num = 1 - src_reg_num;
983
984   offset1 = UNITS_PER_WORD * dest_reg_num;
985   offset2 = UNITS_PER_WORD * (1 - dest_reg_num);
986   src_offset = UNITS_PER_WORD * src_reg_num;
987
988   if (WORDS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
989     {
990       offset1 += UNITS_PER_WORD - 1;
991       offset2 += UNITS_PER_WORD - 1;
992       src_offset += UNITS_PER_WORD - 1;
993     }
994
995   start_sequence ();
996
997   dest_reg = simplify_gen_subreg_concatn (word_mode, SET_DEST (set),
998                                           GET_MODE (SET_DEST (set)),
999                                           offset1);
1000   dest_zero = simplify_gen_subreg_concatn (word_mode, SET_DEST (set),
1001                                            GET_MODE (SET_DEST (set)),
1002                                            offset2);
1003   src_reg = simplify_gen_subreg_concatn (word_mode, op_operand,
1004                                          GET_MODE (op_operand),
1005                                          src_offset);
1006   if (GET_CODE (op) != ZERO_EXTEND)
1007     {
1008       int shift_count = INTVAL (XEXP (op, 1));
1009       if (shift_count > BITS_PER_WORD)
1010         src_reg = expand_shift (GET_CODE (op) == ASHIFT ?
1011                                 LSHIFT_EXPR : RSHIFT_EXPR,
1012                                 word_mode, src_reg,
1013                                 build_int_cst (NULL_TREE,
1014                                                shift_count - BITS_PER_WORD),
1015                                 dest_reg, 1);
1016     }
1017
1018   if (dest_reg != src_reg)
1019     emit_move_insn (dest_reg, src_reg);
1020   emit_move_insn (dest_zero, CONST0_RTX (word_mode));
1021   insns = get_insns ();
1022
1023   end_sequence ();
1024
1025   emit_insn_before (insns, insn);
1026
1027   if (dump_file)
1028     {
1029       rtx in;
1030       fprintf (dump_file, "; Replacing insn: %d with insns: ", INSN_UID (insn));
1031       for (in = insns; in != insn; in = NEXT_INSN (in))
1032         fprintf (dump_file, "%d ", INSN_UID (in));
1033       fprintf (dump_file, "\n");
1034     }
1035
1036   delete_insn (insn);
1037   return insns;
1038 }
1039
1040 /* Look for registers which are always accessed via word-sized SUBREGs
1041    or via copies.  Decompose these registers into several word-sized
1042    pseudo-registers.  */
1043
1044 static void
1045 decompose_multiword_subregs (void)
1046 {
1047   unsigned int max;
1048   basic_block bb;
1049
1050   if (df)
1051     df_set_flags (DF_DEFER_INSN_RESCAN);
1052
1053   max = max_reg_num ();
1054
1055   /* First see if there are any multi-word pseudo-registers.  If there
1056      aren't, there is nothing we can do.  This should speed up this
1057      pass in the normal case, since it should be faster than scanning
1058      all the insns.  */
1059   {
1060     unsigned int i;
1061
1062     for (i = FIRST_PSEUDO_REGISTER; i < max; ++i)
1063       {
1064         if (regno_reg_rtx[i] != NULL
1065             && GET_MODE_SIZE (GET_MODE (regno_reg_rtx[i])) > UNITS_PER_WORD)
1066           break;
1067       }
1068     if (i == max)
1069       return;
1070   }
1071
1072   /* FIXME: When the dataflow branch is merged, we can change this
1073      code to look for each multi-word pseudo-register and to find each
1074      insn which sets or uses that register.  That should be faster
1075      than scanning all the insns.  */
1076
1077   decomposable_context = BITMAP_ALLOC (NULL);
1078   non_decomposable_context = BITMAP_ALLOC (NULL);
1079
1080   reg_copy_graph = VEC_alloc (bitmap, heap, max);
1081   VEC_safe_grow (bitmap, heap, reg_copy_graph, max);
1082   memset (VEC_address (bitmap, reg_copy_graph), 0, sizeof (bitmap) * max);
1083
1084   FOR_EACH_BB (bb)
1085     {
1086       rtx insn;
1087
1088       FOR_BB_INSNS (bb, insn)
1089         {
1090           rtx set;
1091           enum classify_move_insn cmi;
1092           int i, n;
1093
1094           if (!INSN_P (insn)
1095               || GET_CODE (PATTERN (insn)) == CLOBBER
1096               || GET_CODE (PATTERN (insn)) == USE)
1097             continue;
1098
1099           if (find_decomposable_shift_zext (insn))
1100             continue;
1101
1102           recog_memoized (insn);
1103           extract_insn (insn);
1104
1105           set = simple_move (insn);
1106
1107           if (!set)
1108             cmi = NOT_SIMPLE_MOVE;
1109           else
1110             {
1111               if (find_pseudo_copy (set))
1112                 cmi = SIMPLE_PSEUDO_REG_MOVE;
1113               else
1114                 cmi = SIMPLE_MOVE;
1115             }
1116
1117           n = recog_data.n_operands;
1118           for (i = 0; i < n; ++i)
1119             {
1120               for_each_rtx (&recog_data.operand[i],
1121                             find_decomposable_subregs,
1122                             &cmi);
1123
1124               /* We handle ASM_OPERANDS as a special case to support
1125                  things like x86 rdtsc which returns a DImode value.
1126                  We can decompose the output, which will certainly be
1127                  operand 0, but not the inputs.  */
1128
1129               if (cmi == SIMPLE_MOVE
1130                   && GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1131                 {
1132                   gcc_assert (i == 0);
1133                   cmi = NOT_SIMPLE_MOVE;
1134                 }
1135             }
1136         }
1137     }
1138
1139   bitmap_and_compl_into (decomposable_context, non_decomposable_context);
1140   if (!bitmap_empty_p (decomposable_context))
1141     {
1142       sbitmap sub_blocks;
1143       unsigned int i;
1144       sbitmap_iterator sbi;
1145       bitmap_iterator iter;
1146       unsigned int regno;
1147
1148       propagate_pseudo_copies ();
1149
1150       sub_blocks = sbitmap_alloc (last_basic_block);
1151       sbitmap_zero (sub_blocks);
1152
1153       EXECUTE_IF_SET_IN_BITMAP (decomposable_context, 0, regno, iter)
1154         decompose_register (regno);
1155
1156       FOR_EACH_BB (bb)
1157         {
1158           rtx insn;
1159
1160           FOR_BB_INSNS (bb, insn)
1161             {
1162               rtx next, pat;
1163
1164               if (!INSN_P (insn))
1165                 continue;
1166
1167               next = NEXT_INSN (insn);
1168
1169               pat = PATTERN (insn);
1170               if (GET_CODE (pat) == CLOBBER)
1171                 resolve_clobber (pat, insn);
1172               else if (GET_CODE (pat) == USE)
1173                 resolve_use (pat, insn);
1174               else
1175                 {
1176                   rtx set;
1177                   int i;
1178
1179                   recog_memoized (insn);
1180                   extract_insn (insn);
1181
1182                   set = simple_move (insn);
1183                   if (set)
1184                     {
1185                       rtx orig_insn = insn;
1186                       bool cfi = control_flow_insn_p (insn);
1187
1188                       /* We can end up splitting loads to multi-word pseudos
1189                          into separate loads to machine word size pseudos.
1190                          When this happens, we first had one load that can
1191                          throw, and after resolve_simple_move we'll have a
1192                          bunch of loads (at least two).  All those loads may
1193                          trap if we can have non-call exceptions, so they
1194                          all will end the current basic block.  We split the
1195                          block after the outer loop over all insns, but we
1196                          make sure here that we will be able to split the
1197                          basic block and still produce the correct control
1198                          flow graph for it.  */
1199                       gcc_assert (!cfi
1200                                   || (flag_non_call_exceptions
1201                                       && can_throw_internal (insn)));
1202
1203                       insn = resolve_simple_move (set, insn);
1204                       if (insn != orig_insn)
1205                         {
1206                           recog_memoized (insn);
1207                           extract_insn (insn);
1208
1209                           if (cfi)
1210                             SET_BIT (sub_blocks, bb->index);
1211                         }
1212                     }
1213                   else
1214                     {
1215                       rtx decomposed_shift;
1216
1217                       decomposed_shift = resolve_shift_zext (insn);
1218                       if (decomposed_shift != NULL_RTX)
1219                         {
1220                           insn = decomposed_shift;
1221                           recog_memoized (insn);
1222                           extract_insn (insn);
1223                         }
1224                     }
1225
1226                   for (i = recog_data.n_operands - 1; i >= 0; --i)
1227                     for_each_rtx (recog_data.operand_loc[i],
1228                                   resolve_subreg_use,
1229                                   insn);
1230
1231                   resolve_reg_notes (insn);
1232
1233                   if (num_validated_changes () > 0)
1234                     {
1235                       for (i = recog_data.n_dups - 1; i >= 0; --i)
1236                         {
1237                           rtx *pl = recog_data.dup_loc[i];
1238                           int dup_num = recog_data.dup_num[i];
1239                           rtx *px = recog_data.operand_loc[dup_num];
1240
1241                           validate_unshare_change (insn, pl, *px, 1);
1242                         }
1243
1244                       i = apply_change_group ();
1245                       gcc_assert (i);
1246                     }
1247                 }
1248             }
1249         }
1250
1251       /* If we had insns to split that caused control flow insns in the middle
1252          of a basic block, split those blocks now.  Note that we only handle
1253          the case where splitting a load has caused multiple possibly trapping
1254          loads to appear.  */
1255       EXECUTE_IF_SET_IN_SBITMAP (sub_blocks, 0, i, sbi)
1256         {
1257           rtx insn, end;
1258           edge fallthru;
1259
1260           bb = BASIC_BLOCK (i);
1261           insn = BB_HEAD (bb);
1262           end = BB_END (bb);
1263
1264           while (insn != end)
1265             {
1266               if (control_flow_insn_p (insn))
1267                 {
1268                   /* Split the block after insn.  There will be a fallthru
1269                      edge, which is OK so we keep it.  We have to create the
1270                      exception edges ourselves.  */
1271                   fallthru = split_block (bb, insn);
1272                   rtl_make_eh_edge (NULL, bb, BB_END (bb));
1273                   bb = fallthru->dest;
1274                   insn = BB_HEAD (bb);
1275                 }
1276               else
1277                 insn = NEXT_INSN (insn);
1278             }
1279         }
1280
1281       sbitmap_free (sub_blocks);
1282     }
1283
1284   {
1285     unsigned int i;
1286     bitmap b;
1287
1288     for (i = 0; VEC_iterate (bitmap, reg_copy_graph, i, b); ++i)
1289       if (b)
1290         BITMAP_FREE (b);
1291   }
1292
1293   VEC_free (bitmap, heap, reg_copy_graph);  
1294
1295   BITMAP_FREE (decomposable_context);
1296   BITMAP_FREE (non_decomposable_context);
1297 }
1298 \f
1299 /* Gate function for lower subreg pass.  */
1300
1301 static bool
1302 gate_handle_lower_subreg (void)
1303 {
1304   return flag_split_wide_types != 0;
1305 }
1306
1307 /* Implement first lower subreg pass.  */
1308
1309 static unsigned int
1310 rest_of_handle_lower_subreg (void)
1311 {
1312   decompose_multiword_subregs ();
1313   return 0;
1314 }
1315
1316 /* Implement second lower subreg pass.  */
1317
1318 static unsigned int
1319 rest_of_handle_lower_subreg2 (void)
1320 {
1321   decompose_multiword_subregs ();
1322   return 0;
1323 }
1324
1325 struct rtl_opt_pass pass_lower_subreg =
1326 {
1327  {
1328   RTL_PASS,
1329   "subreg",                             /* name */
1330   gate_handle_lower_subreg,             /* gate */
1331   rest_of_handle_lower_subreg,          /* execute */
1332   NULL,                                 /* sub */
1333   NULL,                                 /* next */
1334   0,                                    /* static_pass_number */
1335   TV_LOWER_SUBREG,                      /* tv_id */
1336   0,                                    /* properties_required */
1337   0,                                    /* properties_provided */
1338   0,                                    /* properties_destroyed */
1339   0,                                    /* todo_flags_start */
1340   TODO_dump_func |
1341   TODO_ggc_collect |
1342   TODO_verify_flow                      /* todo_flags_finish */
1343  }
1344 };
1345
1346 struct rtl_opt_pass pass_lower_subreg2 =
1347 {
1348  {
1349   RTL_PASS,
1350   "subreg2",                            /* name */
1351   gate_handle_lower_subreg,             /* gate */
1352   rest_of_handle_lower_subreg2,          /* execute */
1353   NULL,                                 /* sub */
1354   NULL,                                 /* next */
1355   0,                                    /* static_pass_number */
1356   TV_LOWER_SUBREG,                      /* tv_id */
1357   0,                                    /* properties_required */
1358   0,                                    /* properties_provided */
1359   0,                                    /* properties_destroyed */
1360   0,                                    /* todo_flags_start */
1361   TODO_df_finish | TODO_verify_rtl_sharing |
1362   TODO_dump_func |
1363   TODO_ggc_collect |
1364   TODO_verify_flow                      /* todo_flags_finish */
1365  }
1366 };