OSDN Git Service

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