OSDN Git Service

* tree-data-ref.c (dr_analyze_alias): Handle case smt is NULL.
[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, 2007
4    Free Software Foundation, 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, unsigned, HOST_WIDE_INT);
130 static tree emit_block_move_libcall_fn (int);
131 static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);
132 static rtx clear_by_pieces_1 (void *, HOST_WIDE_INT, enum machine_mode);
133 static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);
134 static void store_by_pieces_1 (struct store_by_pieces *, unsigned int);
135 static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode,
136                                struct store_by_pieces *);
137 static tree clear_storage_libcall_fn (int);
138 static rtx compress_float_constant (rtx, rtx);
139 static rtx get_subtarget (rtx);
140 static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,
141                                      HOST_WIDE_INT, enum machine_mode,
142                                      tree, tree, int, int);
143 static void store_constructor (tree, rtx, int, HOST_WIDE_INT);
144 static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode,
145                         tree, tree, int, bool);
146
147 static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);
148
149 static int is_aligning_offset (tree, tree);
150 static void expand_operands (tree, tree, rtx, rtx*, rtx*,
151                              enum expand_modifier);
152 static rtx reduce_to_bit_field_precision (rtx, rtx, tree);
153 static rtx do_store_flag (tree, rtx, enum machine_mode, int);
154 #ifdef PUSH_ROUNDING
155 static void emit_single_push_insn (enum machine_mode, rtx, tree);
156 #endif
157 static void do_tablejump (rtx, enum machine_mode, rtx, rtx, rtx);
158 static rtx const_vector_from_tree (tree);
159 static void write_complex_part (rtx, rtx, bool);
160
161 /* Record for each mode whether we can move a register directly to or
162    from an object of that mode in memory.  If we can't, we won't try
163    to use that mode directly when accessing a field of that mode.  */
164
165 static char direct_load[NUM_MACHINE_MODES];
166 static char direct_store[NUM_MACHINE_MODES];
167
168 /* Record for each mode whether we can float-extend from memory.  */
169
170 static bool float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];
171
172 /* This macro is used to determine whether move_by_pieces should be called
173    to perform a structure copy.  */
174 #ifndef MOVE_BY_PIECES_P
175 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
176   (move_by_pieces_ninsns (SIZE, ALIGN, MOVE_MAX_PIECES + 1) \
177    < (unsigned int) MOVE_RATIO)
178 #endif
179
180 /* This macro is used to determine whether clear_by_pieces should be
181    called to clear storage.  */
182 #ifndef CLEAR_BY_PIECES_P
183 #define CLEAR_BY_PIECES_P(SIZE, ALIGN) \
184   (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
185    < (unsigned int) CLEAR_RATIO)
186 #endif
187
188 /* This macro is used to determine whether store_by_pieces should be
189    called to "memset" storage with byte values other than zero, or
190    to "memcpy" storage when the source is a constant string.  */
191 #ifndef STORE_BY_PIECES_P
192 #define STORE_BY_PIECES_P(SIZE, ALIGN) \
193   (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \
194    < (unsigned int) MOVE_RATIO)
195 #endif
196
197 /* This array records the insn_code of insns to perform block moves.  */
198 enum insn_code movmem_optab[NUM_MACHINE_MODES];
199
200 /* This array records the insn_code of insns to perform block sets.  */
201 enum insn_code setmem_optab[NUM_MACHINE_MODES];
202
203 /* These arrays record the insn_code of three different kinds of insns
204    to perform block compares.  */
205 enum insn_code cmpstr_optab[NUM_MACHINE_MODES];
206 enum insn_code cmpstrn_optab[NUM_MACHINE_MODES];
207 enum insn_code cmpmem_optab[NUM_MACHINE_MODES];
208
209 /* Synchronization primitives.  */
210 enum insn_code sync_add_optab[NUM_MACHINE_MODES];
211 enum insn_code sync_sub_optab[NUM_MACHINE_MODES];
212 enum insn_code sync_ior_optab[NUM_MACHINE_MODES];
213 enum insn_code sync_and_optab[NUM_MACHINE_MODES];
214 enum insn_code sync_xor_optab[NUM_MACHINE_MODES];
215 enum insn_code sync_nand_optab[NUM_MACHINE_MODES];
216 enum insn_code sync_old_add_optab[NUM_MACHINE_MODES];
217 enum insn_code sync_old_sub_optab[NUM_MACHINE_MODES];
218 enum insn_code sync_old_ior_optab[NUM_MACHINE_MODES];
219 enum insn_code sync_old_and_optab[NUM_MACHINE_MODES];
220 enum insn_code sync_old_xor_optab[NUM_MACHINE_MODES];
221 enum insn_code sync_old_nand_optab[NUM_MACHINE_MODES];
222 enum insn_code sync_new_add_optab[NUM_MACHINE_MODES];
223 enum insn_code sync_new_sub_optab[NUM_MACHINE_MODES];
224 enum insn_code sync_new_ior_optab[NUM_MACHINE_MODES];
225 enum insn_code sync_new_and_optab[NUM_MACHINE_MODES];
226 enum insn_code sync_new_xor_optab[NUM_MACHINE_MODES];
227 enum insn_code sync_new_nand_optab[NUM_MACHINE_MODES];
228 enum insn_code sync_compare_and_swap[NUM_MACHINE_MODES];
229 enum insn_code sync_compare_and_swap_cc[NUM_MACHINE_MODES];
230 enum insn_code sync_lock_test_and_set[NUM_MACHINE_MODES];
231 enum insn_code sync_lock_release[NUM_MACHINE_MODES];
232
233 /* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow.  */
234
235 #ifndef SLOW_UNALIGNED_ACCESS
236 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
237 #endif
238 \f
239 /* This is run once per compilation to set up which modes can be used
240    directly in memory and to initialize the block move optab.  */
241
242 void
243 init_expr_once (void)
244 {
245   rtx insn, pat;
246   enum machine_mode mode;
247   int num_clobbers;
248   rtx mem, mem1;
249   rtx reg;
250
251   /* Try indexing by frame ptr and try by stack ptr.
252      It is known that on the Convex the stack ptr isn't a valid index.
253      With luck, one or the other is valid on any machine.  */
254   mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
255   mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
256
257   /* A scratch register we can modify in-place below to avoid
258      useless RTL allocations.  */
259   reg = gen_rtx_REG (VOIDmode, -1);
260
261   insn = rtx_alloc (INSN);
262   pat = gen_rtx_SET (0, NULL_RTX, NULL_RTX);
263   PATTERN (insn) = pat;
264
265   for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
266        mode = (enum machine_mode) ((int) mode + 1))
267     {
268       int regno;
269
270       direct_load[(int) mode] = direct_store[(int) mode] = 0;
271       PUT_MODE (mem, mode);
272       PUT_MODE (mem1, mode);
273       PUT_MODE (reg, mode);
274
275       /* See if there is some register that can be used in this mode and
276          directly loaded or stored from memory.  */
277
278       if (mode != VOIDmode && mode != BLKmode)
279         for (regno = 0; regno < FIRST_PSEUDO_REGISTER
280              && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
281              regno++)
282           {
283             if (! HARD_REGNO_MODE_OK (regno, mode))
284               continue;
285
286             REGNO (reg) = regno;
287
288             SET_SRC (pat) = mem;
289             SET_DEST (pat) = reg;
290             if (recog (pat, insn, &num_clobbers) >= 0)
291               direct_load[(int) mode] = 1;
292
293             SET_SRC (pat) = mem1;
294             SET_DEST (pat) = reg;
295             if (recog (pat, insn, &num_clobbers) >= 0)
296               direct_load[(int) mode] = 1;
297
298             SET_SRC (pat) = reg;
299             SET_DEST (pat) = mem;
300             if (recog (pat, insn, &num_clobbers) >= 0)
301               direct_store[(int) mode] = 1;
302
303             SET_SRC (pat) = reg;
304             SET_DEST (pat) = mem1;
305             if (recog (pat, insn, &num_clobbers) >= 0)
306               direct_store[(int) mode] = 1;
307           }
308     }
309
310   mem = gen_rtx_MEM (VOIDmode, gen_rtx_raw_REG (Pmode, 10000));
311
312   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
313        mode = GET_MODE_WIDER_MODE (mode))
314     {
315       enum machine_mode srcmode;
316       for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;
317            srcmode = GET_MODE_WIDER_MODE (srcmode))
318         {
319           enum insn_code ic;
320
321           ic = can_extend_p (mode, srcmode, 0);
322           if (ic == CODE_FOR_nothing)
323             continue;
324
325           PUT_MODE (mem, srcmode);
326
327           if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))
328             float_extend_from_mem[mode][srcmode] = true;
329         }
330     }
331 }
332
333 /* This is run at the start of compiling a function.  */
334
335 void
336 init_expr (void)
337 {
338   cfun->expr = ggc_alloc_cleared (sizeof (struct expr_status));
339 }
340 \f
341 /* Copy data from FROM to TO, where the machine modes are not the same.
342    Both modes may be integer, or both may be floating.
343    UNSIGNEDP should be nonzero if FROM is an unsigned type.
344    This causes zero-extension instead of sign-extension.  */
345
346 void
347 convert_move (rtx to, rtx from, int unsignedp)
348 {
349   enum machine_mode to_mode = GET_MODE (to);
350   enum machine_mode from_mode = GET_MODE (from);
351   int to_real = SCALAR_FLOAT_MODE_P (to_mode);
352   int from_real = SCALAR_FLOAT_MODE_P (from_mode);
353   enum insn_code code;
354   rtx libcall;
355
356   /* rtx code for making an equivalent value.  */
357   enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN
358                               : (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));
359
360
361   gcc_assert (to_real == from_real);
362   gcc_assert (to_mode != BLKmode);
363   gcc_assert (from_mode != BLKmode);
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_hints (rtx x, rtx y, rtx size, enum block_op_methods method,
1153                        unsigned int expected_align, HOST_WIDE_INT expected_size)
1154 {
1155   bool may_use_call;
1156   rtx retval = 0;
1157   unsigned int align;
1158
1159   switch (method)
1160     {
1161     case BLOCK_OP_NORMAL:
1162     case BLOCK_OP_TAILCALL:
1163       may_use_call = true;
1164       break;
1165
1166     case BLOCK_OP_CALL_PARM:
1167       may_use_call = block_move_libcall_safe_for_call_parm ();
1168
1169       /* Make inhibit_defer_pop nonzero around the library call
1170          to force it to pop the arguments right away.  */
1171       NO_DEFER_POP;
1172       break;
1173
1174     case BLOCK_OP_NO_LIBCALL:
1175       may_use_call = false;
1176       break;
1177
1178     default:
1179       gcc_unreachable ();
1180     }
1181
1182   align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
1183
1184   gcc_assert (MEM_P (x));
1185   gcc_assert (MEM_P (y));
1186   gcc_assert (size);
1187
1188   /* Make sure we've got BLKmode addresses; store_one_arg can decide that
1189      block copy is more efficient for other large modes, e.g. DCmode.  */
1190   x = adjust_address (x, BLKmode, 0);
1191   y = adjust_address (y, BLKmode, 0);
1192
1193   /* Set MEM_SIZE as appropriate for this block copy.  The main place this
1194      can be incorrect is coming from __builtin_memcpy.  */
1195   if (GET_CODE (size) == CONST_INT)
1196     {
1197       if (INTVAL (size) == 0)
1198         return 0;
1199
1200       x = shallow_copy_rtx (x);
1201       y = shallow_copy_rtx (y);
1202       set_mem_size (x, size);
1203       set_mem_size (y, size);
1204     }
1205
1206   if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1207     move_by_pieces (x, y, INTVAL (size), align, 0);
1208   else if (emit_block_move_via_movmem (x, y, size, align,
1209                                        expected_align, expected_size))
1210     ;
1211   else if (may_use_call)
1212     retval = emit_block_move_via_libcall (x, y, size,
1213                                           method == BLOCK_OP_TAILCALL);
1214   else
1215     emit_block_move_via_loop (x, y, size, align);
1216
1217   if (method == BLOCK_OP_CALL_PARM)
1218     OK_DEFER_POP;
1219
1220   return retval;
1221 }
1222
1223 rtx
1224 emit_block_move (rtx x, rtx y, rtx size, enum block_op_methods method)
1225 {
1226   return emit_block_move_hints (x, y, size, method, 0, -1);
1227 }
1228
1229 /* A subroutine of emit_block_move.  Returns true if calling the
1230    block move libcall will not clobber any parameters which may have
1231    already been placed on the stack.  */
1232
1233 static bool
1234 block_move_libcall_safe_for_call_parm (void)
1235 {
1236   /* If arguments are pushed on the stack, then they're safe.  */
1237   if (PUSH_ARGS)
1238     return true;
1239
1240   /* If registers go on the stack anyway, any argument is sure to clobber
1241      an outgoing argument.  */
1242 #if defined (REG_PARM_STACK_SPACE)
1243   if (OUTGOING_REG_PARM_STACK_SPACE)
1244     {
1245       tree fn;
1246       fn = emit_block_move_libcall_fn (false);
1247       if (REG_PARM_STACK_SPACE (fn) != 0)
1248         return false;
1249     }
1250 #endif
1251
1252   /* If any argument goes in memory, then it might clobber an outgoing
1253      argument.  */
1254   {
1255     CUMULATIVE_ARGS args_so_far;
1256     tree fn, arg;
1257
1258     fn = emit_block_move_libcall_fn (false);
1259     INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (fn), NULL_RTX, 0, 3);
1260
1261     arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
1262     for ( ; arg != void_list_node ; arg = TREE_CHAIN (arg))
1263       {
1264         enum machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
1265         rtx tmp = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
1266         if (!tmp || !REG_P (tmp))
1267           return false;
1268         if (targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL, 1))
1269           return false;
1270         FUNCTION_ARG_ADVANCE (args_so_far, mode, NULL_TREE, 1);
1271       }
1272   }
1273   return true;
1274 }
1275
1276 /* A subroutine of emit_block_move.  Expand a movmem pattern;
1277    return true if successful.  */
1278
1279 static bool
1280 emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align,
1281                             unsigned int expected_align, HOST_WIDE_INT expected_size)
1282 {
1283   rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1284   int save_volatile_ok = volatile_ok;
1285   enum machine_mode mode;
1286
1287   if (expected_align < align)
1288     expected_align = align;
1289
1290   /* Since this is a move insn, we don't care about volatility.  */
1291   volatile_ok = 1;
1292
1293   /* Try the most limited insn first, because there's no point
1294      including more than one in the machine description unless
1295      the more limited one has some advantage.  */
1296
1297   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1298        mode = GET_MODE_WIDER_MODE (mode))
1299     {
1300       enum insn_code code = movmem_optab[(int) mode];
1301       insn_operand_predicate_fn pred;
1302
1303       if (code != CODE_FOR_nothing
1304           /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1305              here because if SIZE is less than the mode mask, as it is
1306              returned by the macro, it will definitely be less than the
1307              actual mode mask.  */
1308           && ((GET_CODE (size) == CONST_INT
1309                && ((unsigned HOST_WIDE_INT) INTVAL (size)
1310                    <= (GET_MODE_MASK (mode) >> 1)))
1311               || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1312           && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1313               || (*pred) (x, BLKmode))
1314           && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1315               || (*pred) (y, BLKmode))
1316           && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1317               || (*pred) (opalign, VOIDmode)))
1318         {
1319           rtx op2;
1320           rtx last = get_last_insn ();
1321           rtx pat;
1322
1323           op2 = convert_to_mode (mode, size, 1);
1324           pred = insn_data[(int) code].operand[2].predicate;
1325           if (pred != 0 && ! (*pred) (op2, mode))
1326             op2 = copy_to_mode_reg (mode, op2);
1327
1328           /* ??? When called via emit_block_move_for_call, it'd be
1329              nice if there were some way to inform the backend, so
1330              that it doesn't fail the expansion because it thinks
1331              emitting the libcall would be more efficient.  */
1332
1333           if (insn_data[(int) code].n_operands == 4)
1334             pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1335           else
1336             pat = GEN_FCN ((int) code) (x, y, op2, opalign,
1337                                         GEN_INT (expected_align),
1338                                         GEN_INT (expected_size));
1339           if (pat)
1340             {
1341               emit_insn (pat);
1342               volatile_ok = save_volatile_ok;
1343               return true;
1344             }
1345           else
1346             delete_insns_since (last);
1347         }
1348     }
1349
1350   volatile_ok = save_volatile_ok;
1351   return false;
1352 }
1353
1354 /* A subroutine of emit_block_move.  Expand a call to memcpy.
1355    Return the return value from memcpy, 0 otherwise.  */
1356
1357 rtx
1358 emit_block_move_via_libcall (rtx dst, rtx src, rtx size, bool tailcall)
1359 {
1360   rtx dst_addr, src_addr;
1361   tree call_expr, fn, src_tree, dst_tree, size_tree;
1362   enum machine_mode size_mode;
1363   rtx retval;
1364
1365   /* Emit code to copy the addresses of DST and SRC and SIZE into new
1366      pseudos.  We can then place those new pseudos into a VAR_DECL and
1367      use them later.  */
1368
1369   dst_addr = copy_to_mode_reg (Pmode, XEXP (dst, 0));
1370   src_addr = copy_to_mode_reg (Pmode, XEXP (src, 0));
1371
1372   dst_addr = convert_memory_address (ptr_mode, dst_addr);
1373   src_addr = convert_memory_address (ptr_mode, src_addr);
1374
1375   dst_tree = make_tree (ptr_type_node, dst_addr);
1376   src_tree = make_tree (ptr_type_node, src_addr);
1377
1378   size_mode = TYPE_MODE (sizetype);
1379
1380   size = convert_to_mode (size_mode, size, 1);
1381   size = copy_to_mode_reg (size_mode, size);
1382
1383   /* It is incorrect to use the libcall calling conventions to call
1384      memcpy in this context.  This could be a user call to memcpy and
1385      the user may wish to examine the return value from memcpy.  For
1386      targets where libcalls and normal calls have different conventions
1387      for returning pointers, we could end up generating incorrect code.  */
1388
1389   size_tree = make_tree (sizetype, size);
1390
1391   fn = emit_block_move_libcall_fn (true);
1392   call_expr = build_call_expr (fn, 3, dst_tree, src_tree, size_tree);
1393   CALL_EXPR_TAILCALL (call_expr) = tailcall;
1394
1395   retval = expand_normal (call_expr);
1396
1397   return retval;
1398 }
1399
1400 /* A subroutine of emit_block_move_via_libcall.  Create the tree node
1401    for the function we use for block copies.  The first time FOR_CALL
1402    is true, we call assemble_external.  */
1403
1404 static GTY(()) tree block_move_fn;
1405
1406 void
1407 init_block_move_fn (const char *asmspec)
1408 {
1409   if (!block_move_fn)
1410     {
1411       tree args, fn;
1412
1413       fn = get_identifier ("memcpy");
1414       args = build_function_type_list (ptr_type_node, ptr_type_node,
1415                                        const_ptr_type_node, sizetype,
1416                                        NULL_TREE);
1417
1418       fn = build_decl (FUNCTION_DECL, fn, args);
1419       DECL_EXTERNAL (fn) = 1;
1420       TREE_PUBLIC (fn) = 1;
1421       DECL_ARTIFICIAL (fn) = 1;
1422       TREE_NOTHROW (fn) = 1;
1423       DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
1424       DECL_VISIBILITY_SPECIFIED (fn) = 1;
1425
1426       block_move_fn = fn;
1427     }
1428
1429   if (asmspec)
1430     set_user_assembler_name (block_move_fn, asmspec);
1431 }
1432
1433 static tree
1434 emit_block_move_libcall_fn (int for_call)
1435 {
1436   static bool emitted_extern;
1437
1438   if (!block_move_fn)
1439     init_block_move_fn (NULL);
1440
1441   if (for_call && !emitted_extern)
1442     {
1443       emitted_extern = true;
1444       make_decl_rtl (block_move_fn);
1445       assemble_external (block_move_fn);
1446     }
1447
1448   return block_move_fn;
1449 }
1450
1451 /* A subroutine of emit_block_move.  Copy the data via an explicit
1452    loop.  This is used only when libcalls are forbidden.  */
1453 /* ??? It'd be nice to copy in hunks larger than QImode.  */
1454
1455 static void
1456 emit_block_move_via_loop (rtx x, rtx y, rtx size,
1457                           unsigned int align ATTRIBUTE_UNUSED)
1458 {
1459   rtx cmp_label, top_label, iter, x_addr, y_addr, tmp;
1460   enum machine_mode iter_mode;
1461
1462   iter_mode = GET_MODE (size);
1463   if (iter_mode == VOIDmode)
1464     iter_mode = word_mode;
1465
1466   top_label = gen_label_rtx ();
1467   cmp_label = gen_label_rtx ();
1468   iter = gen_reg_rtx (iter_mode);
1469
1470   emit_move_insn (iter, const0_rtx);
1471
1472   x_addr = force_operand (XEXP (x, 0), NULL_RTX);
1473   y_addr = force_operand (XEXP (y, 0), NULL_RTX);
1474   do_pending_stack_adjust ();
1475
1476   emit_jump (cmp_label);
1477   emit_label (top_label);
1478
1479   tmp = convert_modes (Pmode, iter_mode, iter, true);
1480   x_addr = gen_rtx_PLUS (Pmode, x_addr, tmp);
1481   y_addr = gen_rtx_PLUS (Pmode, y_addr, tmp);
1482   x = change_address (x, QImode, x_addr);
1483   y = change_address (y, QImode, y_addr);
1484
1485   emit_move_insn (x, y);
1486
1487   tmp = expand_simple_binop (iter_mode, PLUS, iter, const1_rtx, iter,
1488                              true, OPTAB_LIB_WIDEN);
1489   if (tmp != iter)
1490     emit_move_insn (iter, tmp);
1491
1492   emit_label (cmp_label);
1493
1494   emit_cmp_and_jump_insns (iter, size, LT, NULL_RTX, iter_mode,
1495                            true, top_label);
1496 }
1497 \f
1498 /* Copy all or part of a value X into registers starting at REGNO.
1499    The number of registers to be filled is NREGS.  */
1500
1501 void
1502 move_block_to_reg (int regno, rtx x, int nregs, enum machine_mode mode)
1503 {
1504   int i;
1505 #ifdef HAVE_load_multiple
1506   rtx pat;
1507   rtx last;
1508 #endif
1509
1510   if (nregs == 0)
1511     return;
1512
1513   if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1514     x = validize_mem (force_const_mem (mode, x));
1515
1516   /* See if the machine can do this with a load multiple insn.  */
1517 #ifdef HAVE_load_multiple
1518   if (HAVE_load_multiple)
1519     {
1520       last = get_last_insn ();
1521       pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1522                                GEN_INT (nregs));
1523       if (pat)
1524         {
1525           emit_insn (pat);
1526           return;
1527         }
1528       else
1529         delete_insns_since (last);
1530     }
1531 #endif
1532
1533   for (i = 0; i < nregs; i++)
1534     emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1535                     operand_subword_force (x, i, mode));
1536 }
1537
1538 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1539    The number of registers to be filled is NREGS.  */
1540
1541 void
1542 move_block_from_reg (int regno, rtx x, int nregs)
1543 {
1544   int i;
1545
1546   if (nregs == 0)
1547     return;
1548
1549   /* See if the machine can do this with a store multiple insn.  */
1550 #ifdef HAVE_store_multiple
1551   if (HAVE_store_multiple)
1552     {
1553       rtx last = get_last_insn ();
1554       rtx pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1555                                     GEN_INT (nregs));
1556       if (pat)
1557         {
1558           emit_insn (pat);
1559           return;
1560         }
1561       else
1562         delete_insns_since (last);
1563     }
1564 #endif
1565
1566   for (i = 0; i < nregs; i++)
1567     {
1568       rtx tem = operand_subword (x, i, 1, BLKmode);
1569
1570       gcc_assert (tem);
1571
1572       emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1573     }
1574 }
1575
1576 /* Generate a PARALLEL rtx for a new non-consecutive group of registers from
1577    ORIG, where ORIG is a non-consecutive group of registers represented by
1578    a PARALLEL.  The clone is identical to the original except in that the
1579    original set of registers is replaced by a new set of pseudo registers.
1580    The new set has the same modes as the original set.  */
1581
1582 rtx
1583 gen_group_rtx (rtx orig)
1584 {
1585   int i, length;
1586   rtx *tmps;
1587
1588   gcc_assert (GET_CODE (orig) == PARALLEL);
1589
1590   length = XVECLEN (orig, 0);
1591   tmps = alloca (sizeof (rtx) * length);
1592
1593   /* Skip a NULL entry in first slot.  */
1594   i = XEXP (XVECEXP (orig, 0, 0), 0) ? 0 : 1;
1595
1596   if (i)
1597     tmps[0] = 0;
1598
1599   for (; i < length; i++)
1600     {
1601       enum machine_mode mode = GET_MODE (XEXP (XVECEXP (orig, 0, i), 0));
1602       rtx offset = XEXP (XVECEXP (orig, 0, i), 1);
1603
1604       tmps[i] = gen_rtx_EXPR_LIST (VOIDmode, gen_reg_rtx (mode), offset);
1605     }
1606
1607   return gen_rtx_PARALLEL (GET_MODE (orig), gen_rtvec_v (length, tmps));
1608 }
1609
1610 /* A subroutine of emit_group_load.  Arguments as for emit_group_load,
1611    except that values are placed in TMPS[i], and must later be moved
1612    into corresponding XEXP (XVECEXP (DST, 0, i), 0) element.  */
1613
1614 static void
1615 emit_group_load_1 (rtx *tmps, rtx dst, rtx orig_src, tree type, int ssize)
1616 {
1617   rtx src;
1618   int start, i;
1619   enum machine_mode m = GET_MODE (orig_src);
1620
1621   gcc_assert (GET_CODE (dst) == PARALLEL);
1622
1623   if (m != VOIDmode
1624       && !SCALAR_INT_MODE_P (m)
1625       && !MEM_P (orig_src)
1626       && GET_CODE (orig_src) != CONCAT)
1627     {
1628       enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_src));
1629       if (imode == BLKmode)
1630         src = assign_stack_temp (GET_MODE (orig_src), ssize, 0);
1631       else
1632         src = gen_reg_rtx (imode);
1633       if (imode != BLKmode)
1634         src = gen_lowpart (GET_MODE (orig_src), src);
1635       emit_move_insn (src, orig_src);
1636       /* ...and back again.  */
1637       if (imode != BLKmode)
1638         src = gen_lowpart (imode, src);
1639       emit_group_load_1 (tmps, dst, src, type, ssize);
1640       return;
1641     }
1642
1643   /* Check for a NULL entry, used to indicate that the parameter goes
1644      both on the stack and in registers.  */
1645   if (XEXP (XVECEXP (dst, 0, 0), 0))
1646     start = 0;
1647   else
1648     start = 1;
1649
1650   /* Process the pieces.  */
1651   for (i = start; i < XVECLEN (dst, 0); i++)
1652     {
1653       enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1654       HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1655       unsigned int bytelen = GET_MODE_SIZE (mode);
1656       int shift = 0;
1657
1658       /* Handle trailing fragments that run over the size of the struct.  */
1659       if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1660         {
1661           /* Arrange to shift the fragment to where it belongs.
1662              extract_bit_field loads to the lsb of the reg.  */
1663           if (
1664 #ifdef BLOCK_REG_PADDING
1665               BLOCK_REG_PADDING (GET_MODE (orig_src), type, i == start)
1666               == (BYTES_BIG_ENDIAN ? upward : downward)
1667 #else
1668               BYTES_BIG_ENDIAN
1669 #endif
1670               )
1671             shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1672           bytelen = ssize - bytepos;
1673           gcc_assert (bytelen > 0);
1674         }
1675
1676       /* If we won't be loading directly from memory, protect the real source
1677          from strange tricks we might play; but make sure that the source can
1678          be loaded directly into the destination.  */
1679       src = orig_src;
1680       if (!MEM_P (orig_src)
1681           && (!CONSTANT_P (orig_src)
1682               || (GET_MODE (orig_src) != mode
1683                   && GET_MODE (orig_src) != VOIDmode)))
1684         {
1685           if (GET_MODE (orig_src) == VOIDmode)
1686             src = gen_reg_rtx (mode);
1687           else
1688             src = gen_reg_rtx (GET_MODE (orig_src));
1689
1690           emit_move_insn (src, orig_src);
1691         }
1692
1693       /* Optimize the access just a bit.  */
1694       if (MEM_P (src)
1695           && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (src))
1696               || MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode))
1697           && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1698           && bytelen == GET_MODE_SIZE (mode))
1699         {
1700           tmps[i] = gen_reg_rtx (mode);
1701           emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
1702         }
1703       else if (COMPLEX_MODE_P (mode)
1704                && GET_MODE (src) == mode
1705                && bytelen == GET_MODE_SIZE (mode))
1706         /* Let emit_move_complex do the bulk of the work.  */
1707         tmps[i] = src;
1708       else if (GET_CODE (src) == CONCAT)
1709         {
1710           unsigned int slen = GET_MODE_SIZE (GET_MODE (src));
1711           unsigned int slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
1712
1713           if ((bytepos == 0 && bytelen == slen0)
1714               || (bytepos != 0 && bytepos + bytelen <= slen))
1715             {
1716               /* The following assumes that the concatenated objects all
1717                  have the same size.  In this case, a simple calculation
1718                  can be used to determine the object and the bit field
1719                  to be extracted.  */
1720               tmps[i] = XEXP (src, bytepos / slen0);
1721               if (! CONSTANT_P (tmps[i])
1722                   && (!REG_P (tmps[i]) || GET_MODE (tmps[i]) != mode))
1723                 tmps[i] = extract_bit_field (tmps[i], bytelen * BITS_PER_UNIT,
1724                                              (bytepos % slen0) * BITS_PER_UNIT,
1725                                              1, NULL_RTX, mode, mode);
1726             }
1727           else
1728             {
1729               rtx mem;
1730
1731               gcc_assert (!bytepos);
1732               mem = assign_stack_temp (GET_MODE (src), slen, 0);
1733               emit_move_insn (mem, src);
1734               tmps[i] = extract_bit_field (mem, bytelen * BITS_PER_UNIT,
1735                                            0, 1, NULL_RTX, mode, mode);
1736             }
1737         }
1738       /* FIXME: A SIMD parallel will eventually lead to a subreg of a
1739          SIMD register, which is currently broken.  While we get GCC
1740          to emit proper RTL for these cases, let's dump to memory.  */
1741       else if (VECTOR_MODE_P (GET_MODE (dst))
1742                && REG_P (src))
1743         {
1744           int slen = GET_MODE_SIZE (GET_MODE (src));
1745           rtx mem;
1746
1747           mem = assign_stack_temp (GET_MODE (src), slen, 0);
1748           emit_move_insn (mem, src);
1749           tmps[i] = adjust_address (mem, mode, (int) bytepos);
1750         }
1751       else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
1752                && XVECLEN (dst, 0) > 1)
1753         tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos);
1754       else if (CONSTANT_P (src)
1755                || (REG_P (src) && GET_MODE (src) == mode))
1756         tmps[i] = src;
1757       else
1758         tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
1759                                      bytepos * BITS_PER_UNIT, 1, NULL_RTX,
1760                                      mode, mode);
1761
1762       if (shift)
1763         tmps[i] = expand_shift (LSHIFT_EXPR, mode, tmps[i],
1764                                 build_int_cst (NULL_TREE, shift), tmps[i], 0);
1765     }
1766 }
1767
1768 /* Emit code to move a block SRC of type TYPE to a block DST,
1769    where DST is non-consecutive registers represented by a PARALLEL.
1770    SSIZE represents the total size of block ORIG_SRC in bytes, or -1
1771    if not known.  */
1772
1773 void
1774 emit_group_load (rtx dst, rtx src, tree type, int ssize)
1775 {
1776   rtx *tmps;
1777   int i;
1778
1779   tmps = alloca (sizeof (rtx) * XVECLEN (dst, 0));
1780   emit_group_load_1 (tmps, dst, src, type, ssize);
1781
1782   /* Copy the extracted pieces into the proper (probable) hard regs.  */
1783   for (i = 0; i < XVECLEN (dst, 0); i++)
1784     {
1785       rtx d = XEXP (XVECEXP (dst, 0, i), 0);
1786       if (d == NULL)
1787         continue;
1788       emit_move_insn (d, tmps[i]);
1789     }
1790 }
1791
1792 /* Similar, but load SRC into new pseudos in a format that looks like
1793    PARALLEL.  This can later be fed to emit_group_move to get things
1794    in the right place.  */
1795
1796 rtx
1797 emit_group_load_into_temps (rtx parallel, rtx src, tree type, int ssize)
1798 {
1799   rtvec vec;
1800   int i;
1801
1802   vec = rtvec_alloc (XVECLEN (parallel, 0));
1803   emit_group_load_1 (&RTVEC_ELT (vec, 0), parallel, src, type, ssize);
1804
1805   /* Convert the vector to look just like the original PARALLEL, except
1806      with the computed values.  */
1807   for (i = 0; i < XVECLEN (parallel, 0); i++)
1808     {
1809       rtx e = XVECEXP (parallel, 0, i);
1810       rtx d = XEXP (e, 0);
1811
1812       if (d)
1813         {
1814           d = force_reg (GET_MODE (d), RTVEC_ELT (vec, i));
1815           e = alloc_EXPR_LIST (REG_NOTE_KIND (e), d, XEXP (e, 1));
1816         }
1817       RTVEC_ELT (vec, i) = e;
1818     }
1819
1820   return gen_rtx_PARALLEL (GET_MODE (parallel), vec);
1821 }
1822
1823 /* Emit code to move a block SRC to block DST, where SRC and DST are
1824    non-consecutive groups of registers, each represented by a PARALLEL.  */
1825
1826 void
1827 emit_group_move (rtx dst, rtx src)
1828 {
1829   int i;
1830
1831   gcc_assert (GET_CODE (src) == PARALLEL
1832               && GET_CODE (dst) == PARALLEL
1833               && XVECLEN (src, 0) == XVECLEN (dst, 0));
1834
1835   /* Skip first entry if NULL.  */
1836   for (i = XEXP (XVECEXP (src, 0, 0), 0) ? 0 : 1; i < XVECLEN (src, 0); i++)
1837     emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0),
1838                     XEXP (XVECEXP (src, 0, i), 0));
1839 }
1840
1841 /* Move a group of registers represented by a PARALLEL into pseudos.  */
1842
1843 rtx
1844 emit_group_move_into_temps (rtx src)
1845 {
1846   rtvec vec = rtvec_alloc (XVECLEN (src, 0));
1847   int i;
1848
1849   for (i = 0; i < XVECLEN (src, 0); i++)
1850     {
1851       rtx e = XVECEXP (src, 0, i);
1852       rtx d = XEXP (e, 0);
1853
1854       if (d)
1855         e = alloc_EXPR_LIST (REG_NOTE_KIND (e), copy_to_reg (d), XEXP (e, 1));
1856       RTVEC_ELT (vec, i) = e;
1857     }
1858
1859   return gen_rtx_PARALLEL (GET_MODE (src), vec);
1860 }
1861
1862 /* Emit code to move a block SRC to a block ORIG_DST of type TYPE,
1863    where SRC is non-consecutive registers represented by a PARALLEL.
1864    SSIZE represents the total size of block ORIG_DST, or -1 if not
1865    known.  */
1866
1867 void
1868 emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
1869 {
1870   rtx *tmps, dst;
1871   int start, finish, i;
1872   enum machine_mode m = GET_MODE (orig_dst);
1873
1874   gcc_assert (GET_CODE (src) == PARALLEL);
1875
1876   if (!SCALAR_INT_MODE_P (m)
1877       && !MEM_P (orig_dst) && GET_CODE (orig_dst) != CONCAT)
1878     {
1879       enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_dst));
1880       if (imode == BLKmode)
1881         dst = assign_stack_temp (GET_MODE (orig_dst), ssize, 0);
1882       else
1883         dst = gen_reg_rtx (imode);
1884       emit_group_store (dst, src, type, ssize);
1885       if (imode != BLKmode)
1886         dst = gen_lowpart (GET_MODE (orig_dst), dst);
1887       emit_move_insn (orig_dst, dst);
1888       return;
1889     }
1890
1891   /* Check for a NULL entry, used to indicate that the parameter goes
1892      both on the stack and in registers.  */
1893   if (XEXP (XVECEXP (src, 0, 0), 0))
1894     start = 0;
1895   else
1896     start = 1;
1897   finish = XVECLEN (src, 0);
1898
1899   tmps = alloca (sizeof (rtx) * finish);
1900
1901   /* Copy the (probable) hard regs into pseudos.  */
1902   for (i = start; i < finish; i++)
1903     {
1904       rtx reg = XEXP (XVECEXP (src, 0, i), 0);
1905       if (!REG_P (reg) || REGNO (reg) < FIRST_PSEUDO_REGISTER)
1906         {
1907           tmps[i] = gen_reg_rtx (GET_MODE (reg));
1908           emit_move_insn (tmps[i], reg);
1909         }
1910       else
1911         tmps[i] = reg;
1912     }
1913
1914   /* If we won't be storing directly into memory, protect the real destination
1915      from strange tricks we might play.  */
1916   dst = orig_dst;
1917   if (GET_CODE (dst) == PARALLEL)
1918     {
1919       rtx temp;
1920
1921       /* We can get a PARALLEL dst if there is a conditional expression in
1922          a return statement.  In that case, the dst and src are the same,
1923          so no action is necessary.  */
1924       if (rtx_equal_p (dst, src))
1925         return;
1926
1927       /* It is unclear if we can ever reach here, but we may as well handle
1928          it.  Allocate a temporary, and split this into a store/load to/from
1929          the temporary.  */
1930
1931       temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
1932       emit_group_store (temp, src, type, ssize);
1933       emit_group_load (dst, temp, type, ssize);
1934       return;
1935     }
1936   else if (!MEM_P (dst) && GET_CODE (dst) != CONCAT)
1937     {
1938       enum machine_mode outer = GET_MODE (dst);
1939       enum machine_mode inner;
1940       HOST_WIDE_INT bytepos;
1941       bool done = false;
1942       rtx temp;
1943
1944       if (!REG_P (dst) || REGNO (dst) < FIRST_PSEUDO_REGISTER)
1945         dst = gen_reg_rtx (outer);
1946
1947       /* Make life a bit easier for combine.  */
1948       /* If the first element of the vector is the low part
1949          of the destination mode, use a paradoxical subreg to
1950          initialize the destination.  */
1951       if (start < finish)
1952         {
1953           inner = GET_MODE (tmps[start]);
1954           bytepos = subreg_lowpart_offset (inner, outer);
1955           if (INTVAL (XEXP (XVECEXP (src, 0, start), 1)) == bytepos)
1956             {
1957               temp = simplify_gen_subreg (outer, tmps[start],
1958                                           inner, 0);
1959               if (temp)
1960                 {
1961                   emit_move_insn (dst, temp);
1962                   done = true;
1963                   start++;
1964                 }
1965             }
1966         }
1967
1968       /* If the first element wasn't the low part, try the last.  */
1969       if (!done
1970           && start < finish - 1)
1971         {
1972           inner = GET_MODE (tmps[finish - 1]);
1973           bytepos = subreg_lowpart_offset (inner, outer);
1974           if (INTVAL (XEXP (XVECEXP (src, 0, finish - 1), 1)) == bytepos)
1975             {
1976               temp = simplify_gen_subreg (outer, tmps[finish - 1],
1977                                           inner, 0);
1978               if (temp)
1979                 {
1980                   emit_move_insn (dst, temp);
1981                   done = true;
1982                   finish--;
1983                 }
1984             }
1985         }
1986
1987       /* Otherwise, simply initialize the result to zero.  */
1988       if (!done)
1989         emit_move_insn (dst, CONST0_RTX (outer));
1990     }
1991
1992   /* Process the pieces.  */
1993   for (i = start; i < finish; i++)
1994     {
1995       HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
1996       enum machine_mode mode = GET_MODE (tmps[i]);
1997       unsigned int bytelen = GET_MODE_SIZE (mode);
1998       rtx dest = dst;
1999
2000       /* Handle trailing fragments that run over the size of the struct.  */
2001       if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2002         {
2003           /* store_bit_field always takes its value from the lsb.
2004              Move the fragment to the lsb if it's not already there.  */
2005           if (
2006 #ifdef BLOCK_REG_PADDING
2007               BLOCK_REG_PADDING (GET_MODE (orig_dst), type, i == start)
2008               == (BYTES_BIG_ENDIAN ? upward : downward)
2009 #else
2010               BYTES_BIG_ENDIAN
2011 #endif
2012               )
2013             {
2014               int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2015               tmps[i] = expand_shift (RSHIFT_EXPR, mode, tmps[i],
2016                                       build_int_cst (NULL_TREE, shift),
2017                                       tmps[i], 0);
2018             }
2019           bytelen = ssize - bytepos;
2020         }
2021
2022       if (GET_CODE (dst) == CONCAT)
2023         {
2024           if (bytepos + bytelen <= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2025             dest = XEXP (dst, 0);
2026           else if (bytepos >= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2027             {
2028               bytepos -= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)));
2029               dest = XEXP (dst, 1);
2030             }
2031           else
2032             {
2033               gcc_assert (bytepos == 0 && XVECLEN (src, 0));
2034               dest = assign_stack_temp (GET_MODE (dest),
2035                                         GET_MODE_SIZE (GET_MODE (dest)), 0);
2036               emit_move_insn (adjust_address (dest, GET_MODE (tmps[i]), bytepos),
2037                               tmps[i]);
2038               dst = dest;
2039               break;
2040             }
2041         }
2042
2043       /* Optimize the access just a bit.  */
2044       if (MEM_P (dest)
2045           && (! SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (dest))
2046               || MEM_ALIGN (dest) >= GET_MODE_ALIGNMENT (mode))
2047           && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2048           && bytelen == GET_MODE_SIZE (mode))
2049         emit_move_insn (adjust_address (dest, mode, bytepos), tmps[i]);
2050       else
2051         store_bit_field (dest, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2052                          mode, tmps[i]);
2053     }
2054
2055   /* Copy from the pseudo into the (probable) hard reg.  */
2056   if (orig_dst != dst)
2057     emit_move_insn (orig_dst, dst);
2058 }
2059
2060 /* Generate code to copy a BLKmode object of TYPE out of a
2061    set of registers starting with SRCREG into TGTBLK.  If TGTBLK
2062    is null, a stack temporary is created.  TGTBLK is returned.
2063
2064    The purpose of this routine is to handle functions that return
2065    BLKmode structures in registers.  Some machines (the PA for example)
2066    want to return all small structures in registers regardless of the
2067    structure's alignment.  */
2068
2069 rtx
2070 copy_blkmode_from_reg (rtx tgtblk, rtx srcreg, tree type)
2071 {
2072   unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2073   rtx src = NULL, dst = NULL;
2074   unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2075   unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0;
2076
2077   if (tgtblk == 0)
2078     {
2079       tgtblk = assign_temp (build_qualified_type (type,
2080                                                   (TYPE_QUALS (type)
2081                                                    | TYPE_QUAL_CONST)),
2082                             0, 1, 1);
2083       preserve_temp_slots (tgtblk);
2084     }
2085
2086   /* This code assumes srcreg is at least a full word.  If it isn't, copy it
2087      into a new pseudo which is a full word.  */
2088
2089   if (GET_MODE (srcreg) != BLKmode
2090       && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2091     srcreg = convert_to_mode (word_mode, srcreg, TYPE_UNSIGNED (type));
2092
2093   /* If the structure doesn't take up a whole number of words, see whether
2094      SRCREG is padded on the left or on the right.  If it's on the left,
2095      set PADDING_CORRECTION to the number of bits to skip.
2096
2097      In most ABIs, the structure will be returned at the least end of
2098      the register, which translates to right padding on little-endian
2099      targets and left padding on big-endian targets.  The opposite
2100      holds if the structure is returned at the most significant
2101      end of the register.  */
2102   if (bytes % UNITS_PER_WORD != 0
2103       && (targetm.calls.return_in_msb (type)
2104           ? !BYTES_BIG_ENDIAN
2105           : BYTES_BIG_ENDIAN))
2106     padding_correction
2107       = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2108
2109   /* Copy the structure BITSIZE bites at a time.
2110
2111      We could probably emit more efficient code for machines which do not use
2112      strict alignment, but it doesn't seem worth the effort at the current
2113      time.  */
2114   for (bitpos = 0, xbitpos = padding_correction;
2115        bitpos < bytes * BITS_PER_UNIT;
2116        bitpos += bitsize, xbitpos += bitsize)
2117     {
2118       /* We need a new source operand each time xbitpos is on a
2119          word boundary and when xbitpos == padding_correction
2120          (the first time through).  */
2121       if (xbitpos % BITS_PER_WORD == 0
2122           || xbitpos == padding_correction)
2123         src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2124                                      GET_MODE (srcreg));
2125
2126       /* We need a new destination operand each time bitpos is on
2127          a word boundary.  */
2128       if (bitpos % BITS_PER_WORD == 0)
2129         dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2130
2131       /* Use xbitpos for the source extraction (right justified) and
2132          xbitpos for the destination store (left justified).  */
2133       store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2134                        extract_bit_field (src, bitsize,
2135                                           xbitpos % BITS_PER_WORD, 1,
2136                                           NULL_RTX, word_mode, word_mode));
2137     }
2138
2139   return tgtblk;
2140 }
2141
2142 /* Add a USE expression for REG to the (possibly empty) list pointed
2143    to by CALL_FUSAGE.  REG must denote a hard register.  */
2144
2145 void
2146 use_reg (rtx *call_fusage, rtx reg)
2147 {
2148   gcc_assert (REG_P (reg) && REGNO (reg) < FIRST_PSEUDO_REGISTER);
2149
2150   *call_fusage
2151     = gen_rtx_EXPR_LIST (VOIDmode,
2152                          gen_rtx_USE (VOIDmode, reg), *call_fusage);
2153 }
2154
2155 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2156    starting at REGNO.  All of these registers must be hard registers.  */
2157
2158 void
2159 use_regs (rtx *call_fusage, int regno, int nregs)
2160 {
2161   int i;
2162
2163   gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
2164
2165   for (i = 0; i < nregs; i++)
2166     use_reg (call_fusage, regno_reg_rtx[regno + i]);
2167 }
2168
2169 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2170    PARALLEL REGS.  This is for calls that pass values in multiple
2171    non-contiguous locations.  The Irix 6 ABI has examples of this.  */
2172
2173 void
2174 use_group_regs (rtx *call_fusage, rtx regs)
2175 {
2176   int i;
2177
2178   for (i = 0; i < XVECLEN (regs, 0); i++)
2179     {
2180       rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2181
2182       /* A NULL entry means the parameter goes both on the stack and in
2183          registers.  This can also be a MEM for targets that pass values
2184          partially on the stack and partially in registers.  */
2185       if (reg != 0 && REG_P (reg))
2186         use_reg (call_fusage, reg);
2187     }
2188 }
2189 \f
2190
2191 /* Determine whether the LEN bytes generated by CONSTFUN can be
2192    stored to memory using several move instructions.  CONSTFUNDATA is
2193    a pointer which will be passed as argument in every CONSTFUN call.
2194    ALIGN is maximum alignment we can assume.  Return nonzero if a
2195    call to store_by_pieces should succeed.  */
2196
2197 int
2198 can_store_by_pieces (unsigned HOST_WIDE_INT len,
2199                      rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2200                      void *constfundata, unsigned int align)
2201 {
2202   unsigned HOST_WIDE_INT l;
2203   unsigned int max_size;
2204   HOST_WIDE_INT offset = 0;
2205   enum machine_mode mode, tmode;
2206   enum insn_code icode;
2207   int reverse;
2208   rtx cst;
2209
2210   if (len == 0)
2211     return 1;
2212
2213   if (! STORE_BY_PIECES_P (len, align))
2214     return 0;
2215
2216   tmode = mode_for_size (STORE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
2217   if (align >= GET_MODE_ALIGNMENT (tmode))
2218     align = GET_MODE_ALIGNMENT (tmode);
2219   else
2220     {
2221       enum machine_mode xmode;
2222
2223       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
2224            tmode != VOIDmode;
2225            xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
2226         if (GET_MODE_SIZE (tmode) > STORE_MAX_PIECES
2227             || SLOW_UNALIGNED_ACCESS (tmode, align))
2228           break;
2229
2230       align = MAX (align, GET_MODE_ALIGNMENT (xmode));
2231     }
2232
2233   /* We would first store what we can in the largest integer mode, then go to
2234      successively smaller modes.  */
2235
2236   for (reverse = 0;
2237        reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2238        reverse++)
2239     {
2240       l = len;
2241       mode = VOIDmode;
2242       max_size = STORE_MAX_PIECES + 1;
2243       while (max_size > 1)
2244         {
2245           for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2246                tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2247             if (GET_MODE_SIZE (tmode) < max_size)
2248               mode = tmode;
2249
2250           if (mode == VOIDmode)
2251             break;
2252
2253           icode = mov_optab->handlers[(int) mode].insn_code;
2254           if (icode != CODE_FOR_nothing
2255               && align >= GET_MODE_ALIGNMENT (mode))
2256             {
2257               unsigned int size = GET_MODE_SIZE (mode);
2258
2259               while (l >= size)
2260                 {
2261                   if (reverse)
2262                     offset -= size;
2263
2264                   cst = (*constfun) (constfundata, offset, mode);
2265                   if (!LEGITIMATE_CONSTANT_P (cst))
2266                     return 0;
2267
2268                   if (!reverse)
2269                     offset += size;
2270
2271                   l -= size;
2272                 }
2273             }
2274
2275           max_size = GET_MODE_SIZE (mode);
2276         }
2277
2278       /* The code above should have handled everything.  */
2279       gcc_assert (!l);
2280     }
2281
2282   return 1;
2283 }
2284
2285 /* Generate several move instructions to store LEN bytes generated by
2286    CONSTFUN to block TO.  (A MEM rtx with BLKmode).  CONSTFUNDATA is a
2287    pointer which will be passed as argument in every CONSTFUN call.
2288    ALIGN is maximum alignment we can assume.
2289    If ENDP is 0 return to, if ENDP is 1 return memory at the end ala
2290    mempcpy, and if ENDP is 2 return memory the end minus one byte ala
2291    stpcpy.  */
2292
2293 rtx
2294 store_by_pieces (rtx to, unsigned HOST_WIDE_INT len,
2295                  rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode),
2296                  void *constfundata, unsigned int align, int endp)
2297 {
2298   struct store_by_pieces data;
2299
2300   if (len == 0)
2301     {
2302       gcc_assert (endp != 2);
2303       return to;
2304     }
2305
2306   gcc_assert (STORE_BY_PIECES_P (len, align));
2307   data.constfun = constfun;
2308   data.constfundata = constfundata;
2309   data.len = len;
2310   data.to = to;
2311   store_by_pieces_1 (&data, align);
2312   if (endp)
2313     {
2314       rtx to1;
2315
2316       gcc_assert (!data.reverse);
2317       if (data.autinc_to)
2318         {
2319           if (endp == 2)
2320             {
2321               if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)
2322                 emit_insn (gen_add2_insn (data.to_addr, constm1_rtx));
2323               else
2324                 data.to_addr = copy_addr_to_reg (plus_constant (data.to_addr,
2325                                                                 -1));
2326             }
2327           to1 = adjust_automodify_address (data.to, QImode, data.to_addr,
2328                                            data.offset);
2329         }
2330       else
2331         {
2332           if (endp == 2)
2333             --data.offset;
2334           to1 = adjust_address (data.to, QImode, data.offset);
2335         }
2336       return to1;
2337     }
2338   else
2339     return data.to;
2340 }
2341
2342 /* Generate several move instructions to clear LEN bytes of block TO.  (A MEM
2343    rtx with BLKmode).  ALIGN is maximum alignment we can assume.  */
2344
2345 static void
2346 clear_by_pieces (rtx to, unsigned HOST_WIDE_INT len, unsigned int align)
2347 {
2348   struct store_by_pieces data;
2349
2350   if (len == 0)
2351     return;
2352
2353   data.constfun = clear_by_pieces_1;
2354   data.constfundata = NULL;
2355   data.len = len;
2356   data.to = to;
2357   store_by_pieces_1 (&data, align);
2358 }
2359
2360 /* Callback routine for clear_by_pieces.
2361    Return const0_rtx unconditionally.  */
2362
2363 static rtx
2364 clear_by_pieces_1 (void *data ATTRIBUTE_UNUSED,
2365                    HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
2366                    enum machine_mode mode ATTRIBUTE_UNUSED)
2367 {
2368   return const0_rtx;
2369 }
2370
2371 /* Subroutine of clear_by_pieces and store_by_pieces.
2372    Generate several move instructions to store LEN bytes of block TO.  (A MEM
2373    rtx with BLKmode).  ALIGN is maximum alignment we can assume.  */
2374
2375 static void
2376 store_by_pieces_1 (struct store_by_pieces *data ATTRIBUTE_UNUSED,
2377                    unsigned int align ATTRIBUTE_UNUSED)
2378 {
2379   rtx to_addr = XEXP (data->to, 0);
2380   unsigned int max_size = STORE_MAX_PIECES + 1;
2381   enum machine_mode mode = VOIDmode, tmode;
2382   enum insn_code icode;
2383
2384   data->offset = 0;
2385   data->to_addr = to_addr;
2386   data->autinc_to
2387     = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2388        || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2389
2390   data->explicit_inc_to = 0;
2391   data->reverse
2392     = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2393   if (data->reverse)
2394     data->offset = data->len;
2395
2396   /* If storing requires more than two move insns,
2397      copy addresses to registers (to make displacements shorter)
2398      and use post-increment if available.  */
2399   if (!data->autinc_to
2400       && move_by_pieces_ninsns (data->len, align, max_size) > 2)
2401     {
2402       /* Determine the main mode we'll be using.  */
2403       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2404            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2405         if (GET_MODE_SIZE (tmode) < max_size)
2406           mode = tmode;
2407
2408       if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2409         {
2410           data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2411           data->autinc_to = 1;
2412           data->explicit_inc_to = -1;
2413         }
2414
2415       if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2416           && ! data->autinc_to)
2417         {
2418           data->to_addr = copy_addr_to_reg (to_addr);
2419           data->autinc_to = 1;
2420           data->explicit_inc_to = 1;
2421         }
2422
2423       if ( !data->autinc_to && CONSTANT_P (to_addr))
2424         data->to_addr = copy_addr_to_reg (to_addr);
2425     }
2426
2427   tmode = mode_for_size (STORE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);
2428   if (align >= GET_MODE_ALIGNMENT (tmode))
2429     align = GET_MODE_ALIGNMENT (tmode);
2430   else
2431     {
2432       enum machine_mode xmode;
2433
2434       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;
2435            tmode != VOIDmode;
2436            xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))
2437         if (GET_MODE_SIZE (tmode) > STORE_MAX_PIECES
2438             || SLOW_UNALIGNED_ACCESS (tmode, align))
2439           break;
2440
2441       align = MAX (align, GET_MODE_ALIGNMENT (xmode));
2442     }
2443
2444   /* First store what we can in the largest integer mode, then go to
2445      successively smaller modes.  */
2446
2447   while (max_size > 1)
2448     {
2449       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2450            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2451         if (GET_MODE_SIZE (tmode) < max_size)
2452           mode = tmode;
2453
2454       if (mode == VOIDmode)
2455         break;
2456
2457       icode = mov_optab->handlers[(int) mode].insn_code;
2458       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2459         store_by_pieces_2 (GEN_FCN (icode), mode, data);
2460
2461       max_size = GET_MODE_SIZE (mode);
2462     }
2463
2464   /* The code above should have handled everything.  */
2465   gcc_assert (!data->len);
2466 }
2467
2468 /* Subroutine of store_by_pieces_1.  Store as many bytes as appropriate
2469    with move instructions for mode MODE.  GENFUN is the gen_... function
2470    to make a move insn for that mode.  DATA has all the other info.  */
2471
2472 static void
2473 store_by_pieces_2 (rtx (*genfun) (rtx, ...), enum machine_mode mode,
2474                    struct store_by_pieces *data)
2475 {
2476   unsigned int size = GET_MODE_SIZE (mode);
2477   rtx to1, cst;
2478
2479   while (data->len >= size)
2480     {
2481       if (data->reverse)
2482         data->offset -= size;
2483
2484       if (data->autinc_to)
2485         to1 = adjust_automodify_address (data->to, mode, data->to_addr,
2486                                          data->offset);
2487       else
2488         to1 = adjust_address (data->to, mode, data->offset);
2489
2490       if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2491         emit_insn (gen_add2_insn (data->to_addr,
2492                                   GEN_INT (-(HOST_WIDE_INT) size)));
2493
2494       cst = (*data->constfun) (data->constfundata, data->offset, mode);
2495       emit_insn ((*genfun) (to1, cst));
2496
2497       if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2498         emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2499
2500       if (! data->reverse)
2501         data->offset += size;
2502
2503       data->len -= size;
2504     }
2505 }
2506 \f
2507 /* Write zeros through the storage of OBJECT.  If OBJECT has BLKmode, SIZE is
2508    its length in bytes.  */
2509
2510 rtx
2511 clear_storage_hints (rtx object, rtx size, enum block_op_methods method,
2512                      unsigned int expected_align, HOST_WIDE_INT expected_size)
2513 {
2514   enum machine_mode mode = GET_MODE (object);
2515   unsigned int align;
2516
2517   gcc_assert (method == BLOCK_OP_NORMAL || method == BLOCK_OP_TAILCALL);
2518
2519   /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2520      just move a zero.  Otherwise, do this a piece at a time.  */
2521   if (mode != BLKmode
2522       && GET_CODE (size) == CONST_INT
2523       && INTVAL (size) == (HOST_WIDE_INT) GET_MODE_SIZE (mode))
2524     {
2525       rtx zero = CONST0_RTX (mode);
2526       if (zero != NULL)
2527         {
2528           emit_move_insn (object, zero);
2529           return NULL;
2530         }
2531
2532       if (COMPLEX_MODE_P (mode))
2533         {
2534           zero = CONST0_RTX (GET_MODE_INNER (mode));
2535           if (zero != NULL)
2536             {
2537               write_complex_part (object, zero, 0);
2538               write_complex_part (object, zero, 1);
2539               return NULL;
2540             }
2541         }
2542     }
2543
2544   if (size == const0_rtx)
2545     return NULL;
2546
2547   align = MEM_ALIGN (object);
2548
2549   if (GET_CODE (size) == CONST_INT
2550       && CLEAR_BY_PIECES_P (INTVAL (size), align))
2551     clear_by_pieces (object, INTVAL (size), align);
2552   else if (set_storage_via_setmem (object, size, const0_rtx, align,
2553                                    expected_align, expected_size))
2554     ;
2555   else
2556     return set_storage_via_libcall (object, size, const0_rtx,
2557                                     method == BLOCK_OP_TAILCALL);
2558
2559   return NULL;
2560 }
2561
2562 rtx
2563 clear_storage (rtx object, rtx size, enum block_op_methods method)
2564 {
2565   return clear_storage_hints (object, size, method, 0, -1);
2566 }
2567
2568
2569 /* A subroutine of clear_storage.  Expand a call to memset.
2570    Return the return value of memset, 0 otherwise.  */
2571
2572 rtx
2573 set_storage_via_libcall (rtx object, rtx size, rtx val, bool tailcall)
2574 {
2575   tree call_expr, fn, object_tree, size_tree, val_tree;
2576   enum machine_mode size_mode;
2577   rtx retval;
2578
2579   /* Emit code to copy OBJECT and SIZE into new pseudos.  We can then
2580      place those into new pseudos into a VAR_DECL and use them later.  */
2581
2582   object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2583
2584   size_mode = TYPE_MODE (sizetype);
2585   size = convert_to_mode (size_mode, size, 1);
2586   size = copy_to_mode_reg (size_mode, size);
2587
2588   /* It is incorrect to use the libcall calling conventions to call
2589      memset in this context.  This could be a user call to memset and
2590      the user may wish to examine the return value from memset.  For
2591      targets where libcalls and normal calls have different conventions
2592      for returning pointers, we could end up generating incorrect code.  */
2593
2594   object_tree = make_tree (ptr_type_node, object);
2595   if (GET_CODE (val) != CONST_INT)
2596     val = convert_to_mode (TYPE_MODE (integer_type_node), val, 1);
2597   size_tree = make_tree (sizetype, size);
2598   val_tree = make_tree (integer_type_node, val);
2599
2600   fn = clear_storage_libcall_fn (true);
2601   call_expr = build_call_expr (fn, 3,
2602                                object_tree, integer_zero_node, size_tree);
2603   CALL_EXPR_TAILCALL (call_expr) = tailcall;
2604
2605   retval = expand_normal (call_expr);
2606
2607   return retval;
2608 }
2609
2610 /* A subroutine of set_storage_via_libcall.  Create the tree node
2611    for the function we use for block clears.  The first time FOR_CALL
2612    is true, we call assemble_external.  */
2613
2614 static GTY(()) tree block_clear_fn;
2615
2616 void
2617 init_block_clear_fn (const char *asmspec)
2618 {
2619   if (!block_clear_fn)
2620     {
2621       tree fn, args;
2622
2623       fn = get_identifier ("memset");
2624       args = build_function_type_list (ptr_type_node, ptr_type_node,
2625                                        integer_type_node, sizetype,
2626                                        NULL_TREE);
2627
2628       fn = build_decl (FUNCTION_DECL, fn, args);
2629       DECL_EXTERNAL (fn) = 1;
2630       TREE_PUBLIC (fn) = 1;
2631       DECL_ARTIFICIAL (fn) = 1;
2632       TREE_NOTHROW (fn) = 1;
2633       DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
2634       DECL_VISIBILITY_SPECIFIED (fn) = 1;
2635
2636       block_clear_fn = fn;
2637     }
2638
2639   if (asmspec)
2640     set_user_assembler_name (block_clear_fn, asmspec);
2641 }
2642
2643 static tree
2644 clear_storage_libcall_fn (int for_call)
2645 {
2646   static bool emitted_extern;
2647
2648   if (!block_clear_fn)
2649     init_block_clear_fn (NULL);
2650
2651   if (for_call && !emitted_extern)
2652     {
2653       emitted_extern = true;
2654       make_decl_rtl (block_clear_fn);
2655       assemble_external (block_clear_fn);
2656     }
2657
2658   return block_clear_fn;
2659 }
2660 \f
2661 /* Expand a setmem pattern; return true if successful.  */
2662
2663 bool
2664 set_storage_via_setmem (rtx object, rtx size, rtx val, unsigned int align,
2665                         unsigned int expected_align, HOST_WIDE_INT expected_size)
2666 {
2667   /* Try the most limited insn first, because there's no point
2668      including more than one in the machine description unless
2669      the more limited one has some advantage.  */
2670
2671   rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2672   enum machine_mode mode;
2673
2674   if (expected_align < align)
2675     expected_align = align;
2676
2677   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2678        mode = GET_MODE_WIDER_MODE (mode))
2679     {
2680       enum insn_code code = setmem_optab[(int) mode];
2681       insn_operand_predicate_fn pred;
2682
2683       if (code != CODE_FOR_nothing
2684           /* We don't need MODE to be narrower than
2685              BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2686              the mode mask, as it is returned by the macro, it will
2687              definitely be less than the actual mode mask.  */
2688           && ((GET_CODE (size) == CONST_INT
2689                && ((unsigned HOST_WIDE_INT) INTVAL (size)
2690                    <= (GET_MODE_MASK (mode) >> 1)))
2691               || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2692           && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2693               || (*pred) (object, BLKmode))
2694           && ((pred = insn_data[(int) code].operand[3].predicate) == 0
2695               || (*pred) (opalign, VOIDmode)))
2696         {
2697           rtx opsize, opchar;
2698           enum machine_mode char_mode;
2699           rtx last = get_last_insn ();
2700           rtx pat;
2701
2702           opsize = convert_to_mode (mode, size, 1);
2703           pred = insn_data[(int) code].operand[1].predicate;
2704           if (pred != 0 && ! (*pred) (opsize, mode))
2705             opsize = copy_to_mode_reg (mode, opsize);
2706
2707           opchar = val;
2708           char_mode = insn_data[(int) code].operand[2].mode;
2709           if (char_mode != VOIDmode)
2710             {
2711               opchar = convert_to_mode (char_mode, opchar, 1);
2712               pred = insn_data[(int) code].operand[2].predicate;
2713               if (pred != 0 && ! (*pred) (opchar, char_mode))
2714                 opchar = copy_to_mode_reg (char_mode, opchar);
2715             }
2716
2717           if (insn_data[(int) code].n_operands == 4)
2718             pat = GEN_FCN ((int) code) (object, opsize, opchar, opalign);
2719           else
2720             pat = GEN_FCN ((int) code) (object, opsize, opchar, opalign,
2721                                         GEN_INT (expected_align),
2722                                         GEN_INT (expected_size));
2723           if (pat)
2724             {
2725               emit_insn (pat);
2726               return true;
2727             }
2728           else
2729             delete_insns_since (last);
2730         }
2731     }
2732
2733   return false;
2734 }
2735
2736 \f
2737 /* Write to one of the components of the complex value CPLX.  Write VAL to
2738    the real part if IMAG_P is false, and the imaginary part if its true.  */
2739
2740 static void
2741 write_complex_part (rtx cplx, rtx val, bool imag_p)
2742 {
2743   enum machine_mode cmode;
2744   enum machine_mode imode;
2745   unsigned ibitsize;
2746
2747   if (GET_CODE (cplx) == CONCAT)
2748     {
2749       emit_move_insn (XEXP (cplx, imag_p), val);
2750       return;
2751     }
2752
2753   cmode = GET_MODE (cplx);
2754   imode = GET_MODE_INNER (cmode);
2755   ibitsize = GET_MODE_BITSIZE (imode);
2756
2757   /* For MEMs simplify_gen_subreg may generate an invalid new address
2758      because, e.g., the original address is considered mode-dependent
2759      by the target, which restricts simplify_subreg from invoking
2760      adjust_address_nv.  Instead of preparing fallback support for an
2761      invalid address, we call adjust_address_nv directly.  */
2762   if (MEM_P (cplx))
2763     {
2764       emit_move_insn (adjust_address_nv (cplx, imode,
2765                                          imag_p ? GET_MODE_SIZE (imode) : 0),
2766                       val);
2767       return;
2768     }
2769
2770   /* If the sub-object is at least word sized, then we know that subregging
2771      will work.  This special case is important, since store_bit_field
2772      wants to operate on integer modes, and there's rarely an OImode to
2773      correspond to TCmode.  */
2774   if (ibitsize >= BITS_PER_WORD
2775       /* For hard regs we have exact predicates.  Assume we can split
2776          the original object if it spans an even number of hard regs.
2777          This special case is important for SCmode on 64-bit platforms
2778          where the natural size of floating-point regs is 32-bit.  */
2779       || (REG_P (cplx)
2780           && REGNO (cplx) < FIRST_PSEUDO_REGISTER
2781           && hard_regno_nregs[REGNO (cplx)][cmode] % 2 == 0))
2782     {
2783       rtx part = simplify_gen_subreg (imode, cplx, cmode,
2784                                       imag_p ? GET_MODE_SIZE (imode) : 0);
2785       if (part)
2786         {
2787           emit_move_insn (part, val);
2788           return;
2789         }
2790       else
2791         /* simplify_gen_subreg may fail for sub-word MEMs.  */
2792         gcc_assert (MEM_P (cplx) && ibitsize < BITS_PER_WORD);
2793     }
2794
2795   store_bit_field (cplx, ibitsize, imag_p ? ibitsize : 0, imode, val);
2796 }
2797
2798 /* Extract one of the components of the complex value CPLX.  Extract the
2799    real part if IMAG_P is false, and the imaginary part if it's true.  */
2800
2801 static rtx
2802 read_complex_part (rtx cplx, bool imag_p)
2803 {
2804   enum machine_mode cmode, imode;
2805   unsigned ibitsize;
2806
2807   if (GET_CODE (cplx) == CONCAT)
2808     return XEXP (cplx, imag_p);
2809
2810   cmode = GET_MODE (cplx);
2811   imode = GET_MODE_INNER (cmode);
2812   ibitsize = GET_MODE_BITSIZE (imode);
2813
2814   /* Special case reads from complex constants that got spilled to memory.  */
2815   if (MEM_P (cplx) && GET_CODE (XEXP (cplx, 0)) == SYMBOL_REF)
2816     {
2817       tree decl = SYMBOL_REF_DECL (XEXP (cplx, 0));
2818       if (decl && TREE_CODE (decl) == COMPLEX_CST)
2819         {
2820           tree part = imag_p ? TREE_IMAGPART (decl) : TREE_REALPART (decl);
2821           if (CONSTANT_CLASS_P (part))
2822             return expand_expr (part, NULL_RTX, imode, EXPAND_NORMAL);
2823         }
2824     }
2825
2826   /* For MEMs simplify_gen_subreg may generate an invalid new address
2827      because, e.g., the original address is considered mode-dependent
2828      by the target, which restricts simplify_subreg from invoking
2829      adjust_address_nv.  Instead of preparing fallback support for an
2830      invalid address, we call adjust_address_nv directly.  */
2831   if (MEM_P (cplx))
2832     return adjust_address_nv (cplx, imode,
2833                               imag_p ? GET_MODE_SIZE (imode) : 0);
2834
2835   /* If the sub-object is at least word sized, then we know that subregging
2836      will work.  This special case is important, since extract_bit_field
2837      wants to operate on integer modes, and there's rarely an OImode to
2838      correspond to TCmode.  */
2839   if (ibitsize >= BITS_PER_WORD
2840       /* For hard regs we have exact predicates.  Assume we can split
2841          the original object if it spans an even number of hard regs.
2842          This special case is important for SCmode on 64-bit platforms
2843          where the natural size of floating-point regs is 32-bit.  */
2844       || (REG_P (cplx)
2845           && REGNO (cplx) < FIRST_PSEUDO_REGISTER
2846           && hard_regno_nregs[REGNO (cplx)][cmode] % 2 == 0))
2847     {
2848       rtx ret = simplify_gen_subreg (imode, cplx, cmode,
2849                                      imag_p ? GET_MODE_SIZE (imode) : 0);
2850       if (ret)
2851         return ret;
2852       else
2853         /* simplify_gen_subreg may fail for sub-word MEMs.  */
2854         gcc_assert (MEM_P (cplx) && ibitsize < BITS_PER_WORD);
2855     }
2856
2857   return extract_bit_field (cplx, ibitsize, imag_p ? ibitsize : 0,
2858                             true, NULL_RTX, imode, imode);
2859 }
2860 \f
2861 /* A subroutine of emit_move_insn_1.  Yet another lowpart generator.
2862    NEW_MODE and OLD_MODE are the same size.  Return NULL if X cannot be
2863    represented in NEW_MODE.  If FORCE is true, this will never happen, as
2864    we'll force-create a SUBREG if needed.  */
2865
2866 static rtx
2867 emit_move_change_mode (enum machine_mode new_mode,
2868                        enum machine_mode old_mode, rtx x, bool force)
2869 {
2870   rtx ret;
2871
2872   if (push_operand (x, GET_MODE (x)))
2873     {
2874       ret = gen_rtx_MEM (new_mode, XEXP (x, 0));
2875       MEM_COPY_ATTRIBUTES (ret, x);
2876     }
2877   else if (MEM_P (x))
2878     {
2879       /* We don't have to worry about changing the address since the
2880          size in bytes is supposed to be the same.  */
2881       if (reload_in_progress)
2882         {
2883           /* Copy the MEM to change the mode and move any
2884              substitutions from the old MEM to the new one.  */
2885           ret = adjust_address_nv (x, new_mode, 0);
2886           copy_replacements (x, ret);
2887         }
2888       else
2889         ret = adjust_address (x, new_mode, 0);
2890     }
2891   else
2892     {
2893       /* Note that we do want simplify_subreg's behavior of validating
2894          that the new mode is ok for a hard register.  If we were to use
2895          simplify_gen_subreg, we would create the subreg, but would
2896          probably run into the target not being able to implement it.  */
2897       /* Except, of course, when FORCE is true, when this is exactly what
2898          we want.  Which is needed for CCmodes on some targets.  */
2899       if (force)
2900         ret = simplify_gen_subreg (new_mode, x, old_mode, 0);
2901       else
2902         ret = simplify_subreg (new_mode, x, old_mode, 0);
2903     }
2904
2905   return ret;
2906 }
2907
2908 /* A subroutine of emit_move_insn_1.  Generate a move from Y into X using
2909    an integer mode of the same size as MODE.  Returns the instruction
2910    emitted, or NULL if such a move could not be generated.  */
2911
2912 static rtx
2913 emit_move_via_integer (enum machine_mode mode, rtx x, rtx y, bool force)
2914 {
2915   enum machine_mode imode;
2916   enum insn_code code;
2917
2918   /* There must exist a mode of the exact size we require.  */
2919   imode = int_mode_for_mode (mode);
2920   if (imode == BLKmode)
2921     return NULL_RTX;
2922
2923   /* The target must support moves in this mode.  */
2924   code = mov_optab->handlers[imode].insn_code;
2925   if (code == CODE_FOR_nothing)
2926     return NULL_RTX;
2927
2928   x = emit_move_change_mode (imode, mode, x, force);
2929   if (x == NULL_RTX)
2930     return NULL_RTX;
2931   y = emit_move_change_mode (imode, mode, y, force);
2932   if (y == NULL_RTX)
2933     return NULL_RTX;
2934   return emit_insn (GEN_FCN (code) (x, y));
2935 }
2936
2937 /* A subroutine of emit_move_insn_1.  X is a push_operand in MODE.
2938    Return an equivalent MEM that does not use an auto-increment.  */
2939
2940 static rtx
2941 emit_move_resolve_push (enum machine_mode mode, rtx x)
2942 {
2943   enum rtx_code code = GET_CODE (XEXP (x, 0));
2944   HOST_WIDE_INT adjust;
2945   rtx temp;
2946
2947   adjust = GET_MODE_SIZE (mode);
2948 #ifdef PUSH_ROUNDING
2949   adjust = PUSH_ROUNDING (adjust);
2950 #endif
2951   if (code == PRE_DEC || code == POST_DEC)
2952     adjust = -adjust;
2953   else if (code == PRE_MODIFY || code == POST_MODIFY)
2954     {
2955       rtx expr = XEXP (XEXP (x, 0), 1);
2956       HOST_WIDE_INT val;
2957
2958       gcc_assert (GET_CODE (expr) == PLUS || GET_CODE (expr) == MINUS);
2959       gcc_assert (GET_CODE (XEXP (expr, 1)) == CONST_INT);
2960       val = INTVAL (XEXP (expr, 1));
2961       if (GET_CODE (expr) == MINUS)
2962         val = -val;
2963       gcc_assert (adjust == val || adjust == -val);
2964       adjust = val;
2965     }
2966
2967   /* Do not use anti_adjust_stack, since we don't want to update
2968      stack_pointer_delta.  */
2969   temp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
2970                               GEN_INT (adjust), stack_pointer_rtx,
2971                               0, OPTAB_LIB_WIDEN);
2972   if (temp != stack_pointer_rtx)
2973     emit_move_insn (stack_pointer_rtx, temp);
2974
2975   switch (code)
2976     {
2977     case PRE_INC:
2978     case PRE_DEC:
2979     case PRE_MODIFY:
2980       temp = stack_pointer_rtx;
2981       break;
2982     case POST_INC:
2983     case POST_DEC:
2984     case POST_MODIFY:
2985       temp = plus_constant (stack_pointer_rtx, -adjust);
2986       break;
2987     default:
2988       gcc_unreachable ();
2989     }
2990
2991   return replace_equiv_address (x, temp);
2992 }
2993
2994 /* A subroutine of emit_move_complex.  Generate a move from Y into X.
2995    X is known to satisfy push_operand, and MODE is known to be complex.
2996    Returns the last instruction emitted.  */
2997
2998 rtx
2999 emit_move_complex_push (enum machine_mode mode, rtx x, rtx y)
3000 {
3001   enum machine_mode submode = GET_MODE_INNER (mode);
3002   bool imag_first;
3003
3004 #ifdef PUSH_ROUNDING
3005   unsigned int submodesize = GET_MODE_SIZE (submode);
3006
3007   /* In case we output to the stack, but the size is smaller than the
3008      machine can push exactly, we need to use move instructions.  */
3009   if (PUSH_ROUNDING (submodesize) != submodesize)
3010     {
3011       x = emit_move_resolve_push (mode, x);
3012       return emit_move_insn (x, y);
3013     }
3014 #endif
3015
3016   /* Note that the real part always precedes the imag part in memory
3017      regardless of machine's endianness.  */
3018   switch (GET_CODE (XEXP (x, 0)))
3019     {
3020     case PRE_DEC:
3021     case POST_DEC:
3022       imag_first = true;
3023       break;
3024     case PRE_INC:
3025     case POST_INC:
3026       imag_first = false;
3027       break;
3028     default:
3029       gcc_unreachable ();
3030     }
3031
3032   emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
3033                   read_complex_part (y, imag_first));
3034   return emit_move_insn (gen_rtx_MEM (submode, XEXP (x, 0)),
3035                          read_complex_part (y, !imag_first));
3036 }
3037
3038 /* A subroutine of emit_move_complex.  Perform the move from Y to X
3039    via two moves of the parts.  Returns the last instruction emitted.  */
3040
3041 rtx
3042 emit_move_complex_parts (rtx x, rtx y)
3043 {
3044   /* Show the output dies here.  This is necessary for SUBREGs
3045      of pseudos since we cannot track their lifetimes correctly;
3046      hard regs shouldn't appear here except as return values.  */
3047   if (!reload_completed && !reload_in_progress
3048       && REG_P (x) && !reg_overlap_mentioned_p (x, y))
3049     emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3050
3051   write_complex_part (x, read_complex_part (y, false), false);
3052   write_complex_part (x, read_complex_part (y, true), true);
3053
3054   return get_last_insn ();
3055 }
3056
3057 /* A subroutine of emit_move_insn_1.  Generate a move from Y into X.
3058    MODE is known to be complex.  Returns the last instruction emitted.  */
3059
3060 static rtx
3061 emit_move_complex (enum machine_mode mode, rtx x, rtx y)
3062 {
3063   bool try_int;
3064
3065   /* Need to take special care for pushes, to maintain proper ordering
3066      of the data, and possibly extra padding.  */
3067   if (push_operand (x, mode))
3068     return emit_move_complex_push (mode, x, y);
3069
3070   /* See if we can coerce the target into moving both values at once.  */
3071
3072   /* Move floating point as parts.  */
3073   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
3074       && mov_optab->handlers[GET_MODE_INNER (mode)].insn_code != CODE_FOR_nothing)
3075     try_int = false;
3076   /* Not possible if the values are inherently not adjacent.  */
3077   else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
3078     try_int = false;
3079   /* Is possible if both are registers (or subregs of registers).  */
3080   else if (register_operand (x, mode) && register_operand (y, mode))
3081     try_int = true;
3082   /* If one of the operands is a memory, and alignment constraints
3083      are friendly enough, we may be able to do combined memory operations.
3084      We do not attempt this if Y is a constant because that combination is
3085      usually better with the by-parts thing below.  */
3086   else if ((MEM_P (x) ? !CONSTANT_P (y) : MEM_P (y))
3087            && (!STRICT_ALIGNMENT
3088                || get_mode_alignment (mode) == BIGGEST_ALIGNMENT))
3089     try_int = true;
3090   else
3091     try_int = false;
3092
3093   if (try_int)
3094     {
3095       rtx ret;
3096
3097       /* For memory to memory moves, optimal behavior can be had with the
3098          existing block move logic.  */
3099       if (MEM_P (x) && MEM_P (y))
3100         {
3101           emit_block_move (x, y, GEN_INT (GET_MODE_SIZE (mode)),
3102                            BLOCK_OP_NO_LIBCALL);
3103           return get_last_insn ();
3104         }
3105
3106       ret = emit_move_via_integer (mode, x, y, true);
3107       if (ret)
3108         return ret;
3109     }
3110
3111   return emit_move_complex_parts (x, y);
3112 }
3113
3114 /* A subroutine of emit_move_insn_1.  Generate a move from Y into X.
3115    MODE is known to be MODE_CC.  Returns the last instruction emitted.  */
3116
3117 static rtx
3118 emit_move_ccmode (enum machine_mode mode, rtx x, rtx y)
3119 {
3120   rtx ret;
3121
3122   /* Assume all MODE_CC modes are equivalent; if we have movcc, use it.  */
3123   if (mode != CCmode)
3124     {
3125       enum insn_code code = mov_optab->handlers[CCmode].insn_code;
3126       if (code != CODE_FOR_nothing)
3127         {
3128           x = emit_move_change_mode (CCmode, mode, x, true);
3129           y = emit_move_change_mode (CCmode, mode, y, true);
3130           return emit_insn (GEN_FCN (code) (x, y));
3131         }
3132     }
3133
3134   /* Otherwise, find the MODE_INT mode of the same width.  */
3135   ret = emit_move_via_integer (mode, x, y, false);
3136   gcc_assert (ret != NULL);
3137   return ret;
3138 }
3139
3140 /* Return true if word I of OP lies entirely in the
3141    undefined bits of a paradoxical subreg.  */
3142
3143 static bool
3144 undefined_operand_subword_p (rtx op, int i)
3145 {
3146   enum machine_mode innermode, innermostmode;
3147   int offset;
3148   if (GET_CODE (op) != SUBREG)
3149     return false;
3150   innermode = GET_MODE (op);
3151   innermostmode = GET_MODE (SUBREG_REG (op));
3152   offset = i * UNITS_PER_WORD + SUBREG_BYTE (op);
3153   /* The SUBREG_BYTE represents offset, as if the value were stored in
3154      memory, except for a paradoxical subreg where we define
3155      SUBREG_BYTE to be 0; undo this exception as in
3156      simplify_subreg.  */
3157   if (SUBREG_BYTE (op) == 0
3158       && GET_MODE_SIZE (innermostmode) < GET_MODE_SIZE (innermode))
3159     {
3160       int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (innermode));
3161       if (WORDS_BIG_ENDIAN)
3162         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3163       if (BYTES_BIG_ENDIAN)
3164         offset += difference % UNITS_PER_WORD;
3165     }
3166   if (offset >= GET_MODE_SIZE (innermostmode)
3167       || offset <= -GET_MODE_SIZE (word_mode))
3168     return true;
3169   return false;
3170 }
3171
3172 /* A subroutine of emit_move_insn_1.  Generate a move from Y into X.
3173    MODE is any multi-word or full-word mode that lacks a move_insn
3174    pattern.  Note that you will get better code if you define such
3175    patterns, even if they must turn into multiple assembler instructions.  */
3176
3177 static rtx
3178 emit_move_multi_word (enum machine_mode mode, rtx x, rtx y)
3179 {
3180   rtx last_insn = 0;
3181   rtx seq, inner;
3182   bool need_clobber;
3183   int i;
3184
3185   gcc_assert (GET_MODE_SIZE (mode) >= UNITS_PER_WORD);
3186
3187   /* If X is a push on the stack, do the push now and replace
3188      X with a reference to the stack pointer.  */
3189   if (push_operand (x, mode))
3190     x = emit_move_resolve_push (mode, x);
3191
3192   /* If we are in reload, see if either operand is a MEM whose address
3193      is scheduled for replacement.  */
3194   if (reload_in_progress && MEM_P (x)
3195       && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
3196     x = replace_equiv_address_nv (x, inner);
3197   if (reload_in_progress && MEM_P (y)
3198       && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
3199     y = replace_equiv_address_nv (y, inner);
3200
3201   start_sequence ();
3202
3203   need_clobber = false;
3204   for (i = 0;
3205        i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
3206        i++)
3207     {
3208       rtx xpart = operand_subword (x, i, 1, mode);
3209       rtx ypart;
3210
3211       /* Do not generate code for a move if it would come entirely
3212          from the undefined bits of a paradoxical subreg.  */
3213       if (undefined_operand_subword_p (y, i))
3214         continue;
3215
3216       ypart = operand_subword (y, i, 1, mode);
3217
3218       /* If we can't get a part of Y, put Y into memory if it is a
3219          constant.  Otherwise, force it into a register.  Then we must
3220          be able to get a part of Y.  */
3221       if (ypart == 0 && CONSTANT_P (y))
3222         {
3223           y = use_anchored_address (force_const_mem (mode, y));
3224           ypart = operand_subword (y, i, 1, mode);
3225         }
3226       else if (ypart == 0)
3227         ypart = operand_subword_force (y, i, mode);
3228
3229       gcc_assert (xpart && ypart);
3230
3231       need_clobber |= (GET_CODE (xpart) == SUBREG);
3232
3233       last_insn = emit_move_insn (xpart, ypart);
3234     }
3235
3236   seq = get_insns ();
3237   end_sequence ();
3238
3239   /* Show the output dies here.  This is necessary for SUBREGs
3240      of pseudos since we cannot track their lifetimes correctly;
3241      hard regs shouldn't appear here except as return values.
3242      We never want to emit such a clobber after reload.  */
3243   if (x != y
3244       && ! (reload_in_progress || reload_completed)
3245       && need_clobber != 0)
3246     emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3247
3248   emit_insn (seq);
3249
3250   return last_insn;
3251 }
3252
3253 /* Low level part of emit_move_insn.
3254    Called just like emit_move_insn, but assumes X and Y
3255    are basically valid.  */
3256
3257 rtx
3258 emit_move_insn_1 (rtx x, rtx y)
3259 {
3260   enum machine_mode mode = GET_MODE (x);
3261   enum insn_code code;
3262
3263   gcc_assert ((unsigned int) mode < (unsigned int) MAX_MACHINE_MODE);
3264
3265   code = mov_optab->handlers[mode].insn_code;
3266   if (code != CODE_FOR_nothing)
3267     return emit_insn (GEN_FCN (code) (x, y));
3268
3269   /* Expand complex moves by moving real part and imag part.  */
3270   if (COMPLEX_MODE_P (mode))
3271     return emit_move_complex (mode, x, y);
3272
3273   if (GET_MODE_CLASS (mode) == MODE_DECIMAL_FLOAT)
3274     {
3275       rtx result = emit_move_via_integer (mode, x, y, true);
3276
3277       /* If we can't find an integer mode, use multi words.  */
3278       if (result)
3279         return result;
3280       else
3281         return emit_move_multi_word (mode, x, y);
3282     }
3283
3284   if (GET_MODE_CLASS (mode) == MODE_CC)
3285     return emit_move_ccmode (mode, x, y);
3286
3287   /* Try using a move pattern for the corresponding integer mode.  This is
3288      only safe when simplify_subreg can convert MODE constants into integer
3289      constants.  At present, it can only do this reliably if the value
3290      fits within a HOST_WIDE_INT.  */
3291   if (!CONSTANT_P (y) || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3292     {
3293       rtx ret = emit_move_via_integer (mode, x, y, false);
3294       if (ret)
3295         return ret;
3296     }
3297
3298   return emit_move_multi_word (mode, x, y);
3299 }
3300
3301 /* Generate code to copy Y into X.
3302    Both Y and X must have the same mode, except that
3303    Y can be a constant with VOIDmode.
3304    This mode cannot be BLKmode; use emit_block_move for that.
3305
3306    Return the last instruction emitted.  */
3307
3308 rtx
3309 emit_move_insn (rtx x, rtx y)
3310 {
3311   enum machine_mode mode = GET_MODE (x);
3312   rtx y_cst = NULL_RTX;
3313   rtx last_insn, set;
3314
3315   gcc_assert (mode != BLKmode
3316               && (GET_MODE (y) == mode || GET_MODE (y) == VOIDmode));
3317
3318   if (CONSTANT_P (y))
3319     {
3320       if (optimize
3321           && SCALAR_FLOAT_MODE_P (GET_MODE (x))
3322           && (last_insn = compress_float_constant (x, y)))
3323         return last_insn;
3324
3325       y_cst = y;
3326
3327       if (!LEGITIMATE_CONSTANT_P (y))
3328         {
3329           y = force_const_mem (mode, y);
3330
3331           /* If the target's cannot_force_const_mem prevented the spill,
3332              assume that the target's move expanders will also take care
3333              of the non-legitimate constant.  */
3334           if (!y)
3335             y = y_cst;
3336           else
3337             y = use_anchored_address (y);
3338         }
3339     }
3340
3341   /* If X or Y are memory references, verify that their addresses are valid
3342      for the machine.  */
3343   if (MEM_P (x)
3344       && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
3345            && ! push_operand (x, GET_MODE (x)))
3346           || (flag_force_addr
3347               && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
3348     x = validize_mem (x);
3349
3350   if (MEM_P (y)
3351       && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
3352           || (flag_force_addr
3353               && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
3354     y = validize_mem (y);
3355
3356   gcc_assert (mode != BLKmode);
3357
3358   last_insn = emit_move_insn_1 (x, y);
3359
3360   if (y_cst && REG_P (x)
3361       && (set = single_set (last_insn)) != NULL_RTX
3362       && SET_DEST (set) == x
3363       && ! rtx_equal_p (y_cst, SET_SRC (set)))
3364     set_unique_reg_note (last_insn, REG_EQUAL, y_cst);
3365
3366   return last_insn;
3367 }
3368
3369 /* If Y is representable exactly in a narrower mode, and the target can
3370    perform the extension directly from constant or memory, then emit the
3371    move as an extension.  */
3372
3373 static rtx
3374 compress_float_constant (rtx x, rtx y)
3375 {
3376   enum machine_mode dstmode = GET_MODE (x);
3377   enum machine_mode orig_srcmode = GET_MODE (y);
3378   enum machine_mode srcmode;
3379   REAL_VALUE_TYPE r;
3380   int oldcost, newcost;
3381
3382   REAL_VALUE_FROM_CONST_DOUBLE (r, y);
3383
3384   if (LEGITIMATE_CONSTANT_P (y))
3385     oldcost = rtx_cost (y, SET);
3386   else
3387     oldcost = rtx_cost (force_const_mem (dstmode, y), SET);
3388
3389   for (srcmode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_srcmode));
3390        srcmode != orig_srcmode;
3391        srcmode = GET_MODE_WIDER_MODE (srcmode))
3392     {
3393       enum insn_code ic;
3394       rtx trunc_y, last_insn;
3395
3396       /* Skip if the target can't extend this way.  */
3397       ic = can_extend_p (dstmode, srcmode, 0);
3398       if (ic == CODE_FOR_nothing)
3399         continue;
3400
3401       /* Skip if the narrowed value isn't exact.  */
3402       if (! exact_real_truncate (srcmode, &r))
3403         continue;
3404
3405       trunc_y = CONST_DOUBLE_FROM_REAL_VALUE (r, srcmode);
3406
3407       if (LEGITIMATE_CONSTANT_P (trunc_y))
3408         {
3409           /* Skip if the target needs extra instructions to perform
3410              the extension.  */
3411           if (! (*insn_data[ic].operand[1].predicate) (trunc_y, srcmode))
3412             continue;
3413           /* This is valid, but may not be cheaper than the original. */
3414           newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET);
3415           if (oldcost < newcost)
3416             continue;
3417         }
3418       else if (float_extend_from_mem[dstmode][srcmode])
3419         {
3420           trunc_y = force_const_mem (srcmode, trunc_y);
3421           /* This is valid, but may not be cheaper than the original. */
3422           newcost = rtx_cost (gen_rtx_FLOAT_EXTEND (dstmode, trunc_y), SET);
3423           if (oldcost < newcost)
3424             continue;
3425           trunc_y = validize_mem (trunc_y);
3426         }
3427       else
3428         continue;
3429
3430       /* For CSE's benefit, force the compressed constant pool entry
3431          into a new pseudo.  This constant may be used in different modes,
3432          and if not, combine will put things back together for us.  */
3433       trunc_y = force_reg (srcmode, trunc_y);
3434       emit_unop_insn (ic, x, trunc_y, UNKNOWN);
3435       last_insn = get_last_insn ();
3436
3437       if (REG_P (x))
3438         set_unique_reg_note (last_insn, REG_EQUAL, y);
3439
3440       return last_insn;
3441     }
3442
3443   return NULL_RTX;
3444 }
3445 \f
3446 /* Pushing data onto the stack.  */
3447
3448 /* Push a block of length SIZE (perhaps variable)
3449    and return an rtx to address the beginning of the block.
3450    The value may be virtual_outgoing_args_rtx.
3451
3452    EXTRA is the number of bytes of padding to push in addition to SIZE.
3453    BELOW nonzero means this padding comes at low addresses;
3454    otherwise, the padding comes at high addresses.  */
3455
3456 rtx
3457 push_block (rtx size, int extra, int below)
3458 {
3459   rtx temp;
3460
3461   size = convert_modes (Pmode, ptr_mode, size, 1);
3462   if (CONSTANT_P (size))
3463     anti_adjust_stack (plus_constant (size, extra));
3464   else if (REG_P (size) && extra == 0)
3465     anti_adjust_stack (size);
3466   else
3467     {
3468       temp = copy_to_mode_reg (Pmode, size);
3469       if (extra != 0)
3470         temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3471                              temp, 0, OPTAB_LIB_WIDEN);
3472       anti_adjust_stack (temp);
3473     }
3474
3475 #ifndef STACK_GROWS_DOWNWARD
3476   if (0)
3477 #else
3478   if (1)
3479 #endif
3480     {
3481       temp = virtual_outgoing_args_rtx;
3482       if (extra != 0 && below)
3483         temp = plus_constant (temp, extra);
3484     }
3485   else
3486     {
3487       if (GET_CODE (size) == CONST_INT)
3488         temp = plus_constant (virtual_outgoing_args_rtx,
3489                               -INTVAL (size) - (below ? 0 : extra));
3490       else if (extra != 0 && !below)
3491         temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3492                              negate_rtx (Pmode, plus_constant (size, extra)));
3493       else
3494         temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3495                              negate_rtx (Pmode, size));
3496     }
3497
3498   return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3499 }
3500
3501 #ifdef PUSH_ROUNDING
3502
3503 /* Emit single push insn.  */
3504
3505 static void
3506 emit_single_push_insn (enum machine_mode mode, rtx x, tree type)
3507 {
3508   rtx dest_addr;
3509   unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3510   rtx dest;
3511   enum insn_code icode;
3512   insn_operand_predicate_fn pred;
3513
3514   stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3515   /* If there is push pattern, use it.  Otherwise try old way of throwing
3516      MEM representing push operation to move expander.  */
3517   icode = push_optab->handlers[(int) mode].insn_code;
3518   if (icode != CODE_FOR_nothing)
3519     {
3520       if (((pred = insn_data[(int) icode].operand[0].predicate)
3521            && !((*pred) (x, mode))))
3522         x = force_reg (mode, x);
3523       emit_insn (GEN_FCN (icode) (x));
3524       return;
3525     }
3526   if (GET_MODE_SIZE (mode) == rounded_size)
3527     dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3528   /* If we are to pad downward, adjust the stack pointer first and
3529      then store X into the stack location using an offset.  This is
3530      because emit_move_insn does not know how to pad; it does not have
3531      access to type.  */
3532   else if (FUNCTION_ARG_PADDING (mode, type) == downward)
3533     {
3534       unsigned padding_size = rounded_size - GET_MODE_SIZE (mode);
3535       HOST_WIDE_INT offset;
3536
3537       emit_move_insn (stack_pointer_rtx,
3538                       expand_binop (Pmode,
3539 #ifdef STACK_GROWS_DOWNWARD
3540                                     sub_optab,
3541 #else
3542                                     add_optab,
3543 #endif
3544                                     stack_pointer_rtx,
3545                                     GEN_INT (rounded_size),
3546                                     NULL_RTX, 0, OPTAB_LIB_WIDEN));
3547
3548       offset = (HOST_WIDE_INT) padding_size;
3549 #ifdef STACK_GROWS_DOWNWARD
3550       if (STACK_PUSH_CODE == POST_DEC)
3551         /* We have already decremented the stack pointer, so get the
3552            previous value.  */
3553         offset += (HOST_WIDE_INT) rounded_size;
3554 #else
3555       if (STACK_PUSH_CODE == POST_INC)
3556         /* We have already incremented the stack pointer, so get the
3557            previous value.  */
3558         offset -= (HOST_WIDE_INT) rounded_size;
3559 #endif
3560       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (offset));
3561     }
3562   else
3563     {
3564 #ifdef STACK_GROWS_DOWNWARD
3565       /* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC.  */
3566       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3567                                 GEN_INT (-(HOST_WIDE_INT) rounded_size));
3568 #else
3569       /* ??? This seems wrong if STACK_PUSH_CODE == POST_INC.  */
3570       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3571                                 GEN_INT (rounded_size));
3572 #endif
3573       dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3574     }
3575
3576   dest = gen_rtx_MEM (mode, dest_addr);
3577
3578   if (type != 0)
3579     {
3580       set_mem_attributes (dest, type, 1);
3581
3582       if (flag_optimize_sibling_calls)
3583         /* Function incoming arguments may overlap with sibling call
3584            outgoing arguments and we cannot allow reordering of reads
3585            from function arguments with stores to outgoing arguments
3586            of sibling calls.  */
3587         set_mem_alias_set (dest, 0);
3588     }
3589   emit_move_insn (dest, x);
3590 }
3591 #endif
3592
3593 /* Generate code to push X onto the stack, assuming it has mode MODE and
3594    type TYPE.
3595    MODE is redundant except when