OSDN Git Service

f9c65485bd247ce7bc48cd4fe16e6ca7c2bf2778
[pf3gnuchains/gcc-fork.git] / gcc / expr.c
1 /* Convert tree expression to rtl instructions, for GNU compiler.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "machmode.h"
27 #include "real.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "flags.h"
31 #include "regs.h"
32 #include "hard-reg-set.h"
33 #include "except.h"
34 #include "function.h"
35 #include "insn-config.h"
36 #include "insn-attr.h"
37 /* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */
38 #include "expr.h"
39 #include "optabs.h"
40 #include "libfuncs.h"
41 #include "recog.h"
42 #include "reload.h"
43 #include "output.h"
44 #include "typeclass.h"
45 #include "toplev.h"
46 #include "ggc.h"
47 #include "langhooks.h"
48 #include "intl.h"
49 #include "tm_p.h"
50 #include "tree-iterator.h"
51 #include "tree-pass.h"
52 #include "tree-flow.h"
53 #include "target.h"
54 #include "timevar.h"
55
56 /* Decide whether a function's arguments should be processed
57    from first to last or from last to first.
58
59    They should if the stack and args grow in opposite directions, but
60    only if we have push insns.  */
61
62 #ifdef PUSH_ROUNDING
63
64 #ifndef PUSH_ARGS_REVERSED
65 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
66 #define PUSH_ARGS_REVERSED      /* If it's last to first.  */
67 #endif
68 #endif
69
70 #endif
71
72 #ifndef STACK_PUSH_CODE
73 #ifdef STACK_GROWS_DOWNWARD
74 #define STACK_PUSH_CODE PRE_DEC
75 #else
76 #define STACK_PUSH_CODE PRE_INC
77 #endif
78 #endif
79
80
81 /* If this is nonzero, we do not bother generating VOLATILE
82    around volatile memory references, and we are willing to
83    output indirect addresses.  If cse is to follow, we reject
84    indirect addresses so a useful potential cse is generated;
85    if it is used only once, instruction combination will produce
86    the same indirect address eventually.  */
87 int cse_not_expected;
88
89 /* This structure is used by move_by_pieces to describe the move to
90    be performed.  */
91 struct move_by_pieces
92 {
93   rtx to;
94   rtx to_addr;
95   int autinc_to;
96   int explicit_inc_to;
97   rtx from;
98   rtx from_addr;
99   int autinc_from;
100   int explicit_inc_from;
101   unsigned HOST_WIDE_INT len;
102   HOST_WIDE_INT offset;
103   int reverse;
104 };
105
106 /* This structure is used by store_by_pieces to describe the clear to
107    be performed.  */
108
109 struct store_by_pieces
110 {
111   rtx to;
112   rtx to_addr;
113   int autinc_to;
114   int explicit_inc_to;
115   unsigned HOST_WIDE_INT len;
116   HOST_WIDE_INT offset;
117   rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode);
118   void *constfundata;
119   int reverse;
120 };
121
122 static rtx enqueue_insn (rtx, rtx);
123 static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,
124                                                      unsigned int);
125 static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode,
126                               struct move_by_pieces *);
127 static bool block_move_libcall_safe_for_call_parm (void);
128 static bool emit_block_move_via_movmem (rtx, rtx, rtx, unsigned);
129 static rtx emit_block_move_via_libcall (rtx, rtx, rtx);
130 static tree emit_block_move_libcall_fn (int);
131 static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);
132 static rtx clear_by_pieces_1 (void *, HOST_WIDE_INT, enum machine_mode);
133 static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);
134 static void store_by_pieces_1 (struct store_by_pieces *, unsigned int);
135 static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode,
136                                struct store_by_pieces *);
137 static bool clear_storage_via_clrmem (rtx, rtx, unsigned);
138 static rtx clear_storage_via_libcall (rtx, rtx);
139 static tree clear_storage_libcall_fn (int);
140 static rtx compress_float_constant (rtx, rtx);
141 static rtx get_subtarget (rtx);
142 static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,
143                                      HOST_WIDE_INT, enum machine_mode,
144                                      tree, tree, int, int);
145 static void store_constructor (tree, rtx, int, HOST_WIDE_INT);
146 static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode,
147                         tree, enum machine_mode, int, tree, int);
148 static rtx var_rtx (tree);
149
150 static unsigned HOST_WIDE_INT highest_pow2_factor (tree);
151 static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);
152
153 static int is_aligning_offset (tree, tree);
154 static rtx expand_increment (tree, int, int);
155 static void expand_operands (tree, tree, rtx, rtx*, rtx*,
156                              enum expand_modifier);
157 static rtx reduce_to_bit_field_precision (rtx, rtx, tree);
158 static rtx do_store_flag (tree, rtx, enum machine_mode, int);
159 #ifdef PUSH_ROUNDING
160 static void emit_single_push_insn (enum machine_mode, rtx, tree);
161 #endif
162 static void do_tablejump (rtx, enum machine_mode, rtx, rtx, rtx);
163 static rtx const_vector_from_tree (tree);
164
165 /* Record for each mode whether we can move a register directly to or
166    from an object of that mode in memory.  If we can't, we won't try
167    to use that mode directly when accessing a field of that mode.  */
168
169 static char direct_load[NUM_MACHINE_MODES];
170 static char direct_store[NUM_MACHINE_MODES];
171
172 /* Record for each mode whether we can float-extend from memory.  */
173
174 static bool float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];
175
176 /* This macro is used to determine whether move_by_pieces should be called
177    to perform a structure copy.  */
178 #ifndef MOVE_BY_PIECES_P
179 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
180   (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) MOVE_RATIO)
181 #endif
182
183 /* This macro is used to determine whether clear_by_pieces should be
184    called to clear storage.  */
185 #ifndef CLEAR_BY_PIECES_P
186 #define CLEAR_BY_PIECES_P(SIZE, ALIGN) \
187   (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) CLEAR_RATIO)
188 #endif
189
190 /* This macro is used to determine whether store_by_pieces should be
191    called to "memset" storage with byte values other than zero, or
192    to "memcpy" storage when the source is a constant string.  */
193 #ifndef STORE_BY_PIECES_P
194 #define STORE_BY_PIECES_P(SIZE, ALIGN)  MOVE_BY_PIECES_P (SIZE, ALIGN)
195 #endif
196
197 /* This array records the insn_code of insns to perform block moves.  */
198 enum insn_code movmem_optab[NUM_MACHINE_MODES];
199
200 /* This array records the insn_code of insns to perform block clears.  */
201 enum insn_code clrmem_optab[NUM_MACHINE_MODES];
202
203 /* These arrays record the insn_code of two different kinds of insns
204    to perform block compares.  */
205 enum insn_code cmpstr_optab[NUM_MACHINE_MODES];
206 enum insn_code cmpmem_optab[NUM_MACHINE_MODES];
207
208 /* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow.  */
209
210 #ifndef SLOW_UNALIGNED_ACCESS
211 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
212 #endif
213 \f
214 /* This is run once per compilation to set up which modes can be used
215    directly in memory and to initialize the block move optab.  */
216
217 void
218 init_expr_once (void)
219 {
220   rtx insn, pat;
221   enum machine_mode mode;
222   int num_clobbers;
223   rtx mem, mem1;
224   rtx reg;
225
226   /* Try indexing by frame ptr and try by stack ptr.
227      It is known that on the Convex the stack ptr isn't a valid index.
228      With luck, one or the other is valid on any machine.  */
229   mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
230   mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
231
232   /* A scratch register we can modify in-place below to avoid
233      useless RTL allocations.  */
234   reg = gen_rtx_REG (VOIDmode, -1);
235
236   insn = rtx_alloc (INSN);
237   pat = gen_rtx_SET (0, NULL_RTX, NULL_RTX);
238   PATTERN (insn) = pat;
239
240   for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
241        mode = (enum machine_mode) ((int) mode + 1))
242     {
243       int regno;
244
245       direct_load[(int) mode] = direct_store[(int) mode] = 0;
246       PUT_MODE (mem, mode);
247       PUT_MODE (mem1, mode);
248       PUT_MODE (reg, mode);
249
250       /* See if there is some register that can be used in this mode and
251          directly loaded or stored from memory.  */
252
253       if (mode != VOIDmode && mode != BLKmode)
254         for (regno = 0; regno < FIRST_PSEUDO_REGISTER
255              && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
256              regno++)
257           {
258             if (! HARD_REGNO_MODE_OK (regno, mode))
259               continue;
260
261             REGNO (reg) = regno;
262
263             SET_SRC (pat) = mem;
264             SET_DEST (pat) = reg;
265             if (recog (pat, insn, &num_clobbers) >= 0)
266               direct_load[(int) mode] = 1;
267
268             SET_SRC (pat) = mem1;
269             SET_DEST (pat) = reg;
270             if (recog (pat, insn, &num_clobbers) >= 0)
271               direct_load[(int) mode] = 1;
272
273             SET_SRC (pat) = reg;
274             SET_DEST (pat) = mem;
275             if (recog (pat, insn, &num_clobbers) >= 0)
276               direct_store[(int) mode] = 1;
277
278             SET_SRC (pat) = reg;
279             SET_DEST (pat) = mem1;
280             if (recog (pat, insn, &num_clobbers) >= 0)
281               direct_store[(int) mode] = 1;
282           }
283     }
284
285   mem = gen_rtx_MEM (VOIDmode, gen_rtx_raw_REG (Pmode, 10000));
286
287   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
288        mode = GET_MODE_WIDER_MODE (mode))
289     {
290       enum machine_mode srcmode;
291       for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;
292            srcmode = GET_MODE_WIDER_MODE (srcmode))
293         {
294           enum insn_code ic;
295
296           ic = can_extend_p (mode, srcmode, 0);
297           if (ic == CODE_FOR_nothing)
298             continue;
299
300           PUT_MODE (mem, srcmode);
301
302           if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))
303             float_extend_from_mem[mode][srcmode] = true;
304         }
305     }
306 }
307
308 /* This is run at the start of compiling a function.  */
309
310 void
311 init_expr (void)
312 {
313   cfun->expr = ggc_alloc_cleared (sizeof (struct expr_status));
314 }
315
316 /* Small sanity check that the queue is empty at the end of a function.  */
317
318 void
319 finish_expr_for_function (void)
320 {
321   if (pending_chain)
322     abort ();
323 }
324 \f
325 /* Manage the queue of increment instructions to be output
326    for POSTINCREMENT_EXPR expressions, etc.  */
327
328 /* Queue up to increment (or change) VAR later.  BODY says how:
329    BODY should be the same thing you would pass to emit_insn
330    to increment right away.  It will go to emit_insn later on.
331
332    The value is a QUEUED expression to be used in place of VAR
333    where you want to guarantee the pre-incrementation value of VAR.  */
334
335 static rtx
336 enqueue_insn (rtx var, rtx body)
337 {
338   pending_chain = gen_rtx_QUEUED (GET_MODE (var), var, NULL_RTX, NULL_RTX,
339                                   body, pending_chain);
340   return pending_chain;
341 }
342
343 /* Use protect_from_queue to convert a QUEUED expression
344    into something that you can put immediately into an instruction.
345    If the queued incrementation has not happened yet,
346    protect_from_queue returns the variable itself.
347    If the incrementation has happened, protect_from_queue returns a temp
348    that contains a copy of the old value of the variable.
349
350    Any time an rtx which might possibly be a QUEUED is to be put
351    into an instruction, it must be passed through protect_from_queue first.
352    QUEUED expressions are not meaningful in instructions.
353
354    Do not pass a value through protect_from_queue and then hold
355    on to it for a while before putting it in an instruction!
356    If the queue is flushed in between, incorrect code will result.  */
357
358 rtx
359 protect_from_queue (rtx x, int modify)
360 {
361   RTX_CODE code = GET_CODE (x);
362
363 #if 0  /* A QUEUED can hang around after the queue is forced out.  */
364   /* Shortcut for most common case.  */
365   if (pending_chain == 0)
366     return x;
367 #endif
368
369   if (code != QUEUED)
370     {
371       /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
372          use of autoincrement.  Make a copy of the contents of the memory
373          location rather than a copy of the address, but not if the value is
374          of mode BLKmode.  Don't modify X in place since it might be
375          shared.  */
376       if (code == MEM && GET_MODE (x) != BLKmode
377           && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
378         {
379           rtx y = XEXP (x, 0);
380           rtx new = replace_equiv_address_nv (x, QUEUED_VAR (y));
381
382           if (QUEUED_INSN (y))
383             {
384               rtx temp = gen_reg_rtx (GET_MODE (x));
385
386               emit_insn_before (gen_move_insn (temp, new),
387                                 QUEUED_INSN (y));
388               return temp;
389             }
390
391           /* Copy the address into a pseudo, so that the returned value
392              remains correct across calls to emit_queue.  */
393           return replace_equiv_address (new, copy_to_reg (XEXP (new, 0)));
394         }
395
396       /* Otherwise, recursively protect the subexpressions of all
397          the kinds of rtx's that can contain a QUEUED.  */
398       if (code == MEM)
399         {
400           rtx tem = protect_from_queue (XEXP (x, 0), 0);
401           if (tem != XEXP (x, 0))
402             {
403               x = copy_rtx (x);
404               XEXP (x, 0) = tem;
405             }
406         }
407       else if (code == PLUS || code == MULT)
408         {
409           rtx new0 = protect_from_queue (XEXP (x, 0), 0);
410           rtx new1 = protect_from_queue (XEXP (x, 1), 0);
411           if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
412             {
413               x = copy_rtx (x);
414               XEXP (x, 0) = new0;
415               XEXP (x, 1) = new1;
416             }
417         }
418       return x;
419     }
420   /* If the increment has not happened, use the variable itself.  Copy it
421      into a new pseudo so that the value remains correct across calls to
422      emit_queue.  */
423   if (QUEUED_INSN (x) == 0)
424     return copy_to_reg (QUEUED_VAR (x));
425   /* If the increment has happened and a pre-increment copy exists,
426      use that copy.  */
427   if (QUEUED_COPY (x) != 0)
428     return QUEUED_COPY (x);
429   /* The increment has happened but we haven't set up a pre-increment copy.
430      Set one up now, and use it.  */
431   QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
432   emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
433                     QUEUED_INSN (x));
434   return QUEUED_COPY (x);
435 }
436
437 /* Return nonzero if X contains a QUEUED expression:
438    if it contains anything that will be altered by a queued increment.
439    We handle only combinations of MEM, PLUS, MINUS and MULT operators
440    since memory addresses generally contain only those.  */
441
442 int
443 queued_subexp_p (rtx x)
444 {
445   enum rtx_code code = GET_CODE (x);
446   switch (code)
447     {
448     case QUEUED:
449       return 1;
450     case MEM:
451       return queued_subexp_p (XEXP (x, 0));
452     case MULT:
453     case PLUS:
454     case MINUS:
455       return (queued_subexp_p (XEXP (x, 0))
456               || queued_subexp_p (XEXP (x, 1)));
457     default:
458       return 0;
459     }
460 }
461
462 /* Retrieve a mark on the queue.  */
463   
464 static rtx
465 mark_queue (void)
466 {
467   return pending_chain;
468 }
469
470 /* Perform all the pending incrementations that have been enqueued
471    after MARK was retrieved.  If MARK is null, perform all the
472    pending incrementations.  */
473
474 static void
475 emit_insns_enqueued_after_mark (rtx mark)
476 {
477   rtx p;
478
479   /* The marked incrementation may have been emitted in the meantime
480      through a call to emit_queue.  In this case, the mark is not valid
481      anymore so do nothing.  */
482   if (mark && ! QUEUED_BODY (mark))
483     return;
484
485   while ((p = pending_chain) != mark)
486     {
487       rtx body = QUEUED_BODY (p);
488
489       switch (GET_CODE (body))
490         {
491         case INSN:
492         case JUMP_INSN:
493         case CALL_INSN:
494         case CODE_LABEL:
495         case BARRIER:
496         case NOTE:
497           QUEUED_INSN (p) = body;
498           emit_insn (body);
499           break;
500
501 #ifdef ENABLE_CHECKING
502         case SEQUENCE:
503           abort ();
504           break;
505 #endif
506
507         default:
508           QUEUED_INSN (p) = emit_insn (body);
509           break;
510         }
511
512       QUEUED_BODY (p) = 0;
513       pending_chain = QUEUED_NEXT (p);
514     }
515 }
516
517 /* Perform all the pending incrementations.  */
518
519 void
520 emit_queue (void)
521 {
522   emit_insns_enqueued_after_mark (NULL_RTX);
523 }
524 \f
525 /* Copy data from FROM to TO, where the machine modes are not the same.
526    Both modes may be integer, or both may be floating.
527    UNSIGNEDP should be nonzero if FROM is an unsigned type.
528    This causes zero-extension instead of sign-extension.  */
529
530 void
531 convert_move (rtx to, rtx from, int unsignedp)
532 {
533   enum machine_mode to_mode = GET_MODE (to);
534   enum machine_mode from_mode = GET_MODE (from);
535   int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
536   int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
537   enum insn_code code;
538   rtx libcall;
539
540   /* rtx code for making an equivalent value.  */
541   enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN
542                               : (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));
543
544   to = protect_from_queue (to, 1);
545   from = protect_from_queue (from, 0);
546
547   if (to_real != from_real)
548     abort ();
549
550   /* If the source and destination are already the same, then there's
551      nothing to do.  */
552   if (to == from)
553     return;
554
555   /* If FROM is a SUBREG that indicates that we have already done at least
556      the required extension, strip it.  We don't handle such SUBREGs as
557      TO here.  */
558
559   if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
560       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
561           >= GET_MODE_SIZE (to_mode))
562       && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
563     from = gen_lowpart (to_mode, from), from_mode = to_mode;
564
565   if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
566     abort ();
567
568   if (to_mode == from_mode
569       || (from_mode == VOIDmode && CONSTANT_P (from)))
570     {
571       emit_move_insn (to, from);
572       return;
573     }
574
575   if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
576     {
577       if (GET_MODE_BITSIZE (from_mode) != GET_MODE_BITSIZE (to_mode))
578         abort ();
579
580       if (VECTOR_MODE_P (to_mode))
581         from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);
582       else
583         to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);
584
585       emit_move_insn (to, from);
586       return;
587     }
588
589   if (GET_CODE (to) == CONCAT && GET_CODE (from) == CONCAT)
590     {
591       convert_move (XEXP (to, 0), XEXP (from, 0), unsignedp);
592       convert_move (XEXP (to, 1), XEXP (from, 1), unsignedp);
593       return;
594     }
595
596   if (to_real)
597     {
598       rtx value, insns;
599       convert_optab tab;
600
601       if (GET_MODE_PRECISION (from_mode) < GET_MODE_PRECISION (to_mode))
602         tab = sext_optab;
603       else if (GET_MODE_PRECISION (from_mode) > GET_MODE_PRECISION (to_mode))
604         tab = trunc_optab;
605       else
606         abort ();
607
608       /* Try converting directly if the insn is supported.  */
609
610       code = tab->handlers[to_mode][from_mode].insn_code;
611       if (code != CODE_FOR_nothing)
612         {
613           emit_unop_insn (code, to, from,
614                           tab == sext_optab ? FLOAT_EXTEND : FLOAT_TRUNCATE);
615           return;
616         }
617
618       /* Otherwise use a libcall.  */
619       libcall = tab->handlers[to_mode][from_mode].libfunc;
620
621       if (!libcall)
622         /* This conversion is not implemented yet.  */
623         abort ();
624
625       start_sequence ();
626       value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
627                                        1, from, from_mode);
628       insns = get_insns ();
629       end_sequence ();
630       emit_libcall_block (insns, to, value,
631                           tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,
632                                                                        from)
633                           : gen_rtx_FLOAT_EXTEND (to_mode, from));
634       return;
635     }
636
637   /* Handle pointer conversion.  */                     /* SPEE 900220.  */
638   /* Targets are expected to provide conversion insns between PxImode and
639      xImode for all MODE_PARTIAL_INT modes they use, but no others.  */
640   if (GET_MODE_CLASS (to_mode) == MODE_PARTIAL_INT)
641     {
642       enum machine_mode full_mode
643         = smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);
644
645       if (trunc_optab->handlers[to_mode][full_mode].insn_code
646           == CODE_FOR_nothing)
647         abort ();
648
649       if (full_mode != from_mode)
650         from = convert_to_mode (full_mode, from, unsignedp);
651       emit_unop_insn (trunc_optab->handlers[to_mode][full_mode].insn_code,
652                       to, from, UNKNOWN);
653       return;
654     }
655   if (GET_MODE_CLASS (from_mode) == MODE_PARTIAL_INT)
656     {
657       enum machine_mode full_mode
658         = smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);
659
660       if (sext_optab->handlers[full_mode][from_mode].insn_code
661           == CODE_FOR_nothing)
662         abort ();
663
664       emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,
665                       to, from, UNKNOWN);
666       if (to_mode == full_mode)
667         return;
668
669       /* else proceed to integer conversions below.  */
670       from_mode = full_mode;
671     }
672
673   /* Now both modes are integers.  */
674
675   /* Handle expanding beyond a word.  */
676   if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
677       && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
678     {
679       rtx insns;
680       rtx lowpart;
681       rtx fill_value;
682       rtx lowfrom;
683       int i;
684       enum machine_mode lowpart_mode;
685       int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
686
687       /* Try converting directly if the insn is supported.  */
688       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
689           != CODE_FOR_nothing)
690         {
691           /* If FROM is a SUBREG, put it into a register.  Do this
692              so that we always generate the same set of insns for
693              better cse'ing; if an intermediate assignment occurred,
694              we won't be doing the operation directly on the SUBREG.  */
695           if (optimize > 0 && GET_CODE (from) == SUBREG)
696             from = force_reg (from_mode, from);
697           emit_unop_insn (code, to, from, equiv_code);
698           return;
699         }
700       /* Next, try converting via full word.  */
701       else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
702                && ((code = can_extend_p (to_mode, word_mode, unsignedp))
703                    != CODE_FOR_nothing))
704         {
705           if (REG_P (to))
706             {
707               if (reg_overlap_mentioned_p (to, from))
708                 from = force_reg (from_mode, from);
709               emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
710             }
711           convert_move (gen_lowpart (word_mode, to), from, unsignedp);
712           emit_unop_insn (code, to,
713                           gen_lowpart (word_mode, to), equiv_code);
714           return;
715         }
716
717       /* No special multiword conversion insn; do it by hand.  */
718       start_sequence ();
719
720       /* Since we will turn this into a no conflict block, we must ensure
721          that the source does not overlap the target.  */
722
723       if (reg_overlap_mentioned_p (to, from))
724         from = force_reg (from_mode, from);
725
726       /* Get a copy of FROM widened to a word, if necessary.  */
727       if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
728         lowpart_mode = word_mode;
729       else
730         lowpart_mode = from_mode;
731
732       lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
733
734       lowpart = gen_lowpart (lowpart_mode, to);
735       emit_move_insn (lowpart, lowfrom);
736
737       /* Compute the value to put in each remaining word.  */
738       if (unsignedp)
739         fill_value = const0_rtx;
740       else
741         {
742 #ifdef HAVE_slt
743           if (HAVE_slt
744               && insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode
745               && STORE_FLAG_VALUE == -1)
746             {
747               emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
748                              lowpart_mode, 0);
749               fill_value = gen_reg_rtx (word_mode);
750               emit_insn (gen_slt (fill_value));
751             }
752           else
753 #endif
754             {
755               fill_value
756                 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
757                                 size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
758                                 NULL_RTX, 0);
759               fill_value = convert_to_mode (word_mode, fill_value, 1);
760             }
761         }
762
763       /* Fill the remaining words.  */
764       for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
765         {
766           int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
767           rtx subword = operand_subword (to, index, 1, to_mode);
768
769           if (subword == 0)
770             abort ();
771
772           if (fill_value != subword)
773             emit_move_insn (subword, fill_value);
774         }
775
776       insns = get_insns ();
777       end_sequence ();
778
779       emit_no_conflict_block (insns, to, from, NULL_RTX,
780                               gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
781       return;
782     }
783
784   /* Truncating multi-word to a word or less.  */
785   if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
786       && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
787     {
788       if (!((MEM_P (from)
789              && ! MEM_VOLATILE_P (from)
790              && direct_load[(int) to_mode]
791              && ! mode_dependent_address_p (XEXP (from, 0)))
792             || REG_P (from)
793             || GET_CODE (from) == SUBREG))
794         from = force_reg (from_mode, from);
795       convert_move (to, gen_lowpart (word_mode, from), 0);
796       return;
797     }
798
799   /* Now follow all the conversions between integers
800      no more than a word long.  */
801
802   /* For truncation, usually we can just refer to FROM in a narrower mode.  */
803   if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
804       && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
805                                 GET_MODE_BITSIZE (from_mode)))
806     {
807       if (!((MEM_P (from)
808              && ! MEM_VOLATILE_P (from)
809              && direct_load[(int) to_mode]
810              && ! mode_dependent_address_p (XEXP (from, 0)))
811             || REG_P (from)
812             || GET_CODE (from) == SUBREG))
813         from = force_reg (from_mode, from);
814       if (REG_P (from) && REGNO (from) < FIRST_PSEUDO_REGISTER
815           && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
816         from = copy_to_reg (from);
817       emit_move_insn (to, gen_lowpart (to_mode, from));
818       return;
819     }
820
821   /* Handle extension.  */
822   if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
823     {
824       /* Convert directly if that works.  */
825       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
826           != CODE_FOR_nothing)
827         {
828           if (flag_force_mem)
829             from = force_not_mem (from);
830
831           emit_unop_insn (code, to, from, equiv_code);
832           return;
833         }
834       else
835         {
836           enum machine_mode intermediate;
837           rtx tmp;
838           tree shift_amount;
839
840           /* Search for a mode to convert via.  */
841           for (intermediate = from_mode; intermediate != VOIDmode;
842                intermediate = GET_MODE_WIDER_MODE (intermediate))
843             if (((can_extend_p (to_mode, intermediate, unsignedp)
844                   != CODE_FOR_nothing)
845                  || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
846                      && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
847                                                GET_MODE_BITSIZE (intermediate))))
848                 && (can_extend_p (intermediate, from_mode, unsignedp)
849                     != CODE_FOR_nothing))
850               {
851                 convert_move (to, convert_to_mode (intermediate, from,
852                                                    unsignedp), unsignedp);
853                 return;
854               }
855
856           /* No suitable intermediate mode.
857              Generate what we need with shifts.  */
858           shift_amount = build_int_2 (GET_MODE_BITSIZE (to_mode)
859                                       - GET_MODE_BITSIZE (from_mode), 0);
860           from = gen_lowpart (to_mode, force_reg (from_mode, from));
861           tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
862                               to, unsignedp);
863           tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
864                               to, unsignedp);
865           if (tmp != to)
866             emit_move_insn (to, tmp);
867           return;
868         }
869     }
870
871   /* Support special truncate insns for certain modes.  */
872   if (trunc_optab->handlers[to_mode][from_mode].insn_code != CODE_FOR_nothing)
873     {
874       emit_unop_insn (trunc_optab->handlers[to_mode][from_mode].insn_code,
875                       to, from, UNKNOWN);
876       return;
877     }
878
879   /* Handle truncation of volatile memrefs, and so on;
880      the things that couldn't be truncated directly,
881      and for which there was no special instruction.
882
883      ??? Code above formerly short-circuited this, for most integer
884      mode pairs, with a force_reg in from_mode followed by a recursive
885      call to this routine.  Appears always to have been wrong.  */
886   if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
887     {
888       rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
889       emit_move_insn (to, temp);
890       return;
891     }
892
893   /* Mode combination is not recognized.  */
894   abort ();
895 }
896
897 /* Return an rtx for a value that would result
898    from converting X to mode MODE.
899    Both X and MODE may be floating, or both integer.
900    UNSIGNEDP is nonzero if X is an unsigned value.
901    This can be done by referring to a part of X in place
902    or by copying to a new temporary with conversion.
903
904    This function *must not* call protect_from_queue
905    except when putting X into an insn (in which case convert_move does it).  */
906
907 rtx
908 convert_to_mode (enum machine_mode mode, rtx x, int unsignedp)
909 {
910   return convert_modes (mode, VOIDmode, x, unsignedp);
911 }
912
913 /* Return an rtx for a value that would result
914    from converting X from mode OLDMODE to mode MODE.
915    Both modes may be floating, or both integer.
916    UNSIGNEDP is nonzero if X is an unsigned value.
917
918    This can be done by referring to a part of X in place
919    or by copying to a new temporary with conversion.
920
921    You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
922
923    This function *must not* call protect_from_queue
924    except when putting X into an insn (in which case convert_move does it).  */
925
926 rtx
927 convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int unsignedp)
928 {
929   rtx temp;
930
931   /* If FROM is a SUBREG that indicates that we have already done at least
932      the required extension, strip it.  */
933
934   if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
935       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
936       && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
937     x = gen_lowpart (mode, x);
938
939   if (GET_MODE (x) != VOIDmode)
940     oldmode = GET_MODE (x);
941
942   if (mode == oldmode)
943     return x;
944
945   /* There is one case that we must handle specially: If we are converting
946      a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
947      we are to interpret the constant as unsigned, gen_lowpart will do
948      the wrong if the constant appears negative.  What we want to do is
949      make the high-order word of the constant zero, not all ones.  */
950
951   if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
952       && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
953       && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
954     {
955       HOST_WIDE_INT val = INTVAL (x);
956
957       if (oldmode != VOIDmode
958           && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))
959         {
960           int width = GET_MODE_BITSIZE (oldmode);
961
962           /* We need to zero extend VAL.  */
963           val &= ((HOST_WIDE_INT) 1 << width) - 1;
964         }
965
966       return immed_double_const (val, (HOST_WIDE_INT) 0, mode);
967     }
968
969   /* We can do this with a gen_lowpart if both desired and current modes
970      are integer, and this is either a constant integer, a register, or a
971      non-volatile MEM.  Except for the constant case where MODE is no
972      wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand.  */
973
974   if ((GET_CODE (x) == CONST_INT
975        && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
976       || (GET_MODE_CLASS (mode) == MODE_INT
977           && GET_MODE_CLASS (oldmode) == MODE_INT
978           && (GET_CODE (x) == CONST_DOUBLE
979               || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
980                   && ((MEM_P (x) && ! MEM_VOLATILE_P (x)
981                        && direct_load[(int) mode])
982                       || (REG_P (x)
983                           && (! HARD_REGISTER_P (x)
984                               || HARD_REGNO_MODE_OK (REGNO (x), mode))
985                           && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
986                                                     GET_MODE_BITSIZE (GET_MODE (x)))))))))
987     {
988       /* ?? If we don't know OLDMODE, we have to assume here that
989          X does not need sign- or zero-extension.   This may not be
990          the case, but it's the best we can do.  */
991       if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
992           && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
993         {
994           HOST_WIDE_INT val = INTVAL (x);
995           int width = GET_MODE_BITSIZE (oldmode);
996
997           /* We must sign or zero-extend in this case.  Start by
998              zero-extending, then sign extend if we need to.  */
999           val &= ((HOST_WIDE_INT) 1 << width) - 1;
1000           if (! unsignedp
1001               && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
1002             val |= (HOST_WIDE_INT) (-1) << width;
1003
1004           return gen_int_mode (val, mode);
1005         }
1006
1007       return gen_lowpart (mode, x);
1008     }
1009
1010   /* Converting from integer constant into mode is always equivalent to an
1011      subreg operation.  */
1012   if (VECTOR_MODE_P (mode) && GET_MODE (x) == VOIDmode)
1013     {
1014       if (GET_MODE_BITSIZE (mode) != GET_MODE_BITSIZE (oldmode))
1015         abort ();
1016       return simplify_gen_subreg (mode, x, oldmode, 0);
1017     }
1018
1019   temp = gen_reg_rtx (mode);
1020   convert_move (temp, x, unsignedp);
1021   return temp;
1022 }
1023 \f
1024 /* STORE_MAX_PIECES is the number of bytes at a time that we can
1025    store efficiently.  Due to internal GCC limitations, this is
1026    MOVE_MAX_PIECES limited by the number of bytes GCC can represent
1027    for an immediate constant.  */
1028
1029 #define STORE_MAX_PIECES  MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT))
1030
1031 /* Determine whether the LEN bytes can be moved by using several move
1032    instructions.  Return nonzero if a call to move_by_pieces should
1033    succeed.  */
1034
1035 int
1036 can_move_by_pieces (unsigned HOST_WIDE_INT len,
1037                     unsigned int align ATTRIBUTE_UNUSED)
1038 {
1039   return MOVE_BY_PIECES_P (len, align);
1040 }
1041
1042 /* Generate several move instructions to copy LEN bytes from block FROM to
1043    block TO.  (These are MEM rtx's with BLKmode).  The caller must pass FROM
1044    and TO through protect_from_queue before calling.
1045
1046    If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
1047    used to push FROM to the stack.
1048
1049    ALIGN is maximum stack alignment we can assume.
1050
1051    If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
1052    mempcpy, and if ENDP is 2 return memory the end minus one byte ala
1053    stpcpy.  */
1054
1055 rtx
1056 move_by_pieces (rtx to, rtx from, unsigned HOST_WIDE_INT len,
1057                 unsigned int align, int endp)
1058 {
1059   struct move_by_pieces data;
1060   rtx to_addr, from_addr = XEXP (from, 0);
1061   unsigned int max_size = MOVE_MAX_PIECES + 1;
1062   enum machine_mode mode = VOIDmode, tmode;
1063   enum insn_code icode;
1064
1065   align = MIN (to ? MEM_ALIGN (to) : align, MEM_ALIGN (from));
1066
1067   data.offset = 0;
1068   data.from_addr = from_addr;
1069   if (to)
1070     {
1071       to_addr = XEXP (to, 0);
1072       data.to = to;
1073       data.autinc_to
1074         = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
1075            || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
1076       data.reverse
1077         = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
1078     }
1079   else
1080     {
1081       to_addr = NULL_RTX;
1082       data.to = NULL_RTX;
1083       data.autinc_to = 1;
1084 #ifdef STACK_GROWS_DOWNWARD
1085       data.reverse = 1;
1086 #else
1087       data.reverse = 0;
1088 #endif
1089     }
1090   data.to_addr = to_addr;
1091   data.from = from;
1092   data.autinc_from
1093     = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
1094        || GET_CODE (from_addr) == POST_INC
1095        || GET_CODE (from_addr) == POST_DEC);
1096
1097   data.explicit_inc_from = 0;
1098   data.explicit_inc_to = 0;
1099   if (data.reverse) data.offset = len;
1100   data.len = len;
1101
1102   /* If copying requires more than two move insns,
1103      copy addresses to registers (to make displacements shorter)
1104      and use post-increment if available.  */
1105   if (!(data.autinc_from && data.autinc_to)
1106       && move_by_pieces_ninsns (len, align) > 2)
1107     {
1108       /* Find the mode of the largest move...  */
1109       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1110            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1111         if (GET_MODE_SIZE (tmode) < max_size)
1112           mode = tmode;
1113
1114       if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
1115         {
1116           data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
1117           data.autinc_from = 1;
1118           data.explicit_inc_from = -1;
1119         }
1120       if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
1121         {
1122           data.from_addr = copy_addr_to_reg (from_addr);
1123           data.autinc_from = 1;
1124           data.explicit_inc_from = 1;
1125         }
1126       if (!data.autinc_from && CONSTANT_P (from_addr))
1127         data.from_addr = copy_addr_to_reg (from_addr);
1128       if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
1129         {
1130           data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
1131           data.autinc_to = 1;
1132           data.explicit_inc_to = -1;
1133         }
1134       if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
1135         {
1136           data.to_addr = copy_addr_to_reg (to_addr);
1137           data.autinc_to = 1;
1138           data.explicit_inc_to = 1;
1139         }
1140       if (!data.autinc_to && CONSTANT_P (to_addr))
1141         data.to_addr = copy_addr_to_reg (to_addr);
1142     }
1143
1144   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1145       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1146     align = MOVE_MAX * BITS_PER_UNIT;
1147
1148   /* First move what we can in the largest integer mode, then go to
1149      successively smaller modes.  */
1150
1151   while (max_size > 1)
1152     {
1153       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1154            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1155         if (GET_MODE_SIZE (tmode) < max_size)
1156           mode = tmode;
1157
1158       if (mode == VOIDmode)
1159         break;
1160
1161       icode = mov_optab->handlers[(int) mode].insn_code;
1162       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1163         move_by_pieces_1 (GEN_FCN (icode), mode, &data);
1164
1165       max_size = GET_MODE_SIZE (mode);
1166     }
1167
1168   /* The code above should have handled everything.  */
1169   if (data.len > 0)
1170     abort ();
1171
1172   if (endp)
1173     {
1174       rtx to1;
1175
1176       if (data.reverse)
1177         abort ();
1178       if (data.autinc_to)
1179         {
1180           if (endp == 2)
1181             {
1182               if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
1183                 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
1184               else
1185                 data.to_addr = copy_addr_to_reg (plus_constant (data.to_addr,
1186                                                                 -1));
1187             }
1188           to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
1189                                            data.offset);
1190         }
1191       else
1192         {
1193           if (endp == 2)
1194             --data.offset;
1195           to1 = adjust_address (data.to, QImode, data.offset);
1196         }
1197       return to1;
1198     }
1199   else
1200     return data.to;
1201 }
1202
1203 /* Return number of insns required to move L bytes by pieces.
1204    ALIGN (in bits) is maximum alignment we can assume.  */
1205
1206 static unsigned HOST_WIDE_INT
1207 move_by_pieces_ninsns (unsigned HOST_WIDE_INT l, unsigned int align)
1208 {
1209   unsigned HOST_WIDE_INT n_insns = 0;
1210   unsigned HOST_WIDE_INT max_size = MOVE_MAX + 1;
1211
1212   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1213       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1214     align = MOVE_MAX * BITS_PER_UNIT;
1215
1216   while (max_size > 1)
1217     {
1218       enum machine_mode mode = VOIDmode, tmode;
1219       enum insn_code icode;
1220
1221       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1222            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1223         if (GET_MODE_SIZE (tmode) < max_size)
1224           mode = tmode;
1225
1226       if (mode == VOIDmode)
1227         break;
1228
1229       icode = mov_optab->handlers[(int) mode].insn_code;
1230       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1231         n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1232
1233       max_size = GET_MODE_SIZE (mode);
1234     }
1235
1236   if (l)
1237     abort ();
1238   return n_insns;
1239 }
1240
1241 /* Subroutine of move_by_pieces.  Move as many bytes as appropriate
1242    with move instructions for mode MODE.  GENFUN is the gen_... function
1243    to make a move insn for that mode.  DATA has all the other info.  */
1244
1245 static void
1246 move_by_pieces_1 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
1247                   struct move_by_pieces *data)
1248 {
1249   unsigned int size = GET_MODE_SIZE (mode);
1250   rtx to1 = NULL_RTX, from1;
1251
1252   while (data->len >= size)
1253     {
1254       if (data->reverse)
1255         data->offset -= size;
1256
1257       if (data->to)
1258         {
1259           if (data->autinc_to)
1260             to1 = adjust_automodify_address (data->to, mode, data->to_addr,
1261                                              data->offset);
1262           else
1263             to1 = adjust_address (data->to, mode, data->offset);
1264         }
1265
1266       if (data->autinc_from)
1267         from1 = adjust_automodify_address (data->from, mode, data->from_addr,
1268                                            data->offset);
1269       else
1270         from1 = adjust_address (data->from, mode, data->offset);
1271
1272       if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1273         emit_insn (gen_add2_insn (data->to_addr,
1274                                   GEN_INT (-(HOST_WIDE_INT)size)));
1275       if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1276         emit_insn (gen_add2_insn (data->from_addr,
1277                                   GEN_INT (-(HOST_WIDE_INT)size)));
1278
1279       if (data->to)
1280         emit_insn ((*genfun) (to1, from1));
1281       else
1282         {
1283 #ifdef PUSH_ROUNDING
1284           emit_single_push_insn (mode, from1, NULL);
1285 #else
1286           abort ();
1287 #endif
1288         }
1289
1290       if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1291         emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1292       if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1293         emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1294
1295       if (! data->reverse)
1296         data->offset += size;
1297
1298       data->len -= size;
1299     }
1300 }
1301 \f
1302 /* Emit code to move a block Y to a block X.  This may be done with
1303    string-move instructions, with multiple scalar move instructions,
1304    or with a library call.
1305
1306    Both X and Y must be MEM rtx's (perhaps inside VOLATILE) with mode BLKmode.
1307    SIZE is an rtx that says how long they are.
1308    ALIGN is the maximum alignment we can assume they have.
1309    METHOD describes what kind of copy this is, and what mechanisms may be used.
1310
1311    Return the address of the new block, if memcpy is called and returns it,
1312    0 otherwise.  */
1313
1314 rtx
1315 emit_block_move (rtx x, rtx y, rtx size, enum block_op_methods method)
1316 {
1317   bool may_use_call;
1318   rtx retval = 0;
1319   unsigned int align;
1320
1321   switch (method)
1322     {
1323     case BLOCK_OP_NORMAL:
1324       may_use_call = true;
1325       break;
1326
1327     case BLOCK_OP_CALL_PARM:
1328       may_use_call = block_move_libcall_safe_for_call_parm ();
1329
1330       /* Make inhibit_defer_pop nonzero around the library call
1331          to force it to pop the arguments right away.  */
1332       NO_DEFER_POP;
1333       break;
1334
1335     case BLOCK_OP_NO_LIBCALL:
1336       may_use_call = false;
1337       break;
1338
1339     default:
1340       abort ();
1341     }
1342
1343   align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
1344
1345   x = protect_from_queue (x, 1);
1346   y = protect_from_queue (y, 0);
1347   size = protect_from_queue (size, 0);
1348
1349   if (!MEM_P (x))
1350     abort ();
1351   if (!MEM_P (y))
1352     abort ();
1353   if (size == 0)
1354     abort ();
1355
1356   /* Make sure we've got BLKmode addresses; store_one_arg can decide that
1357      block copy is more efficient for other large modes, e.g. DCmode.  */
1358   x = adjust_address (x, BLKmode, 0);
1359   y = adjust_address (y, BLKmode, 0);
1360
1361   /* Set MEM_SIZE as appropriate for this block copy.  The main place this
1362      can be incorrect is coming from __builtin_memcpy.  */
1363   if (GET_CODE (size) == CONST_INT)
1364     {
1365       if (INTVAL (size) == 0)
1366         return 0;
1367
1368       x = shallow_copy_rtx (x);
1369       y = shallow_copy_rtx (y);
1370       set_mem_size (x, size);
1371       set_mem_size (y, size);
1372     }
1373
1374   if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1375     move_by_pieces (x, y, INTVAL (size), align, 0);
1376   else if (emit_block_move_via_movmem (x, y, size, align))
1377     ;
1378   else if (may_use_call)
1379     retval = emit_block_move_via_libcall (x, y, size);
1380   else
1381     emit_block_move_via_loop (x, y, size, align);
1382
1383   if (method == BLOCK_OP_CALL_PARM)
1384     OK_DEFER_POP;
1385
1386   return retval;
1387 }
1388
1389 /* A subroutine of emit_block_move.  Returns true if calling the
1390    block move libcall will not clobber any parameters which may have
1391    already been placed on the stack.  */
1392
1393 static bool
1394 block_move_libcall_safe_for_call_parm (void)
1395 {
1396   /* If arguments are pushed on the stack, then they're safe.  */
1397   if (PUSH_ARGS)
1398     return true;
1399
1400   /* If registers go on the stack anyway, any argument is sure to clobber
1401      an outgoing argument.  */
1402 #if defined (REG_PARM_STACK_SPACE) && defined (OUTGOING_REG_PARM_STACK_SPACE)
1403   {
1404     tree fn = emit_block_move_libcall_fn (false);
1405     (void) fn;
1406     if (REG_PARM_STACK_SPACE (fn) != 0)
1407       return false;
1408   }
1409 #endif
1410
1411   /* If any argument goes in memory, then it might clobber an outgoing
1412      argument.  */
1413   {
1414     CUMULATIVE_ARGS args_so_far;
1415     tree fn, arg;
1416
1417     fn = emit_block_move_libcall_fn (false);
1418     INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (fn), NULL_RTX, 0, 3);
1419
1420     arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
1421     for ( ; arg != void_list_node ; arg = TREE_CHAIN (arg))
1422       {
1423         enum machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
1424         rtx tmp = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
1425         if (!tmp || !REG_P (tmp))
1426           return false;
1427         if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode,
1428                                         NULL_TREE, 1))
1429           return false;
1430         FUNCTION_ARG_ADVANCE (args_so_far, mode, NULL_TREE, 1);
1431       }
1432   }
1433   return true;
1434 }
1435
1436 /* A subroutine of emit_block_move.  Expand a movmem pattern;
1437    return true if successful.  */
1438
1439 static bool
1440 emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align)
1441 {
1442   rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1443   int save_volatile_ok = volatile_ok;
1444   enum machine_mode mode;
1445
1446   /* Since this is a move insn, we don't care about volatility.  */
1447   volatile_ok = 1;
1448
1449   /* Try the most limited insn first, because there's no point
1450      including more than one in the machine description unless
1451      the more limited one has some advantage.  */
1452
1453   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1454        mode = GET_MODE_WIDER_MODE (mode))
1455     {
1456       enum insn_code code = movmem_optab[(int) mode];
1457       insn_operand_predicate_fn pred;
1458
1459       if (code != CODE_FOR_nothing
1460           /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1461              here because if SIZE is less than the mode mask, as it is
1462              returned by the macro, it will definitely be less than the
1463              actual mode mask.  */
1464           && ((GET_CODE (size) == CONST_INT
1465                && ((unsigned HOST_WIDE_INT) INTVAL (size)
1466                    <= (GET_MODE_MASK (mode) >> 1)))
1467               || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1468           && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1469               || (*pred) (x, BLKmode))
1470           && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1471               || (*pred) (y, BLKmode))
1472           && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1473               || (*pred) (opalign, VOIDmode)))
1474         {
1475           rtx op2;
1476           rtx last = get_last_insn ();
1477           rtx pat;
1478
1479           op2 = convert_to_mode (mode, size, 1);
1480           pred = insn_data[(int) code].operand[2].predicate;
1481           if (pred != 0 && ! (*pred) (op2, mode))
1482             op2 = copy_to_mode_reg (mode, op2);
1483
1484           /* ??? When called via emit_block_move_for_call, it'd be
1485              nice if there were some way to inform the backend, so
1486              that it doesn't fail the expansion because it thinks
1487              emitting the libcall would be more efficient.  */
1488
1489           pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1490           if (pat)
1491             {
1492               emit_insn (pat);
1493               volatile_ok = save_volatile_ok;
1494               return true;
1495             }
1496           else
1497             delete_insns_since (last);
1498         }
1499     }
1500
1501   volatile_ok = save_volatile_ok;
1502   return false;
1503 }
1504
1505 /* A subroutine of emit_block_move.  Expand a call to memcpy.
1506    Return the return value from memcpy, 0 otherwise.  */
1507
1508 static rtx
1509 emit_block_move_via_libcall (rtx dst, rtx src, rtx size)
1510 {
1511   rtx dst_addr, src_addr;
1512   tree call_expr, arg_list, fn, src_tree, dst_tree, size_tree;
1513   enum machine_mode size_mode;
1514   rtx retval;
1515
1516   /* DST, SRC, or SIZE may have been passed through protect_from_queue.
1517
1518      It is unsafe to save the value generated by protect_from_queue and reuse
1519      it later.  Consider what happens if emit_queue is called before the
1520      return value from protect_from_queue is used.
1521
1522      Expansion of the CALL_EXPR below will call emit_queue before we are
1523      finished emitting RTL for argument setup.  So if we are not careful we
1524      could get the wrong value for an argument.
1525
1526      To avoid this problem we go ahead and emit code to copy the addresses of
1527      DST and SRC and SIZE into new pseudos.
1528
1529      Note this is not strictly needed for library calls since they do not call
1530      emit_queue before loading their arguments.  However, we may need to have
1531      library calls call emit_queue in the future since failing to do so could
1532      cause problems for targets which define SMALL_REGISTER_CLASSES and pass
1533      arguments in registers.  */
1534
1535   dst_addr = copy_to_mode_reg (Pmode, XEXP (dst, 0));
1536   src_addr = copy_to_mode_reg (Pmode, XEXP (src, 0));
1537
1538   dst_addr = convert_memory_address (ptr_mode, dst_addr);
1539   src_addr = convert_memory_address (ptr_mode, src_addr);
1540
1541   dst_tree = make_tree (ptr_type_node, dst_addr);
1542   src_tree = make_tree (ptr_type_node, src_addr);
1543
1544   size_mode = TYPE_MODE (sizetype);
1545
1546   size = convert_to_mode (size_mode, size, 1);
1547   size = copy_to_mode_reg (size_mode, size);
1548
1549   /* It is incorrect to use the libcall calling conventions to call
1550      memcpy in this context.  This could be a user call to memcpy and
1551      the user may wish to examine the return value from memcpy.  For
1552      targets where libcalls and normal calls have different conventions
1553      for returning pointers, we could end up generating incorrect code.  */
1554
1555   size_tree = make_tree (sizetype, size);
1556
1557   fn = emit_block_move_libcall_fn (true);
1558   arg_list = tree_cons (NULL_TREE, size_tree, NULL_TREE);
1559   arg_list = tree_cons (NULL_TREE, src_tree, arg_list);
1560   arg_list = tree_cons (NULL_TREE, dst_tree, arg_list);
1561
1562   /* Now we have to build up the CALL_EXPR itself.  */
1563   call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1564   call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1565                      call_expr, arg_list, NULL_TREE);
1566
1567   retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
1568
1569   /* If we are initializing a readonly value, show the above call clobbered
1570      it. Otherwise, a load from it may erroneously be hoisted from a loop, or
1571      the delay slot scheduler might overlook conflicts and take nasty
1572      decisions.  */
1573   if (RTX_UNCHANGING_P (dst))
1574     add_function_usage_to
1575       (last_call_insn (), gen_rtx_EXPR_LIST (VOIDmode,
1576                                              gen_rtx_CLOBBER (VOIDmode, dst),
1577                                              NULL_RTX));
1578
1579   return retval;
1580 }
1581
1582 /* A subroutine of emit_block_move_via_libcall.  Create the tree node
1583    for the function we use for block copies.  The first time FOR_CALL
1584    is true, we call assemble_external.  */
1585
1586 static GTY(()) tree block_move_fn;
1587
1588 void
1589 init_block_move_fn (const char *asmspec)
1590 {
1591   if (!block_move_fn)
1592     {
1593       tree args, fn;
1594
1595       fn = get_identifier ("memcpy");
1596       args = build_function_type_list (ptr_type_node, ptr_type_node,
1597                                        const_ptr_type_node, sizetype,
1598                                        NULL_TREE);
1599
1600       fn = build_decl (FUNCTION_DECL, fn, args);
1601       DECL_EXTERNAL (fn) = 1;
1602       TREE_PUBLIC (fn) = 1;
1603       DECL_ARTIFICIAL (fn) = 1;
1604       TREE_NOTHROW (fn) = 1;
1605
1606       block_move_fn = fn;
1607     }
1608
1609   if (asmspec)
1610     {
1611       SET_DECL_RTL (block_move_fn, NULL_RTX);
1612       SET_DECL_ASSEMBLER_NAME (block_move_fn, get_identifier (asmspec));
1613     }
1614 }
1615
1616 static tree
1617 emit_block_move_libcall_fn (int for_call)
1618 {
1619   static bool emitted_extern;
1620
1621   if (!block_move_fn)
1622     init_block_move_fn (NULL);
1623
1624   if (for_call && !emitted_extern)
1625     {
1626       emitted_extern = true;
1627       make_decl_rtl (block_move_fn, NULL);
1628       assemble_external (block_move_fn);
1629     }
1630
1631   return block_move_fn;
1632 }
1633
1634 /* A subroutine of emit_block_move.  Copy the data via an explicit
1635    loop.  This is used only when libcalls are forbidden.  */
1636 /* ??? It'd be nice to copy in hunks larger than QImode.  */
1637
1638 static void
1639 emit_block_move_via_loop (rtx x, rtx y, rtx size,
1640                           unsigned int align ATTRIBUTE_UNUSED)
1641 {
1642   rtx cmp_label, top_label, iter, x_addr, y_addr, tmp;
1643   enum machine_mode iter_mode;
1644
1645   iter_mode = GET_MODE (size);
1646   if (iter_mode == VOIDmode)
1647     iter_mode = word_mode;
1648
1649   top_label = gen_label_rtx ();
1650   cmp_label = gen_label_rtx ();
1651   iter = gen_reg_rtx (iter_mode);
1652
1653   emit_move_insn (iter, const0_rtx);
1654
1655   x_addr = force_operand (XEXP (x, 0), NULL_RTX);
1656   y_addr = force_operand (XEXP (y, 0), NULL_RTX);
1657   do_pending_stack_adjust ();
1658
1659   emit_jump (cmp_label);
1660   emit_label (top_label);
1661
1662   tmp = convert_modes (Pmode, iter_mode, iter, true);
1663   x_addr = gen_rtx_PLUS (Pmode, x_addr, tmp);
1664   y_addr = gen_rtx_PLUS (Pmode, y_addr, tmp);
1665   x = change_address (x, QImode, x_addr);
1666   y = change_address (y, QImode, y_addr);
1667
1668   emit_move_insn (x, y);
1669
1670   tmp = expand_simple_binop (iter_mode, PLUS, iter, const1_rtx, iter,
1671                              true, OPTAB_LIB_WIDEN);
1672   if (tmp != iter)
1673     emit_move_insn (iter, tmp);
1674
1675   emit_label (cmp_label);
1676
1677   emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
1678                            true, top_label);
1679 }
1680 \f
1681 /* Copy all or part of a value X into registers starting at REGNO.
1682    The number of registers to be filled is NREGS.  */
1683
1684 void
1685 move_block_to_reg (int regno, rtx x, int nregs, enum machine_mode mode)
1686 {
1687   int i;
1688 #ifdef HAVE_load_multiple
1689   rtx pat;
1690   rtx last;
1691 #endif
1692
1693   if (nregs == 0)
1694     return;
1695
1696   if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1697     x = validize_mem (force_const_mem (mode, x));
1698
1699   /* See if the machine can do this with a load multiple insn.  */
1700 #ifdef HAVE_load_multiple
1701   if (HAVE_load_multiple)
1702     {
1703       last = get_last_insn ();
1704       pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1705                                GEN_INT (nregs));
1706       if (pat)
1707         {
1708           emit_insn (pat);
1709           return;
1710         }
1711       else
1712         delete_insns_since (last);
1713     }
1714 #endif
1715
1716   for (i = 0; i < nregs; i++)
1717     emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1718                     operand_subword_force (x, i, mode));
1719 }
1720
1721 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1722    The number of registers to be filled is NREGS.  */
1723
1724 void
1725 move_block_from_reg (int regno, rtx x, int nregs)
1726 {
1727   int i;
1728
1729   if (nregs == 0)
1730     return;
1731
1732   /* See if the machine can do this with a store multiple insn.  */
1733 #ifdef HAVE_store_multiple
1734   if (HAVE_store_multiple)
1735     {
1736       rtx last = get_last_insn ();
1737       rtx pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1738                                     GEN_INT (nregs));
1739       if (pat)
1740         {
1741           emit_insn (pat);
1742           return;
1743         }
1744       else
1745         delete_insns_since (last);
1746     }
1747 #endif
1748
1749   for (i = 0; i < nregs; i++)
1750     {
1751       rtx tem = operand_subword (x, i, 1, BLKmode);
1752
1753       if (tem == 0)
1754         abort ();
1755
1756       emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1757     }
1758 }
1759
1760 /* Generate a PARALLEL rtx for a new non-consecutive group of registers from
1761    ORIG, where ORIG is a non-consecutive group of registers represented by
1762    a PARALLEL.  The clone is identical to the original except in that the
1763    original set of registers is replaced by a new set of pseudo registers.
1764    The new set has the same modes as the original set.  */
1765
1766 rtx
1767 gen_group_rtx (rtx orig)
1768 {
1769   int i, length;
1770   rtx *tmps;
1771
1772   if (GET_CODE (orig) != PARALLEL)
1773     abort ();
1774
1775   length = XVECLEN (orig, 0);
1776   tmps = alloca (sizeof (rtx) * length);
1777
1778   /* Skip a NULL entry in first slot.  */
1779   i = XEXP (XVECEXP (orig, 0, 0), 0) ? 0 : 1;
1780
1781   if (i)
1782     tmps[0] = 0;
1783
1784   for (; i < length; i++)
1785     {
1786       enum machine_mode mode = GET_MODE (XEXP (XVECEXP (orig, 0, i), 0));
1787       rtx offset = XEXP (XVECEXP (orig, 0, i), 1);
1788
1789       tmps[i] = gen_rtx_EXPR_LIST (VOIDmode, gen_reg_rtx (mode), offset);
1790     }
1791
1792   return gen_rtx_PARALLEL (GET_MODE (orig), gen_rtvec_v (length, tmps));
1793 }
1794
1795 /* Emit code to move a block ORIG_SRC of type TYPE to a block DST,
1796    where DST is non-consecutive registers represented by a PARALLEL.
1797    SSIZE represents the total size of block ORIG_SRC in bytes, or -1
1798    if not known.  */
1799
1800 void
1801 emit_group_load (rtx dst, rtx orig_src, tree type ATTRIBUTE_UNUSED, int ssize)
1802 {
1803   rtx *tmps, src;
1804   int start, i;
1805
1806   if (GET_CODE (dst) != PARALLEL)
1807     abort ();
1808
1809   /* Check for a NULL entry, used to indicate that the parameter goes
1810      both on the stack and in registers.  */
1811   if (XEXP (XVECEXP (dst, 0, 0), 0))
1812     start = 0;
1813   else
1814     start = 1;
1815
1816   tmps = alloca (sizeof (rtx) * XVECLEN (dst, 0));
1817
1818   /* Process the pieces.  */
1819   for (i = start; i < XVECLEN (dst, 0); i++)
1820     {
1821       enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1822       HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1823       unsigned int bytelen = GET_MODE_SIZE (mode);
1824       int shift = 0;
1825
1826       /* Handle trailing fragments that run over the size of the struct.  */
1827       if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1828         {
1829           /* Arrange to shift the fragment to where it belongs.
1830              extract_bit_field loads to the lsb of the reg.  */
1831           if (
1832 #ifdef BLOCK_REG_PADDING
1833               BLOCK_REG_PADDING (GET_MODE (orig_src), type, i == start)
1834               == (BYTES_BIG_ENDIAN ? upward : downward)
1835 #else
1836               BYTES_BIG_ENDIAN
1837 #endif
1838               )
1839             shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1840           bytelen = ssize - bytepos;
1841           if (bytelen <= 0)
1842             abort ();
1843         }
1844
1845       /* If we won't be loading directly from memory, protect the real source
1846          from strange tricks we might play; but make sure that the source can
1847          be loaded directly into the destination.  */
1848       src = orig_src;
1849       if (!MEM_P (orig_src)
1850           && (!CONSTANT_P (orig_src)
1851               || (GET_MODE (orig_src) != mode
1852                   && GET_MODE (orig_src) != VOIDmode)))
1853         {
1854           if (GET_MODE (orig_src) == VOIDmode)
1855             src = gen_reg_rtx (mode);
1856           else
1857             src = gen_reg_rtx (GET_MODE (orig_src));
1858
1859           emit_move_insn (src, orig_src);
1860         }
1861
1862       /* Optimize the access just a bit.  */
1863       if (MEM_P (src)
1864           && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (src))
1865               || MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode))
1866           && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1867           && bytelen == GET_MODE_SIZE (mode))
1868         {
1869           tmps[i] = gen_reg_rtx (mode);
1870           emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
1871         }
1872       else if (GET_CODE (src) == CONCAT)
1873         {
1874           unsigned int slen = GET_MODE_SIZE (GET_MODE (src));
1875           unsigned int slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
1876
1877           if ((bytepos == 0 && bytelen == slen0)
1878               || (bytepos != 0 && bytepos + bytelen <= slen))
1879             {
1880               /* The following assumes that the concatenated objects all
1881                  have the same size.  In this case, a simple calculation
1882                  can be used to determine the object and the bit field
1883                  to be extracted.  */
1884               tmps[i] = XEXP (src, bytepos / slen0);
1885               if (! CONSTANT_P (tmps[i])
1886                   && (!REG_P (tmps[i]) || GET_MODE (tmps[i]) != mode))
1887                 tmps[i] = extract_bit_field (tmps[i], bytelen * BITS_PER_UNIT,
1888                                              (bytepos % slen0) * BITS_PER_UNIT,
1889                                              1, NULL_RTX, mode, mode);
1890             }
1891           else if (bytepos == 0)
1892             {
1893               rtx mem = assign_stack_temp (GET_MODE (src), slen, 0);
1894               emit_move_insn (mem, src);
1895               tmps[i] = adjust_address (mem, mode, 0);
1896             }
1897           else
1898             abort ();
1899         }
1900       /* FIXME: A SIMD parallel will eventually lead to a subreg of a
1901          SIMD register, which is currently broken.  While we get GCC
1902          to emit proper RTL for these cases, let's dump to memory.  */
1903       else if (VECTOR_MODE_P (GET_MODE (dst))
1904                && REG_P (src))
1905         {
1906           int slen = GET_MODE_SIZE (GET_MODE (src));
1907           rtx mem;
1908
1909           mem = assign_stack_temp (GET_MODE (src), slen, 0);
1910           emit_move_insn (mem, src);
1911           tmps[i] = adjust_address (mem, mode, (int) bytepos);
1912         }
1913       else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
1914                && XVECLEN (dst, 0) > 1)
1915         tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos);
1916       else if (CONSTANT_P (src)
1917                || (REG_P (src) && GET_MODE (src) == mode))
1918         tmps[i] = src;
1919       else
1920         tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
1921                                      bytepos * BITS_PER_UNIT, 1, NULL_RTX,
1922                                      mode, mode);
1923
1924       if (shift)
1925         tmps[i] = expand_shift (LSHIFT_EXPR, mode, tmps[i],
1926                                 build_int_2 (shift, 0), tmps[i], 0);
1927     }
1928
1929   emit_queue ();
1930
1931   /* Copy the extracted pieces into the proper (probable) hard regs.  */
1932   for (i = start; i < XVECLEN (dst, 0); i++)
1933     emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0), tmps[i]);
1934 }
1935
1936 /* Emit code to move a block SRC to block DST, where SRC and DST are
1937    non-consecutive groups of registers, each represented by a PARALLEL.  */
1938
1939 void
1940 emit_group_move (rtx dst, rtx src)
1941 {
1942   int i;
1943
1944   if (GET_CODE (src) != PARALLEL
1945       || GET_CODE (dst) != PARALLEL
1946       || XVECLEN (src, 0) != XVECLEN (dst, 0))
1947     abort ();
1948
1949   /* Skip first entry if NULL.  */
1950   for (i = XEXP (XVECEXP (src, 0, 0), 0) ? 0 : 1; i < XVECLEN (src, 0); i++)
1951     emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0),
1952                     XEXP (XVECEXP (src, 0, i), 0));
1953 }
1954
1955 /* Emit code to move a block SRC to a block ORIG_DST of type TYPE,
1956    where SRC is non-consecutive registers represented by a PARALLEL.
1957    SSIZE represents the total size of block ORIG_DST, or -1 if not
1958    known.  */
1959
1960 void
1961 emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
1962 {
1963   rtx *tmps, dst;
1964   int start, i;
1965
1966   if (GET_CODE (src) != PARALLEL)
1967     abort ();
1968
1969   /* Check for a NULL entry, used to indicate that the parameter goes
1970      both on the stack and in registers.  */
1971   if (XEXP (XVECEXP (src, 0, 0), 0))
1972     start = 0;
1973   else
1974     start = 1;
1975
1976   tmps = alloca (sizeof (rtx) * XVECLEN (src, 0));
1977
1978   /* Copy the (probable) hard regs into pseudos.  */
1979   for (i = start; i < XVECLEN (src, 0); i++)
1980     {
1981       rtx reg = XEXP (XVECEXP (src, 0, i), 0);
1982       tmps[i] = gen_reg_rtx (GET_MODE (reg));
1983       emit_move_insn (tmps[i], reg);
1984     }
1985   emit_queue ();
1986
1987   /* If we won't be storing directly into memory, protect the real destination
1988      from strange tricks we might play.  */
1989   dst = orig_dst;
1990   if (GET_CODE (dst) == PARALLEL)
1991     {
1992       rtx temp;
1993
1994       /* We can get a PARALLEL dst if there is a conditional expression in
1995          a return statement.  In that case, the dst and src are the same,
1996          so no action is necessary.  */
1997       if (rtx_equal_p (dst, src))
1998         return;
1999
2000       /* It is unclear if we can ever reach here, but we may as well handle
2001          it.  Allocate a temporary, and split this into a store/load to/from
2002          the temporary.  */
2003
2004       temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
2005       emit_group_store (temp, src, type, ssize);
2006       emit_group_load (dst, temp, type, ssize);
2007       return;
2008     }
2009   else if (!MEM_P (dst) && GET_CODE (dst) != CONCAT)
2010     {
2011       dst = gen_reg_rtx (GET_MODE (orig_dst));
2012       /* Make life a bit easier for combine.  */
2013       emit_move_insn (dst, CONST0_RTX (GET_MODE (orig_dst)));
2014     }
2015
2016   /* Process the pieces.  */
2017   for (i = start; i < XVECLEN (src, 0); i++)
2018     {
2019       HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
2020       enum machine_mode mode = GET_MODE (tmps[i]);
2021       unsigned int bytelen = GET_MODE_SIZE (mode);
2022       rtx dest = dst;
2023
2024       /* Handle trailing fragments that run over the size of the struct.  */
2025       if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2026         {
2027           /* store_bit_field always takes its value from the lsb.
2028              Move the fragment to the lsb if it's not already there.  */
2029           if (
2030 #ifdef BLOCK_REG_PADDING
2031               BLOCK_REG_PADDING (GET_MODE (orig_dst), type, i == start)
2032               == (BYTES_BIG_ENDIAN ? upward : downward)
2033 #else
2034               BYTES_BIG_ENDIAN
2035 #endif
2036               )
2037             {
2038               int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2039               tmps[i] = expand_shift (RSHIFT_EXPR, mode, tmps[i],
2040                                       build_int_2 (shift, 0), tmps[i], 0);
2041             }
2042           bytelen = ssize - bytepos;
2043         }
2044
2045       if (GET_CODE (dst) == CONCAT)
2046         {
2047           if (bytepos + bytelen <= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2048             dest = XEXP (dst, 0);
2049           else if (bytepos >= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2050             {
2051               bytepos -= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)));
2052               dest = XEXP (dst, 1);
2053             }
2054           else if (bytepos == 0 && XVECLEN (src, 0))
2055             {
2056               dest = assign_stack_temp (GET_MODE (dest),
2057                                         GET_MODE_SIZE (GET_MODE (dest)), 0);
2058               emit_move_insn (adjust_address (dest, GET_MODE (tmps[i]), bytepos),
2059                               tmps[i]);
2060               dst = dest;
2061               break;
2062             }
2063           else
2064             abort ();
2065         }
2066
2067       /* Optimize the access just a bit.  */
2068       if (MEM_P (dest)
2069           && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (dest))
2070               || MEM_ALIGN (dest) >= GET_MODE_ALIGNMENT (mode))
2071           && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2072           && bytelen == GET_MODE_SIZE (mode))
2073         emit_move_insn (adjust_address (dest, mode, bytepos), tmps[i]);
2074       else
2075         store_bit_field (dest, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2076                          mode, tmps[i]);
2077     }
2078
2079   emit_queue ();
2080
2081   /* Copy from the pseudo into the (probable) hard reg.  */
2082   if (orig_dst != dst)
2083     emit_move_insn (orig_dst, dst);
2084 }
2085
2086 /* Generate code to copy a BLKmode object of TYPE out of a
2087    set of registers starting with SRCREG into TGTBLK.  If TGTBLK
2088    is null, a stack temporary is created.  TGTBLK is returned.
2089
2090    The purpose of this routine is to handle functions that return
2091    BLKmode structures in registers.  Some machines (the PA for example)
2092    want to return all small structures in registers regardless of the
2093    structure's alignment.  */
2094
2095 rtx
2096 copy_blkmode_from_reg (rtx tgtblk, rtx srcreg, tree type)
2097 {
2098   unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2099   rtx src = NULL, dst = NULL;
2100   unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2101   unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0;
2102
2103   if (tgtblk == 0)
2104     {
2105       tgtblk = assign_temp (build_qualified_type (type,
2106                                                   (TYPE_QUALS (type)
2107                                                    | TYPE_QUAL_CONST)),
2108                             0, 1, 1);
2109       preserve_temp_slots (tgtblk);
2110     }
2111
2112   /* This code assumes srcreg is at least a full word.  If it isn't, copy it
2113      into a new pseudo which is a full word.  */
2114
2115   if (GET_MODE (srcreg) != BLKmode
2116       && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2117     srcreg = convert_to_mode (word_mode, srcreg, TYPE_UNSIGNED (type));
2118
2119   /* If the structure doesn't take up a whole number of words, see whether
2120      SRCREG is padded on the left or on the right.  If it's on the left,
2121      set PADDING_CORRECTION to the number of bits to skip.
2122
2123      In most ABIs, the structure will be returned at the least end of
2124      the register, which translates to right padding on little-endian
2125      targets and left padding on big-endian targets.  The opposite
2126      holds if the structure is returned at the most significant
2127      end of the register.  */
2128   if (bytes % UNITS_PER_WORD != 0
2129       && (targetm.calls.return_in_msb (type)
2130           ? !BYTES_BIG_ENDIAN
2131           : BYTES_BIG_ENDIAN))
2132     padding_correction
2133       = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2134
2135   /* Copy the structure BITSIZE bites at a time.
2136
2137      We could probably emit more efficient code for machines which do not use
2138      strict alignment, but it doesn't seem worth the effort at the current
2139      time.  */
2140   for (bitpos = 0, xbitpos = padding_correction;
2141        bitpos < bytes * BITS_PER_UNIT;
2142        bitpos += bitsize, xbitpos += bitsize)
2143     {
2144       /* We need a new source operand each time xbitpos is on a
2145          word boundary and when xbitpos == padding_correction
2146          (the first time through).  */
2147       if (xbitpos % BITS_PER_WORD == 0
2148           || xbitpos == padding_correction)
2149         src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2150                                      GET_MODE (srcreg));
2151
2152       /* We need a new destination operand each time bitpos is on
2153          a word boundary.  */
2154       if (bitpos % BITS_PER_WORD == 0)
2155         dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2156
2157       /* Use xbitpos for the source extraction (right justified) and
2158          xbitpos for the destination store (left justified).  */
2159       store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2160                        extract_bit_field (src, bitsize,
2161                                           xbitpos % BITS_PER_WORD, 1,
2162                                           NULL_RTX, word_mode, word_mode));
2163     }
2164
2165   return tgtblk;
2166 }
2167
2168 /* Add a USE expression for REG to the (possibly empty) list pointed
2169    to by CALL_FUSAGE.  REG must denote a hard register.  */
2170
2171 void
2172 use_reg (rtx *call_fusage, rtx reg)
2173 {
2174   if (!REG_P (reg)
2175       || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
2176     abort ();
2177
2178   *call_fusage
2179     = gen_rtx_EXPR_LIST (VOIDmode,
2180                          gen_rtx_USE (VOIDmode, reg), *call_fusage);
2181 }
2182
2183 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2184    starting at REGNO.  All of these registers must be hard registers.  */
2185
2186 void
2187 use_regs (rtx *call_fusage, int regno, int nregs)
2188 {
2189   int i;
2190
2191   if (regno + nregs > FIRST_PSEUDO_REGISTER)
2192     abort ();
2193
2194   for (i = 0; i < nregs; i++)
2195     use_reg (call_fusage, regno_reg_rtx[regno + i]);
2196 }
2197
2198 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2199    PARALLEL REGS.  This is for calls that pass values in multiple
2200    non-contiguous locations.  The Irix 6 ABI has examples of this.  */
2201
2202 void
2203 use_group_regs (rtx *call_fusage, rtx regs)
2204 {
2205   int i;
2206
2207   for (i = 0; i < XVECLEN (regs, 0); i++)
2208     {
2209       rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2210
2211       /* A NULL entry means the parameter goes both on the stack and in
2212          registers.  This can also be a MEM for targets that pass values
2213          partially on the stack and partially in registers.  */
2214       if (reg != 0 && REG_P (reg))
2215         use_reg (call_fusage, reg);
2216     }
2217 }
2218 \f
2219
2220 /* Determine whether the LEN bytes generated by CONSTFUN can be
2221    stored to memory using several move instructions.  CONSTFUNDATA is
2222    a pointer which will be passed as argument in every CONSTFUN call.
2223    ALIGN is maximum alignment we can assume.  Return nonzero if a
2224    call to store_by_pieces should succeed.  */
2225
2226 int
2227 can_store_by_pieces (unsigned HOST_WIDE_INT len,
2228                      rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2229                      void *constfundata, unsigned int align)
2230 {
2231   unsigned HOST_WIDE_INT max_size, l;
2232   HOST_WIDE_INT offset = 0;
2233   enum machine_mode mode, tmode;
2234   enum insn_code icode;
2235   int reverse;
2236   rtx cst;
2237
2238   if (len == 0)
2239     return 1;
2240
2241   if (! STORE_BY_PIECES_P (len, align))
2242     return 0;
2243
2244   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2245       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2246     align = MOVE_MAX * BITS_PER_UNIT;
2247
2248   /* We would first store what we can in the largest integer mode, then go to
2249      successively smaller modes.  */
2250
2251   for (reverse = 0;
2252        reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2253        reverse++)
2254     {
2255       l = len;
2256       mode = VOIDmode;
2257       max_size = STORE_MAX_PIECES + 1;
2258       while (max_size > 1)
2259         {
2260           for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2261                tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2262             if (GET_MODE_SIZE (tmode) < max_size)
2263               mode = tmode;
2264
2265           if (mode == VOIDmode)
2266             break;
2267
2268           icode = mov_optab->handlers[(int) mode].insn_code;
2269           if (icode != CODE_FOR_nothing
2270               && align >= GET_MODE_ALIGNMENT (mode))
2271             {
2272               unsigned int size = GET_MODE_SIZE (mode);
2273
2274               while (l >= size)
2275                 {
2276                   if (reverse)
2277                     offset -= size;
2278
2279                   cst = (*constfun) (constfundata, offset, mode);
2280                   if (!LEGITIMATE_CONSTANT_P (cst))
2281                     return 0;
2282
2283                   if (!reverse)
2284                     offset += size;
2285
2286                   l -= size;
2287                 }
2288             }
2289
2290           max_size = GET_MODE_SIZE (mode);
2291         }
2292
2293       /* The code above should have handled everything.  */
2294       if (l != 0)
2295         abort ();
2296     }
2297
2298   return 1;
2299 }
2300
2301 /* Generate several move instructions to store LEN bytes generated by
2302    CONSTFUN to block TO.  (A MEM rtx with BLKmode).  CONSTFUNDATA is a
2303    pointer which will be passed as argument in every CONSTFUN call.
2304    ALIGN is maximum alignment we can assume.
2305    If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
2306    mempcpy, and if ENDP is 2 return memory the end minus one byte ala
2307    stpcpy.  */
2308
2309 rtx
2310 store_by_pieces (rtx to, unsigned HOST_WIDE_INT len,
2311                  rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2312                  void *constfundata, unsigned int align, int endp)
2313 {
2314   struct store_by_pieces data;
2315
2316   if (len == 0)
2317     {
2318       if (endp == 2)
2319         abort ();
2320       return to;
2321     }
2322
2323   if (! STORE_BY_PIECES_P (len, align))
2324     abort ();
2325   to = protect_from_queue (to, 1);
2326   data.constfun = constfun;
2327   data.constfundata = constfundata;
2328   data.len = len;
2329   data.to = to;
2330   store_by_pieces_1 (&data, align);
2331   if (endp)
2332     {
2333       rtx to1;
2334
2335       if (data.reverse)
2336         abort ();
2337       if (data.autinc_to)
2338         {
2339           if (endp == 2)
2340             {
2341               if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
2342                 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
2343               else
2344                 data.to_addr = copy_addr_to_reg (plus_constant (data.to_addr,
2345                                                                 -1));
2346             }
2347           to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
2348                                            data.offset);
2349         }
2350       else
2351         {
2352           if (endp == 2)
2353             --data.offset;
2354           to1 = adjust_address (data.to, QImode, data.offset);
2355         }
2356       return to1;
2357     }
2358   else
2359     return data.to;
2360 }
2361
2362 /* Generate several move instructions to clear LEN bytes of block TO.  (A MEM
2363    rtx with BLKmode).  The caller must pass TO through protect_from_queue
2364    before calling. ALIGN is maximum alignment we can assume.  */
2365
2366 static void
2367 clear_by_pieces (rtx to, unsigned HOST_WIDE_INT len, unsigned int align)
2368 {
2369   struct store_by_pieces data;
2370
2371   if (len == 0)
2372     return;
2373
2374   data.constfun = clear_by_pieces_1;
2375   data.constfundata = NULL;
2376   data.len = len;
2377   data.to = to;
2378   store_by_pieces_1 (&data, align);
2379 }
2380
2381 /* Callback routine for clear_by_pieces.
2382    Return const0_rtx unconditionally.  */
2383
2384 static rtx
2385 clear_by_pieces_1 (void *data ATTRIBUTE_UNUSED,
2386                    HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2387                    enum machine_mode mode ATTRIBUTE_UNUSED)
2388 {
2389   return const0_rtx;
2390 }
2391
2392 /* Subroutine of clear_by_pieces and store_by_pieces.
2393    Generate several move instructions to store LEN bytes of block TO.  (A MEM
2394    rtx with BLKmode).  The caller must pass TO through protect_from_queue
2395    before calling.  ALIGN is maximum alignment we can assume.  */
2396
2397 static void
2398 store_by_pieces_1 (struct store_by_pieces *data ATTRIBUTE_UNUSED,
2399                    unsigned int align ATTRIBUTE_UNUSED)
2400 {
2401   rtx to_addr = XEXP (data->to, 0);
2402   unsigned HOST_WIDE_INT max_size = STORE_MAX_PIECES + 1;
2403   enum machine_mode mode = VOIDmode, tmode;
2404   enum insn_code icode;
2405
2406   data->offset = 0;
2407   data->to_addr = to_addr;
2408   data->autinc_to
2409     = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2410        || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2411
2412   data->explicit_inc_to = 0;
2413   data->reverse
2414     = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2415   if (data->reverse)
2416     data->offset = data->len;
2417
2418   /* If storing requires more than two move insns,
2419      copy addresses to registers (to make displacements shorter)
2420      and use post-increment if available.  */
2421   if (!data->autinc_to
2422       && move_by_pieces_ninsns (data->len, align) > 2)
2423     {
2424       /* Determine the main mode we'll be using.  */
2425       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2426            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2427         if (GET_MODE_SIZE (tmode) < max_size)
2428           mode = tmode;
2429
2430       if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2431         {
2432           data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2433           data->autinc_to = 1;
2434           data->explicit_inc_to = -1;
2435         }
2436
2437       if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2438           && ! data->autinc_to)
2439         {
2440           data->to_addr = copy_addr_to_reg (to_addr);
2441           data->autinc_to = 1;
2442           data->explicit_inc_to = 1;
2443         }
2444
2445       if ( !data->autinc_to && CONSTANT_P (to_addr))
2446         data->to_addr = copy_addr_to_reg (to_addr);
2447     }
2448
2449   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2450       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2451     align = MOVE_MAX * BITS_PER_UNIT;
2452
2453   /* First store what we can in the largest integer mode, then go to
2454      successively smaller modes.  */
2455
2456   while (max_size > 1)
2457     {
2458       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2459            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2460         if (GET_MODE_SIZE (tmode) < max_size)
2461           mode = tmode;
2462
2463       if (mode == VOIDmode)
2464         break;
2465
2466       icode = mov_optab->handlers[(int) mode].insn_code;
2467       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2468         store_by_pieces_2 (GEN_FCN (icode), mode, data);
2469
2470       max_size = GET_MODE_SIZE (mode);
2471     }
2472
2473   /* The code above should have handled everything.  */
2474   if (data->len != 0)
2475     abort ();
2476 }
2477
2478 /* Subroutine of store_by_pieces_1.  Store as many bytes as appropriate
2479    with move instructions for mode MODE.  GENFUN is the gen_... function
2480    to make a move insn for that mode.  DATA has all the other info.  */
2481
2482 static void
2483 store_by_pieces_2 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
2484                    struct store_by_pieces *data)
2485 {
2486   unsigned int size = GET_MODE_SIZE (mode);
2487   rtx to1, cst;
2488
2489   while (data->len >= size)
2490     {
2491       if (data->reverse)
2492         data->offset -= size;
2493
2494       if (data->autinc_to)
2495         to1 = adjust_automodify_address (data->to, mode, data->to_addr,
2496                                          data->offset);
2497       else
2498         to1 = adjust_address (data->to, mode, data->offset);
2499
2500       if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2501         emit_insn (gen_add2_insn (data->to_addr,
2502                                   GEN_INT (-(HOST_WIDE_INT) size)));
2503
2504       cst = (*data->constfun) (data->constfundata, data->offset, mode);
2505       emit_insn ((*genfun) (to1, cst));
2506
2507       if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2508         emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2509
2510       if (! data->reverse)
2511         data->offset += size;
2512
2513       data->len -= size;
2514     }
2515 }
2516 \f
2517 /* Write zeros through the storage of OBJECT.  If OBJECT has BLKmode, SIZE is
2518    its length in bytes.  */
2519
2520 rtx
2521 clear_storage (rtx object, rtx size)
2522 {
2523   rtx retval = 0;
2524   unsigned int align = (MEM_P (object) ? MEM_ALIGN (object)
2525                         : GET_MODE_ALIGNMENT (GET_MODE (object)));
2526
2527   /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2528      just move a zero.  Otherwise, do this a piece at a time.  */
2529   if (GET_MODE (object) != BLKmode
2530       && GET_CODE (size) == CONST_INT
2531       && INTVAL (size) == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (object)))
2532     emit_move_insn (object, CONST0_RTX (GET_MODE (object)));
2533   else
2534     {
2535       object = protect_from_queue (object, 1);
2536       size = protect_from_queue (size, 0);
2537
2538       if (size == const0_rtx)
2539         ;
2540       else if (GET_CODE (size) == CONST_INT
2541           && CLEAR_BY_PIECES_P (INTVAL (size), align))
2542         clear_by_pieces (object, INTVAL (size), align);
2543       else if (clear_storage_via_clrmem (object, size, align))
2544         ;
2545       else
2546         retval = clear_storage_via_libcall (object, size);
2547     }
2548
2549   return retval;
2550 }
2551
2552 /* A subroutine of clear_storage.  Expand a clrmem pattern;
2553    return true if successful.  */
2554
2555 static bool
2556 clear_storage_via_clrmem (rtx object, rtx size, unsigned int align)
2557 {
2558   /* Try the most limited insn first, because there's no point
2559      including more than one in the machine description unless
2560      the more limited one has some advantage.  */
2561
2562   rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2563   enum machine_mode mode;
2564
2565   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2566        mode = GET_MODE_WIDER_MODE (mode))
2567     {
2568       enum insn_code code = clrmem_optab[(int) mode];
2569       insn_operand_predicate_fn pred;
2570
2571       if (code != CODE_FOR_nothing
2572           /* We don't need MODE to be narrower than
2573              BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2574              the mode mask, as it is returned by the macro, it will
2575              definitely be less than the actual mode mask.  */
2576           && ((GET_CODE (size) == CONST_INT
2577                && ((unsigned HOST_WIDE_INT) INTVAL (size)
2578                    <= (GET_MODE_MASK (mode) >> 1)))
2579               || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2580           && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2581               || (*pred) (object, BLKmode))
2582           && ((pred = insn_data[(int) code].operand[2].predicate) == 0
2583               || (*pred) (opalign, VOIDmode)))
2584         {
2585           rtx op1;
2586           rtx last = get_last_insn ();
2587           rtx pat;
2588
2589           op1 = convert_to_mode (mode, size, 1);
2590           pred = insn_data[(int) code].operand[1].predicate;
2591           if (pred != 0 && ! (*pred) (op1, mode))
2592             op1 = copy_to_mode_reg (mode, op1);
2593
2594           pat = GEN_FCN ((int) code) (object, op1, opalign);
2595           if (pat)
2596             {
2597               emit_insn (pat);
2598               return true;
2599             }
2600           else
2601             delete_insns_since (last);
2602         }
2603     }
2604
2605   return false;
2606 }
2607
2608 /* A subroutine of clear_storage.  Expand a call to memset.
2609    Return the return value of memset, 0 otherwise.  */
2610
2611 static rtx
2612 clear_storage_via_libcall (rtx object, rtx size)
2613 {
2614   tree call_expr, arg_list, fn, object_tree, size_tree;
2615   enum machine_mode size_mode;
2616   rtx retval;
2617
2618   /* OBJECT or SIZE may have been passed through protect_from_queue.
2619
2620      It is unsafe to save the value generated by protect_from_queue
2621      and reuse it later.  Consider what happens if emit_queue is
2622      called before the return value from protect_from_queue is used.
2623
2624      Expansion of the CALL_EXPR below will call emit_queue before
2625      we are finished emitting RTL for argument setup.  So if we are
2626      not careful we could get the wrong value for an argument.
2627
2628      To avoid this problem we go ahead and emit code to copy OBJECT
2629      and SIZE into new pseudos.
2630
2631      Note this is not strictly needed for library calls since they
2632      do not call emit_queue before loading their arguments.  However,
2633      we may need to have library calls call emit_queue in the future
2634      since failing to do so could cause problems for targets which
2635      define SMALL_REGISTER_CLASSES and pass arguments in registers.  */
2636
2637   object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2638
2639   size_mode = TYPE_MODE (sizetype);
2640   size = convert_to_mode (size_mode, size, 1);
2641   size = copy_to_mode_reg (size_mode, size);
2642
2643   /* It is incorrect to use the libcall calling conventions to call
2644      memset in this context.  This could be a user call to memset and
2645      the user may wish to examine the return value from memset.  For
2646      targets where libcalls and normal calls have different conventions
2647      for returning pointers, we could end up generating incorrect code.  */
2648
2649   object_tree = make_tree (ptr_type_node, object);
2650   size_tree = make_tree (sizetype, size);
2651
2652   fn = clear_storage_libcall_fn (true);
2653   arg_list = tree_cons (NULL_TREE, size_tree, NULL_TREE);
2654   arg_list = tree_cons (NULL_TREE, integer_zero_node, arg_list);
2655   arg_list = tree_cons (NULL_TREE, object_tree, arg_list);
2656
2657   /* Now we have to build up the CALL_EXPR itself.  */
2658   call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2659   call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
2660                      call_expr, arg_list, NULL_TREE);
2661
2662   retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
2663
2664   /* If we are initializing a readonly value, show the above call
2665      clobbered it.  Otherwise, a load from it may erroneously be
2666      hoisted from a loop.  */
2667   if (RTX_UNCHANGING_P (object))
2668     emit_insn (gen_rtx_CLOBBER (VOIDmode, object));
2669
2670   return retval;
2671 }
2672
2673 /* A subroutine of clear_storage_via_libcall.  Create the tree node
2674    for the function we use for block clears.  The first time FOR_CALL
2675    is true, we call assemble_external.  */
2676
2677 static GTY(()) tree block_clear_fn;
2678
2679 void
2680 init_block_clear_fn (const char *asmspec)
2681 {
2682   if (!block_clear_fn)
2683     {
2684       tree fn, args;
2685
2686       fn = get_identifier ("memset");
2687       args = build_function_type_list (ptr_type_node, ptr_type_node,
2688                                        integer_type_node, sizetype,
2689                                        NULL_TREE);
2690
2691       fn = build_decl (FUNCTION_DECL, fn, args);
2692       DECL_EXTERNAL (fn) = 1;
2693       TREE_PUBLIC (fn) = 1;
2694       DECL_ARTIFICIAL (fn) = 1;
2695       TREE_NOTHROW (fn) = 1;
2696
2697       block_clear_fn = fn;
2698     }
2699
2700   if (asmspec)
2701     {
2702       SET_DECL_RTL (block_clear_fn, NULL_RTX);
2703       SET_DECL_ASSEMBLER_NAME (block_clear_fn, get_identifier (asmspec));
2704     }
2705 }
2706
2707 static tree
2708 clear_storage_libcall_fn (int for_call)
2709 {
2710   static bool emitted_extern;
2711
2712   if (!block_clear_fn)
2713     init_block_clear_fn (NULL);
2714
2715   if (for_call && !emitted_extern)
2716     {
2717       emitted_extern = true;
2718       make_decl_rtl (block_clear_fn, NULL);
2719       assemble_external (block_clear_fn);
2720     }
2721
2722   return block_clear_fn;
2723 }
2724 \f
2725 /* Generate code to copy Y into X.
2726    Both Y and X must have the same mode, except that
2727    Y can be a constant with VOIDmode.
2728    This mode cannot be BLKmode; use emit_block_move for that.
2729
2730    Return the last instruction emitted.  */
2731
2732 rtx
2733 emit_move_insn (rtx x, rtx y)
2734 {
2735   enum machine_mode mode = GET_MODE (x);
2736   rtx y_cst = NULL_RTX;
2737   rtx last_insn, set;
2738
2739   x = protect_from_queue (x, 1);
2740   y = protect_from_queue (y, 0);
2741
2742   if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
2743     abort ();
2744
2745   if (CONSTANT_P (y))
2746     {
2747       if (optimize
2748           && SCALAR_FLOAT_MODE_P (GET_MODE (x))
2749           && (last_insn = compress_float_constant (x, y)))
2750         return last_insn;
2751
2752       y_cst = y;
2753
2754       if (!LEGITIMATE_CONSTANT_P (y))
2755         {
2756           y = force_const_mem (mode, y);
2757
2758           /* If the target's cannot_force_const_mem prevented the spill,
2759              assume that the target's move expanders will also take care
2760              of the non-legitimate constant.  */
2761           if (!y)
2762             y = y_cst;
2763         }
2764     }
2765
2766   /* If X or Y are memory references, verify that their addresses are valid
2767      for the machine.  */
2768   if (MEM_P (x)
2769       && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
2770            && ! push_operand (x, GET_MODE (x)))
2771           || (flag_force_addr
2772               && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
2773     x = validize_mem (x);
2774
2775   if (MEM_P (y)
2776       && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
2777           || (flag_force_addr
2778               && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
2779     y = validize_mem (y);
2780
2781   if (mode == BLKmode)
2782     abort ();
2783
2784   last_insn = emit_move_insn_1 (x, y);
2785
2786   if (y_cst && REG_P (x)
2787       && (set = single_set (last_insn)) != NULL_RTX
2788       && SET_DEST (set) == x
2789       && ! rtx_equal_p (y_cst, SET_SRC (set)))
2790     set_unique_reg_note (last_insn, REG_EQUAL, y_cst);
2791
2792   return last_insn;
2793 }
2794
2795 /* Low level part of emit_move_insn.
2796    Called just like emit_move_insn, but assumes X and Y
2797    are basically valid.  */
2798
2799 rtx
2800 emit_move_insn_1 (rtx x, rtx y)
2801 {
2802   enum machine_mode mode = GET_MODE (x);
2803   enum machine_mode submode;
2804   enum mode_class class = GET_MODE_CLASS (mode);
2805
2806   if ((unsigned int) mode >= (unsigned int) MAX_MACHINE_MODE)
2807     abort ();
2808
2809   if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2810     return
2811       emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
2812
2813   /* Expand complex moves by moving real part and imag part, if possible.  */
2814   else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2815            && BLKmode != (submode = GET_MODE_INNER (mode))
2816            && (mov_optab->handlers[(int) submode].insn_code
2817                != CODE_FOR_nothing))
2818     {
2819       /* Don't split destination if it is a stack push.  */
2820       int stack = push_operand (x, GET_MODE (x));
2821
2822 #ifdef PUSH_ROUNDING
2823       /* In case we output to the stack, but the size is smaller than the
2824          machine can push exactly, we need to use move instructions.  */
2825       if (stack
2826           && (PUSH_ROUNDING (GET_MODE_SIZE (submode))
2827               != GET_MODE_SIZE (submode)))
2828         {
2829           rtx temp;
2830           HOST_WIDE_INT offset1, offset2;
2831
2832           /* Do not use anti_adjust_stack, since we don't want to update
2833              stack_pointer_delta.  */
2834           temp = expand_binop (Pmode,
2835 #ifdef STACK_GROWS_DOWNWARD
2836                                sub_optab,
2837 #else
2838                                add_optab,
2839 #endif
2840                                stack_pointer_rtx,
2841                                GEN_INT
2842                                  (PUSH_ROUNDING
2843                                   (GET_MODE_SIZE (GET_MODE (x)))),
2844                                stack_pointer_rtx, 0, OPTAB_LIB_WIDEN);
2845
2846           if (temp != stack_pointer_rtx)
2847             emit_move_insn (stack_pointer_rtx, temp);
2848
2849 #ifdef STACK_GROWS_DOWNWARD
2850           offset1 = 0;
2851           offset2 = GET_MODE_SIZE (submode);
2852 #else
2853           offset1 = -PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)));
2854           offset2 = (-PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))
2855                      + GET_MODE_SIZE (submode));
2856 #endif
2857
2858           emit_move_insn (change_address (x, submode,
2859                                           gen_rtx_PLUS (Pmode,
2860                                                         stack_pointer_rtx,
2861                                                         GEN_INT (offset1))),
2862                           gen_realpart (submode, y));
2863           emit_move_insn (change_address (x, submode,
2864                                           gen_rtx_PLUS (Pmode,
2865                                                         stack_pointer_rtx,
2866                                                         GEN_INT (offset2))),
2867                           gen_imagpart (submode, y));
2868         }
2869       else
2870 #endif
2871       /* If this is a stack, push the highpart first, so it
2872          will be in the argument order.
2873
2874          In that case, change_address is used only to convert
2875          the mode, not to change the address.  */
2876       if (stack)
2877         {
2878           /* Note that the real part always precedes the imag part in memory
2879              regardless of machine's endianness.  */
2880 #ifdef STACK_GROWS_DOWNWARD
2881           emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
2882                           gen_imagpart (submode, y));
2883           emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
2884                           gen_realpart (submode, y));
2885 #else
2886           emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
2887                           gen_realpart (submode, y));
2888           emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
2889                           gen_imagpart (submode, y));
2890 #endif
2891         }
2892       else
2893         {
2894           rtx realpart_x, realpart_y;
2895           rtx imagpart_x, imagpart_y;
2896
2897           /* If this is a complex value with each part being smaller than a
2898              word, the usual calling sequence will likely pack the pieces into
2899              a single register.  Unfortunately, SUBREG of hard registers only
2900              deals in terms of words, so we have a problem converting input
2901              arguments to the CONCAT of two registers that is used elsewhere
2902              for complex values.  If this is before reload, we can copy it into
2903              memory and reload.  FIXME, we should see about using extract and
2904              insert on integer registers, but complex short and complex char
2905              variables should be rarely used.  */
2906           if (GET_MODE_BITSIZE (mode) < 2 * BITS_PER_WORD
2907               && (reload_in_progress | reload_completed) == 0)
2908             {
2909               int packed_dest_p
2910                 = (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER);
2911               int packed_src_p
2912                 = (REG_P (y) && REGNO (y) < FIRST_PSEUDO_REGISTER);
2913
2914               if (packed_dest_p || packed_src_p)
2915                 {
2916                   enum mode_class reg_class = ((class == MODE_COMPLEX_FLOAT)
2917                                                ? MODE_FLOAT : MODE_INT);
2918
2919                   enum machine_mode reg_mode
2920                     = mode_for_size (GET_MODE_BITSIZE (mode), reg_class, 1);
2921
2922                   if (reg_mode != BLKmode)
2923                     {
2924                       rtx mem = assign_stack_temp (reg_mode,
2925                                                    GET_MODE_SIZE (mode), 0);
2926                       rtx cmem = adjust_address (mem, mode, 0);
2927
2928                       if (packed_dest_p)
2929                         {
2930                           rtx sreg = gen_rtx_SUBREG (reg_mode, x, 0);
2931
2932                           emit_move_insn_1 (cmem, y);
2933                           return emit_move_insn_1 (sreg, mem);
2934                         }
2935                       else
2936                         {
2937                           rtx sreg = gen_rtx_SUBREG (reg_mode, y, 0);
2938
2939                           emit_move_insn_1 (mem, sreg);
2940                           return emit_move_insn_1 (x, cmem);
2941                         }
2942                     }
2943                 }
2944             }
2945
2946           realpart_x = gen_realpart (submode, x);
2947           realpart_y = gen_realpart (submode, y);
2948           imagpart_x = gen_imagpart (submode, x);
2949           imagpart_y = gen_imagpart (submode, y);
2950
2951           /* Show the output dies here.  This is necessary for SUBREGs
2952              of pseudos since we cannot track their lifetimes correctly;
2953              hard regs shouldn't appear here except as return values.
2954              We never want to emit such a clobber after reload.  */
2955           if (x != y
2956               && ! (reload_in_progress || reload_completed)
2957               && (GET_CODE (realpart_x) == SUBREG
2958                   || GET_CODE (imagpart_x) == SUBREG))
2959             emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
2960
2961           emit_move_insn (realpart_x, realpart_y);
2962           emit_move_insn (imagpart_x, imagpart_y);
2963         }
2964
2965       return get_last_insn ();
2966     }
2967
2968   /* Handle MODE_CC modes:  If we don't have a special move insn for this mode,
2969      find a mode to do it in.  If we have a movcc, use it.  Otherwise,
2970      find the MODE_INT mode of the same width.  */
2971   else if (GET_MODE_CLASS (mode) == MODE_CC
2972            && mov_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2973     {
2974       enum insn_code insn_code;
2975       enum machine_mode tmode = VOIDmode;
2976       rtx x1 = x, y1 = y;
2977
2978       if (mode != CCmode
2979           && mov_optab->handlers[(int) CCmode].insn_code != CODE_FOR_nothing)
2980         tmode = CCmode;
2981       else
2982         for (tmode = QImode; tmode != VOIDmode;
2983              tmode = GET_MODE_WIDER_MODE (tmode))
2984           if (GET_MODE_SIZE (tmode) == GET_MODE_SIZE (mode))
2985             break;
2986
2987       if (tmode == VOIDmode)
2988         abort ();
2989
2990       /* Get X and Y in TMODE.  We can't use gen_lowpart here because it
2991          may call change_address which is not appropriate if we were
2992          called when a reload was in progress.  We don't have to worry
2993          about changing the address since the size in bytes is supposed to
2994          be the same.  Copy the MEM to change the mode and move any
2995          substitutions from the old MEM to the new one.  */
2996
2997       if (reload_in_progress)
2998         {
2999           x = gen_lowpart_common (tmode, x1);
3000           if (x == 0 && MEM_P (x1))
3001             {
3002               x = adjust_address_nv (x1, tmode, 0);
3003               copy_replacements (x1, x);
3004             }
3005
3006           y = gen_lowpart_common (tmode, y1);
3007           if (y == 0 && MEM_P (y1))
3008             {
3009               y = adjust_address_nv (y1, tmode, 0);
3010               copy_replacements (y1, y);
3011             }
3012         }
3013       else
3014         {
3015           x = gen_lowpart (tmode, x);
3016           y = gen_lowpart (tmode, y);
3017         }
3018
3019       insn_code = mov_optab->handlers[(int) tmode].insn_code;
3020       return emit_insn (GEN_FCN (insn_code) (x, y));
3021     }
3022
3023   /* Try using a move pattern for the corresponding integer mode.  This is
3024      only safe when simplify_subreg can convert MODE constants into integer
3025      constants.  At present, it can only do this reliably if the value
3026      fits within a HOST_WIDE_INT.  */
3027   else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
3028            && (submode = int_mode_for_mode (mode)) != BLKmode
3029            && mov_optab->handlers[submode].insn_code != CODE_FOR_nothing)
3030     return emit_insn (GEN_FCN (mov_optab->handlers[submode].insn_code)
3031                       (simplify_gen_subreg (submode, x, mode, 0),
3032                        simplify_gen_subreg (submode, y, mode, 0)));
3033
3034   /* This will handle any multi-word or full-word mode that lacks a move_insn
3035      pattern.  However, you will get better code if you define such patterns,
3036      even if they must turn into multiple assembler instructions.  */
3037   else if (GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
3038     {
3039       rtx last_insn = 0;
3040       rtx seq, inner;
3041       int need_clobber;
3042       int i;
3043
3044 #ifdef PUSH_ROUNDING
3045
3046       /* If X is a push on the stack, do the push now and replace
3047          X with a reference to the stack pointer.  */
3048       if (push_operand (x, GET_MODE (x)))
3049         {
3050           rtx temp;
3051           enum rtx_code code;
3052
3053           /* Do not use anti_adjust_stack, since we don't want to update
3054              stack_pointer_delta.  */
3055           temp = expand_binop (Pmode,
3056 #ifdef STACK_GROWS_DOWNWARD
3057                                sub_optab,
3058 #else
3059                                add_optab,
3060 #endif
3061                                stack_pointer_rtx,
3062                                GEN_INT
3063                                  (PUSH_ROUNDING
3064                                   (GET_MODE_SIZE (GET_MODE (x)))),
3065                                stack_pointer_rtx, 0, OPTAB_LIB_WIDEN);
3066
3067           if (temp != stack_pointer_rtx)
3068             emit_move_insn (stack_pointer_rtx, temp);
3069
3070           code = GET_CODE (XEXP (x, 0));
3071
3072           /* Just hope that small offsets off SP are OK.  */
3073           if (code == POST_INC)
3074             temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3075                                 GEN_INT (-((HOST_WIDE_INT)
3076                                            GET_MODE_SIZE (GET_MODE (x)))));
3077           else if (code == POST_DEC)
3078             temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3079                                 GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
3080           else
3081             temp = stack_pointer_rtx;
3082
3083           x = change_address (x, VOIDmode, temp);
3084         }
3085 #endif
3086
3087       /* If we are in reload, see if either operand is a MEM whose address
3088          is scheduled for replacement.  */
3089       if (reload_in_progress && MEM_P (x)
3090           && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
3091         x = replace_equiv_address_nv (x, inner);
3092       if (reload_in_progress && MEM_P (y)
3093           && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
3094         y = replace_equiv_address_nv (y, inner);
3095
3096       start_sequence ();
3097
3098       need_clobber = 0;
3099       for (i = 0;
3100            i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
3101            i++)
3102         {
3103           rtx xpart = operand_subword (x, i, 1, mode);
3104           rtx ypart = operand_subword (y, i, 1, mode);
3105
3106           /* If we can't get a part of Y, put Y into memory if it is a
3107              constant.  Otherwise, force it into a register.  If we still
3108              can't get a part of Y, abort.  */
3109           if (ypart == 0 && CONSTANT_P (y))
3110             {
3111               y = force_const_mem (mode, y);
3112               ypart = operand_subword (y, i, 1, mode);
3113             }
3114           else if (ypart == 0)
3115             ypart = operand_subword_force (y, i, mode);
3116
3117           if (xpart == 0 || ypart == 0)
3118             abort ();
3119
3120           need_clobber |= (GET_CODE (xpart) == SUBREG);
3121
3122           last_insn = emit_move_insn (xpart, ypart);
3123         }
3124
3125       seq = get_insns ();
3126       end_sequence ();
3127
3128       /* Show the output dies here.  This is necessary for SUBREGs
3129          of pseudos since we cannot track their lifetimes correctly;
3130          hard regs shouldn't appear here except as return values.
3131          We never want to emit such a clobber after reload.  */
3132       if (x != y
3133           && ! (reload_in_progress || reload_completed)
3134           && need_clobber != 0)
3135         emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3136
3137       emit_insn (seq);
3138
3139       return last_insn;
3140     }
3141   else
3142     abort ();
3143 }
3144
3145 /* If Y is representable exactly in a narrower mode, and the target can
3146    perform the extension directly from constant or memory, then emit the
3147    move as an extension.  */
3148
3149 static rtx
3150 compress_float_constant (rtx x, rtx y)
3151 {
3152   enum machine_mode dstmode = GET_MODE (x);
3153   enum machine_mode orig_srcmode = GET_MODE (y);
3154   enum machine_mode srcmode;
3155   REAL_VALUE_TYPE r;
3156
3157   REAL_VALUE_FROM_CONST_DOUBLE (r, y);
3158
3159   for (srcmode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode));
3160        srcmode != orig_srcmode;
3161        srcmode = GET_MODE_WIDER_MODE (srcmode))
3162     {
3163       enum insn_code ic;
3164       rtx trunc_y, last_insn;
3165
3166       /* Skip if the target can't extend this way.  */
3167       ic = can_extend_p (dstmode, srcmode, 0);
3168       if (ic == CODE_FOR_nothing)
3169         continue;
3170
3171       /* Skip if the narrowed value isn't exact.  */
3172       if (! exact_real_truncate (srcmode, &r))
3173         continue;
3174
3175       trunc_y = CONST_DOUBLE_FROM_REAL_VALUE (r, srcmode);
3176
3177       if (LEGITIMATE_CONSTANT_P (trunc_y))
3178         {
3179           /* Skip if the target needs extra instructions to perform
3180              the extension.  */
3181           if (! (*insn_data[ic].operand[1].predicate) (trunc_y, srcmode))
3182             continue;
3183         }
3184       else if (float_extend_from_mem[dstmode][srcmode])
3185         trunc_y = validize_mem (force_const_mem (srcmode, trunc_y));
3186       else
3187         continue;
3188
3189       emit_unop_insn (ic, x, trunc_y, UNKNOWN);
3190       last_insn = get_last_insn ();
3191
3192       if (REG_P (x))
3193         set_unique_reg_note (last_insn, REG_EQUAL, y);
3194
3195       return last_insn;
3196     }
3197
3198   return NULL_RTX;
3199 }
3200 \f
3201 /* Pushing data onto the stack.  */
3202
3203 /* Push a block of length SIZE (perhaps variable)
3204    and return an rtx to address the beginning of the block.
3205    Note that it is not possible for the value returned to be a QUEUED.
3206    The value may be virtual_outgoing_args_rtx.
3207
3208    EXTRA is the number of bytes of padding to push in addition to SIZE.
3209    BELOW nonzero means this padding comes at low addresses;
3210    otherwise, the padding comes at high addresses.  */
3211
3212 rtx
3213 push_block (rtx size, int extra, int below)
3214 {
3215   rtx temp;
3216
3217   size = convert_modes (Pmode, ptr_mode, size, 1);
3218   if (CONSTANT_P (size))
3219     anti_adjust_stack (plus_constant (size, extra));
3220   else if (REG_P (size) && extra == 0)
3221     anti_adjust_stack (size);
3222   else
3223     {
3224       temp = copy_to_mode_reg (Pmode, size);
3225       if (extra != 0)
3226         temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3227                              temp, 0, OPTAB_LIB_WIDEN);
3228       anti_adjust_stack (temp);
3229     }
3230
3231 #ifndef STACK_GROWS_DOWNWARD
3232   if (0)
3233 #else
3234   if (1)
3235 #endif
3236     {
3237       temp = virtual_outgoing_args_rtx;
3238       if (extra != 0 && below)
3239         temp = plus_constant (temp, extra);
3240     }
3241   else
3242     {
3243       if (GET_CODE (size) == CONST_INT)
3244         temp = plus_constant (virtual_outgoing_args_rtx,
3245                               -INTVAL (size) - (below ? 0 : extra));
3246       else if (extra != 0 && !below)
3247         temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3248                              negate_rtx (Pmode, plus_constant (size, extra)));
3249       else
3250         temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3251                              negate_rtx (Pmode, size));
3252     }
3253
3254   return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3255 }
3256
3257 #ifdef PUSH_ROUNDING
3258
3259 /* Emit single push insn.  */
3260
3261 static void
3262 emit_single_push_insn (enum machine_mode mode, rtx x, tree type)
3263 {
3264   rtx dest_addr;
3265   unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3266   rtx dest;
3267   enum insn_code icode;
3268   insn_operand_predicate_fn pred;
3269
3270   stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3271   /* If there is push pattern, use it.  Otherwise try old way of throwing
3272      MEM representing push operation to move expander.  */
3273   icode = push_optab->handlers[(int) mode].insn_code;
3274   if (icode != CODE_FOR_nothing)
3275     {
3276       if (((pred = insn_data[(int) icode].operand[0].predicate)
3277            && !((*pred) (x, mode))))
3278         x = force_reg (mode, x);
3279       emit_insn (GEN_FCN (icode) (x));
3280       return;
3281     }
3282   if (GET_MODE_SIZE (mode) == rounded_size)
3283     dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3284   /* If we are to pad downward, adjust the stack pointer first and
3285      then store X into the stack location using an offset.  This is
3286      because emit_move_insn does not know how to pad; it does not have
3287      access to type.  */
3288   else if (FUNCTION_ARG_PADDING (mode, type) == downward)
3289     {
3290       unsigned padding_size = rounded_size - GET_MODE_SIZE (mode);
3291       HOST_WIDE_INT offset;
3292
3293       emit_move_insn (stack_pointer_rtx,
3294                       expand_binop (Pmode,
3295 #ifdef STACK_GROWS_DOWNWARD
3296                                     sub_optab,
3297 #else
3298                                     add_optab,
3299 #endif
3300                                     stack_pointer_rtx,
3301                                     GEN_INT (rounded_size),
3302                                     NULL_RTX, 0, OPTAB_LIB_WIDEN));
3303
3304       offset = (HOST_WIDE_INT) padding_size;
3305 #ifdef STACK_GROWS_DOWNWARD
3306       if (STACK_PUSH_CODE == POST_DEC)
3307         /* We have already decremented the stack pointer, so get the
3308            previous value.  */
3309         offset += (HOST_WIDE_INT) rounded_size;
3310 #else
3311       if (STACK_PUSH_CODE == POST_INC)
3312         /* We have already incremented the stack pointer, so get the
3313            previous value.  */
3314         offset -= (HOST_WIDE_INT) rounded_size;
3315 #endif
3316       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (offset));
3317     }
3318   else
3319     {
3320 #ifdef STACK_GROWS_DOWNWARD
3321       /* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC.  */
3322       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3323                                 GEN_INT (-(HOST_WIDE_INT) rounded_size));
3324 #else
3325       /* ??? This seems wrong if STACK_PUSH_CODE == POST_INC.  */
3326       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3327                                 GEN_INT (rounded_size));
3328 #endif
3329       dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3330     }
3331
3332   dest = gen_rtx_MEM (mode, dest_addr);
3333
3334   if (type != 0)
3335     {
3336       set_mem_attributes (dest, type, 1);
3337
3338       if (flag_optimize_sibling_calls)
3339         /* Function incoming arguments may overlap with sibling call
3340            outgoing arguments and we cannot allow reordering of reads
3341            from function arguments with stores to outgoing arguments
3342            of sibling calls.  */
3343         set_mem_alias_set (dest, 0);
3344     }
3345   emit_move_insn (dest, x);
3346 }
3347 #endif
3348
3349 /* Generate code to push X onto the stack, assuming it has mode MODE and
3350    type TYPE.
3351    MODE is redundant except when X is a CONST_INT (since they don't
3352    carry mode info).
3353    SIZE is an rtx for the size of data to be copied (in bytes),
3354    needed only if X is BLKmode.
3355
3356    ALIGN (in bits) is maximum alignment we can assume.
3357
3358    If PARTIAL and REG are both nonzero, then copy that many of the first
3359    words of X into registers starting with REG, and push the rest of X.
3360    The amount of space pushed is decreased by PARTIAL words,
3361    rounded *down* to a multiple of PARM_BOUNDARY.
3362    REG must be a hard register in this case.
3363    If REG is zero but PARTIAL is not, take any all others actions for an
3364    argument partially in registers, but do not actually load any
3365    registers.
3366
3367    EXTRA is the amount in bytes of extra space to leave next to this arg.
3368    This is ignored if an argument block has already been allocated.
3369
3370    On a machine that lacks real push insns, ARGS_ADDR is the address of
3371    the bottom of the argument block for this call.  We use indexing off there
3372    to store the arg.  On machines with push insns, ARGS_ADDR is 0 when a
3373    argument block has not been preallocated.
3374
3375    ARGS_SO_FAR is the size of args previously pushed for this call.
3376
3377    REG_PARM_STACK_SPACE is nonzero if functions require stack space
3378    for arguments passed in registers.  If nonzero, it will be the number
3379    of bytes required.  */
3380
3381 void
3382 emit_push_insn (rtx x, enum machine_mode mode, tree type, rtx size,
3383                 unsigned int align, int partial, rtx reg, int extra,
3384                 rtx args_addr, rtx args_so_far, int reg_parm_stack_space,
3385                 rtx alignment_pad)
3386 {
3387   rtx xinner;
3388   enum direction stack_direction
3389 #ifdef STACK_GROWS_DOWNWARD
3390     = downward;
3391 #else
3392     = upward;
3393 #endif
3394
3395   /* Decide where to pad the argument: `downward' for below,
3396      `upward' for above, or `none' for don't pad it.
3397      Default is below for small data on big-endian machines; else above.  */
3398   enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3399
3400   /* Invert direction if stack is post-decrement.
3401      FIXME: why?  */
3402   if (STACK_PUSH_CODE == POST_DEC)
3403     if (where_pad != none)
3404       where_pad = (where_pad == downward ? upward : downward);
3405
3406   xinner = x = protect_from_queue (x, 0);
3407
3408   if (mode == BLKmode)
3409     {
3410       /* Copy a block into the stack, entirely or partially.  */
3411
3412       rtx temp;
3413       int used = partial * UNITS_PER_WORD;
3414       int offset;
3415       int skip;
3416
3417       if (reg && GET_CODE (reg) == PARALLEL)
3418         {
3419           /* Use the size of the elt to compute offset.  */
3420           rtx elt = XEXP (XVECEXP (reg, 0, 0), 0);
3421           used = partial * GET_MODE_SIZE (GET_MODE (elt));
3422           offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
3423         }
3424       else
3425         offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
3426
3427       if (size == 0)
3428         abort ();
3429
3430       used -= offset;
3431
3432       /* USED is now the # of bytes we need not copy to the stack
3433          because registers will take care of them.  */
3434
3435       if (partial != 0)
3436         xinner = adjust_address (xinner, BLKmode, used);
3437
3438       /* If the partial register-part of the arg counts in its stack size,
3439          skip the part of stack space corresponding to the registers.
3440          Otherwise, start copying to the beginning of the stack space,
3441          by setting SKIP to 0.  */
3442       skip = (reg_parm_stack_space == 0) ? 0 : used;
3443
3444 #ifdef PUSH_ROUNDING
3445       /* Do it with several push insns if that doesn't take lots of insns
3446          and if there is no difficulty with push insns that skip bytes
3447          on the stack for alignment purposes.  */
3448       if (args_addr == 0
3449           && PUSH_ARGS
3450           && GET_CODE (size) == CONST_INT
3451           && skip == 0
3452           && MEM_ALIGN (xinner) >= align
3453           && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3454           /* Here we avoid the case of a structure whose weak alignment
3455              forces many pushes of a small amount of data,
3456              and such small pushes do rounding that causes trouble.  */
3457           && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3458               || align >= BIGGEST_ALIGNMENT
3459               || (PUSH_ROUNDING (align / BITS_PER_UNIT)
3460                   == (align / BITS_PER_UNIT)))
3461           && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3462         {
3463           /* Push padding now if padding above and stack grows down,
3464              or if padding below and stack grows up.
3465              But if space already allocated, this has already been done.  */
3466           if (extra && args_addr == 0
3467               && where_pad != none && where_pad != stack_direction)
3468             anti_adjust_stack (GEN_INT (extra));
3469
3470           move_by_pieces (NULL, xinner, INTVAL (size) - used, align, 0);
3471         }
3472       else
3473 #endif /* PUSH_ROUNDING  */
3474         {
3475           rtx target;
3476
3477           /* Otherwise make space on the stack and copy the data
3478              to the address of that space.  */
3479
3480           /* Deduct words put into registers from the size we must copy.  */
3481           if (partial != 0)
3482             {
3483               if (GET_CODE (size) == CONST_INT)
3484                 size = GEN_INT (INTVAL (size) - used);
3485               else
3486                 size = expand_binop (GET_MODE (size), sub_optab, size,
3487                                      GEN_INT (used), NULL_RTX, 0,
3488                                      OPTAB_LIB_WIDEN);
3489             }
3490
3491           /* Get the address of the stack space.
3492              In this case, we do not deal with EXTRA separately.
3493              A single stack adjust will do.  */
3494           if (! args_addr)
3495             {
3496               temp = push_block (size, extra, where_pad == downward);
3497               extra = 0;
3498             }
3499           else if (GET_CODE (args_so_far) == CONST_INT)
3500             temp = memory_address (BLKmode,
3501                                    plus_constant (args_addr,
3502                                                   skip + INTVAL (args_so_far)));
3503           else
3504             temp = memory_address (BLKmode,
3505                                    plus_constant (gen_rtx_PLUS (Pmode,
3506                                                                 args_addr,
3507                                                                 args_so_far),
3508                                                   skip));
3509
3510           if (!ACCUMULATE_OUTGOING_ARGS)
3511             {
3512               /* If the source is referenced relative to the stack pointer,
3513                  copy it to another register to stabilize it.  We do not need
3514                  to do this if we know that we won't be changing sp.  */
3515
3516               if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3517                   || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3518                 temp = copy_to_reg (temp);
3519             }
3520
3521           target = gen_rtx_MEM (BLKmode, temp);
3522
3523           if (type != 0)
3524             {
3525               set_mem_attributes (target, type, 1);
3526               /* Function incoming arguments may overlap with sibling call
3527                  outgoing arguments and we cannot allow reordering of reads
3528                  from function arguments with stores to outgoing arguments
3529                  of sibling calls.  */
3530               set_mem_alias_set (target, 0);
3531             }
3532
3533           /* ALIGN may well be better aligned than TYPE, e.g. due to
3534              PARM_BOUNDARY.  Assume the caller isn't lying.  */
3535           set_mem_align (target, align);
3536
3537           emit_block_move (target, xinner, size, BLOCK_OP_CALL_PARM);
3538         }
3539     }
3540   else if (partial > 0)
3541     {
3542       /* Scalar partly in registers.  */
3543
3544       int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3545       int i;
3546       int not_stack;
3547       /* # words of start of argument
3548          that we must make space for but need not store.  */
3549       int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3550       int args_offset = INTVAL (args_so_far);
3551       int skip;
3552
3553       /* Push padding now if padding above and stack grows down,
3554          or if padding below and stack grows up.
3555          But if space already allocated, this has already been done.  */
3556       if (extra && args_addr == 0
3557           && where_pad != none && where_pad != stack_direction)
3558         anti_adjust_stack (GEN_INT (extra));
3559
3560       /* If we make space by pushing it, we might as well push
3561          the real data.  Otherwise, we can leave OFFSET nonzero
3562          and leave the space uninitialized.  */
3563       if (args_addr == 0)
3564         offset = 0;
3565
3566       /* Now NOT_STACK gets the number of words that we don't need to
3567          allocate on the stack.  */
3568       not_stack = partial - offset;
3569
3570       /* If the partial register-part of the arg counts in its stack size,
3571          skip the part of stack space corresponding to the registers.
3572          Otherwise, start copying to the beginning of the stack space,
3573          by setting SKIP to 0.  */
3574       skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3575
3576       if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3577         x = validize_mem (force_const_mem (mode, x));
3578
3579       /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3580          SUBREGs of such registers are not allowed.  */
3581       if ((REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
3582            && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3583         x = copy_to_reg (x);
3584
3585       /* Loop over all the words allocated on the stack for this arg.  */
3586       /* We can do it by words, because any scalar bigger than a word
3587          has a size a multiple of a word.  */
3588 #ifndef PUSH_ARGS_REVERSED
3589       for (i = not_stack; i < size; i++)
3590 #else
3591       for (i = size - 1; i >= not_stack; i--)
3592 #endif
3593         if (i >= not_stack + offset)
3594           emit_push_insn (operand_subword_force (x, i, mode),
3595                           word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3596                           0, args_addr,
3597                           GEN_INT (args_offset + ((i - not_stack + skip)
3598                                                   * UNITS_PER_WORD)),
3599                           reg_parm_stack_space, alignment_pad);
3600     }
3601   else
3602     {
3603       rtx addr;
3604       rtx dest;
3605
3606       /* Push padding now if padding above and stack grows down,
3607          or if padding below and stack grows up.
3608          But if space already allocated, this has already been done.  */
3609       if (extra && args_addr == 0
3610           && where_pad != none && where_pad != stack_direction)
3611         anti_adjust_stack (GEN_INT (extra));
3612
3613 #ifdef PUSH_ROUNDING
3614       if (args_addr == 0 && PUSH_ARGS)
3615         emit_single_push_insn (mode, x, type);
3616       else
3617 #endif
3618         {
3619           if (GET_CODE (args_so_far) == CONST_INT)
3620             addr
3621               = memory_address (mode,
3622                                 plus_constant (args_addr,
3623                                                INTVAL (args_so_far)));
3624           else
3625             addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3626                                                        args_so_far));
3627           dest = gen_rtx_MEM (mode, addr);
3628           if (type != 0)
3629             {
3630               set_mem_attributes (dest, type, 1);
3631               /* Function incoming arguments may overlap with sibling call
3632                  outgoing arguments and we cannot allow reordering of reads
3633                  from function arguments with stores to outgoing arguments
3634                  of sibling calls.  */
3635               set_mem_alias_set (dest, 0);
3636             }
3637
3638           emit_move_insn (dest, x);
3639         }
3640     }
3641
3642   /* If part should go in registers, copy that part
3643      into the appropriate registers.  Do this now, at the end,
3644      since mem-to-mem copies above may do function calls.  */
3645   if (partial > 0 && reg != 0)
3646     {
3647       /* Handle calls that pass values in multiple non-contiguous locations.
3648          The Irix 6 ABI has examples of this.  */
3649       if (GET_CODE (reg) == PARALLEL)
3650         emit_group_load (reg, x, type, -1);
3651       else
3652         move_block_to_reg (REGNO (reg), x, partial, mode);
3653     }
3654
3655   if (extra && args_addr == 0 && where_pad == stack_direction)
3656     anti_adjust_stack (GEN_INT (extra));
3657
3658   if (alignment_pad && args_addr == 0)
3659     anti_adjust_stack (alignment_pad);
3660 }
3661 \f
3662 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3663    operations.  */
3664
3665 static rtx
3666 get_subtarget (rtx x)
3667 {
3668   return ((x == 0
3669            /* Only registers can be subtargets.  */
3670            || !REG_P (x)
3671            /* If the register is readonly, it can't be set more than once.  */
3672            || RTX_UNCHANGING_P (x)
3673            /* Don't use hard regs to avoid extending their life.  */
3674            || REGNO (x) < FIRST_PSEUDO_REGISTER
3675            /* Avoid subtargets inside loops,
3676               since they hide some invariant expressions.  */
3677            || preserve_subexpressions_p ())
3678           ? 0 : x);
3679 }
3680
3681 /* Expand an assignment that stores the value of FROM into TO.
3682    If WANT_VALUE is nonzero, return an rtx for the value of TO.
3683    (This may contain a QUEUED rtx;
3684    if the value is constant, this rtx is a constant.)
3685    Otherwise, the returned value is NULL_RTX.  */
3686
3687 rtx
3688 expand_assignment (tree to, tree from, int want_value)
3689 {
3690   rtx to_rtx = 0;
3691   rtx result;
3692
3693   /* Don't crash if the lhs of the assignment was erroneous.  */
3694
3695   if (TREE_CODE (to) == ERROR_MARK)
3696     {
3697       result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3698       return want_value ? result : NULL_RTX;
3699     }
3700
3701   /* Assignment of a structure component needs special treatment
3702      if the structure component's rtx is not simply a MEM.
3703      Assignment of an array element at a constant index, and assignment of
3704      an array element in an unaligned packed structure field, has the same
3705      problem.  */
3706
3707   if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
3708       || TREE_CODE (to) == ARRAY_REF || TREE_CODE (to) == ARRAY_RANGE_REF
3709       || TREE_CODE (TREE_TYPE (to)) == ARRAY_TYPE)
3710     {
3711       enum machine_mode mode1;
3712       HOST_WIDE_INT bitsize, bitpos;
3713       rtx orig_to_rtx;
3714       tree offset;
3715       int unsignedp;
3716       int volatilep = 0;
3717       tree tem;
3718
3719       push_temp_slots ();
3720       tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3721                                  &unsignedp, &volatilep);
3722
3723       /* If we are going to use store_bit_field and extract_bit_field,
3724          make sure to_rtx will be safe for multiple use.  */
3725
3726       if (mode1 == VOIDmode && want_value)
3727         tem = stabilize_reference (tem);
3728
3729       orig_to_rtx = to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
3730
3731       if (offset != 0)
3732         {
3733           rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, EXPAND_SUM);
3734
3735           if (!MEM_P (to_rtx))
3736             abort ();
3737
3738 #ifdef POINTERS_EXTEND_UNSIGNED
3739           if (GET_MODE (offset_rtx) != Pmode)
3740             offset_rtx = convert_to_mode (Pmode, offset_rtx, 0);
3741 #else
3742           if (GET_MODE (offset_rtx) != ptr_mode)
3743             offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3744 #endif
3745
3746           /* A constant address in TO_RTX can have VOIDmode, we must not try
3747              to call force_reg for that case.  Avoid that case.  */
3748           if (MEM_P (to_rtx)
3749               && GET_MODE (to_rtx) == BLKmode
3750               && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3751               && bitsize > 0
3752               && (bitpos % bitsize) == 0
3753               && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3754               && MEM_ALIGN (to_rtx) == GET_MODE_ALIGNMENT (mode1))
3755             {
3756               to_rtx = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
3757               bitpos = 0;
3758             }
3759
3760           to_rtx = offset_address (to_rtx, offset_rtx,
3761                                    highest_pow2_factor_for_target (to,
3762                                                                    offset));
3763         }
3764
3765       if (MEM_P (to_rtx))
3766         {
3767           /* If the field is at offset zero, we could have been given the
3768              DECL_RTX of the parent struct.  Don't munge it.  */
3769           to_rtx = shallow_copy_rtx (to_rtx);
3770
3771           set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos);
3772         }
3773
3774       /* Deal with volatile and readonly fields.  The former is only done
3775          for MEM.  Also set MEM_KEEP_ALIAS_SET_P if needed.  */
3776       if (volatilep && MEM_P (to_rtx))
3777         {
3778           if (to_rtx == orig_to_rtx)
3779             to_rtx = copy_rtx (to_rtx);
3780           MEM_VOLATILE_P (to_rtx) = 1;
3781         }
3782
3783       if (TREE_CODE (to) == COMPONENT_REF
3784           && TREE_READONLY (TREE_OPERAND (to, 1))
3785           /* We can't assert that a MEM won't be set more than once
3786              if the component is not addressable because another
3787              non-addressable component may be referenced by the same MEM.  */
3788           && ! (MEM_P (to_rtx) && ! can_address_p (to)))
3789         {
3790           if (to_rtx == orig_to_rtx)
3791             to_rtx = copy_rtx (to_rtx);
3792           RTX_UNCHANGING_P (to_rtx) = 1;
3793         }
3794
3795       if (MEM_P (to_rtx) && ! can_address_p (to))
3796         {
3797           if (to_rtx == orig_to_rtx)
3798             to_rtx = copy_rtx (to_rtx);
3799           MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
3800         }
3801
3802       /* Disabled temporarily.  GET_MODE (to_rtx) is often not the right
3803          mode.  */
3804       while (0 && mode1 == VOIDmode && !want_value
3805              && bitpos + bitsize <= BITS_PER_WORD
3806              && bitsize < BITS_PER_WORD
3807              && GET_MODE_BITSIZE (GET_MODE (to_rtx)) <= BITS_PER_WORD
3808              && !TREE_SIDE_EFFECTS (to)
3809              && !TREE_THIS_VOLATILE (to))
3810         {
3811           tree src, op0, op1;
3812           rtx value;
3813           HOST_WIDE_INT count = bitpos;
3814           optab binop;
3815
3816           src = from;
3817           STRIP_NOPS (src);
3818           if (TREE_CODE (TREE_TYPE (src)) != INTEGER_TYPE
3819               || TREE_CODE_CLASS (TREE_CODE (src)) != '2')
3820             break;
3821
3822           op0 = TREE_OPERAND (src, 0);
3823           op1 = TREE_OPERAND (src, 1);
3824           STRIP_NOPS (op0);
3825
3826           if (! operand_equal_p (to, op0, 0))
3827             break;
3828
3829           if (BYTES_BIG_ENDIAN)
3830             count = GET_MODE_BITSIZE (GET_MODE (to_rtx)) - bitpos - bitsize;
3831
3832           /* Special case some bitfield op= exp.  */
3833           switch (TREE_CODE (src))
3834             {
3835             case PLUS_EXPR:
3836             case MINUS_EXPR:
3837               if (count <= 0)
3838                 break;
3839
3840               /* For now, just optimize the case of the topmost bitfield
3841                  where we don't need to do any masking and also
3842                  1 bit bitfields where xor can be used.
3843                  We might win by one instruction for the other bitfields
3844                  too if insv/extv instructions aren't used, so that
3845                  can be added later.  */
3846               if (count + bitsize != GET_MODE_BITSIZE (GET_MODE (to_rtx))
3847                   && (bitsize != 1 || TREE_CODE (op1) != INTEGER_CST))
3848                 break;
3849               value = expand_expr (op1, NULL_RTX, VOIDmode, 0);
3850               value = protect_from_queue (value, 0);
3851               to_rtx = protect_from_queue (to_rtx, 1);
3852               binop = TREE_CODE (src) == PLUS_EXPR ? add_optab : sub_optab;
3853               if (bitsize == 1
3854                   && count + bitsize != GET_MODE_BITSIZE (GET_MODE (to_rtx)))
3855                 {
3856                   value = expand_and (GET_MODE (to_rtx), value, const1_rtx,
3857                                       NULL_RTX);
3858                   binop = xor_optab;
3859                 }
3860               value = expand_shift (LSHIFT_EXPR, GET_MODE (to_rtx),
3861                                     value, build_int_2 (count, 0),
3862                                     NULL_RTX, 1);
3863               result = expand_binop (GET_MODE (to_rtx), binop, to_rtx,
3864                                      value, to_rtx, 1, OPTAB_WIDEN);
3865               if (result != to_rtx)
3866                 emit_move_insn (to_rtx, result);
3867               free_temp_slots ();
3868               pop_temp_slots ();
3869               return NULL_RTX;
3870             default:
3871               break;
3872             }
3873
3874           break;
3875         }
3876
3877       result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3878                             (want_value
3879                              /* Spurious cast for HPUX compiler.  */
3880                              ? ((enum machine_mode)
3881                                 TYPE_MODE (TREE_TYPE (to)))
3882                              : VOIDmode),
3883                             unsignedp, TREE_TYPE (tem), get_alias_set (to));
3884
3885       preserve_temp_slots (result);
3886       free_temp_slots ();
3887       pop_temp_slots ();
3888
3889       /* If the value is meaningful, convert RESULT to the proper mode.
3890          Otherwise, return nothing.  */
3891       return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
3892                                           TYPE_MODE (TREE_TYPE (from)),
3893                                           result,
3894                                           TYPE_UNSIGNED (TREE_TYPE (to)))
3895               : NULL_RTX);
3896     }
3897
3898   /* If the rhs is a function call and its value is not an aggregate,
3899      call the function before we start to compute the lhs.
3900      This is needed for correct code for cases such as
3901      val = setjmp (buf) on machines where reference to val
3902      requires loading up part of an address in a separate insn.
3903
3904      Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3905      since it might be a promoted variable where the zero- or sign- extension
3906      needs to be done.  Handling this in the normal way is safe because no
3907      computation is done before the call.  */
3908   if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from, from)
3909       && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3910       && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3911             && REG_P (DECL_RTL (to))))
3912     {
3913       rtx value;
3914
3915       push_temp_slots ();
3916       value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3917       if (to_rtx == 0)
3918         to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
3919
3920       /* Handle calls that return values in multiple non-contiguous locations.
3921          The Irix 6 ABI has examples of this.  */
3922       if (GET_CODE (to_rtx) == PARALLEL)
3923         emit_group_load (to_rtx, value, TREE_TYPE (from),
3924                          int_size_in_bytes (TREE_TYPE (from)));
3925       else if (GET_MODE (to_rtx) == BLKmode)
3926         emit_block_move (to_rtx, value, expr_size (from), BLOCK_OP_NORMAL);
3927       else
3928         {
3929           if (POINTER_TYPE_P (TREE_TYPE (to)))
3930             value = convert_memory_address (GET_MODE (to_rtx), value);
3931           emit_move_insn (to_rtx, value);
3932         }
3933       preserve_temp_slots (to_rtx);
3934       free_temp_slots ();
3935       pop_temp_slots ();
3936       return want_value ? to_rtx : NULL_RTX;
3937     }
3938
3939   /* Ordinary treatment.  Expand TO to get a REG or MEM rtx.
3940      Don't re-expand if it was expanded already (in COMPONENT_REF case).  */
3941
3942   if (to_rtx == 0)
3943     to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
3944
3945   /* Don't move directly into a return register.  */
3946   if (TREE_CODE (to) == RESULT_DECL
3947       && (REG_P (to_rtx) || GET_CODE (to_rtx) == PARALLEL))
3948     {
3949       rtx temp;
3950
3951       push_temp_slots ();
3952       temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3953
3954       if (GET_CODE (to_rtx) == PARALLEL)
3955         emit_group_load (to_rtx, temp, TREE_TYPE (from),
3956                          int_size_in_bytes (TREE_TYPE (from)));
3957       else
3958         emit_move_insn (to_rtx, temp);
3959
3960       preserve_temp_slots (to_rtx);
3961       free_temp_slots ();
3962       pop_temp_slots ();
3963       return want_value ? to_rtx : NULL_RTX;
3964     }
3965
3966   /* In case we are returning the contents of an object which overlaps
3967      the place the value is being stored, use a safe function when copying
3968      a value through a pointer into a structure value return block.  */
3969   if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3970       && current_function_returns_struct
3971       && !current_function_returns_pcc_struct)
3972     {
3973       rtx from_rtx, size;
3974
3975       push_temp_slots ();
3976       size = expr_size (from);
3977       from_rtx = expand_expr (from, NULL_RTX, VOIDmode, 0);
3978
3979       emit_library_call (memmove_libfunc, LCT_NORMAL,
3980                          VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3981                          XEXP (from_rtx, 0), Pmode,
3982                          convert_to_mode (TYPE_MODE (sizetype),
3983                                           size, TYPE_UNSIGNED (sizetype)),
3984                          TYPE_MODE (sizetype));
3985
3986       preserve_temp_slots (to_rtx);
3987       free_temp_slots ();
3988       pop_temp_slots ();
3989       return want_value ? to_rtx : NULL_RTX;
3990     }
3991
3992   /* Compute FROM and store the value in the rtx we got.  */
3993
3994   push_temp_slots ();
3995   result = store_expr (from, to_rtx, want_value);
3996   preserve_temp_slots (result);
3997   free_temp_slots ();
3998   pop_temp_slots ();
3999   return want_value ? result : NULL_RTX;
4000 }
4001
4002 /* Generate code for computing expression EXP,
4003    and storing the value into TARGET.
4004    TARGET may contain a QUEUED rtx.
4005
4006    If WANT_VALUE & 1 is nonzero, return a copy of the value
4007    not in TARGET, so that we can be sure to use the proper
4008    value in a containing expression even if TARGET has something
4009    else stored in it.  If possible, we copy the value through a pseudo
4010    and return that pseudo.  Or, if the value is constant, we try to
4011    return the constant.  In some cases, we return a pseudo
4012    copied *from* TARGET.
4013
4014    If the mode is BLKmode then we may return TARGET itself.
4015    It turns out that in BLKmode it doesn't cause a problem.
4016    because C has no operators that could combine two different
4017    assignments into the same BLKmode object with different values
4018    with no sequence point.  Will other languages need this to
4019    be more thorough?
4020
4021    If WANT_VALUE & 1 is 0, we return NULL, to make sure
4022    to catch quickly any cases where the caller uses the value
4023    and fails to set WANT_VALUE.
4024
4025    If WANT_VALUE & 2 is set, this is a store into a call param on the
4026    stack, and block moves may need to be treated specially.  */
4027
4028 rtx
4029 store_expr (tree exp, rtx target, int want_value)
4030 {
4031   rtx temp;
4032   rtx alt_rtl = NULL_RTX;
4033   rtx mark = mark_queue ();
4034   int dont_return_target = 0;
4035   int dont_store_target = 0;
4036
4037   if (VOID_TYPE_P (TREE_TYPE (exp)))
4038     {
4039       /* C++ can generate ?: expressions with a throw expression in one
4040          branch and an rvalue in the other. Here, we resolve attempts to
4041          store the throw expression's nonexistent result.  */
4042       if (want_value)
4043         abort ();
4044       expand_expr (exp, const0_rtx, VOIDmode, 0);
4045       return NULL_RTX;
4046     }
4047   if (TREE_CODE (exp) == COMPOUND_EXPR)
4048     {
4049       /* Perform first part of compound expression, then assign from second
4050          part.  */
4051       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
4052                    want_value & 2 ? EXPAND_STACK_PARM : EXPAND_NORMAL);
4053       emit_queue ();
4054       return store_expr (TREE_OPERAND (exp, 1), target, want_value);
4055     }
4056   else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4057     {
4058       /* For conditional expression, get safe form of the target.  Then
4059          test the condition, doing the appropriate assignment on either
4060          side.  This avoids the creation of unnecessary temporaries.
4061          For non-BLKmode, it is more efficient not to do this.  */
4062
4063       rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
4064
4065       emit_queue ();
4066       target = protect_from_queue (target, 1);
4067
4068       do_pending_stack_adjust ();
4069       NO_DEFER_POP;
4070       jumpifnot (TREE_OPERAND (exp, 0), lab1);
4071       store_expr (TREE_OPERAND (exp, 1), target, want_value & 2);
4072       emit_queue ();
4073       emit_jump_insn (gen_jump (lab2));
4074       emit_barrier ();
4075       emit_label (lab1);
4076       store_expr (TREE_OPERAND (exp, 2), target, want_value & 2);
4077       emit_queue ();
4078       emit_label (lab2);
4079       OK_DEFER_POP;
4080
4081       return want_value & 1 ? target : NULL_RTX;
4082     }
4083   else if (queued_subexp_p (target))
4084     /* If target contains a postincrement, let's not risk
4085        using it as the place to generate the rhs.  */
4086     {
4087       if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
4088         {
4089           /* Expand EXP into a new pseudo.  */
4090           temp = gen_reg_rtx (GET_MODE (target));
4091           temp = expand_expr (exp, temp, GET_MODE (target),
4092                               (want_value & 2
4093                                ? EXPAND_STACK_PARM : EXPAND_NORMAL));
4094         }
4095       else
4096         temp = expand_expr (exp, NULL_RTX, GET_MODE (target),
4097                             (want_value & 2
4098                              ? EXPAND_STACK_PARM : EXPAND_NORMAL));
4099
4100       /* If target is volatile, ANSI requires accessing the value
4101          *from* the target, if it is accessed.  So make that happen.
4102          In no case return the target itself.  */
4103       if (! MEM_VOLATILE_P (target) && (want_value & 1) != 0)
4104         dont_return_target = 1;
4105     }
4106   else if ((want_value & 1) != 0
4107            && MEM_P (target)
4108            && ! MEM_VOLATILE_P (target)
4109            && GET_MODE (target) != BLKmode)
4110     /* If target is in memory and caller wants value in a register instead,
4111        arrange that.  Pass TARGET as target for expand_expr so that,
4112        if EXP is another assignment, WANT_VALUE will be nonzero for it.
4113        We know expand_expr will not use the target in that case.
4114        Don't do this if TARGET is volatile because we are supposed
4115        to write it and then read it.  */
4116     {
4117       temp = expand_expr (exp, target, GET_MODE (target),
4118                           want_value & 2 ? EXPAND_STACK_PARM : EXPAND_NORMAL);
4119       if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
4120         {
4121           /* If TEMP is already in the desired TARGET, only copy it from
4122              memory and don't store it there again.  */
4123           if (temp == target
4124               || (rtx_equal_p (temp, target)
4125                   && ! side_effects_p (temp) && ! side_effects_p (target)))
4126             dont_store_target = 1;