OSDN Git Service

PR middle-end/26983
[pf3gnuchains/gcc-fork.git] / gcc / builtins.c
1 /* Expand builtin functions.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, 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 "tree-gimple.h"
31 #include "flags.h"
32 #include "regs.h"
33 #include "hard-reg-set.h"
34 #include "except.h"
35 #include "function.h"
36 #include "insn-config.h"
37 #include "expr.h"
38 #include "optabs.h"
39 #include "libfuncs.h"
40 #include "recog.h"
41 #include "output.h"
42 #include "typeclass.h"
43 #include "toplev.h"
44 #include "predict.h"
45 #include "tm_p.h"
46 #include "target.h"
47 #include "langhooks.h"
48 #include "basic-block.h"
49 #include "tree-mudflap.h"
50
51 #ifndef PAD_VARARGS_DOWN
52 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
53 #endif
54
55 /* Define the names of the builtin function types and codes.  */
56 const char *const built_in_class_names[4]
57   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
58
59 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
60 const char * built_in_names[(int) END_BUILTINS] =
61 {
62 #include "builtins.def"
63 };
64 #undef DEF_BUILTIN
65
66 /* Setup an array of _DECL trees, make sure each element is
67    initialized to NULL_TREE.  */
68 tree built_in_decls[(int) END_BUILTINS];
69 /* Declarations used when constructing the builtin implicitly in the compiler.
70    It may be NULL_TREE when this is invalid (for instance runtime is not
71    required to implement the function call in all cases).  */
72 tree implicit_built_in_decls[(int) END_BUILTINS];
73
74 static int get_pointer_alignment (tree, unsigned int);
75 static const char *c_getstr (tree);
76 static rtx c_readstr (const char *, enum machine_mode);
77 static int target_char_cast (tree, char *);
78 static rtx get_memory_rtx (tree, tree);
79 static int apply_args_size (void);
80 static int apply_result_size (void);
81 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
82 static rtx result_vector (int, rtx);
83 #endif
84 static rtx expand_builtin_setjmp (tree, rtx);
85 static void expand_builtin_update_setjmp_buf (rtx);
86 static void expand_builtin_prefetch (tree);
87 static rtx expand_builtin_apply_args (void);
88 static rtx expand_builtin_apply_args_1 (void);
89 static rtx expand_builtin_apply (rtx, rtx, rtx);
90 static void expand_builtin_return (rtx);
91 static enum type_class type_to_class (tree);
92 static rtx expand_builtin_classify_type (tree);
93 static void expand_errno_check (tree, rtx);
94 static rtx expand_builtin_mathfn (tree, rtx, rtx);
95 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
96 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
97 static rtx expand_builtin_sincos (tree);
98 static rtx expand_builtin_int_roundingfn (tree, rtx, rtx);
99 static rtx expand_builtin_args_info (tree);
100 static rtx expand_builtin_next_arg (void);
101 static rtx expand_builtin_va_start (tree);
102 static rtx expand_builtin_va_end (tree);
103 static rtx expand_builtin_va_copy (tree);
104 static rtx expand_builtin_memcmp (tree, tree, rtx, enum machine_mode);
105 static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
106 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
107 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
108 static rtx expand_builtin_strcat (tree, tree, rtx, enum machine_mode);
109 static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
110 static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
111 static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
112 static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
113 static rtx expand_builtin_mempcpy (tree, tree, rtx, enum machine_mode, int);
114 static rtx expand_builtin_memmove (tree, tree, rtx, enum machine_mode, tree);
115 static rtx expand_builtin_bcopy (tree);
116 static rtx expand_builtin_strcpy (tree, tree, rtx, enum machine_mode);
117 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
118 static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
119 static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
120 static rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
121 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
122 static rtx expand_builtin_memset (tree, rtx, enum machine_mode, tree);
123 static rtx expand_builtin_bzero (tree);
124 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
125 static rtx expand_builtin_strstr (tree, tree, rtx, enum machine_mode);
126 static rtx expand_builtin_strpbrk (tree, tree, rtx, enum machine_mode);
127 static rtx expand_builtin_strchr (tree, tree, rtx, enum machine_mode);
128 static rtx expand_builtin_strrchr (tree, tree, rtx, enum machine_mode);
129 static rtx expand_builtin_alloca (tree, rtx);
130 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
131 static rtx expand_builtin_frame_address (tree, tree);
132 static rtx expand_builtin_fputs (tree, rtx, bool);
133 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
134 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
135 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
136 static tree stabilize_va_list (tree, int);
137 static rtx expand_builtin_expect (tree, rtx);
138 static tree fold_builtin_constant_p (tree);
139 static tree fold_builtin_classify_type (tree);
140 static tree fold_builtin_strlen (tree);
141 static tree fold_builtin_inf (tree, int);
142 static tree fold_builtin_nan (tree, tree, int);
143 static int validate_arglist (tree, ...);
144 static bool integer_valued_real_p (tree);
145 static tree fold_trunc_transparent_mathfn (tree, tree);
146 static bool readonly_data_expr (tree);
147 static rtx expand_builtin_fabs (tree, rtx, rtx);
148 static rtx expand_builtin_signbit (tree, rtx);
149 static tree fold_builtin_sqrt (tree, tree);
150 static tree fold_builtin_cbrt (tree, tree);
151 static tree fold_builtin_pow (tree, tree, tree);
152 static tree fold_builtin_powi (tree, tree, tree);
153 static tree fold_builtin_sin (tree);
154 static tree fold_builtin_cos (tree, tree, tree);
155 static tree fold_builtin_tan (tree);
156 static tree fold_builtin_atan (tree, tree);
157 static tree fold_builtin_trunc (tree, tree);
158 static tree fold_builtin_floor (tree, tree);
159 static tree fold_builtin_ceil (tree, tree);
160 static tree fold_builtin_round (tree, tree);
161 static tree fold_builtin_int_roundingfn (tree, tree);
162 static tree fold_builtin_bitop (tree, tree);
163 static tree fold_builtin_memory_op (tree, tree, bool, int);
164 static tree fold_builtin_strchr (tree, tree);
165 static tree fold_builtin_memcmp (tree);
166 static tree fold_builtin_strcmp (tree);
167 static tree fold_builtin_strncmp (tree);
168 static tree fold_builtin_signbit (tree, tree);
169 static tree fold_builtin_copysign (tree, tree, tree);
170 static tree fold_builtin_isascii (tree);
171 static tree fold_builtin_toascii (tree);
172 static tree fold_builtin_isdigit (tree);
173 static tree fold_builtin_fabs (tree, tree);
174 static tree fold_builtin_abs (tree, tree);
175 static tree fold_builtin_unordered_cmp (tree, tree, enum tree_code,
176                                         enum tree_code);
177 static tree fold_builtin_1 (tree, tree, bool);
178
179 static tree fold_builtin_strpbrk (tree, tree);
180 static tree fold_builtin_strstr (tree, tree);
181 static tree fold_builtin_strrchr (tree, tree);
182 static tree fold_builtin_strcat (tree);
183 static tree fold_builtin_strncat (tree);
184 static tree fold_builtin_strspn (tree);
185 static tree fold_builtin_strcspn (tree);
186 static tree fold_builtin_sprintf (tree, int);
187
188 static rtx expand_builtin_object_size (tree);
189 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
190                                       enum built_in_function);
191 static void maybe_emit_chk_warning (tree, enum built_in_function);
192 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
193 static tree fold_builtin_object_size (tree);
194 static tree fold_builtin_strcat_chk (tree, tree);
195 static tree fold_builtin_strncat_chk (tree, tree);
196 static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
197 static tree fold_builtin_printf (tree, tree, bool, enum built_in_function);
198 static tree fold_builtin_fprintf (tree, tree, bool, enum built_in_function);
199 static bool init_target_chars (void);
200
201 static unsigned HOST_WIDE_INT target_newline;
202 static unsigned HOST_WIDE_INT target_percent;
203 static unsigned HOST_WIDE_INT target_c;
204 static unsigned HOST_WIDE_INT target_s;
205 static char target_percent_c[3];
206 static char target_percent_s[3];
207 static char target_percent_s_newline[4];
208
209 /* Return true if NODE should be considered for inline expansion regardless
210    of the optimization level.  This means whenever a function is invoked with
211    its "internal" name, which normally contains the prefix "__builtin".  */
212
213 static bool called_as_built_in (tree node)
214 {
215   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
216   if (strncmp (name, "__builtin_", 10) == 0)
217     return true;
218   if (strncmp (name, "__sync_", 7) == 0)
219     return true;
220   return false;
221 }
222
223 /* Return the alignment in bits of EXP, a pointer valued expression.
224    But don't return more than MAX_ALIGN no matter what.
225    The alignment returned is, by default, the alignment of the thing that
226    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
227
228    Otherwise, look at the expression to see if we can do better, i.e., if the
229    expression is actually pointing at an object whose alignment is tighter.  */
230
231 static int
232 get_pointer_alignment (tree exp, unsigned int max_align)
233 {
234   unsigned int align, inner;
235
236   if (! POINTER_TYPE_P (TREE_TYPE (exp)))
237     return 0;
238
239   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
240   align = MIN (align, max_align);
241
242   while (1)
243     {
244       switch (TREE_CODE (exp))
245         {
246         case NOP_EXPR:
247         case CONVERT_EXPR:
248         case NON_LVALUE_EXPR:
249           exp = TREE_OPERAND (exp, 0);
250           if (! POINTER_TYPE_P (TREE_TYPE (exp)))
251             return align;
252
253           inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
254           align = MIN (inner, max_align);
255           break;
256
257         case PLUS_EXPR:
258           /* If sum of pointer + int, restrict our maximum alignment to that
259              imposed by the integer.  If not, we can't do any better than
260              ALIGN.  */
261           if (! host_integerp (TREE_OPERAND (exp, 1), 1))
262             return align;
263
264           while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
265                   & (max_align / BITS_PER_UNIT - 1))
266                  != 0)
267             max_align >>= 1;
268
269           exp = TREE_OPERAND (exp, 0);
270           break;
271
272         case ADDR_EXPR:
273           /* See what we are pointing at and look at its alignment.  */
274           exp = TREE_OPERAND (exp, 0);
275           inner = max_align;
276           if (handled_component_p (exp))
277             {
278               HOST_WIDE_INT bitsize, bitpos;
279               tree offset;
280               enum machine_mode mode; 
281               int unsignedp, volatilep;
282
283               exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
284                                          &mode, &unsignedp, &volatilep, true);
285               if (bitpos)
286                 inner = MIN (inner, (unsigned) (bitpos & -bitpos));
287               if (offset && TREE_CODE (offset) == PLUS_EXPR
288                   && host_integerp (TREE_OPERAND (offset, 1), 1))
289                 {
290                   /* Any overflow in calculating offset_bits won't change
291                      the alignment.  */
292                   unsigned offset_bits
293                     = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
294                        * BITS_PER_UNIT);
295
296                   if (offset_bits)
297                     inner = MIN (inner, (offset_bits & -offset_bits));
298                   offset = TREE_OPERAND (offset, 0);
299                 }
300               if (offset && TREE_CODE (offset) == MULT_EXPR
301                   && host_integerp (TREE_OPERAND (offset, 1), 1))
302                 {
303                   /* Any overflow in calculating offset_factor won't change
304                      the alignment.  */
305                   unsigned offset_factor
306                     = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
307                        * BITS_PER_UNIT);
308
309                   if (offset_factor)
310                     inner = MIN (inner, (offset_factor & -offset_factor));
311                 }
312               else if (offset)
313                 inner = MIN (inner, BITS_PER_UNIT);
314             }
315           if (TREE_CODE (exp) == FUNCTION_DECL)
316             align = FUNCTION_BOUNDARY;
317           else if (DECL_P (exp))
318             align = MIN (inner, DECL_ALIGN (exp));
319 #ifdef CONSTANT_ALIGNMENT
320           else if (CONSTANT_CLASS_P (exp))
321             align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
322 #endif
323           else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
324                    || TREE_CODE (exp) == INDIRECT_REF)
325             align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
326           else
327             align = MIN (align, inner);
328           return MIN (align, max_align);
329
330         default:
331           return align;
332         }
333     }
334 }
335
336 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
337    way, because it could contain a zero byte in the middle.
338    TREE_STRING_LENGTH is the size of the character array, not the string.
339
340    ONLY_VALUE should be nonzero if the result is not going to be emitted
341    into the instruction stream and zero if it is going to be expanded.
342    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
343    is returned, otherwise NULL, since
344    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
345    evaluate the side-effects.
346
347    The value returned is of type `ssizetype'.
348
349    Unfortunately, string_constant can't access the values of const char
350    arrays with initializers, so neither can we do so here.  */
351
352 tree
353 c_strlen (tree src, int only_value)
354 {
355   tree offset_node;
356   HOST_WIDE_INT offset;
357   int max;
358   const char *ptr;
359
360   STRIP_NOPS (src);
361   if (TREE_CODE (src) == COND_EXPR
362       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
363     {
364       tree len1, len2;
365
366       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
367       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
368       if (tree_int_cst_equal (len1, len2))
369         return len1;
370     }
371
372   if (TREE_CODE (src) == COMPOUND_EXPR
373       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
374     return c_strlen (TREE_OPERAND (src, 1), only_value);
375
376   src = string_constant (src, &offset_node);
377   if (src == 0)
378     return 0;
379
380   max = TREE_STRING_LENGTH (src) - 1;
381   ptr = TREE_STRING_POINTER (src);
382
383   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
384     {
385       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
386          compute the offset to the following null if we don't know where to
387          start searching for it.  */
388       int i;
389
390       for (i = 0; i < max; i++)
391         if (ptr[i] == 0)
392           return 0;
393
394       /* We don't know the starting offset, but we do know that the string
395          has no internal zero bytes.  We can assume that the offset falls
396          within the bounds of the string; otherwise, the programmer deserves
397          what he gets.  Subtract the offset from the length of the string,
398          and return that.  This would perhaps not be valid if we were dealing
399          with named arrays in addition to literal string constants.  */
400
401       return size_diffop (size_int (max), offset_node);
402     }
403
404   /* We have a known offset into the string.  Start searching there for
405      a null character if we can represent it as a single HOST_WIDE_INT.  */
406   if (offset_node == 0)
407     offset = 0;
408   else if (! host_integerp (offset_node, 0))
409     offset = -1;
410   else
411     offset = tree_low_cst (offset_node, 0);
412
413   /* If the offset is known to be out of bounds, warn, and call strlen at
414      runtime.  */
415   if (offset < 0 || offset > max)
416     {
417       warning (0, "offset outside bounds of constant string");
418       return 0;
419     }
420
421   /* Use strlen to search for the first zero byte.  Since any strings
422      constructed with build_string will have nulls appended, we win even
423      if we get handed something like (char[4])"abcd".
424
425      Since OFFSET is our starting index into the string, no further
426      calculation is needed.  */
427   return ssize_int (strlen (ptr + offset));
428 }
429
430 /* Return a char pointer for a C string if it is a string constant
431    or sum of string constant and integer constant.  */
432
433 static const char *
434 c_getstr (tree src)
435 {
436   tree offset_node;
437
438   src = string_constant (src, &offset_node);
439   if (src == 0)
440     return 0;
441
442   if (offset_node == 0)
443     return TREE_STRING_POINTER (src);
444   else if (!host_integerp (offset_node, 1)
445            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
446     return 0;
447
448   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
449 }
450
451 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
452    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
453
454 static rtx
455 c_readstr (const char *str, enum machine_mode mode)
456 {
457   HOST_WIDE_INT c[2];
458   HOST_WIDE_INT ch;
459   unsigned int i, j;
460
461   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
462
463   c[0] = 0;
464   c[1] = 0;
465   ch = 1;
466   for (i = 0; i < GET_MODE_SIZE (mode); i++)
467     {
468       j = i;
469       if (WORDS_BIG_ENDIAN)
470         j = GET_MODE_SIZE (mode) - i - 1;
471       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
472           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
473         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
474       j *= BITS_PER_UNIT;
475       gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
476
477       if (ch)
478         ch = (unsigned char) str[i];
479       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
480     }
481   return immed_double_const (c[0], c[1], mode);
482 }
483
484 /* Cast a target constant CST to target CHAR and if that value fits into
485    host char type, return zero and put that value into variable pointed to by
486    P.  */
487
488 static int
489 target_char_cast (tree cst, char *p)
490 {
491   unsigned HOST_WIDE_INT val, hostval;
492
493   if (!host_integerp (cst, 1)
494       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
495     return 1;
496
497   val = tree_low_cst (cst, 1);
498   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
499     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
500
501   hostval = val;
502   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
503     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
504
505   if (val != hostval)
506     return 1;
507
508   *p = hostval;
509   return 0;
510 }
511
512 /* Similar to save_expr, but assumes that arbitrary code is not executed
513    in between the multiple evaluations.  In particular, we assume that a
514    non-addressable local variable will not be modified.  */
515
516 static tree
517 builtin_save_expr (tree exp)
518 {
519   if (TREE_ADDRESSABLE (exp) == 0
520       && (TREE_CODE (exp) == PARM_DECL
521           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
522     return exp;
523
524   return save_expr (exp);
525 }
526
527 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
528    times to get the address of either a higher stack frame, or a return
529    address located within it (depending on FNDECL_CODE).  */
530
531 static rtx
532 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
533 {
534   int i;
535
536 #ifdef INITIAL_FRAME_ADDRESS_RTX
537   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
538 #else
539   rtx tem;
540
541   /* For a zero count with __builtin_return_address, we don't care what
542      frame address we return, because target-specific definitions will
543      override us.  Therefore frame pointer elimination is OK, and using
544      the soft frame pointer is OK.
545
546      For a non-zero count, or a zero count with __builtin_frame_address,
547      we require a stable offset from the current frame pointer to the
548      previous one, so we must use the hard frame pointer, and
549      we must disable frame pointer elimination.  */
550   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
551     tem = frame_pointer_rtx;
552   else
553     {
554       tem = hard_frame_pointer_rtx;
555
556       /* Tell reload not to eliminate the frame pointer.  */
557       current_function_accesses_prior_frames = 1;
558     }
559 #endif
560
561   /* Some machines need special handling before we can access
562      arbitrary frames.  For example, on the sparc, we must first flush
563      all register windows to the stack.  */
564 #ifdef SETUP_FRAME_ADDRESSES
565   if (count > 0)
566     SETUP_FRAME_ADDRESSES ();
567 #endif
568
569   /* On the sparc, the return address is not in the frame, it is in a
570      register.  There is no way to access it off of the current frame
571      pointer, but it can be accessed off the previous frame pointer by
572      reading the value from the register window save area.  */
573 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
574   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
575     count--;
576 #endif
577
578   /* Scan back COUNT frames to the specified frame.  */
579   for (i = 0; i < count; i++)
580     {
581       /* Assume the dynamic chain pointer is in the word that the
582          frame address points to, unless otherwise specified.  */
583 #ifdef DYNAMIC_CHAIN_ADDRESS
584       tem = DYNAMIC_CHAIN_ADDRESS (tem);
585 #endif
586       tem = memory_address (Pmode, tem);
587       tem = gen_frame_mem (Pmode, tem);
588       tem = copy_to_reg (tem);
589     }
590
591   /* For __builtin_frame_address, return what we've got.  */
592   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
593     return tem;
594
595   /* For __builtin_return_address, Get the return address from that
596      frame.  */
597 #ifdef RETURN_ADDR_RTX
598   tem = RETURN_ADDR_RTX (count, tem);
599 #else
600   tem = memory_address (Pmode,
601                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
602   tem = gen_frame_mem (Pmode, tem);
603 #endif
604   return tem;
605 }
606
607 /* Alias set used for setjmp buffer.  */
608 static HOST_WIDE_INT setjmp_alias_set = -1;
609
610 /* Construct the leading half of a __builtin_setjmp call.  Control will
611    return to RECEIVER_LABEL.  This is used directly by sjlj exception
612    handling code.  */
613
614 void
615 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
616 {
617   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
618   rtx stack_save;
619   rtx mem;
620
621   if (setjmp_alias_set == -1)
622     setjmp_alias_set = new_alias_set ();
623
624   buf_addr = convert_memory_address (Pmode, buf_addr);
625
626   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
627
628   /* We store the frame pointer and the address of receiver_label in
629      the buffer and use the rest of it for the stack save area, which
630      is machine-dependent.  */
631
632   mem = gen_rtx_MEM (Pmode, buf_addr);
633   set_mem_alias_set (mem, setjmp_alias_set);
634   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
635
636   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
637   set_mem_alias_set (mem, setjmp_alias_set);
638
639   emit_move_insn (validize_mem (mem),
640                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
641
642   stack_save = gen_rtx_MEM (sa_mode,
643                             plus_constant (buf_addr,
644                                            2 * GET_MODE_SIZE (Pmode)));
645   set_mem_alias_set (stack_save, setjmp_alias_set);
646   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
647
648   /* If there is further processing to do, do it.  */
649 #ifdef HAVE_builtin_setjmp_setup
650   if (HAVE_builtin_setjmp_setup)
651     emit_insn (gen_builtin_setjmp_setup (buf_addr));
652 #endif
653
654   /* Tell optimize_save_area_alloca that extra work is going to
655      need to go on during alloca.  */
656   current_function_calls_setjmp = 1;
657
658   /* Set this so all the registers get saved in our frame; we need to be
659      able to copy the saved values for any registers from frames we unwind.  */
660   current_function_has_nonlocal_label = 1;
661 }
662
663 /* Construct the trailing part of a __builtin_setjmp call.
664    This is used directly by sjlj exception handling code.  */
665
666 void
667 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
668 {
669   /* Clobber the FP when we get here, so we have to make sure it's
670      marked as used by this function.  */
671   emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
672
673   /* Mark the static chain as clobbered here so life information
674      doesn't get messed up for it.  */
675   emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
676
677   /* Now put in the code to restore the frame pointer, and argument
678      pointer, if needed.  */
679 #ifdef HAVE_nonlocal_goto
680   if (! HAVE_nonlocal_goto)
681 #endif
682     emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
683
684 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
685   if (fixed_regs[ARG_POINTER_REGNUM])
686     {
687 #ifdef ELIMINABLE_REGS
688       size_t i;
689       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
690
691       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
692         if (elim_regs[i].from == ARG_POINTER_REGNUM
693             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
694           break;
695
696       if (i == ARRAY_SIZE (elim_regs))
697 #endif
698         {
699           /* Now restore our arg pointer from the address at which it
700              was saved in our stack frame.  */
701           emit_move_insn (virtual_incoming_args_rtx,
702                           copy_to_reg (get_arg_pointer_save_area (cfun)));
703         }
704     }
705 #endif
706
707 #ifdef HAVE_builtin_setjmp_receiver
708   if (HAVE_builtin_setjmp_receiver)
709     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
710   else
711 #endif
712 #ifdef HAVE_nonlocal_goto_receiver
713     if (HAVE_nonlocal_goto_receiver)
714       emit_insn (gen_nonlocal_goto_receiver ());
715     else
716 #endif
717       { /* Nothing */ }
718
719   /* @@@ This is a kludge.  Not all machine descriptions define a blockage
720      insn, but we must not allow the code we just generated to be reordered
721      by scheduling.  Specifically, the update of the frame pointer must
722      happen immediately, not later.  So emit an ASM_INPUT to act as blockage
723      insn.  */
724   emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
725 }
726
727 /* __builtin_setjmp is passed a pointer to an array of five words (not
728    all will be used on all machines).  It operates similarly to the C
729    library function of the same name, but is more efficient.  Much of
730    the code below (and for longjmp) is copied from the handling of
731    non-local gotos.
732
733    NOTE: This is intended for use by GNAT and the exception handling
734    scheme in the compiler and will only work in the method used by
735    them.  */
736
737 static rtx
738 expand_builtin_setjmp (tree arglist, rtx target)
739 {
740   rtx buf_addr, next_lab, cont_lab;
741
742   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
743     return NULL_RTX;
744
745   if (target == 0 || !REG_P (target)
746       || REGNO (target) < FIRST_PSEUDO_REGISTER)
747     target = gen_reg_rtx (TYPE_MODE (integer_type_node));
748
749   buf_addr = expand_normal (TREE_VALUE (arglist));
750
751   next_lab = gen_label_rtx ();
752   cont_lab = gen_label_rtx ();
753
754   expand_builtin_setjmp_setup (buf_addr, next_lab);
755
756   /* Set TARGET to zero and branch to the continue label.  Use emit_jump to
757      ensure that pending stack adjustments are flushed.  */
758   emit_move_insn (target, const0_rtx);
759   emit_jump (cont_lab);
760
761   emit_label (next_lab);
762
763   /* Because setjmp and longjmp are not represented in the CFG, a cfgcleanup
764      may find that the basic block starting with NEXT_LAB is unreachable.
765      The whole block, along with NEXT_LAB, would be removed (see PR26983).
766      Make sure that never happens.  */
767   LABEL_PRESERVE_P (next_lab) = 1;
768      
769   expand_builtin_setjmp_receiver (next_lab);
770
771   /* Set TARGET to one.  */
772   emit_move_insn (target, const1_rtx);
773   emit_label (cont_lab);
774
775   /* Tell flow about the strange goings on.  Putting `next_lab' on
776      `nonlocal_goto_handler_labels' to indicates that function
777      calls may traverse the arc back to this label.  */
778
779   current_function_has_nonlocal_label = 1;
780   nonlocal_goto_handler_labels
781     = gen_rtx_EXPR_LIST (VOIDmode, next_lab, nonlocal_goto_handler_labels);
782
783   return target;
784 }
785
786 /* __builtin_longjmp is passed a pointer to an array of five words (not
787    all will be used on all machines).  It operates similarly to the C
788    library function of the same name, but is more efficient.  Much of
789    the code below is copied from the handling of non-local gotos.
790
791    NOTE: This is intended for use by GNAT and the exception handling
792    scheme in the compiler and will only work in the method used by
793    them.  */
794
795 static void
796 expand_builtin_longjmp (rtx buf_addr, rtx value)
797 {
798   rtx fp, lab, stack, insn, last;
799   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
800
801   if (setjmp_alias_set == -1)
802     setjmp_alias_set = new_alias_set ();
803
804   buf_addr = convert_memory_address (Pmode, buf_addr);
805
806   buf_addr = force_reg (Pmode, buf_addr);
807
808   /* We used to store value in static_chain_rtx, but that fails if pointers
809      are smaller than integers.  We instead require that the user must pass
810      a second argument of 1, because that is what builtin_setjmp will
811      return.  This also makes EH slightly more efficient, since we are no
812      longer copying around a value that we don't care about.  */
813   gcc_assert (value == const1_rtx);
814
815   last = get_last_insn ();
816 #ifdef HAVE_builtin_longjmp
817   if (HAVE_builtin_longjmp)
818     emit_insn (gen_builtin_longjmp (buf_addr));
819   else
820 #endif
821     {
822       fp = gen_rtx_MEM (Pmode, buf_addr);
823       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
824                                                GET_MODE_SIZE (Pmode)));
825
826       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
827                                                    2 * GET_MODE_SIZE (Pmode)));
828       set_mem_alias_set (fp, setjmp_alias_set);
829       set_mem_alias_set (lab, setjmp_alias_set);
830       set_mem_alias_set (stack, setjmp_alias_set);
831
832       /* Pick up FP, label, and SP from the block and jump.  This code is
833          from expand_goto in stmt.c; see there for detailed comments.  */
834 #ifdef HAVE_nonlocal_goto
835       if (HAVE_nonlocal_goto)
836         /* We have to pass a value to the nonlocal_goto pattern that will
837            get copied into the static_chain pointer, but it does not matter
838            what that value is, because builtin_setjmp does not use it.  */
839         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
840       else
841 #endif
842         {
843           lab = copy_to_reg (lab);
844
845           emit_insn (gen_rtx_CLOBBER (VOIDmode,
846                                       gen_rtx_MEM (BLKmode,
847                                                    gen_rtx_SCRATCH (VOIDmode))));
848           emit_insn (gen_rtx_CLOBBER (VOIDmode,
849                                       gen_rtx_MEM (BLKmode,
850                                                    hard_frame_pointer_rtx)));
851
852           emit_move_insn (hard_frame_pointer_rtx, fp);
853           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
854
855           emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
856           emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
857           emit_indirect_jump (lab);
858         }
859     }
860
861   /* Search backwards and mark the jump insn as a non-local goto.
862      Note that this precludes the use of __builtin_longjmp to a
863      __builtin_setjmp target in the same function.  However, we've
864      already cautioned the user that these functions are for
865      internal exception handling use only.  */
866   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
867     {
868       gcc_assert (insn != last);
869
870       if (JUMP_P (insn))
871         {
872           REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
873                                               REG_NOTES (insn));
874           break;
875         }
876       else if (CALL_P (insn))
877         break;
878     }
879 }
880
881 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
882    and the address of the save area.  */
883
884 static rtx
885 expand_builtin_nonlocal_goto (tree arglist)
886 {
887   tree t_label, t_save_area;
888   rtx r_label, r_save_area, r_fp, r_sp, insn;
889
890   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
891     return NULL_RTX;
892
893   t_label = TREE_VALUE (arglist);
894   arglist = TREE_CHAIN (arglist);
895   t_save_area = TREE_VALUE (arglist);
896
897   r_label = expand_normal (t_label);
898   r_label = convert_memory_address (Pmode, r_label);
899   r_save_area = expand_normal (t_save_area);
900   r_save_area = convert_memory_address (Pmode, r_save_area);
901   r_fp = gen_rtx_MEM (Pmode, r_save_area);
902   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
903                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
904
905   current_function_has_nonlocal_goto = 1;
906
907 #ifdef HAVE_nonlocal_goto
908   /* ??? We no longer need to pass the static chain value, afaik.  */
909   if (HAVE_nonlocal_goto)
910     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
911   else
912 #endif
913     {
914       r_label = copy_to_reg (r_label);
915
916       emit_insn (gen_rtx_CLOBBER (VOIDmode,
917                                   gen_rtx_MEM (BLKmode,
918                                                gen_rtx_SCRATCH (VOIDmode))));
919
920       emit_insn (gen_rtx_CLOBBER (VOIDmode,
921                                   gen_rtx_MEM (BLKmode,
922                                                hard_frame_pointer_rtx)));
923
924       /* Restore frame pointer for containing function.
925          This sets the actual hard register used for the frame pointer
926          to the location of the function's incoming static chain info.
927          The non-local goto handler will then adjust it to contain the
928          proper value and reload the argument pointer, if needed.  */
929       emit_move_insn (hard_frame_pointer_rtx, r_fp);
930       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
931
932       /* USE of hard_frame_pointer_rtx added for consistency;
933          not clear if really needed.  */
934       emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
935       emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
936       emit_indirect_jump (r_label);
937     }
938
939   /* Search backwards to the jump insn and mark it as a
940      non-local goto.  */
941   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
942     {
943       if (JUMP_P (insn))
944         {
945           REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO,
946                                               const0_rtx, REG_NOTES (insn));
947           break;
948         }
949       else if (CALL_P (insn))
950         break;
951     }
952
953   return const0_rtx;
954 }
955
956 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
957    (not all will be used on all machines) that was passed to __builtin_setjmp.
958    It updates the stack pointer in that block to correspond to the current
959    stack pointer.  */
960
961 static void
962 expand_builtin_update_setjmp_buf (rtx buf_addr)
963 {
964   enum machine_mode sa_mode = Pmode;
965   rtx stack_save;
966
967
968 #ifdef HAVE_save_stack_nonlocal
969   if (HAVE_save_stack_nonlocal)
970     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
971 #endif
972 #ifdef STACK_SAVEAREA_MODE
973   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
974 #endif
975
976   stack_save
977     = gen_rtx_MEM (sa_mode,
978                    memory_address
979                    (sa_mode,
980                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
981
982 #ifdef HAVE_setjmp
983   if (HAVE_setjmp)
984     emit_insn (gen_setjmp ());
985 #endif
986
987   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
988 }
989
990 /* Expand a call to __builtin_prefetch.  For a target that does not support
991    data prefetch, evaluate the memory address argument in case it has side
992    effects.  */
993
994 static void
995 expand_builtin_prefetch (tree arglist)
996 {
997   tree arg0, arg1, arg2;
998   rtx op0, op1, op2;
999
1000   if (!validate_arglist (arglist, POINTER_TYPE, 0))
1001     return;
1002
1003   arg0 = TREE_VALUE (arglist);
1004   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1005      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1006      locality).  */
1007   if (TREE_CHAIN (arglist))
1008     {
1009       arg1 = TREE_VALUE (TREE_CHAIN (arglist));
1010       if (TREE_CHAIN (TREE_CHAIN (arglist)))
1011         arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
1012       else
1013         arg2 = build_int_cst (NULL_TREE, 3);
1014     }
1015   else
1016     {
1017       arg1 = integer_zero_node;
1018       arg2 = build_int_cst (NULL_TREE, 3);
1019     }
1020
1021   /* Argument 0 is an address.  */
1022   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1023
1024   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1025   if (TREE_CODE (arg1) != INTEGER_CST)
1026     {
1027       error ("second argument to %<__builtin_prefetch%> must be a constant");
1028       arg1 = integer_zero_node;
1029     }
1030   op1 = expand_normal (arg1);
1031   /* Argument 1 must be either zero or one.  */
1032   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1033     {
1034       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1035                " using zero");
1036       op1 = const0_rtx;
1037     }
1038
1039   /* Argument 2 (locality) must be a compile-time constant int.  */
1040   if (TREE_CODE (arg2) != INTEGER_CST)
1041     {
1042       error ("third argument to %<__builtin_prefetch%> must be a constant");
1043       arg2 = integer_zero_node;
1044     }
1045   op2 = expand_normal (arg2);
1046   /* Argument 2 must be 0, 1, 2, or 3.  */
1047   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1048     {
1049       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1050       op2 = const0_rtx;
1051     }
1052
1053 #ifdef HAVE_prefetch
1054   if (HAVE_prefetch)
1055     {
1056       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1057              (op0,
1058               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1059           || (GET_MODE (op0) != Pmode))
1060         {
1061           op0 = convert_memory_address (Pmode, op0);
1062           op0 = force_reg (Pmode, op0);
1063         }
1064       emit_insn (gen_prefetch (op0, op1, op2));
1065     }
1066 #endif
1067
1068   /* Don't do anything with direct references to volatile memory, but
1069      generate code to handle other side effects.  */
1070   if (!MEM_P (op0) && side_effects_p (op0))
1071     emit_insn (op0);
1072 }
1073
1074 /* Get a MEM rtx for expression EXP which is the address of an operand
1075    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1076    the maximum length of the block of memory that might be accessed or
1077    NULL if unknown.  */
1078
1079 static rtx
1080 get_memory_rtx (tree exp, tree len)
1081 {
1082   rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1083   rtx mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1084
1085   /* Get an expression we can use to find the attributes to assign to MEM.
1086      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1087      we can.  First remove any nops.  */
1088   while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
1089           || TREE_CODE (exp) == NON_LVALUE_EXPR)
1090          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1091     exp = TREE_OPERAND (exp, 0);
1092
1093   if (TREE_CODE (exp) == ADDR_EXPR)
1094     exp = TREE_OPERAND (exp, 0);
1095   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1096     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1097   else
1098     exp = NULL;
1099
1100   /* Honor attributes derived from exp, except for the alias set
1101      (as builtin stringops may alias with anything) and the size
1102      (as stringops may access multiple array elements).  */
1103   if (exp)
1104     {
1105       set_mem_attributes (mem, exp, 0);
1106
1107       /* Allow the string and memory builtins to overflow from one
1108          field into another, see http://gcc.gnu.org/PR23561.
1109          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1110          memory accessed by the string or memory builtin will fit
1111          within the field.  */
1112       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1113         {
1114           tree mem_expr = MEM_EXPR (mem);
1115           HOST_WIDE_INT offset = -1, length = -1;
1116           tree inner = exp;
1117
1118           while (TREE_CODE (inner) == ARRAY_REF
1119                  || TREE_CODE (inner) == NOP_EXPR
1120                  || TREE_CODE (inner) == CONVERT_EXPR
1121                  || TREE_CODE (inner) == NON_LVALUE_EXPR
1122                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1123                  || TREE_CODE (inner) == SAVE_EXPR)
1124             inner = TREE_OPERAND (inner, 0);
1125
1126           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1127
1128           if (MEM_OFFSET (mem)
1129               && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
1130             offset = INTVAL (MEM_OFFSET (mem));
1131
1132           if (offset >= 0 && len && host_integerp (len, 0))
1133             length = tree_low_cst (len, 0);
1134
1135           while (TREE_CODE (inner) == COMPONENT_REF)
1136             {
1137               tree field = TREE_OPERAND (inner, 1);
1138               gcc_assert (! DECL_BIT_FIELD (field));
1139               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1140               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1141
1142               if (length >= 0
1143                   && TYPE_SIZE_UNIT (TREE_TYPE (inner))
1144                   && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0))
1145                 {
1146                   HOST_WIDE_INT size
1147                     = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0);
1148                   /* If we can prove the memory starting at XEXP (mem, 0)
1149                      and ending at XEXP (mem, 0) + LENGTH will fit into
1150                      this field, we can keep that COMPONENT_REF in MEM_EXPR.  */
1151                   if (offset <= size
1152                       && length <= size
1153                       && offset + length <= size)
1154                     break;
1155                 }
1156
1157               if (offset >= 0
1158                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1159                 offset += tree_low_cst (DECL_FIELD_OFFSET (field), 0)
1160                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1161                             / BITS_PER_UNIT;
1162               else
1163                 {
1164                   offset = -1;
1165                   length = -1;
1166                 }
1167
1168               mem_expr = TREE_OPERAND (mem_expr, 0);
1169               inner = TREE_OPERAND (inner, 0);
1170             }
1171
1172           if (mem_expr == NULL)
1173             offset = -1;
1174           if (mem_expr != MEM_EXPR (mem))
1175             {
1176               set_mem_expr (mem, mem_expr);
1177               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1178             }
1179         }
1180       set_mem_alias_set (mem, 0);
1181       set_mem_size (mem, NULL_RTX);
1182     }
1183
1184   return mem;
1185 }
1186 \f
1187 /* Built-in functions to perform an untyped call and return.  */
1188
1189 /* For each register that may be used for calling a function, this
1190    gives a mode used to copy the register's value.  VOIDmode indicates
1191    the register is not used for calling a function.  If the machine
1192    has register windows, this gives only the outbound registers.
1193    INCOMING_REGNO gives the corresponding inbound register.  */
1194 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1195
1196 /* For each register that may be used for returning values, this gives
1197    a mode used to copy the register's value.  VOIDmode indicates the
1198    register is not used for returning values.  If the machine has
1199    register windows, this gives only the outbound registers.
1200    INCOMING_REGNO gives the corresponding inbound register.  */
1201 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1202
1203 /* For each register that may be used for calling a function, this
1204    gives the offset of that register into the block returned by
1205    __builtin_apply_args.  0 indicates that the register is not
1206    used for calling a function.  */
1207 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1208
1209 /* Return the size required for the block returned by __builtin_apply_args,
1210    and initialize apply_args_mode.  */
1211
1212 static int
1213 apply_args_size (void)
1214 {
1215   static int size = -1;
1216   int align;
1217   unsigned int regno;
1218   enum machine_mode mode;
1219
1220   /* The values computed by this function never change.  */
1221   if (size < 0)
1222     {
1223       /* The first value is the incoming arg-pointer.  */
1224       size = GET_MODE_SIZE (Pmode);
1225
1226       /* The second value is the structure value address unless this is
1227          passed as an "invisible" first argument.  */
1228       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1229         size += GET_MODE_SIZE (Pmode);
1230
1231       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1232         if (FUNCTION_ARG_REGNO_P (regno))
1233           {
1234             mode = reg_raw_mode[regno];
1235
1236             gcc_assert (mode != VOIDmode);
1237
1238             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1239             if (size % align != 0)
1240               size = CEIL (size, align) * align;
1241             apply_args_reg_offset[regno] = size;
1242             size += GET_MODE_SIZE (mode);
1243             apply_args_mode[regno] = mode;
1244           }
1245         else
1246           {
1247             apply_args_mode[regno] = VOIDmode;
1248             apply_args_reg_offset[regno] = 0;
1249           }
1250     }
1251   return size;
1252 }
1253
1254 /* Return the size required for the block returned by __builtin_apply,
1255    and initialize apply_result_mode.  */
1256
1257 static int
1258 apply_result_size (void)
1259 {
1260   static int size = -1;
1261   int align, regno;
1262   enum machine_mode mode;
1263
1264   /* The values computed by this function never change.  */
1265   if (size < 0)
1266     {
1267       size = 0;
1268
1269       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1270         if (FUNCTION_VALUE_REGNO_P (regno))
1271           {
1272             mode = reg_raw_mode[regno];
1273
1274             gcc_assert (mode != VOIDmode);
1275
1276             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1277             if (size % align != 0)
1278               size = CEIL (size, align) * align;
1279             size += GET_MODE_SIZE (mode);
1280             apply_result_mode[regno] = mode;
1281           }
1282         else
1283           apply_result_mode[regno] = VOIDmode;
1284
1285       /* Allow targets that use untyped_call and untyped_return to override
1286          the size so that machine-specific information can be stored here.  */
1287 #ifdef APPLY_RESULT_SIZE
1288       size = APPLY_RESULT_SIZE;
1289 #endif
1290     }
1291   return size;
1292 }
1293
1294 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1295 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1296    the result block is used to save the values; otherwise it is used to
1297    restore the values.  */
1298
1299 static rtx
1300 result_vector (int savep, rtx result)
1301 {
1302   int regno, size, align, nelts;
1303   enum machine_mode mode;
1304   rtx reg, mem;
1305   rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
1306
1307   size = nelts = 0;
1308   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1309     if ((mode = apply_result_mode[regno]) != VOIDmode)
1310       {
1311         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1312         if (size % align != 0)
1313           size = CEIL (size, align) * align;
1314         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1315         mem = adjust_address (result, mode, size);
1316         savevec[nelts++] = (savep
1317                             ? gen_rtx_SET (VOIDmode, mem, reg)
1318                             : gen_rtx_SET (VOIDmode, reg, mem));
1319         size += GET_MODE_SIZE (mode);
1320       }
1321   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1322 }
1323 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1324
1325 /* Save the state required to perform an untyped call with the same
1326    arguments as were passed to the current function.  */
1327
1328 static rtx
1329 expand_builtin_apply_args_1 (void)
1330 {
1331   rtx registers, tem;
1332   int size, align, regno;
1333   enum machine_mode mode;
1334   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1335
1336   /* Create a block where the arg-pointer, structure value address,
1337      and argument registers can be saved.  */
1338   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1339
1340   /* Walk past the arg-pointer and structure value address.  */
1341   size = GET_MODE_SIZE (Pmode);
1342   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1343     size += GET_MODE_SIZE (Pmode);
1344
1345   /* Save each register used in calling a function to the block.  */
1346   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1347     if ((mode = apply_args_mode[regno]) != VOIDmode)
1348       {
1349         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1350         if (size % align != 0)
1351           size = CEIL (size, align) * align;
1352
1353         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1354
1355         emit_move_insn (adjust_address (registers, mode, size), tem);
1356         size += GET_MODE_SIZE (mode);
1357       }
1358
1359   /* Save the arg pointer to the block.  */
1360   tem = copy_to_reg (virtual_incoming_args_rtx);
1361 #ifdef STACK_GROWS_DOWNWARD
1362   /* We need the pointer as the caller actually passed them to us, not
1363      as we might have pretended they were passed.  Make sure it's a valid
1364      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1365   tem
1366     = force_operand (plus_constant (tem, current_function_pretend_args_size),
1367                      NULL_RTX);
1368 #endif
1369   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1370
1371   size = GET_MODE_SIZE (Pmode);
1372
1373   /* Save the structure value address unless this is passed as an
1374      "invisible" first argument.  */
1375   if (struct_incoming_value)
1376     {
1377       emit_move_insn (adjust_address (registers, Pmode, size),
1378                       copy_to_reg (struct_incoming_value));
1379       size += GET_MODE_SIZE (Pmode);
1380     }
1381
1382   /* Return the address of the block.  */
1383   return copy_addr_to_reg (XEXP (registers, 0));
1384 }
1385
1386 /* __builtin_apply_args returns block of memory allocated on
1387    the stack into which is stored the arg pointer, structure
1388    value address, static chain, and all the registers that might
1389    possibly be used in performing a function call.  The code is
1390    moved to the start of the function so the incoming values are
1391    saved.  */
1392
1393 static rtx
1394 expand_builtin_apply_args (void)
1395 {
1396   /* Don't do __builtin_apply_args more than once in a function.
1397      Save the result of the first call and reuse it.  */
1398   if (apply_args_value != 0)
1399     return apply_args_value;
1400   {
1401     /* When this function is called, it means that registers must be
1402        saved on entry to this function.  So we migrate the
1403        call to the first insn of this function.  */
1404     rtx temp;
1405     rtx seq;
1406
1407     start_sequence ();
1408     temp = expand_builtin_apply_args_1 ();
1409     seq = get_insns ();
1410     end_sequence ();
1411
1412     apply_args_value = temp;
1413
1414     /* Put the insns after the NOTE that starts the function.
1415        If this is inside a start_sequence, make the outer-level insn
1416        chain current, so the code is placed at the start of the
1417        function.  */
1418     push_topmost_sequence ();
1419     emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1420     pop_topmost_sequence ();
1421     return temp;
1422   }
1423 }
1424
1425 /* Perform an untyped call and save the state required to perform an
1426    untyped return of whatever value was returned by the given function.  */
1427
1428 static rtx
1429 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1430 {
1431   int size, align, regno;
1432   enum machine_mode mode;
1433   rtx incoming_args, result, reg, dest, src, call_insn;
1434   rtx old_stack_level = 0;
1435   rtx call_fusage = 0;
1436   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1437
1438   arguments = convert_memory_address (Pmode, arguments);
1439
1440   /* Create a block where the return registers can be saved.  */
1441   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1442
1443   /* Fetch the arg pointer from the ARGUMENTS block.  */
1444   incoming_args = gen_reg_rtx (Pmode);
1445   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1446 #ifndef STACK_GROWS_DOWNWARD
1447   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1448                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1449 #endif
1450
1451   /* Push a new argument block and copy the arguments.  Do not allow
1452      the (potential) memcpy call below to interfere with our stack
1453      manipulations.  */
1454   do_pending_stack_adjust ();
1455   NO_DEFER_POP;
1456
1457   /* Save the stack with nonlocal if available.  */
1458 #ifdef HAVE_save_stack_nonlocal
1459   if (HAVE_save_stack_nonlocal)
1460     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1461   else
1462 #endif
1463     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1464
1465   /* Allocate a block of memory onto the stack and copy the memory
1466      arguments to the outgoing arguments address.  */
1467   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1468   dest = virtual_outgoing_args_rtx;
1469 #ifndef STACK_GROWS_DOWNWARD
1470   if (GET_CODE (argsize) == CONST_INT)
1471     dest = plus_constant (dest, -INTVAL (argsize));
1472   else
1473     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1474 #endif
1475   dest = gen_rtx_MEM (BLKmode, dest);
1476   set_mem_align (dest, PARM_BOUNDARY);
1477   src = gen_rtx_MEM (BLKmode, incoming_args);
1478   set_mem_align (src, PARM_BOUNDARY);
1479   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1480
1481   /* Refer to the argument block.  */
1482   apply_args_size ();
1483   arguments = gen_rtx_MEM (BLKmode, arguments);
1484   set_mem_align (arguments, PARM_BOUNDARY);
1485
1486   /* Walk past the arg-pointer and structure value address.  */
1487   size = GET_MODE_SIZE (Pmode);
1488   if (struct_value)
1489     size += GET_MODE_SIZE (Pmode);
1490
1491   /* Restore each of the registers previously saved.  Make USE insns
1492      for each of these registers for use in making the call.  */
1493   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1494     if ((mode = apply_args_mode[regno]) != VOIDmode)
1495       {
1496         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1497         if (size % align != 0)
1498           size = CEIL (size, align) * align;
1499         reg = gen_rtx_REG (mode, regno);
1500         emit_move_insn (reg, adjust_address (arguments, mode, size));
1501         use_reg (&call_fusage, reg);
1502         size += GET_MODE_SIZE (mode);
1503       }
1504
1505   /* Restore the structure value address unless this is passed as an
1506      "invisible" first argument.  */
1507   size = GET_MODE_SIZE (Pmode);
1508   if (struct_value)
1509     {
1510       rtx value = gen_reg_rtx (Pmode);
1511       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1512       emit_move_insn (struct_value, value);
1513       if (REG_P (struct_value))
1514         use_reg (&call_fusage, struct_value);
1515       size += GET_MODE_SIZE (Pmode);
1516     }
1517
1518   /* All arguments and registers used for the call are set up by now!  */
1519   function = prepare_call_address (function, NULL, &call_fusage, 0, 0);
1520
1521   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1522      and we don't want to load it into a register as an optimization,
1523      because prepare_call_address already did it if it should be done.  */
1524   if (GET_CODE (function) != SYMBOL_REF)
1525     function = memory_address (FUNCTION_MODE, function);
1526
1527   /* Generate the actual call instruction and save the return value.  */
1528 #ifdef HAVE_untyped_call
1529   if (HAVE_untyped_call)
1530     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1531                                       result, result_vector (1, result)));
1532   else
1533 #endif
1534 #ifdef HAVE_call_value
1535   if (HAVE_call_value)
1536     {
1537       rtx valreg = 0;
1538
1539       /* Locate the unique return register.  It is not possible to
1540          express a call that sets more than one return register using
1541          call_value; use untyped_call for that.  In fact, untyped_call
1542          only needs to save the return registers in the given block.  */
1543       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1544         if ((mode = apply_result_mode[regno]) != VOIDmode)
1545           {
1546             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1547
1548             valreg = gen_rtx_REG (mode, regno);
1549           }
1550
1551       emit_call_insn (GEN_CALL_VALUE (valreg,
1552                                       gen_rtx_MEM (FUNCTION_MODE, function),
1553                                       const0_rtx, NULL_RTX, const0_rtx));
1554
1555       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1556     }
1557   else
1558 #endif
1559     gcc_unreachable ();
1560
1561   /* Find the CALL insn we just emitted, and attach the register usage
1562      information.  */
1563   call_insn = last_call_insn ();
1564   add_function_usage_to (call_insn, call_fusage);
1565
1566   /* Restore the stack.  */
1567 #ifdef HAVE_save_stack_nonlocal
1568   if (HAVE_save_stack_nonlocal)
1569     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1570   else
1571 #endif
1572     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1573
1574   OK_DEFER_POP;
1575
1576   /* Return the address of the result block.  */
1577   result = copy_addr_to_reg (XEXP (result, 0));
1578   return convert_memory_address (ptr_mode, result);
1579 }
1580
1581 /* Perform an untyped return.  */
1582
1583 static void
1584 expand_builtin_return (rtx result)
1585 {
1586   int size, align, regno;
1587   enum machine_mode mode;
1588   rtx reg;
1589   rtx call_fusage = 0;
1590
1591   result = convert_memory_address (Pmode, result);
1592
1593   apply_result_size ();
1594   result = gen_rtx_MEM (BLKmode, result);
1595
1596 #ifdef HAVE_untyped_return
1597   if (HAVE_untyped_return)
1598     {
1599       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1600       emit_barrier ();
1601       return;
1602     }
1603 #endif
1604
1605   /* Restore the return value and note that each value is used.  */
1606   size = 0;
1607   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1608     if ((mode = apply_result_mode[regno]) != VOIDmode)
1609       {
1610         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1611         if (size % align != 0)
1612           size = CEIL (size, align) * align;
1613         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1614         emit_move_insn (reg, adjust_address (result, mode, size));
1615
1616         push_to_sequence (call_fusage);
1617         emit_insn (gen_rtx_USE (VOIDmode, reg));
1618         call_fusage = get_insns ();
1619         end_sequence ();
1620         size += GET_MODE_SIZE (mode);
1621       }
1622
1623   /* Put the USE insns before the return.  */
1624   emit_insn (call_fusage);
1625
1626   /* Return whatever values was restored by jumping directly to the end
1627      of the function.  */
1628   expand_naked_return ();
1629 }
1630
1631 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1632
1633 static enum type_class
1634 type_to_class (tree type)
1635 {
1636   switch (TREE_CODE (type))
1637     {
1638     case VOID_TYPE:        return void_type_class;
1639     case INTEGER_TYPE:     return integer_type_class;
1640     case ENUMERAL_TYPE:    return enumeral_type_class;
1641     case BOOLEAN_TYPE:     return boolean_type_class;
1642     case POINTER_TYPE:     return pointer_type_class;
1643     case REFERENCE_TYPE:   return reference_type_class;
1644     case OFFSET_TYPE:      return offset_type_class;
1645     case REAL_TYPE:        return real_type_class;
1646     case COMPLEX_TYPE:     return complex_type_class;
1647     case FUNCTION_TYPE:    return function_type_class;
1648     case METHOD_TYPE:      return method_type_class;
1649     case RECORD_TYPE:      return record_type_class;
1650     case UNION_TYPE:
1651     case QUAL_UNION_TYPE:  return union_type_class;
1652     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1653                                    ? string_type_class : array_type_class);
1654     case LANG_TYPE:        return lang_type_class;
1655     default:               return no_type_class;
1656     }
1657 }
1658
1659 /* Expand a call to __builtin_classify_type with arguments found in
1660    ARGLIST.  */
1661
1662 static rtx
1663 expand_builtin_classify_type (tree arglist)
1664 {
1665   if (arglist != 0)
1666     return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
1667   return GEN_INT (no_type_class);
1668 }
1669
1670 /* This helper macro, meant to be used in mathfn_built_in below,
1671    determines which among a set of three builtin math functions is
1672    appropriate for a given type mode.  The `F' and `L' cases are
1673    automatically generated from the `double' case.  */
1674 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1675   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1676   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1677   fcodel = BUILT_IN_MATHFN##L ; break;
1678
1679 /* Return mathematic function equivalent to FN but operating directly
1680    on TYPE, if available.  If we can't do the conversion, return zero.  */
1681 tree
1682 mathfn_built_in (tree type, enum built_in_function fn)
1683 {
1684   enum built_in_function fcode, fcodef, fcodel;
1685
1686   switch (fn)
1687     {
1688       CASE_MATHFN (BUILT_IN_ACOS)
1689       CASE_MATHFN (BUILT_IN_ACOSH)
1690       CASE_MATHFN (BUILT_IN_ASIN)
1691       CASE_MATHFN (BUILT_IN_ASINH)
1692       CASE_MATHFN (BUILT_IN_ATAN)
1693       CASE_MATHFN (BUILT_IN_ATAN2)
1694       CASE_MATHFN (BUILT_IN_ATANH)
1695       CASE_MATHFN (BUILT_IN_CBRT)
1696       CASE_MATHFN (BUILT_IN_CEIL)
1697       CASE_MATHFN (BUILT_IN_COPYSIGN)
1698       CASE_MATHFN (BUILT_IN_COS)
1699       CASE_MATHFN (BUILT_IN_COSH)
1700       CASE_MATHFN (BUILT_IN_DREM)
1701       CASE_MATHFN (BUILT_IN_ERF)
1702       CASE_MATHFN (BUILT_IN_ERFC)
1703       CASE_MATHFN (BUILT_IN_EXP)
1704       CASE_MATHFN (BUILT_IN_EXP10)
1705       CASE_MATHFN (BUILT_IN_EXP2)
1706       CASE_MATHFN (BUILT_IN_EXPM1)
1707       CASE_MATHFN (BUILT_IN_FABS)
1708       CASE_MATHFN (BUILT_IN_FDIM)
1709       CASE_MATHFN (BUILT_IN_FLOOR)
1710       CASE_MATHFN (BUILT_IN_FMA)
1711       CASE_MATHFN (BUILT_IN_FMAX)
1712       CASE_MATHFN (BUILT_IN_FMIN)
1713       CASE_MATHFN (BUILT_IN_FMOD)
1714       CASE_MATHFN (BUILT_IN_FREXP)
1715       CASE_MATHFN (BUILT_IN_GAMMA)
1716       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1717       CASE_MATHFN (BUILT_IN_HYPOT)
1718       CASE_MATHFN (BUILT_IN_ILOGB)
1719       CASE_MATHFN (BUILT_IN_INF)
1720       CASE_MATHFN (BUILT_IN_J0)
1721       CASE_MATHFN (BUILT_IN_J1)
1722       CASE_MATHFN (BUILT_IN_JN)
1723       CASE_MATHFN (BUILT_IN_LCEIL)
1724       CASE_MATHFN (BUILT_IN_LDEXP)
1725       CASE_MATHFN (BUILT_IN_LFLOOR)
1726       CASE_MATHFN (BUILT_IN_LGAMMA)
1727       CASE_MATHFN (BUILT_IN_LLCEIL)
1728       CASE_MATHFN (BUILT_IN_LLFLOOR)
1729       CASE_MATHFN (BUILT_IN_LLRINT)
1730       CASE_MATHFN (BUILT_IN_LLROUND)
1731       CASE_MATHFN (BUILT_IN_LOG)
1732       CASE_MATHFN (BUILT_IN_LOG10)
1733       CASE_MATHFN (BUILT_IN_LOG1P)
1734       CASE_MATHFN (BUILT_IN_LOG2)
1735       CASE_MATHFN (BUILT_IN_LOGB)
1736       CASE_MATHFN (BUILT_IN_LRINT)
1737       CASE_MATHFN (BUILT_IN_LROUND)
1738       CASE_MATHFN (BUILT_IN_MODF)
1739       CASE_MATHFN (BUILT_IN_NAN)
1740       CASE_MATHFN (BUILT_IN_NANS)
1741       CASE_MATHFN (BUILT_IN_NEARBYINT)
1742       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1743       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1744       CASE_MATHFN (BUILT_IN_POW)
1745       CASE_MATHFN (BUILT_IN_POWI)
1746       CASE_MATHFN (BUILT_IN_POW10)
1747       CASE_MATHFN (BUILT_IN_REMAINDER)
1748       CASE_MATHFN (BUILT_IN_REMQUO)
1749       CASE_MATHFN (BUILT_IN_RINT)
1750       CASE_MATHFN (BUILT_IN_ROUND)
1751       CASE_MATHFN (BUILT_IN_SCALB)
1752       CASE_MATHFN (BUILT_IN_SCALBLN)
1753       CASE_MATHFN (BUILT_IN_SCALBN)
1754       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1755       CASE_MATHFN (BUILT_IN_SIN)
1756       CASE_MATHFN (BUILT_IN_SINCOS)
1757       CASE_MATHFN (BUILT_IN_SINH)
1758       CASE_MATHFN (BUILT_IN_SQRT)
1759       CASE_MATHFN (BUILT_IN_TAN)
1760       CASE_MATHFN (BUILT_IN_TANH)
1761       CASE_MATHFN (BUILT_IN_TGAMMA)
1762       CASE_MATHFN (BUILT_IN_TRUNC)
1763       CASE_MATHFN (BUILT_IN_Y0)
1764       CASE_MATHFN (BUILT_IN_Y1)
1765       CASE_MATHFN (BUILT_IN_YN)
1766
1767       default:
1768         return 0;
1769       }
1770
1771   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1772     return implicit_built_in_decls[fcode];
1773   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1774     return implicit_built_in_decls[fcodef];
1775   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1776     return implicit_built_in_decls[fcodel];
1777   else
1778     return 0;
1779 }
1780
1781 /* If errno must be maintained, expand the RTL to check if the result,
1782    TARGET, of a built-in function call, EXP, is NaN, and if so set
1783    errno to EDOM.  */
1784
1785 static void
1786 expand_errno_check (tree exp, rtx target)
1787 {
1788   rtx lab = gen_label_rtx ();
1789
1790   /* Test the result; if it is NaN, set errno=EDOM because
1791      the argument was not in the domain.  */
1792   emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1793                            0, lab);
1794
1795 #ifdef TARGET_EDOM
1796   /* If this built-in doesn't throw an exception, set errno directly.  */
1797   if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
1798     {
1799 #ifdef GEN_ERRNO_RTX
1800       rtx errno_rtx = GEN_ERRNO_RTX;
1801 #else
1802       rtx errno_rtx
1803           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1804 #endif
1805       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1806       emit_label (lab);
1807       return;
1808     }
1809 #endif
1810
1811   /* We can't set errno=EDOM directly; let the library call do it.
1812      Pop the arguments right away in case the call gets deleted.  */
1813   NO_DEFER_POP;
1814   expand_call (exp, target, 0);
1815   OK_DEFER_POP;
1816   emit_label (lab);
1817 }
1818
1819
1820 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1821    Return 0 if a normal call should be emitted rather than expanding the
1822    function in-line.  EXP is the expression that is a call to the builtin
1823    function; if convenient, the result should be placed in TARGET.
1824    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1825
1826 static rtx
1827 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1828 {
1829   optab builtin_optab;
1830   rtx op0, insns, before_call;
1831   tree fndecl = get_callee_fndecl (exp);
1832   tree arglist = TREE_OPERAND (exp, 1);
1833   enum machine_mode mode;
1834   bool errno_set = false;
1835   tree arg, narg;
1836
1837   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
1838     return 0;
1839
1840   arg = TREE_VALUE (arglist);
1841
1842   switch (DECL_FUNCTION_CODE (fndecl))
1843     {
1844     CASE_FLT_FN (BUILT_IN_SQRT):
1845       errno_set = ! tree_expr_nonnegative_p (arg);
1846       builtin_optab = sqrt_optab;
1847       break;
1848     CASE_FLT_FN (BUILT_IN_EXP):
1849       errno_set = true; builtin_optab = exp_optab; break;
1850     CASE_FLT_FN (BUILT_IN_EXP10):
1851     CASE_FLT_FN (BUILT_IN_POW10):
1852       errno_set = true; builtin_optab = exp10_optab; break;
1853     CASE_FLT_FN (BUILT_IN_EXP2):
1854       errno_set = true; builtin_optab = exp2_optab; break;
1855     CASE_FLT_FN (BUILT_IN_EXPM1):
1856       errno_set = true; builtin_optab = expm1_optab; break;
1857     CASE_FLT_FN (BUILT_IN_LOGB):
1858       errno_set = true; builtin_optab = logb_optab; break;
1859     CASE_FLT_FN (BUILT_IN_ILOGB):
1860       errno_set = true; builtin_optab = ilogb_optab; break;
1861     CASE_FLT_FN (BUILT_IN_LOG):
1862       errno_set = true; builtin_optab = log_optab; break;
1863     CASE_FLT_FN (BUILT_IN_LOG10):
1864       errno_set = true; builtin_optab = log10_optab; break;
1865     CASE_FLT_FN (BUILT_IN_LOG2):
1866       errno_set = true; builtin_optab = log2_optab; break;
1867     CASE_FLT_FN (BUILT_IN_LOG1P):
1868       errno_set = true; builtin_optab = log1p_optab; break;
1869     CASE_FLT_FN (BUILT_IN_ASIN):
1870       builtin_optab = asin_optab; break;
1871     CASE_FLT_FN (BUILT_IN_ACOS):
1872       builtin_optab = acos_optab; break;
1873     CASE_FLT_FN (BUILT_IN_TAN):
1874       builtin_optab = tan_optab; break;
1875     CASE_FLT_FN (BUILT_IN_ATAN):
1876       builtin_optab = atan_optab; break;
1877     CASE_FLT_FN (BUILT_IN_FLOOR):
1878       builtin_optab = floor_optab; break;
1879     CASE_FLT_FN (BUILT_IN_CEIL):
1880       builtin_optab = ceil_optab; break;
1881     CASE_FLT_FN (BUILT_IN_TRUNC):
1882       builtin_optab = btrunc_optab; break;
1883     CASE_FLT_FN (BUILT_IN_ROUND):
1884       builtin_optab = round_optab; break;
1885     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1886       builtin_optab = nearbyint_optab; break;
1887     CASE_FLT_FN (BUILT_IN_RINT):
1888       builtin_optab = rint_optab; break;
1889     CASE_FLT_FN (BUILT_IN_LRINT):
1890     CASE_FLT_FN (BUILT_IN_LLRINT):
1891       builtin_optab = lrint_optab; break;
1892     default:
1893       gcc_unreachable ();
1894     }
1895
1896   /* Make a suitable register to place result in.  */
1897   mode = TYPE_MODE (TREE_TYPE (exp));
1898
1899   if (! flag_errno_math || ! HONOR_NANS (mode))
1900     errno_set = false;
1901
1902   /* Before working hard, check whether the instruction is available.  */
1903   if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1904     {
1905       target = gen_reg_rtx (mode);
1906
1907       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1908          need to expand the argument again.  This way, we will not perform
1909          side-effects more the once.  */
1910       narg = builtin_save_expr (arg);
1911       if (narg != arg)
1912         {
1913           arg = narg;
1914           arglist = build_tree_list (NULL_TREE, arg);
1915           exp = build_function_call_expr (fndecl, arglist);
1916         }
1917
1918       op0 = expand_expr (arg, subtarget, VOIDmode, 0);
1919
1920       start_sequence ();
1921
1922       /* Compute into TARGET.
1923          Set TARGET to wherever the result comes back.  */
1924       target = expand_unop (mode, builtin_optab, op0, target, 0);
1925
1926       if (target != 0)
1927         {
1928           if (errno_set)
1929             expand_errno_check (exp, target);
1930
1931           /* Output the entire sequence.  */
1932           insns = get_insns ();
1933           end_sequence ();
1934           emit_insn (insns);
1935           return target;
1936         }
1937
1938       /* If we were unable to expand via the builtin, stop the sequence
1939          (without outputting the insns) and call to the library function
1940          with the stabilized argument list.  */
1941       end_sequence ();
1942     }
1943
1944   before_call = get_last_insn ();
1945
1946   target = expand_call (exp, target, target == const0_rtx);
1947
1948   /* If this is a sqrt operation and we don't care about errno, try to
1949      attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1950      This allows the semantics of the libcall to be visible to the RTL
1951      optimizers.  */
1952   if (builtin_optab == sqrt_optab && !errno_set)
1953     {
1954       /* Search backwards through the insns emitted by expand_call looking
1955          for the instruction with the REG_RETVAL note.  */
1956       rtx last = get_last_insn ();
1957       while (last != before_call)
1958         {
1959           if (find_reg_note (last, REG_RETVAL, NULL))
1960             {
1961               rtx note = find_reg_note (last, REG_EQUAL, NULL);
1962               /* Check that the REQ_EQUAL note is an EXPR_LIST with
1963                  two elements, i.e. symbol_ref(sqrt) and the operand.  */
1964               if (note
1965                   && GET_CODE (note) == EXPR_LIST
1966                   && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1967                   && XEXP (XEXP (note, 0), 1) != NULL_RTX
1968                   && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1969                 {
1970                   rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1971                   /* Check operand is a register with expected mode.  */
1972                   if (operand
1973                       && REG_P (operand)
1974                       && GET_MODE (operand) == mode)
1975                     {
1976                       /* Replace the REG_EQUAL note with a SQRT rtx.  */
1977                       rtx equiv = gen_rtx_SQRT (mode, operand);
1978                       set_unique_reg_note (last, REG_EQUAL, equiv);
1979                     }
1980                 }
1981               break;
1982             }
1983           last = PREV_INSN (last);
1984         }
1985     }
1986
1987   return target;
1988 }
1989
1990 /* Expand a call to the builtin binary math functions (pow and atan2).
1991    Return 0 if a normal call should be emitted rather than expanding the
1992    function in-line.  EXP is the expression that is a call to the builtin
1993    function; if convenient, the result should be placed in TARGET.
1994    SUBTARGET may be used as the target for computing one of EXP's
1995    operands.  */
1996
1997 static rtx
1998 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
1999 {
2000   optab builtin_optab;
2001   rtx op0, op1, insns;
2002   int op1_type = REAL_TYPE;
2003   tree fndecl = get_callee_fndecl (exp);
2004   tree arglist = TREE_OPERAND (exp, 1);
2005   tree arg0, arg1, temp, narg;
2006   enum machine_mode mode;
2007   bool errno_set = true;
2008   bool stable = true;
2009
2010   if ((DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXP)
2011       || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPF)
2012       || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPL))
2013     op1_type = INTEGER_TYPE;
2014
2015   if (!validate_arglist (arglist, REAL_TYPE, op1_type, VOID_TYPE))
2016     return 0;
2017
2018   arg0 = TREE_VALUE (arglist);
2019   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2020
2021   switch (DECL_FUNCTION_CODE (fndecl))
2022     {
2023     CASE_FLT_FN (BUILT_IN_POW):
2024       builtin_optab = pow_optab; break;
2025     CASE_FLT_FN (BUILT_IN_ATAN2):
2026       builtin_optab = atan2_optab; break;
2027     CASE_FLT_FN (BUILT_IN_LDEXP):
2028       builtin_optab = ldexp_optab; break;
2029     CASE_FLT_FN (BUILT_IN_FMOD):
2030       builtin_optab = fmod_optab; break;
2031     CASE_FLT_FN (BUILT_IN_DREM):
2032       builtin_optab = drem_optab; break;
2033     default:
2034       gcc_unreachable ();
2035     }
2036
2037   /* Make a suitable register to place result in.  */
2038   mode = TYPE_MODE (TREE_TYPE (exp));
2039
2040   /* Before working hard, check whether the instruction is available.  */
2041   if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2042     return 0;
2043
2044   target = gen_reg_rtx (mode);
2045
2046   if (! flag_errno_math || ! HONOR_NANS (mode))
2047     errno_set = false;
2048
2049   /* Always stabilize the argument list.  */
2050   narg = builtin_save_expr (arg1);
2051   if (narg != arg1)
2052     {
2053       arg1 = narg;
2054       temp = build_tree_list (NULL_TREE, narg);
2055       stable = false;
2056     }
2057   else
2058     temp = TREE_CHAIN (arglist);
2059
2060   narg = builtin_save_expr (arg0);
2061   if (narg != arg0)
2062     {
2063       arg0 = narg;
2064       arglist = tree_cons (NULL_TREE, narg, temp);
2065       stable = false;
2066     }
2067   else if (! stable)
2068     arglist = tree_cons (NULL_TREE, arg0, temp);
2069
2070   if (! stable)
2071     exp = build_function_call_expr (fndecl, arglist);
2072
2073   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2074   op1 = expand_normal (arg1);
2075
2076   start_sequence ();
2077
2078   /* Compute into TARGET.
2079      Set TARGET to wherever the result comes back.  */
2080   target = expand_binop (mode, builtin_optab, op0, op1,
2081                          target, 0, OPTAB_DIRECT);
2082
2083   /* If we were unable to expand via the builtin, stop the sequence
2084      (without outputting the insns) and call to the library function
2085      with the stabilized argument list.  */
2086   if (target == 0)
2087     {
2088       end_sequence ();
2089       return expand_call (exp, target, target == const0_rtx);
2090     }
2091
2092   if (errno_set)
2093     expand_errno_check (exp, target);
2094
2095   /* Output the entire sequence.  */
2096   insns = get_insns ();
2097   end_sequence ();
2098   emit_insn (insns);
2099
2100   return target;
2101 }
2102
2103 /* Expand a call to the builtin sin and cos math functions.
2104    Return 0 if a normal call should be emitted rather than expanding the
2105    function in-line.  EXP is the expression that is a call to the builtin
2106    function; if convenient, the result should be placed in TARGET.
2107    SUBTARGET may be used as the target for computing one of EXP's
2108    operands.  */
2109
2110 static rtx
2111 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2112 {
2113   optab builtin_optab;
2114   rtx op0, insns;
2115   tree fndecl = get_callee_fndecl (exp);
2116   tree arglist = TREE_OPERAND (exp, 1);
2117   enum machine_mode mode;
2118   tree arg, narg;
2119
2120   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
2121     return 0;
2122
2123   arg = TREE_VALUE (arglist);
2124
2125   switch (DECL_FUNCTION_CODE (fndecl))
2126     {
2127     CASE_FLT_FN (BUILT_IN_SIN):
2128     CASE_FLT_FN (BUILT_IN_COS):
2129       builtin_optab = sincos_optab; break;
2130     default:
2131       gcc_unreachable ();
2132     }
2133
2134   /* Make a suitable register to place result in.  */
2135   mode = TYPE_MODE (TREE_TYPE (exp));
2136
2137   /* Check if sincos insn is available, otherwise fallback
2138      to sin or cos insn.  */
2139   if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing) {
2140     switch (DECL_FUNCTION_CODE (fndecl))
2141       {
2142       CASE_FLT_FN (BUILT_IN_SIN):
2143         builtin_optab = sin_optab; break;
2144       CASE_FLT_FN (BUILT_IN_COS):
2145         builtin_optab = cos_optab; break;
2146       default:
2147         gcc_unreachable ();
2148       }
2149   }
2150
2151   /* Before working hard, check whether the instruction is available.  */
2152   if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2153     {
2154       target = gen_reg_rtx (mode);
2155
2156       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2157          need to expand the argument again.  This way, we will not perform
2158          side-effects more the once.  */
2159       narg = save_expr (arg);
2160       if (narg != arg)
2161         {
2162           arg = narg;
2163           arglist = build_tree_list (NULL_TREE, arg);
2164           exp = build_function_call_expr (fndecl, arglist);
2165         }
2166
2167       op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2168
2169       start_sequence ();
2170
2171       /* Compute into TARGET.
2172          Set TARGET to wherever the result comes back.  */
2173       if (builtin_optab == sincos_optab)
2174         {
2175           int result;
2176
2177           switch (DECL_FUNCTION_CODE (fndecl))
2178             {
2179             CASE_FLT_FN (BUILT_IN_SIN):
2180               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2181               break;
2182             CASE_FLT_FN (BUILT_IN_COS):
2183               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2184               break;
2185             default:
2186               gcc_unreachable ();
2187             }
2188           gcc_assert (result);
2189         }
2190       else
2191         {
2192           target = expand_unop (mode, builtin_optab, op0, target, 0);
2193         }
2194
2195       if (target != 0)
2196         {
2197           /* Output the entire sequence.  */
2198           insns = get_insns ();
2199           end_sequence ();
2200           emit_insn (insns);
2201           return target;
2202         }
2203
2204       /* If we were unable to expand via the builtin, stop the sequence
2205          (without outputting the insns) and call to the library function
2206          with the stabilized argument list.  */
2207       end_sequence ();
2208     }
2209
2210   target = expand_call (exp, target, target == const0_rtx);
2211
2212   return target;
2213 }
2214
2215 /* Expand a call to the builtin sincos math function.
2216    Return 0 if a normal call should be emitted rather than expanding the
2217    function in-line.  EXP is the expression that is a call to the builtin
2218    function.  */
2219
2220 static rtx
2221 expand_builtin_sincos (tree exp)
2222 {
2223   rtx op0, op1, op2, target1, target2;
2224   tree arglist = TREE_OPERAND (exp, 1);
2225   enum machine_mode mode;
2226   tree arg, sinp, cosp;
2227   int result;
2228
2229   if (!validate_arglist (arglist, REAL_TYPE,
2230                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2231     return 0;
2232
2233   arg = TREE_VALUE (arglist);
2234   sinp = TREE_VALUE (TREE_CHAIN (arglist));
2235   cosp = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2236
2237   /* Make a suitable register to place result in.  */
2238   mode = TYPE_MODE (TREE_TYPE (arg));
2239
2240   /* Check if sincos insn is available, otherwise emit the call.  */
2241   if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2242     return NULL_RTX;
2243
2244   target1 = gen_reg_rtx (mode);
2245   target2 = gen_reg_rtx (mode);
2246
2247   op0 = expand_normal (arg);
2248   op1 = expand_normal (build_fold_indirect_ref (sinp));
2249   op2 = expand_normal (build_fold_indirect_ref (cosp));
2250
2251   /* Compute into target1 and target2.
2252      Set TARGET to wherever the result comes back.  */
2253   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2254   gcc_assert (result);
2255
2256   /* Move target1 and target2 to the memory locations indicated
2257      by op1 and op2.  */
2258   emit_move_insn (op1, target1);
2259   emit_move_insn (op2, target2);
2260
2261   return const0_rtx;
2262 }
2263
2264 /* Expand a call to one of the builtin rounding functions (lfloor).
2265    If expanding via optab fails, lower expression to (int)(floor(x)).
2266    EXP is the expression that is a call to the builtin function;
2267    if convenient, the result should be placed in TARGET.  SUBTARGET may
2268    be used as the target for computing one of EXP's operands.  */
2269
2270 static rtx
2271 expand_builtin_int_roundingfn (tree exp, rtx target, rtx subtarget)
2272 {
2273   optab builtin_optab;
2274   rtx op0, insns, tmp;
2275   tree fndecl = get_callee_fndecl (exp);
2276   tree arglist = TREE_OPERAND (exp, 1);
2277   enum built_in_function fallback_fn;
2278   tree fallback_fndecl;
2279   enum machine_mode mode;
2280   tree arg, narg;
2281
2282   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
2283     gcc_unreachable ();
2284
2285   arg = TREE_VALUE (arglist);
2286
2287   switch (DECL_FUNCTION_CODE (fndecl))
2288     {
2289     CASE_FLT_FN (BUILT_IN_LCEIL):
2290     CASE_FLT_FN (BUILT_IN_LLCEIL):
2291       builtin_optab = lceil_optab;
2292       fallback_fn = BUILT_IN_CEIL;
2293       break;
2294
2295     CASE_FLT_FN (BUILT_IN_LFLOOR):
2296     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2297       builtin_optab = lfloor_optab;
2298       fallback_fn = BUILT_IN_FLOOR;
2299       break;
2300
2301     default:
2302       gcc_unreachable ();
2303     }
2304
2305   /* Make a suitable register to place result in.  */
2306   mode = TYPE_MODE (TREE_TYPE (exp));
2307
2308   /* Before working hard, check whether the instruction is available.  */
2309   if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2310     {
2311       target = gen_reg_rtx (mode);
2312
2313       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2314          need to expand the argument again.  This way, we will not perform
2315          side-effects more the once.  */
2316       narg = builtin_save_expr (arg);
2317       if (narg != arg)
2318         {
2319           arg = narg;
2320           arglist = build_tree_list (NULL_TREE, arg);
2321           exp = build_function_call_expr (fndecl, arglist);
2322         }
2323
2324       op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2325
2326       start_sequence ();
2327
2328       /* Compute into TARGET.
2329          Set TARGET to wherever the result comes back.  */
2330       target = expand_unop (mode, builtin_optab, op0, target, 0);
2331
2332       if (target != 0)
2333         {
2334           /* Output the entire sequence.  */
2335           insns = get_insns ();
2336           end_sequence ();
2337           emit_insn (insns);
2338           return target;
2339         }
2340
2341       /* If we were unable to expand via the builtin, stop the sequence
2342          (without outputting the insns).  */
2343       end_sequence ();
2344     }
2345
2346   /* Fall back to floating point rounding optab.  */
2347   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2348   /* We shouldn't get here on targets without TARGET_C99_FUNCTIONS.
2349      ??? Perhaps convert (int)floorf(x) into (int)floor((double)x).  */
2350   gcc_assert (fallback_fndecl != NULL_TREE);
2351   exp = build_function_call_expr (fallback_fndecl, arglist);
2352
2353   tmp = expand_normal (exp);
2354
2355   /* Truncate the result of floating point optab to integer
2356      via expand_fix ().  */
2357   target = gen_reg_rtx (mode);
2358   expand_fix (target, tmp, 0);
2359
2360   return target;
2361 }
2362
2363 /* To evaluate powi(x,n), the floating point value x raised to the
2364    constant integer exponent n, we use a hybrid algorithm that
2365    combines the "window method" with look-up tables.  For an
2366    introduction to exponentiation algorithms and "addition chains",
2367    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2368    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2369    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2370    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2371
2372 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2373    multiplications to inline before calling the system library's pow
2374    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2375    so this default never requires calling pow, powf or powl.  */
2376
2377 #ifndef POWI_MAX_MULTS
2378 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2379 #endif
2380
2381 /* The size of the "optimal power tree" lookup table.  All
2382    exponents less than this value are simply looked up in the
2383    powi_table below.  This threshold is also used to size the
2384    cache of pseudo registers that hold intermediate results.  */
2385 #define POWI_TABLE_SIZE 256
2386
2387 /* The size, in bits of the window, used in the "window method"
2388    exponentiation algorithm.  This is equivalent to a radix of
2389    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2390 #define POWI_WINDOW_SIZE 3
2391
2392 /* The following table is an efficient representation of an
2393    "optimal power tree".  For each value, i, the corresponding
2394    value, j, in the table states than an optimal evaluation
2395    sequence for calculating pow(x,i) can be found by evaluating
2396    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2397    100 integers is given in Knuth's "Seminumerical algorithms".  */
2398
2399 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2400   {
2401       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2402       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2403       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2404      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2405      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2406      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2407      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2408      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2409      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2410      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2411      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2412      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2413      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2414      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2415      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2416      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2417      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2418      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2419      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2420      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2421      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2422      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2423      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2424      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2425      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2426     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2427     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2428     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2429     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2430     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2431     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2432     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2433   };
2434
2435
2436 /* Return the number of multiplications required to calculate
2437    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2438    subroutine of powi_cost.  CACHE is an array indicating
2439    which exponents have already been calculated.  */
2440
2441 static int
2442 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2443 {
2444   /* If we've already calculated this exponent, then this evaluation
2445      doesn't require any additional multiplications.  */
2446   if (cache[n])
2447     return 0;
2448
2449   cache[n] = true;
2450   return powi_lookup_cost (n - powi_table[n], cache)
2451          + powi_lookup_cost (powi_table[n], cache) + 1;
2452 }
2453
2454 /* Return the number of multiplications required to calculate
2455    powi(x,n) for an arbitrary x, given the exponent N.  This
2456    function needs to be kept in sync with expand_powi below.  */
2457
2458 static int
2459 powi_cost (HOST_WIDE_INT n)
2460 {
2461   bool cache[POWI_TABLE_SIZE];
2462   unsigned HOST_WIDE_INT digit;
2463   unsigned HOST_WIDE_INT val;
2464   int result;
2465
2466   if (n == 0)
2467     return 0;
2468
2469   /* Ignore the reciprocal when calculating the cost.  */
2470   val = (n < 0) ? -n : n;
2471
2472   /* Initialize the exponent cache.  */
2473   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2474   cache[1] = true;
2475
2476   result = 0;
2477
2478   while (val >= POWI_TABLE_SIZE)
2479     {
2480       if (val & 1)
2481         {
2482           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2483           result += powi_lookup_cost (digit, cache)
2484                     + POWI_WINDOW_SIZE + 1;
2485           val >>= POWI_WINDOW_SIZE;
2486         }
2487       else
2488         {
2489           val >>= 1;
2490           result++;
2491         }
2492     }
2493
2494   return result + powi_lookup_cost (val, cache);
2495 }
2496
2497 /* Recursive subroutine of expand_powi.  This function takes the array,
2498    CACHE, of already calculated exponents and an exponent N and returns
2499    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2500
2501 static rtx
2502 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2503 {
2504   unsigned HOST_WIDE_INT digit;
2505   rtx target, result;
2506   rtx op0, op1;
2507
2508   if (n < POWI_TABLE_SIZE)
2509     {
2510       if (cache[n])
2511         return cache[n];
2512
2513       target = gen_reg_rtx (mode);
2514       cache[n] = target;
2515
2516       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2517       op1 = expand_powi_1 (mode, powi_table[n], cache);
2518     }
2519   else if (n & 1)
2520     {
2521       target = gen_reg_rtx (mode);
2522       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2523       op0 = expand_powi_1 (mode, n - digit, cache);
2524       op1 = expand_powi_1 (mode, digit, cache);
2525     }
2526   else
2527     {
2528       target = gen_reg_rtx (mode);
2529       op0 = expand_powi_1 (mode, n >> 1, cache);
2530       op1 = op0;
2531     }
2532
2533   result = expand_mult (mode, op0, op1, target, 0);
2534   if (result != target)
2535     emit_move_insn (target, result);
2536   return target;
2537 }
2538
2539 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2540    floating point operand in mode MODE, and N is the exponent.  This
2541    function needs to be kept in sync with powi_cost above.  */
2542
2543 static rtx
2544 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2545 {
2546   unsigned HOST_WIDE_INT val;
2547   rtx cache[POWI_TABLE_SIZE];
2548   rtx result;
2549
2550   if (n == 0)
2551     return CONST1_RTX (mode);
2552
2553   val = (n < 0) ? -n : n;
2554
2555   memset (cache, 0, sizeof (cache));
2556   cache[1] = x;
2557
2558   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2559
2560   /* If the original exponent was negative, reciprocate the result.  */
2561   if (n < 0)
2562     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2563                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2564
2565   return result;
2566 }
2567
2568 /* Expand a call to the pow built-in mathematical function.  Return 0 if
2569    a normal call should be emitted rather than expanding the function
2570    in-line.  EXP is the expression that is a call to the builtin
2571    function; if convenient, the result should be placed in TARGET.  */
2572
2573 static rtx
2574 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2575 {
2576   tree arglist = TREE_OPERAND (exp, 1);
2577   tree arg0, arg1;
2578
2579   if (! validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2580     return 0;
2581
2582   arg0 = TREE_VALUE (arglist);
2583   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2584
2585   if (TREE_CODE (arg1) == REAL_CST
2586       && ! TREE_CONSTANT_OVERFLOW (arg1))
2587     {
2588       REAL_VALUE_TYPE cint;
2589       REAL_VALUE_TYPE c;
2590       HOST_WIDE_INT n;
2591
2592       c = TREE_REAL_CST (arg1);
2593       n = real_to_integer (&c);
2594       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2595       if (real_identical (&c, &cint))
2596         {
2597           /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2598              Otherwise, check the number of multiplications required.
2599              Note that pow never sets errno for an integer exponent.  */
2600           if ((n >= -1 && n <= 2)
2601               || (flag_unsafe_math_optimizations
2602                   && ! optimize_size
2603                   && powi_cost (n) <= POWI_MAX_MULTS))
2604             {
2605               enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2606               rtx op = expand_expr (arg0, subtarget, VOIDmode, 0);
2607               op = force_reg (mode, op);
2608               return expand_powi (op, mode, n);
2609             }
2610         }
2611     }
2612
2613   if (! flag_unsafe_math_optimizations)
2614     return NULL_RTX;
2615   return expand_builtin_mathfn_2 (exp, target, subtarget);
2616 }
2617
2618 /* Expand a call to the powi built-in mathematical function.  Return 0 if
2619    a normal call should be emitted rather than expanding the function
2620    in-line.  EXP is the expression that is a call to the builtin
2621    function; if convenient, the result should be placed in TARGET.  */
2622
2623 static rtx
2624 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
2625 {
2626   tree arglist = TREE_OPERAND (exp, 1);
2627   tree arg0, arg1;
2628   rtx op0, op1;
2629   enum machine_mode mode;
2630   enum machine_mode mode2;
2631
2632   if (! validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2633     return 0;
2634
2635   arg0 = TREE_VALUE (arglist);
2636   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2637   mode = TYPE_MODE (TREE_TYPE (exp));
2638
2639   /* Handle constant power.  */
2640
2641   if (TREE_CODE (arg1) == INTEGER_CST
2642       && ! TREE_CONSTANT_OVERFLOW (arg1))
2643     {
2644       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
2645
2646       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2647          Otherwise, check the number of multiplications required.  */
2648       if ((TREE_INT_CST_HIGH (arg1) == 0
2649            || TREE_INT_CST_HIGH (arg1) == -1)
2650           && ((n >= -1 && n <= 2)
2651               || (! optimize_size
2652                   && powi_cost (n) <= POWI_MAX_MULTS)))
2653         {
2654           op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
2655           op0 = force_reg (mode, op0);
2656           return expand_powi (op0, mode, n);
2657         }
2658     }
2659
2660   /* Emit a libcall to libgcc.  */
2661
2662   /* Mode of the 2nd argument must match that of an int. */
2663   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2664
2665   if (target == NULL_RTX)
2666     target = gen_reg_rtx (mode);
2667
2668   op0 = expand_expr (arg0, subtarget, mode, 0);
2669   if (GET_MODE (op0) != mode)
2670     op0 = convert_to_mode (mode, op0, 0);
2671   op1 = expand_expr (arg1, 0, mode2, 0);
2672   if (GET_MODE (op1) != mode2)
2673     op1 = convert_to_mode (mode2, op1, 0);
2674
2675   target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
2676                                     target, LCT_CONST_MAKE_BLOCK, mode, 2,
2677                                     op0, mode, op1, mode2);
2678
2679   return target;
2680 }
2681
2682 /* Expand expression EXP which is a call to the strlen builtin.  Return 0
2683    if we failed the caller should emit a normal call, otherwise
2684    try to get the result in TARGET, if convenient.  */
2685
2686 static rtx
2687 expand_builtin_strlen (tree arglist, rtx target,
2688                        enum machine_mode target_mode)
2689 {
2690   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
2691     return 0;
2692   else
2693     {
2694       rtx pat;
2695       tree len, src = TREE_VALUE (arglist);
2696       rtx result, src_reg, char_rtx, before_strlen;
2697       enum machine_mode insn_mode = target_mode, char_mode;
2698       enum insn_code icode = CODE_FOR_nothing;
2699       int align;
2700
2701       /* If the length can be computed at compile-time, return it.  */
2702       len = c_strlen (src, 0);
2703       if (len)
2704         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2705
2706       /* If the length can be computed at compile-time and is constant
2707          integer, but there are side-effects in src, evaluate
2708          src for side-effects, then return len.
2709          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2710          can be optimized into: i++; x = 3;  */
2711       len = c_strlen (src, 1);
2712       if (len && TREE_CODE (len) == INTEGER_CST)
2713         {
2714           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2715           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2716         }
2717
2718       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2719
2720       /* If SRC is not a pointer type, don't do this operation inline.  */
2721       if (align == 0)
2722         return 0;
2723
2724       /* Bail out if we can't compute strlen in the right mode.  */
2725       while (insn_mode != VOIDmode)
2726         {
2727           icode = strlen_optab->handlers[(int) insn_mode].insn_code;
2728           if (icode != CODE_FOR_nothing)
2729             break;
2730
2731           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2732         }
2733       if (insn_mode == VOIDmode)
2734         return 0;
2735
2736       /* Make a place to write the result of the instruction.  */
2737       result = target;
2738       if (! (result != 0
2739              && REG_P (result)
2740              && GET_MODE (result) == insn_mode
2741              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
2742         result = gen_reg_rtx (insn_mode);
2743
2744       /* Make a place to hold the source address.  We will not expand
2745          the actual source until we are sure that the expansion will
2746          not fail -- there are trees that cannot be expanded twice.  */
2747       src_reg = gen_reg_rtx (Pmode);
2748
2749       /* Mark the beginning of the strlen sequence so we can emit the
2750          source operand later.  */
2751       before_strlen = get_last_insn ();
2752
2753       char_rtx = const0_rtx;
2754       char_mode = insn_data[(int) icode].operand[2].mode;
2755       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
2756                                                             char_mode))
2757         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
2758
2759       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
2760                              char_rtx, GEN_INT (align));
2761       if (! pat)
2762         return 0;
2763       emit_insn (pat);
2764
2765       /* Now that we are assured of success, expand the source.  */
2766       start_sequence ();
2767       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
2768       if (pat != src_reg)
2769         emit_move_insn (src_reg, pat);
2770       pat = get_insns ();
2771       end_sequence ();
2772
2773       if (before_strlen)
2774         emit_insn_after (pat, before_strlen);
2775       else
2776         emit_insn_before (pat, get_insns ());
2777
2778       /* Return the value in the proper mode for this function.  */
2779       if (GET_MODE (result) == target_mode)
2780         target = result;
2781       else if (target != 0)
2782         convert_move (target, result, 0);
2783       else
2784         target = convert_to_mode (target_mode, result, 0);
2785
2786       return target;
2787     }
2788 }
2789
2790 /* Expand a call to the strstr builtin.  Return 0 if we failed the
2791    caller should emit a normal call, otherwise try to get the result
2792    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2793
2794 static rtx
2795 expand_builtin_strstr (tree arglist, tree type, rtx target, enum machine_mode mode)
2796 {
2797   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2798     {
2799       tree result = fold_builtin_strstr (arglist, type);
2800       if (result)
2801         return expand_expr (result, target, mode, EXPAND_NORMAL);
2802     }
2803   return 0;
2804 }
2805
2806 /* Expand a call to the strchr builtin.  Return 0 if we failed the
2807    caller should emit a normal call, otherwise try to get the result
2808    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2809
2810 static rtx
2811 expand_builtin_strchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2812 {
2813   if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2814     {
2815       tree result = fold_builtin_strchr (arglist, type);
2816       if (result)
2817         return expand_expr (result, target, mode, EXPAND_NORMAL);
2818
2819       /* FIXME: Should use strchrM optab so that ports can optimize this.  */
2820     }
2821   return 0;
2822 }
2823
2824 /* Expand a call to the strrchr builtin.  Return 0 if we failed the
2825    caller should emit a normal call, otherwise try to get the result
2826    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2827
2828 static rtx
2829 expand_builtin_strrchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2830 {
2831   if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2832     {
2833       tree result = fold_builtin_strrchr (arglist, type);
2834       if (result)
2835         return expand_expr (result, target, mode, EXPAND_NORMAL);
2836     }
2837   return 0;
2838 }
2839
2840 /* Expand a call to the strpbrk builtin.  Return 0 if we failed the
2841    caller should emit a normal call, otherwise try to get the result
2842    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2843
2844 static rtx
2845 expand_builtin_strpbrk (tree arglist, tree type, rtx target, enum machine_mode mode)
2846 {
2847   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2848     {
2849       tree result = fold_builtin_strpbrk (arglist, type);
2850       if (result)
2851         return expand_expr (result, target, mode, EXPAND_NORMAL);
2852     }
2853   return 0;
2854 }
2855
2856 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
2857    bytes from constant string DATA + OFFSET and return it as target
2858    constant.  */
2859
2860 static rtx
2861 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2862                          enum machine_mode mode)
2863 {
2864   const char *str = (const char *) data;
2865
2866   gcc_assert (offset >= 0
2867               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2868                   <= strlen (str) + 1));
2869
2870   return c_readstr (str + offset, mode);
2871 }
2872
2873 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2874    Return 0 if we failed, the caller should emit a normal call,
2875    otherwise try to get the result in TARGET, if convenient (and in
2876    mode MODE if that's convenient).  */
2877 static rtx
2878 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
2879 {
2880   tree fndecl = get_callee_fndecl (exp);
2881   tree arglist = TREE_OPERAND (exp, 1);
2882   if (!validate_arglist (arglist,
2883                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2884     return 0;
2885   else
2886     {
2887       tree dest = TREE_VALUE (arglist);
2888       tree src = TREE_VALUE (TREE_CHAIN (arglist));
2889       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2890       const char *src_str;
2891       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2892       unsigned int dest_align
2893         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2894       rtx dest_mem, src_mem, dest_addr, len_rtx;
2895       tree result = fold_builtin_memory_op (arglist, TREE_TYPE (TREE_TYPE (fndecl)),
2896                                             false, /*endp=*/0);
2897
2898       if (result)
2899         {
2900           while (TREE_CODE (result) == COMPOUND_EXPR)
2901             {
2902               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
2903                            EXPAND_NORMAL);
2904               result = TREE_OPERAND (result, 1);
2905             }
2906           return expand_expr (result, target, mode, EXPAND_NORMAL);
2907         }
2908
2909       /* If DEST is not a pointer type, call the normal function.  */
2910       if (dest_align == 0)
2911         return 0;
2912
2913       /* If either SRC is not a pointer type, don't do this
2914          operation in-line.  */
2915       if (src_align == 0)
2916         return 0;
2917
2918       dest_mem = get_memory_rtx (dest, len);
2919       set_mem_align (dest_mem, dest_align);
2920       len_rtx = expand_normal (len);
2921       src_str = c_getstr (src);
2922
2923       /* If SRC is a string constant and block move would be done
2924          by pieces, we can avoid loading the string from memory
2925          and only stored the computed constants.  */
2926       if (src_str
2927           && GET_CODE (len_rtx) == CONST_INT
2928           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2929           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2930                                   (void *) src_str, dest_align))
2931         {
2932           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2933                                       builtin_memcpy_read_str,
2934                                       (void *) src_str, dest_align, 0);
2935           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2936           dest_mem = convert_memory_address (ptr_mode, dest_mem);
2937           return dest_mem;
2938         }
2939
2940       src_mem = get_memory_rtx (src, len);
2941       set_mem_align (src_mem, src_align);
2942
2943       /* Copy word part most expediently.  */
2944       dest_addr = emit_block_move (dest_mem, src_mem, len_rtx,
2945                                    CALL_EXPR_TAILCALL (exp)
2946                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
2947
2948       if (dest_addr == 0)
2949         {
2950           dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2951           dest_addr = convert_memory_address (ptr_mode, dest_addr);
2952         }
2953       return dest_addr;
2954     }
2955 }
2956
2957 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2958    Return 0 if we failed; the caller should emit a normal call,
2959    otherwise try to get the result in TARGET, if convenient (and in
2960    mode MODE if that's convenient).  If ENDP is 0 return the
2961    destination pointer, if ENDP is 1 return the end pointer ala
2962    mempcpy, and if ENDP is 2 return the end pointer minus one ala
2963    stpcpy.  */
2964
2965 static rtx
2966 expand_builtin_mempcpy (tree arglist, tree type, rtx target, enum machine_mode mode,
2967                         int endp)
2968 {
2969   if (!validate_arglist (arglist,
2970                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2971     return 0;
2972   /* If return value is ignored, transform mempcpy into memcpy.  */
2973   else if (target == const0_rtx)
2974     {
2975       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2976
2977       if (!fn)
2978         return 0;
2979
2980       return expand_expr (build_function_call_expr (fn, arglist),
2981                           target, mode, EXPAND_NORMAL);
2982     }
2983   else
2984     {
2985       tree dest = TREE_VALUE (arglist);
2986       tree src = TREE_VALUE (TREE_CHAIN (arglist));
2987       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2988       const char *src_str;
2989       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2990       unsigned int dest_align
2991         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2992       rtx dest_mem, src_mem, len_rtx;
2993       tree result = fold_builtin_memory_op (arglist, type, false, endp);
2994
2995       if (result)
2996         {
2997           while (TREE_CODE (result) == COMPOUND_EXPR)
2998             {
2999               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3000                            EXPAND_NORMAL);
3001               result = TREE_OPERAND (result, 1);
3002             }
3003           return expand_expr (result, target, mode, EXPAND_NORMAL);
3004         }
3005
3006       /* If either SRC or DEST is not a pointer type, don't do this
3007          operation in-line.  */
3008       if (dest_align == 0 || src_align == 0)
3009         return 0;
3010
3011       /* If LEN is not constant, call the normal function.  */
3012       if (! host_integerp (len, 1))
3013         return 0;
3014
3015       len_rtx = expand_normal (len);
3016       src_str = c_getstr (src);
3017
3018       /* If SRC is a string constant and block move would be done
3019          by pieces, we can avoid loading the string from memory
3020          and only stored the computed constants.  */
3021       if (src_str
3022           && GET_CODE (len_rtx) == CONST_INT
3023           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3024           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3025                                   (void *) src_str, dest_align))
3026         {
3027           dest_mem = get_memory_rtx (dest, len);
3028           set_mem_align (dest_mem, dest_align);
3029           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3030                                       builtin_memcpy_read_str,
3031                                       (void *) src_str, dest_align, endp);
3032           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3033           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3034           return dest_mem;
3035         }
3036
3037       if (GET_CODE (len_rtx) == CONST_INT
3038           && can_move_by_pieces (INTVAL (len_rtx),
3039                                  MIN (dest_align, src_align)))
3040         {
3041           dest_mem = get_memory_rtx (dest, len);
3042           set_mem_align (dest_mem, dest_align);
3043           src_mem = get_memory_rtx (src, len);
3044           set_mem_align (src_mem, src_align);
3045           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3046                                      MIN (dest_align, src_align), endp);
3047           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3048           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3049           return dest_mem;
3050         }
3051
3052       return 0;
3053     }
3054 }
3055
3056 /* Expand expression EXP, which is a call to the memmove builtin.  Return 0
3057    if we failed; the caller should emit a normal call.  */
3058
3059 static rtx
3060 expand_builtin_memmove (tree arglist, tree type, rtx target,
3061                         enum machine_mode mode, tree orig_exp)
3062 {
3063   if (!validate_arglist (arglist,
3064                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3065     return 0;
3066   else
3067     {
3068       tree dest = TREE_VALUE (arglist);
3069       tree src = TREE_VALUE (TREE_CHAIN (arglist));
3070       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3071
3072       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3073       unsigned int dest_align
3074         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3075       tree result = fold_builtin_memory_op (arglist, type, false, /*endp=*/3);
3076
3077       if (result)
3078         {
3079           while (TREE_CODE (result) == COMPOUND_EXPR)
3080             {
3081               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3082                            EXPAND_NORMAL);
3083               result = TREE_OPERAND (result, 1);
3084             }
3085           return expand_expr (result, target, mode, EXPAND_NORMAL);
3086         }
3087
3088       /* If DEST is not a pointer type, call the normal function.  */
3089       if (dest_align == 0)
3090         return 0;
3091
3092       /* If either SRC is not a pointer type, don't do this
3093          operation in-line.  */
3094       if (src_align == 0)
3095         return 0;
3096
3097       /* If src is categorized for a readonly section we can use
3098          normal memcpy.  */
3099       if (readonly_data_expr (src))
3100         {
3101           tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3102           if (!fn)
3103             return 0;
3104           fn = build_function_call_expr (fn, arglist);
3105           if (TREE_CODE (fn) == CALL_EXPR)
3106             CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3107           return expand_expr (fn, target, mode, EXPAND_NORMAL);
3108         }
3109
3110       /* If length is 1 and we can expand memcpy call inline,
3111          it is ok to use memcpy as well.  */
3112       if (integer_onep (len))
3113         {
3114           rtx ret = expand_builtin_mempcpy (arglist, type, target, mode,
3115                                             /*endp=*/0);
3116           if (ret)
3117             return ret;
3118         }
3119
3120       /* Otherwise, call the normal function.  */
3121       return 0;
3122    }
3123 }
3124
3125 /* Expand expression EXP, which is a call to the bcopy builtin.  Return 0
3126    if we failed the caller should emit a normal call.  */
3127
3128 static rtx
3129 expand_builtin_bcopy (tree exp)
3130 {
3131   tree arglist = TREE_OPERAND (exp, 1);
3132   tree type = TREE_TYPE (exp);
3133   tree src, dest, size, newarglist;
3134
3135   if (!validate_arglist (arglist,
3136                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3137     return NULL_RTX;
3138
3139   src = TREE_VALUE (arglist);
3140   dest = TREE_VALUE (TREE_CHAIN (arglist));
3141   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3142
3143   /* New argument list transforming bcopy(ptr x, ptr y, int z) to
3144      memmove(ptr y, ptr x, size_t z).   This is done this way
3145      so that if it isn't expanded inline, we fallback to
3146      calling bcopy instead of memmove.  */
3147
3148   newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
3149   newarglist = tree_cons (NULL_TREE, src, newarglist);
3150   newarglist = tree_cons (NULL_TREE, dest, newarglist);
3151
3152   return expand_builtin_memmove (newarglist, type, const0_rtx, VOIDmode, exp);
3153 }
3154
3155 #ifndef HAVE_movstr
3156 # define HAVE_movstr 0
3157 # define CODE_FOR_movstr CODE_FOR_nothing
3158 #endif
3159
3160 /* Expand into a movstr instruction, if one is available.  Return 0 if
3161    we failed, the caller should emit a normal call, otherwise try to
3162    get the result in TARGET, if convenient.  If ENDP is 0 return the
3163    destination pointer, if ENDP is 1 return the end pointer ala
3164    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3165    stpcpy.  */
3166
3167 static rtx
3168 expand_movstr (tree dest, tree src, rtx target, int endp)
3169 {
3170   rtx end;
3171   rtx dest_mem;
3172   rtx src_mem;
3173   rtx insn;
3174   const struct insn_data * data;
3175
3176   if (!HAVE_movstr)
3177     return 0;
3178
3179   dest_mem = get_memory_rtx (dest, NULL);
3180   src_mem = get_memory_rtx (src, NULL);
3181   if (!endp)
3182     {
3183       target = force_reg (Pmode, XEXP (dest_mem, 0));
3184       dest_mem = replace_equiv_address (dest_mem, target);
3185       end = gen_reg_rtx (Pmode);
3186     }
3187   else
3188     {
3189       if (target == 0 || target == const0_rtx)
3190         {
3191           end = gen_reg_rtx (Pmode);
3192           if (target == 0)
3193             target = end;
3194         }
3195       else
3196         end = target;
3197     }
3198
3199   data = insn_data + CODE_FOR_movstr;
3200
3201   if (data->operand[0].mode != VOIDmode)
3202     end = gen_lowpart (data->operand[0].mode, end);
3203
3204   insn = data->genfun (end, dest_mem, src_mem);
3205
3206   gcc_assert (insn);
3207
3208   emit_insn (insn);
3209
3210   /* movstr is supposed to set end to the address of the NUL
3211      terminator.  If the caller requested a mempcpy-like return value,
3212      adjust it.  */
3213   if (endp == 1 && target != const0_rtx)
3214     {
3215       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3216       emit_move_insn (target, force_operand (tem, NULL_RTX));
3217     }
3218
3219   return target;
3220 }
3221
3222 /* Expand expression EXP, which is a call to the strcpy builtin.  Return 0
3223    if we failed the caller should emit a normal call, otherwise try to get
3224    the result in TARGET, if convenient (and in mode MODE if that's
3225    convenient).  */
3226
3227 static rtx
3228 expand_builtin_strcpy (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3229 {
3230   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3231     {
3232       tree result = fold_builtin_strcpy (fndecl, arglist, 0);
3233       if (result)
3234         {
3235           while (TREE_CODE (result) == COMPOUND_EXPR)
3236             {
3237               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3238                            EXPAND_NORMAL);
3239               result = TREE_OPERAND (result, 1);
3240             }
3241           return expand_expr (result, target, mode, EXPAND_NORMAL);
3242         }
3243
3244       return expand_movstr (TREE_VALUE (arglist),
3245                             TREE_VALUE (TREE_CHAIN (arglist)),
3246                             target, /*endp=*/0);
3247     }
3248   return 0;
3249 }
3250
3251 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3252    Return 0 if we failed the caller should emit a normal call,
3253    otherwise try to get the result in TARGET, if convenient (and in
3254    mode MODE if that's convenient).  */
3255
3256 static rtx
3257 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3258 {
3259   tree arglist = TREE_OPERAND (exp, 1);
3260   /* If return value is ignored, transform stpcpy into strcpy.  */
3261   if (target == const0_rtx)
3262     {
3263       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3264       if (!fn)
3265         return 0;
3266
3267       return expand_expr (build_function_call_expr (fn, arglist),
3268                           target, mode, EXPAND_NORMAL);
3269     }
3270
3271   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3272     return 0;
3273   else
3274     {
3275       tree dst, src, len, lenp1;
3276       tree narglist;
3277       rtx ret;
3278
3279       /* Ensure we get an actual string whose length can be evaluated at
3280          compile-time, not an expression containing a string.  This is
3281          because the latter will potentially produce pessimized code
3282          when used to produce the return value.  */
3283       src = TREE_VALUE (TREE_CHAIN (arglist));
3284       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3285         return expand_movstr (TREE_VALUE (arglist),
3286                               TREE_VALUE (TREE_CHAIN (arglist)),
3287                               target, /*endp=*/2);
3288
3289       dst = TREE_VALUE (arglist);
3290       lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
3291       narglist = build_tree_list (NULL_TREE, lenp1);
3292       narglist = tree_cons (NULL_TREE, src, narglist);
3293       narglist = tree_cons (NULL_TREE, dst, narglist);
3294       ret = expand_builtin_mempcpy (narglist, TREE_TYPE (exp),
3295                                     target, mode, /*endp=*/2);
3296
3297       if (ret)
3298         return ret;
3299
3300       if (TREE_CODE (len) == INTEGER_CST)
3301         {
3302           rtx len_rtx = expand_normal (len);
3303
3304           if (GET_CODE (len_rtx) == CONST_INT)
3305             {
3306               ret = expand_builtin_strcpy (get_callee_fndecl (exp),
3307                                            arglist, target, mode);
3308
3309               if (ret)
3310                 {
3311                   if (! target)
3312                     {
3313                       if (mode != VOIDmode)
3314                         target = gen_reg_rtx (mode);
3315                       else
3316                         target = gen_reg_rtx (GET_MODE (ret));
3317                     }
3318                   if (GET_MODE (target) != GET_MODE (ret))
3319                     ret = gen_lowpart (GET_MODE (target), ret);
3320
3321                   ret = plus_constant (ret, INTVAL (len_rtx));
3322                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3323                   gcc_assert (ret);
3324
3325                   return target;
3326                 }
3327             }
3328         }
3329
3330       return expand_movstr (TREE_VALUE (arglist),
3331                             TREE_VALUE (TREE_CHAIN (arglist)),
3332                             target, /*endp=*/2);
3333     }
3334 }
3335
3336 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3337    bytes from constant string DATA + OFFSET and return it as target
3338    constant.  */
3339
3340 static rtx
3341 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3342                           enum machine_mode mode)
3343 {
3344   const char *str = (const char *) data;
3345
3346   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3347     return const0_rtx;
3348
3349   return c_readstr (str + offset, mode);
3350 }
3351
3352 /* Expand expression EXP, which is a call to the strncpy builtin.  Return 0
3353    if we failed the caller should emit a normal call.  */
3354
3355 static rtx
3356 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3357 {
3358   tree fndecl = get_callee_fndecl (exp);
3359   tree arglist = TREE_OPERAND (exp, 1);
3360   if (validate_arglist (arglist,
3361                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3362     {
3363       tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
3364       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3365       tree result = fold_builtin_strncpy (fndecl, arglist, slen);
3366
3367       if (result)
3368         {
3369           while (TREE_CODE (result) == COMPOUND_EXPR)
3370             {
3371               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3372                            EXPAND_NORMAL);
3373               result = TREE_OPERAND (result, 1);
3374             }
3375           return expand_expr (result, target, mode, EXPAND_NORMAL);
3376         }
3377
3378       /* We must be passed a constant len and src parameter.  */
3379       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3380         return 0;
3381
3382       slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
3383
3384       /* We're required to pad with trailing zeros if the requested
3385          len is greater than strlen(s2)+1.  In that case try to
3386          use store_by_pieces, if it fails, punt.  */
3387       if (tree_int_cst_lt (slen, len))
3388         {
3389           tree dest = TREE_VALUE (arglist);
3390           unsigned int dest_align
3391             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3392           const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
3393           rtx dest_mem;
3394
3395           if (!p || dest_align == 0 || !host_integerp (len, 1)
3396               || !can_store_by_pieces (tree_low_cst (len, 1),
3397                                        builtin_strncpy_read_str,
3398                                        (void *) p, dest_align))
3399             return 0;
3400
3401           dest_mem = get_memory_rtx (dest, len);
3402           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3403                            builtin_strncpy_read_str,
3404                            (void *) p, dest_align, 0);
3405           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3406           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3407           return dest_mem;
3408         }
3409     }
3410   return 0;
3411 }
3412
3413 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3414    bytes from constant string DATA + OFFSET and return it as target
3415    constant.  */
3416
3417 static rtx
3418 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3419                          enum machine_mode mode)
3420 {
3421   const char *c = (const char *) data;
3422   char *p = alloca (GET_MODE_SIZE (mode));
3423
3424   memset (p, *c, GET_MODE_SIZE (mode));
3425
3426   return c_readstr (p, mode);
3427 }
3428
3429 /* Callback routine for store_by_pieces.  Return the RTL of a register
3430    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3431    char value given in the RTL register data.  For example, if mode is
3432    4 bytes wide, return the RTL for 0x01010101*data.  */
3433
3434 static rtx
3435 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3436                         enum machine_mode mode)
3437 {
3438   rtx target, coeff;
3439   size_t size;
3440   char *p;
3441
3442   size = GET_MODE_SIZE (mode);
3443   if (size == 1)
3444     return (rtx) data;
3445
3446   p = alloca (size);
3447   memset (p, 1, size);
3448   coeff = c_readstr (p, mode);
3449
3450   target = convert_to_mode (mode, (rtx) data, 1);
3451   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3452   return force_reg (mode, target);
3453 }
3454
3455 /* Expand expression EXP, which is a call to the memset builtin.  Return 0
3456    if we failed the caller should emit a normal call, otherwise try to get
3457    the result in TARGET, if convenient (and in mode MODE if that's
3458    convenient).  */
3459
3460 static rtx
3461 expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode,
3462                        tree orig_exp)
3463 {
3464   if (!validate_arglist (arglist,
3465                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3466     return 0;
3467   else
3468     {
3469       tree dest = TREE_VALUE (arglist);
3470       tree val = TREE_VALUE (TREE_CHAIN (arglist));
3471       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3472       tree fndecl, fn;
3473       enum built_in_function fcode;
3474       char c;
3475       unsigned int dest_align;
3476       rtx dest_mem, dest_addr, len_rtx;
3477
3478       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3479
3480       /* If DEST is not a pointer type, don't do this
3481          operation in-line.  */
3482       if (dest_align == 0)
3483         return 0;
3484
3485       /* If the LEN parameter is zero, return DEST.  */
3486       if (integer_zerop (len))
3487         {
3488           /* Evaluate and ignore VAL in case it has side-effects.  */
3489           expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3490           return expand_expr (dest, target, mode, EXPAND_NORMAL);
3491         }
3492
3493       /* Stabilize the arguments in case we fail.  */
3494       dest = builtin_save_expr (dest);
3495       val = builtin_save_expr (val);
3496       len = builtin_save_expr (len);
3497
3498       len_rtx = expand_normal (len);
3499       dest_mem = get_memory_rtx (dest, len);
3500
3501       if (TREE_CODE (val) != INTEGER_CST)
3502         {
3503           rtx val_rtx;
3504
3505           val_rtx = expand_normal (val);
3506           val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3507                                      val_rtx, 0);
3508
3509           /* Assume that we can memset by pieces if we can store the
3510            * the coefficients by pieces (in the required modes).
3511            * We can't pass builtin_memset_gen_str as that emits RTL.  */
3512           c = 1;
3513           if (host_integerp (len, 1)
3514               && !(optimize_size && tree_low_cst (len, 1) > 1)
3515               && can_store_by_pieces (tree_low_cst (len, 1),
3516                                       builtin_memset_read_str, &c, dest_align))
3517             {
3518               val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3519                                    val_rtx);
3520               store_by_pieces (dest_mem, tree_low_cst (len, 1),
3521                                builtin_memset_gen_str, val_rtx, dest_align, 0);
3522             }
3523           else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3524                                             dest_align))
3525             goto do_libcall;
3526
3527           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3528           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3529           return dest_mem;
3530         }
3531
3532       if (target_char_cast (val, &c))
3533         goto do_libcall;
3534
3535       if (c)
3536         {
3537           if (host_integerp (len, 1)
3538               && !(optimize_size && tree_low_cst (len, 1) > 1)
3539               && can_store_by_pieces (tree_low_cst (len, 1),
3540                                       builtin_memset_read_str, &c, dest_align))
3541             store_by_pieces (dest_mem, tree_low_cst (len, 1),
3542                              builtin_memset_read_str, &c, dest_align, 0);
3543           else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),