OSDN Git Service

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