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