OSDN Git Service

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