OSDN Git Service

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