OSDN Git Service

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