OSDN Git Service

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