OSDN Git Service

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