OSDN Git Service

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