OSDN Git Service

* optabs.h (enum optab_index): Add new OTI_significand.
[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     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
1979       builtin_optab = significand_optab; break;
1980     default:
1981       gcc_unreachable ();
1982     }
1983
1984   /* Make a suitable register to place result in.  */
1985   mode = TYPE_MODE (TREE_TYPE (exp));
1986
1987   if (! flag_errno_math || ! HONOR_NANS (mode))
1988     errno_set = false;
1989
1990   /* Before working hard, check whether the instruction is available.  */
1991   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
1992     {
1993       target = gen_reg_rtx (mode);
1994
1995       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1996          need to expand the argument again.  This way, we will not perform
1997          side-effects more the once.  */
1998       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
1999
2000       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2001
2002       start_sequence ();
2003
2004       /* Compute into TARGET.
2005          Set TARGET to wherever the result comes back.  */
2006       target = expand_unop (mode, builtin_optab, op0, target, 0);
2007
2008       if (target != 0)
2009         {
2010           if (errno_set)
2011             expand_errno_check (exp, target);
2012
2013           /* Output the entire sequence.  */
2014           insns = get_insns ();
2015           end_sequence ();
2016           emit_insn (insns);
2017           return target;
2018         }
2019
2020       /* If we were unable to expand via the builtin, stop the sequence
2021          (without outputting the insns) and call to the library function
2022          with the stabilized argument list.  */
2023       end_sequence ();
2024     }
2025
2026   before_call = get_last_insn ();
2027
2028   return expand_call (exp, target, target == const0_rtx);
2029 }
2030
2031 /* Expand a call to the builtin binary math functions (pow and atan2).
2032    Return NULL_RTX if a normal call should be emitted rather than expanding the
2033    function in-line.  EXP is the expression that is a call to the builtin
2034    function; if convenient, the result should be placed in TARGET.
2035    SUBTARGET may be used as the target for computing one of EXP's
2036    operands.  */
2037
2038 static rtx
2039 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2040 {
2041   optab builtin_optab;
2042   rtx op0, op1, insns;
2043   int op1_type = REAL_TYPE;
2044   tree fndecl = get_callee_fndecl (exp);
2045   tree arg0, arg1;
2046   enum machine_mode mode;
2047   bool errno_set = true;
2048
2049   switch (DECL_FUNCTION_CODE (fndecl))
2050     {
2051     CASE_FLT_FN (BUILT_IN_SCALBN):
2052     CASE_FLT_FN (BUILT_IN_SCALBLN):
2053     CASE_FLT_FN (BUILT_IN_LDEXP):
2054       op1_type = INTEGER_TYPE;
2055     default:
2056       break;
2057     }
2058
2059   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2060     return NULL_RTX;
2061
2062   arg0 = CALL_EXPR_ARG (exp, 0);
2063   arg1 = CALL_EXPR_ARG (exp, 1);
2064
2065   switch (DECL_FUNCTION_CODE (fndecl))
2066     {
2067     CASE_FLT_FN (BUILT_IN_POW):
2068       builtin_optab = pow_optab; break;
2069     CASE_FLT_FN (BUILT_IN_ATAN2):
2070       builtin_optab = atan2_optab; break;
2071     CASE_FLT_FN (BUILT_IN_SCALB):
2072       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2073         return 0;
2074       builtin_optab = scalb_optab; break;
2075     CASE_FLT_FN (BUILT_IN_SCALBN):
2076     CASE_FLT_FN (BUILT_IN_SCALBLN):
2077       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2078         return 0;
2079     /* Fall through... */
2080     CASE_FLT_FN (BUILT_IN_LDEXP):
2081       builtin_optab = ldexp_optab; break;
2082     CASE_FLT_FN (BUILT_IN_FMOD):
2083       builtin_optab = fmod_optab; break;
2084     CASE_FLT_FN (BUILT_IN_REMAINDER):
2085     CASE_FLT_FN (BUILT_IN_DREM):
2086       builtin_optab = remainder_optab; break;
2087     default:
2088       gcc_unreachable ();
2089     }
2090
2091   /* Make a suitable register to place result in.  */
2092   mode = TYPE_MODE (TREE_TYPE (exp));
2093
2094   /* Before working hard, check whether the instruction is available.  */
2095   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2096     return NULL_RTX;
2097
2098   target = gen_reg_rtx (mode);
2099
2100   if (! flag_errno_math || ! HONOR_NANS (mode))
2101     errno_set = false;
2102
2103   /* Always stabilize the argument list.  */
2104   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2105   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2106
2107   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2108   op1 = expand_normal (arg1);
2109
2110   start_sequence ();
2111
2112   /* Compute into TARGET.
2113      Set TARGET to wherever the result comes back.  */
2114   target = expand_binop (mode, builtin_optab, op0, op1,
2115                          target, 0, OPTAB_DIRECT);
2116
2117   /* If we were unable to expand via the builtin, stop the sequence
2118      (without outputting the insns) and call to the library function
2119      with the stabilized argument list.  */
2120   if (target == 0)
2121     {
2122       end_sequence ();
2123       return expand_call (exp, target, target == const0_rtx);
2124     }
2125
2126   if (errno_set)
2127     expand_errno_check (exp, target);
2128
2129   /* Output the entire sequence.  */
2130   insns = get_insns ();
2131   end_sequence ();
2132   emit_insn (insns);
2133
2134   return target;
2135 }
2136
2137 /* Expand a call to the builtin sin and cos math functions.
2138    Return NULL_RTX if a normal call should be emitted rather than expanding the
2139    function in-line.  EXP is the expression that is a call to the builtin
2140    function; if convenient, the result should be placed in TARGET.
2141    SUBTARGET may be used as the target for computing one of EXP's
2142    operands.  */
2143
2144 static rtx
2145 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2146 {
2147   optab builtin_optab;
2148   rtx op0, insns;
2149   tree fndecl = get_callee_fndecl (exp);
2150   enum machine_mode mode;
2151   tree arg;
2152
2153   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2154     return NULL_RTX;
2155
2156   arg = CALL_EXPR_ARG (exp, 0);
2157
2158   switch (DECL_FUNCTION_CODE (fndecl))
2159     {
2160     CASE_FLT_FN (BUILT_IN_SIN):
2161     CASE_FLT_FN (BUILT_IN_COS):
2162       builtin_optab = sincos_optab; break;
2163     default:
2164       gcc_unreachable ();
2165     }
2166
2167   /* Make a suitable register to place result in.  */
2168   mode = TYPE_MODE (TREE_TYPE (exp));
2169
2170   /* Check if sincos insn is available, otherwise fallback
2171      to sin or cos insn.  */
2172   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2173     switch (DECL_FUNCTION_CODE (fndecl))
2174       {
2175       CASE_FLT_FN (BUILT_IN_SIN):
2176         builtin_optab = sin_optab; break;
2177       CASE_FLT_FN (BUILT_IN_COS):
2178         builtin_optab = cos_optab; break;
2179       default:
2180         gcc_unreachable ();
2181       }
2182
2183   /* Before working hard, check whether the instruction is available.  */
2184   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2185     {
2186       target = gen_reg_rtx (mode);
2187
2188       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2189          need to expand the argument again.  This way, we will not perform
2190          side-effects more the once.  */
2191       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2192
2193       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2194
2195       start_sequence ();
2196
2197       /* Compute into TARGET.
2198          Set TARGET to wherever the result comes back.  */
2199       if (builtin_optab == sincos_optab)
2200         {
2201           int result;
2202
2203           switch (DECL_FUNCTION_CODE (fndecl))
2204             {
2205             CASE_FLT_FN (BUILT_IN_SIN):
2206               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2207               break;
2208             CASE_FLT_FN (BUILT_IN_COS):
2209               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2210               break;
2211             default:
2212               gcc_unreachable ();
2213             }
2214           gcc_assert (result);
2215         }
2216       else
2217         {
2218           target = expand_unop (mode, builtin_optab, op0, target, 0);
2219         }
2220
2221       if (target != 0)
2222         {
2223           /* Output the entire sequence.  */
2224           insns = get_insns ();
2225           end_sequence ();
2226           emit_insn (insns);
2227           return target;
2228         }
2229
2230       /* If we were unable to expand via the builtin, stop the sequence
2231          (without outputting the insns) and call to the library function
2232          with the stabilized argument list.  */
2233       end_sequence ();
2234     }
2235
2236   target = expand_call (exp, target, target == const0_rtx);
2237
2238   return target;
2239 }
2240
2241 /* Expand a call to one of the builtin math functions that operate on
2242    floating point argument and output an integer result (ilogb, isinf,
2243    isnan, etc).
2244    Return 0 if a normal call should be emitted rather than expanding the
2245    function in-line.  EXP is the expression that is a call to the builtin
2246    function; if convenient, the result should be placed in TARGET.
2247    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2248
2249 static rtx
2250 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2251 {
2252   optab builtin_optab = 0;
2253   enum insn_code icode = CODE_FOR_nothing;
2254   rtx op0;
2255   tree fndecl = get_callee_fndecl (exp);
2256   enum machine_mode mode;
2257   bool errno_set = false;
2258   tree arg;
2259
2260   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2261     return NULL_RTX;
2262
2263   arg = CALL_EXPR_ARG (exp, 0);
2264
2265   switch (DECL_FUNCTION_CODE (fndecl))
2266     {
2267     CASE_FLT_FN (BUILT_IN_ILOGB):
2268       errno_set = true; builtin_optab = ilogb_optab; break;
2269     CASE_FLT_FN (BUILT_IN_ISINF):
2270       builtin_optab = isinf_optab; break;
2271     case BUILT_IN_ISNORMAL:
2272     case BUILT_IN_ISFINITE:
2273     CASE_FLT_FN (BUILT_IN_FINITE):
2274       /* These builtins have no optabs (yet).  */
2275       break;
2276     default:
2277       gcc_unreachable ();
2278     }
2279
2280   /* There's no easy way to detect the case we need to set EDOM.  */
2281   if (flag_errno_math && errno_set)
2282     return NULL_RTX;
2283
2284   /* Optab mode depends on the mode of the input argument.  */
2285   mode = TYPE_MODE (TREE_TYPE (arg));
2286
2287   if (builtin_optab)
2288     icode = optab_handler (builtin_optab, mode)->insn_code;
2289  
2290   /* Before working hard, check whether the instruction is available.  */
2291   if (icode != CODE_FOR_nothing)
2292     {
2293       /* Make a suitable register to place result in.  */
2294       if (!target
2295           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2296          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2297
2298       gcc_assert (insn_data[icode].operand[0].predicate
2299                   (target, GET_MODE (target)));
2300
2301       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2302          need to expand the argument again.  This way, we will not perform
2303          side-effects more the once.  */
2304       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2305
2306       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2307
2308       if (mode != GET_MODE (op0))
2309         op0 = convert_to_mode (mode, op0, 0);
2310
2311       /* Compute into TARGET.
2312          Set TARGET to wherever the result comes back.  */
2313       emit_unop_insn (icode, target, op0, UNKNOWN);
2314       return target;
2315     }
2316
2317   /* If there is no optab, try generic code.  */
2318   switch (DECL_FUNCTION_CODE (fndecl))
2319     {
2320       tree result;
2321
2322     CASE_FLT_FN (BUILT_IN_ISINF):
2323       {
2324         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
2325         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
2326         tree const type = TREE_TYPE (arg);
2327         REAL_VALUE_TYPE r;
2328         char buf[128];
2329
2330         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2331         real_from_string (&r, buf);
2332         result = build_call_expr (isgr_fn, 2,
2333                                   fold_build1 (ABS_EXPR, type, arg),
2334                                   build_real (type, r));
2335         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2336       }
2337     CASE_FLT_FN (BUILT_IN_FINITE):
2338     case BUILT_IN_ISFINITE:
2339       {
2340         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
2341         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
2342         tree const type = TREE_TYPE (arg);
2343         REAL_VALUE_TYPE r;
2344         char buf[128];
2345
2346         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2347         real_from_string (&r, buf);
2348         result = build_call_expr (isle_fn, 2,
2349                                   fold_build1 (ABS_EXPR, type, arg),
2350                                   build_real (type, r));
2351         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2352       }
2353     case BUILT_IN_ISNORMAL:
2354       {
2355         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
2356            islessequal(fabs(x),DBL_MAX).  */
2357         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
2358         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
2359         tree const type = TREE_TYPE (arg);
2360         REAL_VALUE_TYPE rmax, rmin;
2361         char buf[128];
2362
2363         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2364         real_from_string (&rmax, buf);
2365         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
2366         real_from_string (&rmin, buf);
2367         arg = builtin_save_expr (fold_build1 (ABS_EXPR, type, arg));
2368         result = build_call_expr (isle_fn, 2, arg,
2369                                   build_real (type, rmax));
2370         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
2371                               build_call_expr (isge_fn, 2, arg,
2372                                                build_real (type, rmin)));
2373         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2374       }
2375     default:
2376       break;
2377     }
2378
2379   target = expand_call (exp, target, target == const0_rtx);
2380
2381   return target;
2382 }
2383
2384 /* Expand a call to the builtin sincos math function.
2385    Return NULL_RTX if a normal call should be emitted rather than expanding the
2386    function in-line.  EXP is the expression that is a call to the builtin
2387    function.  */
2388
2389 static rtx
2390 expand_builtin_sincos (tree exp)
2391 {
2392   rtx op0, op1, op2, target1, target2;
2393   enum machine_mode mode;
2394   tree arg, sinp, cosp;
2395   int result;
2396
2397   if (!validate_arglist (exp, REAL_TYPE,
2398                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2399     return NULL_RTX;
2400
2401   arg = CALL_EXPR_ARG (exp, 0);
2402   sinp = CALL_EXPR_ARG (exp, 1);
2403   cosp = CALL_EXPR_ARG (exp, 2);
2404
2405   /* Make a suitable register to place result in.  */
2406   mode = TYPE_MODE (TREE_TYPE (arg));
2407
2408   /* Check if sincos insn is available, otherwise emit the call.  */
2409   if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2410     return NULL_RTX;
2411
2412   target1 = gen_reg_rtx (mode);
2413   target2 = gen_reg_rtx (mode);
2414
2415   op0 = expand_normal (arg);
2416   op1 = expand_normal (build_fold_indirect_ref (sinp));
2417   op2 = expand_normal (build_fold_indirect_ref (cosp));
2418
2419   /* Compute into target1 and target2.
2420      Set TARGET to wherever the result comes back.  */
2421   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2422   gcc_assert (result);
2423
2424   /* Move target1 and target2 to the memory locations indicated
2425      by op1 and op2.  */
2426   emit_move_insn (op1, target1);
2427   emit_move_insn (op2, target2);
2428
2429   return const0_rtx;
2430 }
2431
2432 /* Expand a call to the internal cexpi builtin to the sincos math function.
2433    EXP is the expression that is a call to the builtin function; if convenient,
2434    the result should be placed in TARGET.  SUBTARGET may be used as the target
2435    for computing one of EXP's operands.  */
2436
2437 static rtx
2438 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2439 {
2440   tree fndecl = get_callee_fndecl (exp);
2441   tree arg, type;
2442   enum machine_mode mode;
2443   rtx op0, op1, op2;
2444
2445   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2446     return NULL_RTX;
2447
2448   arg = CALL_EXPR_ARG (exp, 0);
2449   type = TREE_TYPE (arg);
2450   mode = TYPE_MODE (TREE_TYPE (arg));
2451
2452   /* Try expanding via a sincos optab, fall back to emitting a libcall
2453      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2454      is only generated from sincos, cexp or if we have either of them.  */
2455   if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2456     {
2457       op1 = gen_reg_rtx (mode);
2458       op2 = gen_reg_rtx (mode);
2459
2460       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2461
2462       /* Compute into op1 and op2.  */
2463       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2464     }
2465   else if (TARGET_HAS_SINCOS)
2466     {
2467       tree call, fn = NULL_TREE;
2468       tree top1, top2;
2469       rtx op1a, op2a;
2470
2471       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2472         fn = built_in_decls[BUILT_IN_SINCOSF];
2473       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2474         fn = built_in_decls[BUILT_IN_SINCOS];
2475       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2476         fn = built_in_decls[BUILT_IN_SINCOSL];
2477       else
2478         gcc_unreachable ();
2479  
2480       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2481       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2482       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2483       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2484       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2485       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2486
2487       /* Make sure not to fold the sincos call again.  */
2488       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2489       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2490                                       call, 3, arg, top1, top2));
2491     }
2492   else
2493     {
2494       tree call, fn = NULL_TREE, narg;
2495       tree ctype = build_complex_type (type);
2496
2497       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2498         fn = built_in_decls[BUILT_IN_CEXPF];
2499       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2500         fn = built_in_decls[BUILT_IN_CEXP];
2501       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2502         fn = built_in_decls[BUILT_IN_CEXPL];
2503       else
2504         gcc_unreachable ();
2505
2506       /* If we don't have a decl for cexp create one.  This is the
2507          friendliest fallback if the user calls __builtin_cexpi
2508          without full target C99 function support.  */
2509       if (fn == NULL_TREE)
2510         {
2511           tree fntype;
2512           const char *name = NULL;
2513
2514           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2515             name = "cexpf";
2516           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2517             name = "cexp";
2518           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2519             name = "cexpl";
2520
2521           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2522           fn = build_fn_decl (name, fntype);
2523         }
2524
2525       narg = fold_build2 (COMPLEX_EXPR, ctype,
2526                           build_real (type, dconst0), arg);
2527
2528       /* Make sure not to fold the cexp call again.  */
2529       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2530       return expand_expr (build_call_nary (ctype, call, 1, narg), 
2531                           target, VOIDmode, EXPAND_NORMAL);
2532     }
2533
2534   /* Now build the proper return type.  */
2535   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2536                               make_tree (TREE_TYPE (arg), op2),
2537                               make_tree (TREE_TYPE (arg), op1)),
2538                       target, VOIDmode, EXPAND_NORMAL);
2539 }
2540
2541 /* Expand a call to one of the builtin rounding functions gcc defines
2542    as an extension (lfloor and lceil).  As these are gcc extensions we
2543    do not need to worry about setting errno to EDOM.
2544    If expanding via optab fails, lower expression to (int)(floor(x)).
2545    EXP is the expression that is a call to the builtin function;
2546    if convenient, the result should be placed in TARGET.  */
2547
2548 static rtx
2549 expand_builtin_int_roundingfn (tree exp, rtx target)
2550 {
2551   convert_optab builtin_optab;
2552   rtx op0, insns, tmp;
2553   tree fndecl = get_callee_fndecl (exp);
2554   enum built_in_function fallback_fn;
2555   tree fallback_fndecl;
2556   enum machine_mode mode;
2557   tree arg;
2558
2559   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2560     gcc_unreachable ();
2561
2562   arg = CALL_EXPR_ARG (exp, 0);
2563
2564   switch (DECL_FUNCTION_CODE (fndecl))
2565     {
2566     CASE_FLT_FN (BUILT_IN_LCEIL):
2567     CASE_FLT_FN (BUILT_IN_LLCEIL):
2568       builtin_optab = lceil_optab;
2569       fallback_fn = BUILT_IN_CEIL;
2570       break;
2571
2572     CASE_FLT_FN (BUILT_IN_LFLOOR):
2573     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2574       builtin_optab = lfloor_optab;
2575       fallback_fn = BUILT_IN_FLOOR;
2576       break;
2577
2578     default:
2579       gcc_unreachable ();
2580     }
2581
2582   /* Make a suitable register to place result in.  */
2583   mode = TYPE_MODE (TREE_TYPE (exp));
2584
2585   target = gen_reg_rtx (mode);
2586
2587   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2588      need to expand the argument again.  This way, we will not perform
2589      side-effects more the once.  */
2590   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2591
2592   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2593
2594   start_sequence ();
2595
2596   /* Compute into TARGET.  */
2597   if (expand_sfix_optab (target, op0, builtin_optab))
2598     {
2599       /* Output the entire sequence.  */
2600       insns = get_insns ();
2601       end_sequence ();
2602       emit_insn (insns);
2603       return target;
2604     }
2605
2606   /* If we were unable to expand via the builtin, stop the sequence
2607      (without outputting the insns).  */
2608   end_sequence ();
2609
2610   /* Fall back to floating point rounding optab.  */
2611   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2612
2613   /* For non-C99 targets we may end up without a fallback fndecl here
2614      if the user called __builtin_lfloor directly.  In this case emit
2615      a call to the floor/ceil variants nevertheless.  This should result
2616      in the best user experience for not full C99 targets.  */
2617   if (fallback_fndecl == NULL_TREE)
2618     {
2619       tree fntype;
2620       const char *name = NULL;
2621
2622       switch (DECL_FUNCTION_CODE (fndecl))
2623         {
2624         case BUILT_IN_LCEIL:
2625         case BUILT_IN_LLCEIL:
2626           name = "ceil";
2627           break;
2628         case BUILT_IN_LCEILF:
2629         case BUILT_IN_LLCEILF:
2630           name = "ceilf";
2631           break;
2632         case BUILT_IN_LCEILL:
2633         case BUILT_IN_LLCEILL:
2634           name = "ceill";
2635           break;
2636         case BUILT_IN_LFLOOR:
2637         case BUILT_IN_LLFLOOR:
2638           name = "floor";
2639           break;
2640         case BUILT_IN_LFLOORF:
2641         case BUILT_IN_LLFLOORF:
2642           name = "floorf";
2643           break;
2644         case BUILT_IN_LFLOORL:
2645         case BUILT_IN_LLFLOORL:
2646           name = "floorl";
2647           break;
2648         default:
2649           gcc_unreachable ();
2650         }
2651
2652       fntype = build_function_type_list (TREE_TYPE (arg),
2653                                          TREE_TYPE (arg), NULL_TREE);
2654       fallback_fndecl = build_fn_decl (name, fntype);
2655     }
2656
2657   exp = build_call_expr (fallback_fndecl, 1, arg);
2658
2659   tmp = expand_normal (exp);
2660
2661   /* Truncate the result of floating point optab to integer
2662      via expand_fix ().  */
2663   target = gen_reg_rtx (mode);
2664   expand_fix (target, tmp, 0);
2665
2666   return target;
2667 }
2668
2669 /* Expand a call to one of the builtin math functions doing integer
2670    conversion (lrint).
2671    Return 0 if a normal call should be emitted rather than expanding the
2672    function in-line.  EXP is the expression that is a call to the builtin
2673    function; if convenient, the result should be placed in TARGET.  */
2674
2675 static rtx
2676 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2677 {
2678   convert_optab builtin_optab;
2679   rtx op0, insns;
2680   tree fndecl = get_callee_fndecl (exp);
2681   tree arg;
2682   enum machine_mode mode;
2683
2684   /* There's no easy way to detect the case we need to set EDOM.  */
2685   if (flag_errno_math)
2686     return NULL_RTX;
2687
2688   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2689      gcc_unreachable ();
2690  
2691   arg = CALL_EXPR_ARG (exp, 0);
2692
2693   switch (DECL_FUNCTION_CODE (fndecl))
2694     {
2695     CASE_FLT_FN (BUILT_IN_LRINT):
2696     CASE_FLT_FN (BUILT_IN_LLRINT):
2697       builtin_optab = lrint_optab; break;
2698     CASE_FLT_FN (BUILT_IN_LROUND):
2699     CASE_FLT_FN (BUILT_IN_LLROUND):
2700       builtin_optab = lround_optab; break;
2701     default:
2702       gcc_unreachable ();
2703     }
2704
2705   /* Make a suitable register to place result in.  */
2706   mode = TYPE_MODE (TREE_TYPE (exp));
2707
2708   target = gen_reg_rtx (mode);
2709
2710   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2711      need to expand the argument again.  This way, we will not perform
2712      side-effects more the once.  */
2713   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2714
2715   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2716
2717   start_sequence ();
2718
2719   if (expand_sfix_optab (target, op0, builtin_optab))
2720     {
2721       /* Output the entire sequence.  */
2722       insns = get_insns ();
2723       end_sequence ();
2724       emit_insn (insns);
2725       return target;
2726     }
2727
2728   /* If we were unable to expand via the builtin, stop the sequence
2729      (without outputting the insns) and call to the library function
2730      with the stabilized argument list.  */
2731   end_sequence ();
2732
2733   target = expand_call (exp, target, target == const0_rtx);
2734
2735   return target;
2736 }
2737
2738 /* To evaluate powi(x,n), the floating point value x raised to the
2739    constant integer exponent n, we use a hybrid algorithm that
2740    combines the "window method" with look-up tables.  For an
2741    introduction to exponentiation algorithms and "addition chains",
2742    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2743    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2744    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2745    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2746
2747 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2748    multiplications to inline before calling the system library's pow
2749    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2750    so this default never requires calling pow, powf or powl.  */
2751
2752 #ifndef POWI_MAX_MULTS
2753 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2754 #endif
2755
2756 /* The size of the "optimal power tree" lookup table.  All
2757    exponents less than this value are simply looked up in the
2758    powi_table below.  This threshold is also used to size the
2759    cache of pseudo registers that hold intermediate results.  */
2760 #define POWI_TABLE_SIZE 256
2761
2762 /* The size, in bits of the window, used in the "window method"
2763    exponentiation algorithm.  This is equivalent to a radix of
2764    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2765 #define POWI_WINDOW_SIZE 3
2766
2767 /* The following table is an efficient representation of an
2768    "optimal power tree".  For each value, i, the corresponding
2769    value, j, in the table states than an optimal evaluation
2770    sequence for calculating pow(x,i) can be found by evaluating
2771    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2772    100 integers is given in Knuth's "Seminumerical algorithms".  */
2773
2774 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2775   {
2776       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2777       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2778       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2779      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2780      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2781      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2782      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2783      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2784      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2785      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2786      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2787      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2788      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2789      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2790      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2791      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2792      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2793      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2794      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2795      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2796      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2797      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2798      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2799      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2800      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2801     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2802     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2803     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2804     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2805     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2806     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2807     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2808   };
2809
2810
2811 /* Return the number of multiplications required to calculate
2812    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2813    subroutine of powi_cost.  CACHE is an array indicating
2814    which exponents have already been calculated.  */
2815
2816 static int
2817 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2818 {
2819   /* If we've already calculated this exponent, then this evaluation
2820      doesn't require any additional multiplications.  */
2821   if (cache[n])
2822     return 0;
2823
2824   cache[n] = true;
2825   return powi_lookup_cost (n - powi_table[n], cache)
2826          + powi_lookup_cost (powi_table[n], cache) + 1;
2827 }
2828
2829 /* Return the number of multiplications required to calculate
2830    powi(x,n) for an arbitrary x, given the exponent N.  This
2831    function needs to be kept in sync with expand_powi below.  */
2832
2833 static int
2834 powi_cost (HOST_WIDE_INT n)
2835 {
2836   bool cache[POWI_TABLE_SIZE];
2837   unsigned HOST_WIDE_INT digit;
2838   unsigned HOST_WIDE_INT val;
2839   int result;
2840
2841   if (n == 0)
2842     return 0;
2843
2844   /* Ignore the reciprocal when calculating the cost.  */
2845   val = (n < 0) ? -n : n;
2846
2847   /* Initialize the exponent cache.  */
2848   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2849   cache[1] = true;
2850
2851   result = 0;
2852
2853   while (val >= POWI_TABLE_SIZE)
2854     {
2855       if (val & 1)
2856         {
2857           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2858           result += powi_lookup_cost (digit, cache)
2859                     + POWI_WINDOW_SIZE + 1;
2860           val >>= POWI_WINDOW_SIZE;
2861         }
2862       else
2863         {
2864           val >>= 1;
2865           result++;
2866         }
2867     }
2868
2869   return result + powi_lookup_cost (val, cache);
2870 }
2871
2872 /* Recursive subroutine of expand_powi.  This function takes the array,
2873    CACHE, of already calculated exponents and an exponent N and returns
2874    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2875
2876 static rtx
2877 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2878 {
2879   unsigned HOST_WIDE_INT digit;
2880   rtx target, result;
2881   rtx op0, op1;
2882
2883   if (n < POWI_TABLE_SIZE)
2884     {
2885       if (cache[n])
2886         return cache[n];
2887
2888       target = gen_reg_rtx (mode);
2889       cache[n] = target;
2890
2891       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2892       op1 = expand_powi_1 (mode, powi_table[n], cache);
2893     }
2894   else if (n & 1)
2895     {
2896       target = gen_reg_rtx (mode);
2897       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2898       op0 = expand_powi_1 (mode, n - digit, cache);
2899       op1 = expand_powi_1 (mode, digit, cache);
2900     }
2901   else
2902     {
2903       target = gen_reg_rtx (mode);
2904       op0 = expand_powi_1 (mode, n >> 1, cache);
2905       op1 = op0;
2906     }
2907
2908   result = expand_mult (mode, op0, op1, target, 0);
2909   if (result != target)
2910     emit_move_insn (target, result);
2911   return target;
2912 }
2913
2914 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2915    floating point operand in mode MODE, and N is the exponent.  This
2916    function needs to be kept in sync with powi_cost above.  */
2917
2918 static rtx
2919 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2920 {
2921   unsigned HOST_WIDE_INT val;
2922   rtx cache[POWI_TABLE_SIZE];
2923   rtx result;
2924
2925   if (n == 0)
2926     return CONST1_RTX (mode);
2927
2928   val = (n < 0) ? -n : n;
2929
2930   memset (cache, 0, sizeof (cache));
2931   cache[1] = x;
2932
2933   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2934
2935   /* If the original exponent was negative, reciprocate the result.  */
2936   if (n < 0)
2937     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2938                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2939
2940   return result;
2941 }
2942
2943 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
2944    a normal call should be emitted rather than expanding the function
2945    in-line.  EXP is the expression that is a call to the builtin
2946    function; if convenient, the result should be placed in TARGET.  */
2947
2948 static rtx
2949 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2950 {
2951   tree arg0, arg1;
2952   tree fn, narg0;
2953   tree type = TREE_TYPE (exp);
2954   REAL_VALUE_TYPE cint, c, c2;
2955   HOST_WIDE_INT n;
2956   rtx op, op2;
2957   enum machine_mode mode = TYPE_MODE (type);
2958
2959   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2960     return NULL_RTX;
2961
2962   arg0 = CALL_EXPR_ARG (exp, 0);
2963   arg1 = CALL_EXPR_ARG (exp, 1);
2964
2965   if (TREE_CODE (arg1) != REAL_CST
2966       || TREE_OVERFLOW (arg1))
2967     return expand_builtin_mathfn_2 (exp, target, subtarget);
2968
2969   /* Handle constant exponents.  */
2970
2971   /* For integer valued exponents we can expand to an optimal multiplication
2972      sequence using expand_powi.  */
2973   c = TREE_REAL_CST (arg1);
2974   n = real_to_integer (&c);
2975   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2976   if (real_identical (&c, &cint)
2977       && ((n >= -1 && n <= 2)
2978           || (flag_unsafe_math_optimizations
2979               && optimize_insn_for_speed_p ()
2980               && powi_cost (n) <= POWI_MAX_MULTS)))
2981     {
2982       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2983       if (n != 1)
2984         {
2985           op = force_reg (mode, op);
2986           op = expand_powi (op, mode, n);
2987         }
2988       return op;
2989     }
2990
2991   narg0 = builtin_save_expr (arg0);
2992
2993   /* If the exponent is not integer valued, check if it is half of an integer.
2994      In this case we can expand to sqrt (x) * x**(n/2).  */
2995   fn = mathfn_built_in (type, BUILT_IN_SQRT);
2996   if (fn != NULL_TREE)
2997     {
2998       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2999       n = real_to_integer (&c2);
3000       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3001       if (real_identical (&c2, &cint)
3002           && ((flag_unsafe_math_optimizations
3003                && optimize_insn_for_speed_p ()
3004                && powi_cost (n/2) <= POWI_MAX_MULTS)
3005               || n == 1))
3006         {
3007           tree call_expr = build_call_expr (fn, 1, narg0);
3008           /* Use expand_expr in case the newly built call expression
3009              was folded to a non-call.  */
3010           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3011           if (n != 1)
3012             {
3013               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3014               op2 = force_reg (mode, op2);
3015               op2 = expand_powi (op2, mode, abs (n / 2));
3016               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3017                                         0, OPTAB_LIB_WIDEN);
3018               /* If the original exponent was negative, reciprocate the
3019                  result.  */
3020               if (n < 0)
3021                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3022                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3023             }
3024           return op;
3025         }
3026     }
3027
3028   /* Try if the exponent is a third of an integer.  In this case
3029      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3030      different from pow (x, 1./3.) due to rounding and behavior
3031      with negative x we need to constrain this transformation to
3032      unsafe math and positive x or finite math.  */
3033   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3034   if (fn != NULL_TREE
3035       && flag_unsafe_math_optimizations
3036       && (tree_expr_nonnegative_p (arg0)
3037           || !HONOR_NANS (mode)))
3038     {
3039       REAL_VALUE_TYPE dconst3;
3040       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3041       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3042       real_round (&c2, mode, &c2);
3043       n = real_to_integer (&c2);
3044       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3045       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3046       real_convert (&c2, mode, &c2);
3047       if (real_identical (&c2, &c)
3048           && ((optimize_insn_for_speed_p ()
3049                && powi_cost (n/3) <= POWI_MAX_MULTS)
3050               || n == 1))
3051         {
3052           tree call_expr = build_call_expr (fn, 1,narg0);
3053           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3054           if (abs (n) % 3 == 2)
3055             op = expand_simple_binop (mode, MULT, op, op, op,
3056                                       0, OPTAB_LIB_WIDEN);
3057           if (n != 1)
3058             {
3059               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3060               op2 = force_reg (mode, op2);
3061               op2 = expand_powi (op2, mode, abs (n / 3));
3062               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3063                                         0, OPTAB_LIB_WIDEN);
3064               /* If the original exponent was negative, reciprocate the
3065                  result.  */
3066               if (n < 0)
3067                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3068                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3069             }
3070           return op;
3071         }
3072     }
3073
3074   /* Fall back to optab expansion.  */
3075   return expand_builtin_mathfn_2 (exp, target, subtarget);
3076 }
3077
3078 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3079    a normal call should be emitted rather than expanding the function
3080    in-line.  EXP is the expression that is a call to the builtin
3081    function; if convenient, the result should be placed in TARGET.  */
3082
3083 static rtx
3084 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3085 {
3086   tree arg0, arg1;
3087   rtx op0, op1;
3088   enum machine_mode mode;
3089   enum machine_mode mode2;
3090
3091   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3092     return NULL_RTX;
3093
3094   arg0 = CALL_EXPR_ARG (exp, 0);
3095   arg1 = CALL_EXPR_ARG (exp, 1);
3096   mode = TYPE_MODE (TREE_TYPE (exp));
3097
3098   /* Handle constant power.  */
3099
3100   if (TREE_CODE (arg1) == INTEGER_CST
3101       && !TREE_OVERFLOW (arg1))
3102     {
3103       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3104
3105       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3106          Otherwise, check the number of multiplications required.  */
3107       if ((TREE_INT_CST_HIGH (arg1) == 0
3108            || TREE_INT_CST_HIGH (arg1) == -1)
3109           && ((n >= -1 && n <= 2)
3110               || (optimize_insn_for_speed_p ()
3111                   && powi_cost (n) <= POWI_MAX_MULTS)))
3112         {
3113           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3114           op0 = force_reg (mode, op0);
3115           return expand_powi (op0, mode, n);
3116         }
3117     }
3118
3119   /* Emit a libcall to libgcc.  */
3120
3121   /* Mode of the 2nd argument must match that of an int.  */
3122   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3123
3124   if (target == NULL_RTX)
3125     target = gen_reg_rtx (mode);
3126
3127   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3128   if (GET_MODE (op0) != mode)
3129     op0 = convert_to_mode (mode, op0, 0);
3130   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3131   if (GET_MODE (op1) != mode2)
3132     op1 = convert_to_mode (mode2, op1, 0);
3133
3134   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3135                                     target, LCT_CONST, mode, 2,
3136                                     op0, mode, op1, mode2);
3137
3138   return target;
3139 }
3140
3141 /* Expand expression EXP which is a call to the strlen builtin.  Return 
3142    NULL_RTX if we failed the caller should emit a normal call, otherwise
3143    try to get the result in TARGET, if convenient.  */
3144
3145 static rtx
3146 expand_builtin_strlen (tree exp, rtx target,
3147                        enum machine_mode target_mode)
3148 {
3149   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3150     return NULL_RTX;
3151   else
3152     {
3153       rtx pat;
3154       tree len;
3155       tree src = CALL_EXPR_ARG (exp, 0);
3156       rtx result, src_reg, char_rtx, before_strlen;
3157       enum machine_mode insn_mode = target_mode, char_mode;
3158       enum insn_code icode = CODE_FOR_nothing;
3159       int align;
3160
3161       /* If the length can be computed at compile-time, return it.  */
3162       len = c_strlen (src, 0);
3163       if (len)
3164         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3165
3166       /* If the length can be computed at compile-time and is constant
3167          integer, but there are side-effects in src, evaluate
3168          src for side-effects, then return len.
3169          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3170          can be optimized into: i++; x = 3;  */
3171       len = c_strlen (src, 1);
3172       if (len && TREE_CODE (len) == INTEGER_CST)
3173         {
3174           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3175           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3176         }
3177
3178       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3179
3180       /* If SRC is not a pointer type, don't do this operation inline.  */
3181       if (align == 0)
3182         return NULL_RTX;
3183
3184       /* Bail out if we can't compute strlen in the right mode.  */
3185       while (insn_mode != VOIDmode)
3186         {
3187           icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3188           if (icode != CODE_FOR_nothing)
3189             break;
3190
3191           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3192         }
3193       if (insn_mode == VOIDmode)
3194         return NULL_RTX;
3195
3196       /* Make a place to write the result of the instruction.  */
3197       result = target;
3198       if (! (result != 0
3199              && REG_P (result)
3200              && GET_MODE (result) == insn_mode
3201              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3202         result = gen_reg_rtx (insn_mode);
3203
3204       /* Make a place to hold the source address.  We will not expand
3205          the actual source until we are sure that the expansion will
3206          not fail -- there are trees that cannot be expanded twice.  */
3207       src_reg = gen_reg_rtx (Pmode);
3208
3209       /* Mark the beginning of the strlen sequence so we can emit the
3210          source operand later.  */
3211       before_strlen = get_last_insn ();
3212
3213       char_rtx = const0_rtx;
3214       char_mode = insn_data[(int) icode].operand[2].mode;
3215       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3216                                                             char_mode))
3217         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3218
3219       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3220                              char_rtx, GEN_INT (align));
3221       if (! pat)
3222         return NULL_RTX;
3223       emit_insn (pat);
3224
3225       /* Now that we are assured of success, expand the source.  */
3226       start_sequence ();
3227       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3228       if (pat != src_reg)
3229         emit_move_insn (src_reg, pat);
3230       pat = get_insns ();
3231       end_sequence ();
3232
3233       if (before_strlen)
3234         emit_insn_after (pat, before_strlen);
3235       else
3236         emit_insn_before (pat, get_insns ());
3237
3238       /* Return the value in the proper mode for this function.  */
3239       if (GET_MODE (result) == target_mode)
3240         target = result;
3241       else if (target != 0)
3242         convert_move (target, result, 0);
3243       else
3244         target = convert_to_mode (target_mode, result, 0);
3245
3246       return target;
3247     }
3248 }
3249
3250 /* Expand a call to the strstr builtin.  Return NULL_RTX if we failed the
3251    caller should emit a normal call, otherwise try to get the result
3252    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3253
3254 static rtx
3255 expand_builtin_strstr (tree exp, rtx target, enum machine_mode mode)
3256 {
3257   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3258     {
3259       tree type = TREE_TYPE (exp);
3260       tree result = fold_builtin_strstr (CALL_EXPR_ARG (exp, 0),
3261                                          CALL_EXPR_ARG (exp, 1), type);
3262       if (result)
3263         return expand_expr (result, target, mode, EXPAND_NORMAL);
3264     }
3265   return NULL_RTX;
3266 }
3267
3268 /* Expand a call to the strchr builtin.  Return NULL_RTX if we failed the
3269    caller should emit a normal call, otherwise try to get the result
3270    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3271
3272 static rtx
3273 expand_builtin_strchr (tree exp, rtx target, enum machine_mode mode)
3274 {
3275   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3276     {
3277       tree type = TREE_TYPE (exp);
3278       tree result = fold_builtin_strchr (CALL_EXPR_ARG (exp, 0),
3279                                          CALL_EXPR_ARG (exp, 1), type);
3280       if (result)
3281         return expand_expr (result, target, mode, EXPAND_NORMAL);
3282
3283       /* FIXME: Should use strchrM optab so that ports can optimize this.  */
3284     }
3285   return NULL_RTX;
3286 }
3287
3288 /* Expand a call to the strrchr builtin.  Return NULL_RTX if we failed the
3289    caller should emit a normal call, otherwise try to get the result
3290    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3291
3292 static rtx
3293 expand_builtin_strrchr (tree exp, rtx target, enum machine_mode mode)
3294 {
3295   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3296     {
3297       tree type = TREE_TYPE (exp);
3298       tree result = fold_builtin_strrchr (CALL_EXPR_ARG (exp, 0),
3299                                           CALL_EXPR_ARG (exp, 1), type);
3300       if (result)
3301         return expand_expr (result, target, mode, EXPAND_NORMAL);
3302     }
3303   return NULL_RTX;
3304 }
3305
3306 /* Expand a call to the strpbrk builtin.  Return NULL_RTX if we failed the
3307    caller should emit a normal call, otherwise try to get the result
3308    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3309
3310 static rtx
3311 expand_builtin_strpbrk (tree exp, rtx target, enum machine_mode mode)
3312 {
3313   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3314     {
3315       tree type = TREE_TYPE (exp);
3316       tree result = fold_builtin_strpbrk (CALL_EXPR_ARG (exp, 0),
3317                                           CALL_EXPR_ARG (exp, 1), type);
3318       if (result)
3319         return expand_expr (result, target, mode, EXPAND_NORMAL);
3320     }
3321   return NULL_RTX;
3322 }
3323
3324 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3325    bytes from constant string DATA + OFFSET and return it as target
3326    constant.  */
3327
3328 static rtx
3329 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3330                          enum machine_mode mode)
3331 {
3332   const char *str = (const char *) data;
3333
3334   gcc_assert (offset >= 0
3335               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3336                   <= strlen (str) + 1));
3337
3338   return c_readstr (str + offset, mode);
3339 }
3340
3341 /* Expand a call EXP to the memcpy builtin.
3342    Return NULL_RTX if we failed, the caller should emit a normal call,
3343    otherwise try to get the result in TARGET, if convenient (and in
3344    mode MODE if that's convenient).  */
3345
3346 static rtx
3347 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
3348 {
3349   tree fndecl = get_callee_fndecl (exp);
3350
3351   if (!validate_arglist (exp,
3352                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3353     return NULL_RTX;
3354   else
3355     {
3356       tree dest = CALL_EXPR_ARG (exp, 0);
3357       tree src = CALL_EXPR_ARG (exp, 1);
3358       tree len = CALL_EXPR_ARG (exp, 2);
3359       const char *src_str;
3360       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3361       unsigned int dest_align
3362         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3363       rtx dest_mem, src_mem, dest_addr, len_rtx;
3364       tree result = fold_builtin_memory_op (dest, src, len, 
3365                                             TREE_TYPE (TREE_TYPE (fndecl)),
3366                                             false, /*endp=*/0);
3367       HOST_WIDE_INT expected_size = -1;
3368       unsigned int expected_align = 0;
3369       tree_ann_common_t ann;
3370
3371       if (result)
3372         {
3373           while (TREE_CODE (result) == COMPOUND_EXPR)
3374             {
3375               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3376                            EXPAND_NORMAL);
3377               result = TREE_OPERAND (result, 1);
3378             }
3379           return expand_expr (result, target, mode, EXPAND_NORMAL);
3380         }
3381
3382       /* If DEST is not a pointer type, call the normal function.  */
3383       if (dest_align == 0)
3384         return NULL_RTX;
3385
3386       /* If either SRC is not a pointer type, don't do this
3387          operation in-line.  */
3388       if (src_align == 0)
3389         return NULL_RTX;
3390  
3391       ann = tree_common_ann (exp);
3392       if (ann)
3393         stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3394
3395       if (expected_align < dest_align)
3396         expected_align = dest_align;
3397       dest_mem = get_memory_rtx (dest, len);
3398       set_mem_align (dest_mem, dest_align);
3399       len_rtx = expand_normal (len);
3400       src_str = c_getstr (src);
3401
3402       /* If SRC is a string constant and block move would be done
3403          by pieces, we can avoid loading the string from memory
3404          and only stored the computed constants.  */
3405       if (src_str
3406           && GET_CODE (len_rtx) == CONST_INT
3407           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3408           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3409                                   CONST_CAST (char *, src_str),
3410                                   dest_align, false))
3411         {
3412           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3413                                       builtin_memcpy_read_str,
3414                                       CONST_CAST (char *, src_str),
3415                                       dest_align, false, 0);
3416           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3417           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3418           return dest_mem;
3419         }
3420
3421       src_mem = get_memory_rtx (src, len);
3422       set_mem_align (src_mem, src_align);
3423
3424       /* Copy word part most expediently.  */
3425       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3426                                          CALL_EXPR_TAILCALL (exp)
3427                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3428                                          expected_align, expected_size);
3429
3430       if (dest_addr == 0)
3431         {
3432           dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3433           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3434         }
3435       return dest_addr;
3436     }
3437 }
3438
3439 /* Expand a call EXP to the mempcpy builtin.
3440    Return NULL_RTX if we failed; the caller should emit a normal call,
3441    otherwise try to get the result in TARGET, if convenient (and in
3442    mode MODE if that's convenient).  If ENDP is 0 return the
3443    destination pointer, if ENDP is 1 return the end pointer ala
3444    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3445    stpcpy.  */
3446
3447 static rtx
3448 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3449 {
3450   if (!validate_arglist (exp,
3451                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3452     return NULL_RTX;
3453   else
3454     {
3455       tree dest = CALL_EXPR_ARG (exp, 0);
3456       tree src = CALL_EXPR_ARG (exp, 1);
3457       tree len = CALL_EXPR_ARG (exp, 2);
3458       return expand_builtin_mempcpy_args (dest, src, len,
3459                                           TREE_TYPE (exp),
3460                                           target, mode, /*endp=*/ 1);
3461     }
3462 }
3463
3464 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3465    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3466    so that this can also be called without constructing an actual CALL_EXPR.
3467    TYPE is the return type of the call.  The other arguments and return value
3468    are the same as for expand_builtin_mempcpy.  */
3469
3470 static rtx
3471 expand_builtin_mempcpy_args (tree dest, tree src, tree len, tree type,
3472                              rtx target, enum machine_mode mode, int endp)
3473 {
3474     /* If return value is ignored, transform mempcpy into memcpy.  */
3475   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3476     {
3477       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3478       tree result = build_call_expr (fn, 3, dest, src, len);
3479
3480       while (TREE_CODE (result) == COMPOUND_EXPR)
3481         {
3482           expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3483                        EXPAND_NORMAL);
3484           result = TREE_OPERAND (result, 1);
3485         }
3486       return expand_expr (result, target, mode, EXPAND_NORMAL);
3487     }
3488   else
3489     {
3490       const char *src_str;
3491       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3492       unsigned int dest_align
3493         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3494       rtx dest_mem, src_mem, len_rtx;
3495       tree result = fold_builtin_memory_op (dest, src, len, type, false, endp);
3496
3497       if (result)
3498         {
3499           while (TREE_CODE (result) == COMPOUND_EXPR)
3500             {
3501               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3502                            EXPAND_NORMAL);
3503               result = TREE_OPERAND (result, 1);
3504             }
3505           return expand_expr (result, target, mode, EXPAND_NORMAL);
3506         }
3507
3508       /* If either SRC or DEST is not a pointer type, don't do this
3509          operation in-line.  */
3510       if (dest_align == 0 || src_align == 0)
3511         return NULL_RTX;
3512
3513       /* If LEN is not constant, call the normal function.  */
3514       if (! host_integerp (len, 1))
3515         return NULL_RTX;
3516
3517       len_rtx = expand_normal (len);
3518       src_str = c_getstr (src);
3519
3520       /* If SRC is a string constant and block move would be done
3521          by pieces, we can avoid loading the string from memory
3522          and only stored the computed constants.  */
3523       if (src_str
3524           && GET_CODE (len_rtx) == CONST_INT
3525           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3526           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3527                                   CONST_CAST (char *, src_str),
3528                                   dest_align, false))
3529         {
3530           dest_mem = get_memory_rtx (dest, len);
3531           set_mem_align (dest_mem, dest_align);
3532           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3533                                       builtin_memcpy_read_str,
3534                                       CONST_CAST (char *, src_str),
3535                                       dest_align, false, endp);
3536           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3537           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3538           return dest_mem;
3539         }
3540
3541       if (GET_CODE (len_rtx) == CONST_INT
3542           && can_move_by_pieces (INTVAL (len_rtx),
3543                                  MIN (dest_align, src_align)))
3544         {
3545           dest_mem = get_memory_rtx (dest, len);
3546           set_mem_align (dest_mem, dest_align);
3547           src_mem = get_memory_rtx (src, len);
3548