OSDN Git Service

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