OSDN Git Service

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