OSDN Git Service

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