OSDN Git Service

b3fc3041377aab5a77a4bebf33d3c60612b73369
[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   target = expand_call (exp, target, target == const0_rtx);
1949
1950   /* If this is a sqrt operation and we don't care about errno, try to
1951      attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1952      This allows the semantics of the libcall to be visible to the RTL
1953      optimizers.  */
1954   if (builtin_optab == sqrt_optab && !errno_set)
1955     {
1956       /* Search backwards through the insns emitted by expand_call looking
1957          for the instruction with the REG_RETVAL note.  */
1958       rtx last = get_last_insn ();
1959       while (last != before_call)
1960         {
1961           if (find_reg_note (last, REG_RETVAL, NULL))
1962             {
1963               rtx note = find_reg_note (last, REG_EQUAL, NULL);
1964               /* Check that the REQ_EQUAL note is an EXPR_LIST with
1965                  two elements, i.e. symbol_ref(sqrt) and the operand.  */
1966               if (note
1967                   && GET_CODE (note) == EXPR_LIST
1968                   && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1969                   && XEXP (XEXP (note, 0), 1) != NULL_RTX
1970                   && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1971                 {
1972                   rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1973                   /* Check operand is a register with expected mode.  */
1974                   if (operand
1975                       && REG_P (operand)
1976                       && GET_MODE (operand) == mode)
1977                     {
1978                       /* Replace the REG_EQUAL note with a SQRT rtx.  */
1979                       rtx equiv = gen_rtx_SQRT (mode, operand);
1980                       set_unique_reg_note (last, REG_EQUAL, equiv);
1981                     }
1982                 }
1983               break;
1984             }
1985           last = PREV_INSN (last);
1986         }
1987     }
1988
1989   return target;
1990 }
1991
1992 /* Expand a call to the builtin binary math functions (pow and atan2).
1993    Return NULL_RTX if a normal call should be emitted rather than expanding the
1994    function in-line.  EXP is the expression that is a call to the builtin
1995    function; if convenient, the result should be placed in TARGET.
1996    SUBTARGET may be used as the target for computing one of EXP's
1997    operands.  */
1998
1999 static rtx
2000 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2001 {
2002   optab builtin_optab;
2003   rtx op0, op1, insns;
2004   int op1_type = REAL_TYPE;
2005   tree fndecl = get_callee_fndecl (exp);
2006   tree arg0, arg1;
2007   enum machine_mode mode;
2008   bool errno_set = true;
2009
2010   switch (DECL_FUNCTION_CODE (fndecl))
2011     {
2012     CASE_FLT_FN (BUILT_IN_SCALBN):
2013     CASE_FLT_FN (BUILT_IN_SCALBLN):
2014     CASE_FLT_FN (BUILT_IN_LDEXP):
2015       op1_type = INTEGER_TYPE;
2016     default:
2017       break;
2018     }
2019
2020   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2021     return NULL_RTX;
2022
2023   arg0 = CALL_EXPR_ARG (exp, 0);
2024   arg1 = CALL_EXPR_ARG (exp, 1);
2025
2026   switch (DECL_FUNCTION_CODE (fndecl))
2027     {
2028     CASE_FLT_FN (BUILT_IN_POW):
2029       builtin_optab = pow_optab; break;
2030     CASE_FLT_FN (BUILT_IN_ATAN2):
2031       builtin_optab = atan2_optab; break;
2032     CASE_FLT_FN (BUILT_IN_SCALB):
2033       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2034         return 0;
2035       builtin_optab = scalb_optab; break;
2036     CASE_FLT_FN (BUILT_IN_SCALBN):
2037     CASE_FLT_FN (BUILT_IN_SCALBLN):
2038       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2039         return 0;
2040     /* Fall through... */
2041     CASE_FLT_FN (BUILT_IN_LDEXP):
2042       builtin_optab = ldexp_optab; break;
2043     CASE_FLT_FN (BUILT_IN_FMOD):
2044       builtin_optab = fmod_optab; break;
2045     CASE_FLT_FN (BUILT_IN_REMAINDER):
2046     CASE_FLT_FN (BUILT_IN_DREM):
2047       builtin_optab = remainder_optab; break;
2048     default:
2049       gcc_unreachable ();
2050     }
2051
2052   /* Make a suitable register to place result in.  */
2053   mode = TYPE_MODE (TREE_TYPE (exp));
2054
2055   /* Before working hard, check whether the instruction is available.  */
2056   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2057     return NULL_RTX;
2058
2059   target = gen_reg_rtx (mode);
2060
2061   if (! flag_errno_math || ! HONOR_NANS (mode))
2062     errno_set = false;
2063
2064   /* Always stabilize the argument list.  */
2065   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2066   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2067
2068   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2069   op1 = expand_normal (arg1);
2070
2071   start_sequence ();
2072
2073   /* Compute into TARGET.
2074      Set TARGET to wherever the result comes back.  */
2075   target = expand_binop (mode, builtin_optab, op0, op1,
2076                          target, 0, OPTAB_DIRECT);
2077
2078   /* If we were unable to expand via the builtin, stop the sequence
2079      (without outputting the insns) and call to the library function
2080      with the stabilized argument list.  */
2081   if (target == 0)
2082     {
2083       end_sequence ();
2084       return expand_call (exp, target, target == const0_rtx);
2085     }
2086
2087   if (errno_set)
2088     expand_errno_check (exp, target);
2089
2090   /* Output the entire sequence.  */
2091   insns = get_insns ();
2092   end_sequence ();
2093   emit_insn (insns);
2094
2095   return target;
2096 }
2097
2098 /* Expand a call to the builtin sin and cos math functions.
2099    Return NULL_RTX if a normal call should be emitted rather than expanding the
2100    function in-line.  EXP is the expression that is a call to the builtin
2101    function; if convenient, the result should be placed in TARGET.
2102    SUBTARGET may be used as the target for computing one of EXP's
2103    operands.  */
2104
2105 static rtx
2106 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2107 {
2108   optab builtin_optab;
2109   rtx op0, insns;
2110   tree fndecl = get_callee_fndecl (exp);
2111   enum machine_mode mode;
2112   tree arg;
2113
2114   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2115     return NULL_RTX;
2116
2117   arg = CALL_EXPR_ARG (exp, 0);
2118
2119   switch (DECL_FUNCTION_CODE (fndecl))
2120     {
2121     CASE_FLT_FN (BUILT_IN_SIN):
2122     CASE_FLT_FN (BUILT_IN_COS):
2123       builtin_optab = sincos_optab; break;
2124     default:
2125       gcc_unreachable ();
2126     }
2127
2128   /* Make a suitable register to place result in.  */
2129   mode = TYPE_MODE (TREE_TYPE (exp));
2130
2131   /* Check if sincos insn is available, otherwise fallback
2132      to sin or cos insn.  */
2133   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2134     switch (DECL_FUNCTION_CODE (fndecl))
2135       {
2136       CASE_FLT_FN (BUILT_IN_SIN):
2137         builtin_optab = sin_optab; break;
2138       CASE_FLT_FN (BUILT_IN_COS):
2139         builtin_optab = cos_optab; break;
2140       default:
2141         gcc_unreachable ();
2142       }
2143
2144   /* Before working hard, check whether the instruction is available.  */
2145   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2146     {
2147       target = gen_reg_rtx (mode);
2148
2149       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2150          need to expand the argument again.  This way, we will not perform
2151          side-effects more the once.  */
2152       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2153
2154       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2155
2156       start_sequence ();
2157
2158       /* Compute into TARGET.
2159          Set TARGET to wherever the result comes back.  */
2160       if (builtin_optab == sincos_optab)
2161         {
2162           int result;
2163
2164           switch (DECL_FUNCTION_CODE (fndecl))
2165             {
2166             CASE_FLT_FN (BUILT_IN_SIN):
2167               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2168               break;
2169             CASE_FLT_FN (BUILT_IN_COS):
2170               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2171               break;
2172             default:
2173               gcc_unreachable ();
2174             }
2175           gcc_assert (result);
2176         }
2177       else
2178         {
2179           target = expand_unop (mode, builtin_optab, op0, target, 0);
2180         }
2181
2182       if (target != 0)
2183         {
2184           /* Output the entire sequence.  */
2185           insns = get_insns ();
2186           end_sequence ();
2187           emit_insn (insns);
2188           return target;
2189         }
2190
2191       /* If we were unable to expand via the builtin, stop the sequence
2192          (without outputting the insns) and call to the library function
2193          with the stabilized argument list.  */
2194       end_sequence ();
2195     }
2196
2197   target = expand_call (exp, target, target == const0_rtx);
2198
2199   return target;
2200 }
2201
2202 /* Expand a call to one of the builtin math functions that operate on
2203    floating point argument and output an integer result (ilogb, isinf,
2204    isnan, etc).
2205    Return 0 if a normal call should be emitted rather than expanding the
2206    function in-line.  EXP is the expression that is a call to the builtin
2207    function; if convenient, the result should be placed in TARGET.
2208    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2209
2210 static rtx
2211 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2212 {
2213   optab builtin_optab = 0;
2214   enum insn_code icode = CODE_FOR_nothing;
2215   rtx op0;
2216   tree fndecl = get_callee_fndecl (exp);
2217   enum machine_mode mode;
2218   bool errno_set = false;
2219   tree arg;
2220
2221   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2222     return NULL_RTX;
2223
2224   arg = CALL_EXPR_ARG (exp, 0);
2225
2226   switch (DECL_FUNCTION_CODE (fndecl))
2227     {
2228     CASE_FLT_FN (BUILT_IN_ILOGB):
2229       errno_set = true; builtin_optab = ilogb_optab; break;
2230     CASE_FLT_FN (BUILT_IN_ISINF):
2231       builtin_optab = isinf_optab; break;
2232     case BUILT_IN_ISNORMAL:
2233     case BUILT_IN_ISFINITE:
2234     CASE_FLT_FN (BUILT_IN_FINITE):
2235       /* These builtins have no optabs (yet).  */
2236       break;
2237     default:
2238       gcc_unreachable ();
2239     }
2240
2241   /* There's no easy way to detect the case we need to set EDOM.  */
2242   if (flag_errno_math && errno_set)
2243     return NULL_RTX;
2244
2245   /* Optab mode depends on the mode of the input argument.  */
2246   mode = TYPE_MODE (TREE_TYPE (arg));
2247
2248   if (builtin_optab)
2249     icode = optab_handler (builtin_optab, mode)->insn_code;
2250  
2251   /* Before working hard, check whether the instruction is available.  */
2252   if (icode != CODE_FOR_nothing)
2253     {
2254       /* Make a suitable register to place result in.  */
2255       if (!target
2256           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2257          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2258
2259       gcc_assert (insn_data[icode].operand[0].predicate
2260                   (target, GET_MODE (target)));
2261
2262       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2263          need to expand the argument again.  This way, we will not perform
2264          side-effects more the once.  */
2265       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2266
2267       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2268
2269       if (mode != GET_MODE (op0))
2270         op0 = convert_to_mode (mode, op0, 0);
2271
2272       /* Compute into TARGET.
2273          Set TARGET to wherever the result comes back.  */
2274       emit_unop_insn (icode, target, op0, UNKNOWN);
2275       return target;
2276     }
2277
2278   /* If there is no optab, try generic code.  */
2279   switch (DECL_FUNCTION_CODE (fndecl))
2280     {
2281       tree result;
2282
2283     CASE_FLT_FN (BUILT_IN_ISINF):
2284       {
2285         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
2286         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
2287         tree const type = TREE_TYPE (arg);
2288         REAL_VALUE_TYPE r;
2289         char buf[128];
2290
2291         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2292         real_from_string (&r, buf);
2293         result = build_call_expr (isgr_fn, 2,
2294                                   fold_build1 (ABS_EXPR, type, arg),
2295                                   build_real (type, r));
2296         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2297       }
2298     CASE_FLT_FN (BUILT_IN_FINITE):
2299     case BUILT_IN_ISFINITE:
2300       {
2301         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
2302         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
2303         tree const type = TREE_TYPE (arg);
2304         REAL_VALUE_TYPE r;
2305         char buf[128];
2306
2307         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2308         real_from_string (&r, buf);
2309         result = build_call_expr (isle_fn, 2,
2310                                   fold_build1 (ABS_EXPR, type, arg),
2311                                   build_real (type, r));
2312         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2313       }
2314     case BUILT_IN_ISNORMAL:
2315       {
2316         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
2317            islessequal(fabs(x),DBL_MAX).  */
2318         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
2319         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
2320         tree const type = TREE_TYPE (arg);
2321         REAL_VALUE_TYPE rmax, rmin;
2322         char buf[128];
2323
2324         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2325         real_from_string (&rmax, buf);
2326         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
2327         real_from_string (&rmin, buf);
2328         arg = builtin_save_expr (fold_build1 (ABS_EXPR, type, arg));
2329         result = build_call_expr (isle_fn, 2, arg,
2330                                   build_real (type, rmax));
2331         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
2332                               build_call_expr (isge_fn, 2, arg,
2333                                                build_real (type, rmin)));
2334         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2335       }
2336     default:
2337       break;
2338     }
2339
2340   target = expand_call (exp, target, target == const0_rtx);
2341
2342   return target;
2343 }
2344
2345 /* Expand a call to the builtin sincos math function.
2346    Return NULL_RTX if a normal call should be emitted rather than expanding the
2347    function in-line.  EXP is the expression that is a call to the builtin
2348    function.  */
2349
2350 static rtx
2351 expand_builtin_sincos (tree exp)
2352 {
2353   rtx op0, op1, op2, target1, target2;
2354   enum machine_mode mode;
2355   tree arg, sinp, cosp;
2356   int result;
2357
2358   if (!validate_arglist (exp, REAL_TYPE,
2359                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2360     return NULL_RTX;
2361
2362   arg = CALL_EXPR_ARG (exp, 0);
2363   sinp = CALL_EXPR_ARG (exp, 1);
2364   cosp = CALL_EXPR_ARG (exp, 2);
2365
2366   /* Make a suitable register to place result in.  */
2367   mode = TYPE_MODE (TREE_TYPE (arg));
2368
2369   /* Check if sincos insn is available, otherwise emit the call.  */
2370   if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2371     return NULL_RTX;
2372
2373   target1 = gen_reg_rtx (mode);
2374   target2 = gen_reg_rtx (mode);
2375
2376   op0 = expand_normal (arg);
2377   op1 = expand_normal (build_fold_indirect_ref (sinp));
2378   op2 = expand_normal (build_fold_indirect_ref (cosp));
2379
2380   /* Compute into target1 and target2.
2381      Set TARGET to wherever the result comes back.  */
2382   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2383   gcc_assert (result);
2384
2385   /* Move target1 and target2 to the memory locations indicated
2386      by op1 and op2.  */
2387   emit_move_insn (op1, target1);
2388   emit_move_insn (op2, target2);
2389
2390   return const0_rtx;
2391 }
2392
2393 /* Expand a call to the internal cexpi builtin to the sincos math function.
2394    EXP is the expression that is a call to the builtin function; if convenient,
2395    the result should be placed in TARGET.  SUBTARGET may be used as the target
2396    for computing one of EXP's operands.  */
2397
2398 static rtx
2399 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2400 {
2401   tree fndecl = get_callee_fndecl (exp);
2402   tree arg, type;
2403   enum machine_mode mode;
2404   rtx op0, op1, op2;
2405
2406   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2407     return NULL_RTX;
2408
2409   arg = CALL_EXPR_ARG (exp, 0);
2410   type = TREE_TYPE (arg);
2411   mode = TYPE_MODE (TREE_TYPE (arg));
2412
2413   /* Try expanding via a sincos optab, fall back to emitting a libcall
2414      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2415      is only generated from sincos, cexp or if we have either of them.  */
2416   if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2417     {
2418       op1 = gen_reg_rtx (mode);
2419       op2 = gen_reg_rtx (mode);
2420
2421       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2422
2423       /* Compute into op1 and op2.  */
2424       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2425     }
2426   else if (TARGET_HAS_SINCOS)
2427     {
2428       tree call, fn = NULL_TREE;
2429       tree top1, top2;
2430       rtx op1a, op2a;
2431
2432       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2433         fn = built_in_decls[BUILT_IN_SINCOSF];
2434       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2435         fn = built_in_decls[BUILT_IN_SINCOS];
2436       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2437         fn = built_in_decls[BUILT_IN_SINCOSL];
2438       else
2439         gcc_unreachable ();
2440  
2441       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2442       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2443       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2444       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2445       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2446       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2447
2448       /* Make sure not to fold the sincos call again.  */
2449       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2450       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2451                                       call, 3, arg, top1, top2));
2452     }
2453   else
2454     {
2455       tree call, fn = NULL_TREE, narg;
2456       tree ctype = build_complex_type (type);
2457
2458       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2459         fn = built_in_decls[BUILT_IN_CEXPF];
2460       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2461         fn = built_in_decls[BUILT_IN_CEXP];
2462       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2463         fn = built_in_decls[BUILT_IN_CEXPL];
2464       else
2465         gcc_unreachable ();
2466
2467       /* If we don't have a decl for cexp create one.  This is the
2468          friendliest fallback if the user calls __builtin_cexpi
2469          without full target C99 function support.  */
2470       if (fn == NULL_TREE)
2471         {
2472           tree fntype;
2473           const char *name = NULL;
2474
2475           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2476             name = "cexpf";
2477           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2478             name = "cexp";
2479           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2480             name = "cexpl";
2481
2482           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2483           fn = build_fn_decl (name, fntype);
2484         }
2485
2486       narg = fold_build2 (COMPLEX_EXPR, ctype,
2487                           build_real (type, dconst0), arg);
2488
2489       /* Make sure not to fold the cexp call again.  */
2490       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2491       return expand_expr (build_call_nary (ctype, call, 1, narg), 
2492                           target, VOIDmode, EXPAND_NORMAL);
2493     }
2494
2495   /* Now build the proper return type.  */
2496   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2497                               make_tree (TREE_TYPE (arg), op2),
2498                               make_tree (TREE_TYPE (arg), op1)),
2499                       target, VOIDmode, EXPAND_NORMAL);
2500 }
2501
2502 /* Expand a call to one of the builtin rounding functions gcc defines
2503    as an extension (lfloor and lceil).  As these are gcc extensions we
2504    do not need to worry about setting errno to EDOM.
2505    If expanding via optab fails, lower expression to (int)(floor(x)).
2506    EXP is the expression that is a call to the builtin function;
2507    if convenient, the result should be placed in TARGET.  SUBTARGET may
2508    be used as the target for computing one of EXP's operands.  */
2509
2510 static rtx
2511 expand_builtin_int_roundingfn (tree exp, rtx target, rtx subtarget)
2512 {
2513   convert_optab builtin_optab;
2514   rtx op0, insns, tmp;
2515   tree fndecl = get_callee_fndecl (exp);
2516   enum built_in_function fallback_fn;
2517   tree fallback_fndecl;
2518   enum machine_mode mode;
2519   tree arg;
2520
2521   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2522     gcc_unreachable ();
2523
2524   arg = CALL_EXPR_ARG (exp, 0);
2525
2526   switch (DECL_FUNCTION_CODE (fndecl))
2527     {
2528     CASE_FLT_FN (BUILT_IN_LCEIL):
2529     CASE_FLT_FN (BUILT_IN_LLCEIL):
2530       builtin_optab = lceil_optab;
2531       fallback_fn = BUILT_IN_CEIL;
2532       break;
2533
2534     CASE_FLT_FN (BUILT_IN_LFLOOR):
2535     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2536       builtin_optab = lfloor_optab;
2537       fallback_fn = BUILT_IN_FLOOR;
2538       break;
2539
2540     default:
2541       gcc_unreachable ();
2542     }
2543
2544   /* Make a suitable register to place result in.  */
2545   mode = TYPE_MODE (TREE_TYPE (exp));
2546
2547   target = gen_reg_rtx (mode);
2548
2549   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2550      need to expand the argument again.  This way, we will not perform
2551      side-effects more the once.  */
2552   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2553
2554   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2555
2556   start_sequence ();
2557
2558   /* Compute into TARGET.  */
2559   if (expand_sfix_optab (target, op0, builtin_optab))
2560     {
2561       /* Output the entire sequence.  */
2562       insns = get_insns ();
2563       end_sequence ();
2564       emit_insn (insns);
2565       return target;
2566     }
2567
2568   /* If we were unable to expand via the builtin, stop the sequence
2569      (without outputting the insns).  */
2570   end_sequence ();
2571
2572   /* Fall back to floating point rounding optab.  */
2573   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2574
2575   /* For non-C99 targets we may end up without a fallback fndecl here
2576      if the user called __builtin_lfloor directly.  In this case emit
2577      a call to the floor/ceil variants nevertheless.  This should result
2578      in the best user experience for not full C99 targets.  */
2579   if (fallback_fndecl == NULL_TREE)
2580     {
2581       tree fntype;
2582       const char *name = NULL;
2583
2584       switch (DECL_FUNCTION_CODE (fndecl))
2585         {
2586         case BUILT_IN_LCEIL:
2587         case BUILT_IN_LLCEIL:
2588           name = "ceil";
2589           break;
2590         case BUILT_IN_LCEILF:
2591         case BUILT_IN_LLCEILF:
2592           name = "ceilf";
2593           break;
2594         case BUILT_IN_LCEILL:
2595         case BUILT_IN_LLCEILL:
2596           name = "ceill";
2597           break;
2598         case BUILT_IN_LFLOOR:
2599         case BUILT_IN_LLFLOOR:
2600           name = "floor";
2601           break;
2602         case BUILT_IN_LFLOORF:
2603         case BUILT_IN_LLFLOORF:
2604           name = "floorf";
2605           break;
2606         case BUILT_IN_LFLOORL:
2607         case BUILT_IN_LLFLOORL:
2608           name = "floorl";
2609           break;
2610         default:
2611           gcc_unreachable ();
2612         }
2613
2614       fntype = build_function_type_list (TREE_TYPE (arg),
2615                                          TREE_TYPE (arg), NULL_TREE);
2616       fallback_fndecl = build_fn_decl (name, fntype);
2617     }
2618
2619   exp = build_call_expr (fallback_fndecl, 1, arg);
2620
2621   tmp = expand_normal (exp);
2622
2623   /* Truncate the result of floating point optab to integer
2624      via expand_fix ().  */
2625   target = gen_reg_rtx (mode);
2626   expand_fix (target, tmp, 0);
2627
2628   return target;
2629 }
2630
2631 /* Expand a call to one of the builtin math functions doing integer
2632    conversion (lrint).
2633    Return 0 if a normal call should be emitted rather than expanding the
2634    function in-line.  EXP is the expression that is a call to the builtin
2635    function; if convenient, the result should be placed in TARGET.
2636    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2637
2638 static rtx
2639 expand_builtin_int_roundingfn_2 (tree exp, rtx target, rtx subtarget)
2640 {
2641   convert_optab builtin_optab;
2642   rtx op0, insns;
2643   tree fndecl = get_callee_fndecl (exp);
2644   tree arg;
2645   enum machine_mode mode;
2646
2647   /* There's no easy way to detect the case we need to set EDOM.  */
2648   if (flag_errno_math)
2649     return NULL_RTX;
2650
2651   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2652      gcc_unreachable ();
2653  
2654   arg = CALL_EXPR_ARG (exp, 0);
2655
2656   switch (DECL_FUNCTION_CODE (fndecl))
2657     {
2658     CASE_FLT_FN (BUILT_IN_LRINT):
2659     CASE_FLT_FN (BUILT_IN_LLRINT):
2660       builtin_optab = lrint_optab; break;
2661     CASE_FLT_FN (BUILT_IN_LROUND):
2662     CASE_FLT_FN (BUILT_IN_LLROUND):
2663       builtin_optab = lround_optab; break;
2664     default:
2665       gcc_unreachable ();
2666     }
2667
2668   /* Make a suitable register to place result in.  */
2669   mode = TYPE_MODE (TREE_TYPE (exp));
2670
2671   target = gen_reg_rtx (mode);
2672
2673   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2674      need to expand the argument again.  This way, we will not perform
2675      side-effects more the once.  */
2676   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2677
2678   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2679
2680   start_sequence ();
2681
2682   if (expand_sfix_optab (target, op0, builtin_optab))
2683     {
2684       /* Output the entire sequence.  */
2685       insns = get_insns ();
2686       end_sequence ();
2687       emit_insn (insns);
2688       return target;
2689     }
2690
2691   /* If we were unable to expand via the builtin, stop the sequence
2692      (without outputting the insns) and call to the library function
2693      with the stabilized argument list.  */
2694   end_sequence ();
2695
2696   target = expand_call (exp, target, target == const0_rtx);
2697
2698   return target;
2699 }
2700
2701 /* To evaluate powi(x,n), the floating point value x raised to the
2702    constant integer exponent n, we use a hybrid algorithm that
2703    combines the "window method" with look-up tables.  For an
2704    introduction to exponentiation algorithms and "addition chains",
2705    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2706    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2707    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2708    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2709
2710 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2711    multiplications to inline before calling the system library's pow
2712    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2713    so this default never requires calling pow, powf or powl.  */
2714
2715 #ifndef POWI_MAX_MULTS
2716 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2717 #endif
2718
2719 /* The size of the "optimal power tree" lookup table.  All
2720    exponents less than this value are simply looked up in the
2721    powi_table below.  This threshold is also used to size the
2722    cache of pseudo registers that hold intermediate results.  */
2723 #define POWI_TABLE_SIZE 256
2724
2725 /* The size, in bits of the window, used in the "window method"
2726    exponentiation algorithm.  This is equivalent to a radix of
2727    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2728 #define POWI_WINDOW_SIZE 3
2729
2730 /* The following table is an efficient representation of an
2731    "optimal power tree".  For each value, i, the corresponding
2732    value, j, in the table states than an optimal evaluation
2733    sequence for calculating pow(x,i) can be found by evaluating
2734    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2735    100 integers is given in Knuth's "Seminumerical algorithms".  */
2736
2737 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2738   {
2739       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2740       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2741       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2742      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2743      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2744      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2745      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2746      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2747      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2748      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2749      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2750      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2751      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2752      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2753      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2754      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2755      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2756      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2757      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2758      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2759      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2760      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2761      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2762      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2763      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2764     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2765     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2766     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2767     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2768     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2769     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2770     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2771   };
2772
2773
2774 /* Return the number of multiplications required to calculate
2775    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2776    subroutine of powi_cost.  CACHE is an array indicating
2777    which exponents have already been calculated.  */
2778
2779 static int
2780 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2781 {
2782   /* If we've already calculated this exponent, then this evaluation
2783      doesn't require any additional multiplications.  */
2784   if (cache[n])
2785     return 0;
2786
2787   cache[n] = true;
2788   return powi_lookup_cost (n - powi_table[n], cache)
2789          + powi_lookup_cost (powi_table[n], cache) + 1;
2790 }
2791
2792 /* Return the number of multiplications required to calculate
2793    powi(x,n) for an arbitrary x, given the exponent N.  This
2794    function needs to be kept in sync with expand_powi below.  */
2795
2796 static int
2797 powi_cost (HOST_WIDE_INT n)
2798 {
2799   bool cache[POWI_TABLE_SIZE];
2800   unsigned HOST_WIDE_INT digit;
2801   unsigned HOST_WIDE_INT val;
2802   int result;
2803
2804   if (n == 0)
2805     return 0;
2806
2807   /* Ignore the reciprocal when calculating the cost.  */
2808   val = (n < 0) ? -n : n;
2809
2810   /* Initialize the exponent cache.  */
2811   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2812   cache[1] = true;
2813
2814   result = 0;
2815
2816   while (val >= POWI_TABLE_SIZE)
2817     {
2818       if (val & 1)
2819         {
2820           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2821           result += powi_lookup_cost (digit, cache)
2822                     + POWI_WINDOW_SIZE + 1;
2823           val >>= POWI_WINDOW_SIZE;
2824         }
2825       else
2826         {
2827           val >>= 1;
2828           result++;
2829         }
2830     }
2831
2832   return result + powi_lookup_cost (val, cache);
2833 }
2834
2835 /* Recursive subroutine of expand_powi.  This function takes the array,
2836    CACHE, of already calculated exponents and an exponent N and returns
2837    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2838
2839 static rtx
2840 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2841 {
2842   unsigned HOST_WIDE_INT digit;
2843   rtx target, result;
2844   rtx op0, op1;
2845
2846   if (n < POWI_TABLE_SIZE)
2847     {
2848       if (cache[n])
2849         return cache[n];
2850
2851       target = gen_reg_rtx (mode);
2852       cache[n] = target;
2853
2854       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2855       op1 = expand_powi_1 (mode, powi_table[n], cache);
2856     }
2857   else if (n & 1)
2858     {
2859       target = gen_reg_rtx (mode);
2860       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2861       op0 = expand_powi_1 (mode, n - digit, cache);
2862       op1 = expand_powi_1 (mode, digit, cache);
2863     }
2864   else
2865     {
2866       target = gen_reg_rtx (mode);
2867       op0 = expand_powi_1 (mode, n >> 1, cache);
2868       op1 = op0;
2869     }
2870
2871   result = expand_mult (mode, op0, op1, target, 0);
2872   if (result != target)
2873     emit_move_insn (target, result);
2874   return target;
2875 }
2876
2877 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2878    floating point operand in mode MODE, and N is the exponent.  This
2879    function needs to be kept in sync with powi_cost above.  */
2880
2881 static rtx
2882 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2883 {
2884   unsigned HOST_WIDE_INT val;
2885   rtx cache[POWI_TABLE_SIZE];
2886   rtx result;
2887
2888   if (n == 0)
2889     return CONST1_RTX (mode);
2890
2891   val = (n < 0) ? -n : n;
2892
2893   memset (cache, 0, sizeof (cache));
2894   cache[1] = x;
2895
2896   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2897
2898   /* If the original exponent was negative, reciprocate the result.  */
2899   if (n < 0)
2900     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2901                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2902
2903   return result;
2904 }
2905
2906 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
2907    a normal call should be emitted rather than expanding the function
2908    in-line.  EXP is the expression that is a call to the builtin
2909    function; if convenient, the result should be placed in TARGET.  */
2910
2911 static rtx
2912 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2913 {
2914   tree arg0, arg1;
2915   tree fn, narg0;
2916   tree type = TREE_TYPE (exp);
2917   REAL_VALUE_TYPE cint, c, c2;
2918   HOST_WIDE_INT n;
2919   rtx op, op2;
2920   enum machine_mode mode = TYPE_MODE (type);
2921
2922   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2923     return NULL_RTX;
2924
2925   arg0 = CALL_EXPR_ARG (exp, 0);
2926   arg1 = CALL_EXPR_ARG (exp, 1);
2927
2928   if (TREE_CODE (arg1) != REAL_CST
2929       || TREE_OVERFLOW (arg1))
2930     return expand_builtin_mathfn_2 (exp, target, subtarget);
2931
2932   /* Handle constant exponents.  */
2933
2934   /* For integer valued exponents we can expand to an optimal multiplication
2935      sequence using expand_powi.  */
2936   c = TREE_REAL_CST (arg1);
2937   n = real_to_integer (&c);
2938   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2939   if (real_identical (&c, &cint)
2940       && ((n >= -1 && n <= 2)
2941           || (flag_unsafe_math_optimizations
2942               && !optimize_size
2943               && powi_cost (n) <= POWI_MAX_MULTS)))
2944     {
2945       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2946       if (n != 1)
2947         {
2948           op = force_reg (mode, op);
2949           op = expand_powi (op, mode, n);
2950         }
2951       return op;
2952     }
2953
2954   narg0 = builtin_save_expr (arg0);
2955
2956   /* If the exponent is not integer valued, check if it is half of an integer.
2957      In this case we can expand to sqrt (x) * x**(n/2).  */
2958   fn = mathfn_built_in (type, BUILT_IN_SQRT);
2959   if (fn != NULL_TREE)
2960     {
2961       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2962       n = real_to_integer (&c2);
2963       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2964       if (real_identical (&c2, &cint)
2965           && ((flag_unsafe_math_optimizations
2966                && !optimize_size
2967                && powi_cost (n/2) <= POWI_MAX_MULTS)
2968               || n == 1))
2969         {
2970           tree call_expr = build_call_expr (fn, 1, narg0);
2971           /* Use expand_expr in case the newly built call expression
2972              was folded to a non-call.  */
2973           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
2974           if (n != 1)
2975             {
2976               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
2977               op2 = force_reg (mode, op2);
2978               op2 = expand_powi (op2, mode, abs (n / 2));
2979               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
2980                                         0, OPTAB_LIB_WIDEN);
2981               /* If the original exponent was negative, reciprocate the
2982                  result.  */
2983               if (n < 0)
2984                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2985                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2986             }
2987           return op;
2988         }
2989     }
2990
2991   /* Try if the exponent is a third of an integer.  In this case
2992      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
2993      different from pow (x, 1./3.) due to rounding and behavior
2994      with negative x we need to constrain this transformation to
2995      unsafe math and positive x or finite math.  */
2996   fn = mathfn_built_in (type, BUILT_IN_CBRT);
2997   if (fn != NULL_TREE
2998       && flag_unsafe_math_optimizations
2999       && (tree_expr_nonnegative_p (arg0)
3000           || !HONOR_NANS (mode)))
3001     {
3002       REAL_VALUE_TYPE dconst3;
3003       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3004       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3005       real_round (&c2, mode, &c2);
3006       n = real_to_integer (&c2);
3007       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3008       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3009       real_convert (&c2, mode, &c2);
3010       if (real_identical (&c2, &c)
3011           && ((!optimize_size
3012                && powi_cost (n/3) <= POWI_MAX_MULTS)
3013               || n == 1))
3014         {
3015           tree call_expr = build_call_expr (fn, 1,narg0);
3016           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3017           if (abs (n) % 3 == 2)
3018             op = expand_simple_binop (mode, MULT, op, op, op,
3019                                       0, OPTAB_LIB_WIDEN);
3020           if (n != 1)
3021             {
3022               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3023               op2 = force_reg (mode, op2);
3024               op2 = expand_powi (op2, mode, abs (n / 3));
3025               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3026                                         0, OPTAB_LIB_WIDEN);
3027               /* If the original exponent was negative, reciprocate the
3028                  result.  */
3029               if (n < 0)
3030                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3031                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3032             }
3033           return op;
3034         }
3035     }
3036
3037   /* Fall back to optab expansion.  */
3038   return expand_builtin_mathfn_2 (exp, target, subtarget);
3039 }
3040
3041 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3042    a normal call should be emitted rather than expanding the function
3043    in-line.  EXP is the expression that is a call to the builtin
3044    function; if convenient, the result should be placed in TARGET.  */
3045
3046 static rtx
3047 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3048 {
3049   tree arg0, arg1;
3050   rtx op0, op1;
3051   enum machine_mode mode;
3052   enum machine_mode mode2;
3053
3054   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3055     return NULL_RTX;
3056
3057   arg0 = CALL_EXPR_ARG (exp, 0);
3058   arg1 = CALL_EXPR_ARG (exp, 1);
3059   mode = TYPE_MODE (TREE_TYPE (exp));
3060
3061   /* Handle constant power.  */
3062
3063   if (TREE_CODE (arg1) == INTEGER_CST
3064       && !TREE_OVERFLOW (arg1))
3065     {
3066       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3067
3068       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3069          Otherwise, check the number of multiplications required.  */
3070       if ((TREE_INT_CST_HIGH (arg1) == 0
3071            || TREE_INT_CST_HIGH (arg1) == -1)
3072           && ((n >= -1 && n <= 2)
3073               || (! optimize_size
3074                   && powi_cost (n) <= POWI_MAX_MULTS)))
3075         {
3076           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3077           op0 = force_reg (mode, op0);
3078           return expand_powi (op0, mode, n);
3079         }
3080     }
3081
3082   /* Emit a libcall to libgcc.  */
3083
3084   /* Mode of the 2nd argument must match that of an int.  */
3085   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3086
3087   if (target == NULL_RTX)
3088     target = gen_reg_rtx (mode);
3089
3090   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3091   if (GET_MODE (op0) != mode)
3092     op0 = convert_to_mode (mode, op0, 0);
3093   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3094   if (GET_MODE (op1) != mode2)
3095     op1 = convert_to_mode (mode2, op1, 0);
3096
3097   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3098                                     target, LCT_CONST, mode, 2,
3099                                     op0, mode, op1, mode2);
3100
3101   return target;
3102 }
3103
3104 /* Expand expression EXP which is a call to the strlen builtin.  Return 
3105    NULL_RTX if we failed the caller should emit a normal call, otherwise
3106    try to get the result in TARGET, if convenient.  */
3107
3108 static rtx
3109 expand_builtin_strlen (tree exp, rtx target,
3110                        enum machine_mode target_mode)
3111 {
3112   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3113     return NULL_RTX;
3114   else
3115     {
3116       rtx pat;
3117       tree len;
3118       tree src = CALL_EXPR_ARG (exp, 0);
3119       rtx result, src_reg, char_rtx, before_strlen;
3120       enum machine_mode insn_mode = target_mode, char_mode;
3121       enum insn_code icode = CODE_FOR_nothing;
3122       int align;
3123
3124       /* If the length can be computed at compile-time, return it.  */
3125       len = c_strlen (src, 0);
3126       if (len)
3127         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3128
3129       /* If the length can be computed at compile-time and is constant
3130          integer, but there are side-effects in src, evaluate
3131          src for side-effects, then return len.
3132          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3133          can be optimized into: i++; x = 3;  */
3134       len = c_strlen (src, 1);
3135       if (len && TREE_CODE (len) == INTEGER_CST)
3136         {
3137           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3138           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3139         }
3140
3141       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3142
3143       /* If SRC is not a pointer type, don't do this operation inline.  */
3144       if (align == 0)
3145         return NULL_RTX;
3146
3147       /* Bail out if we can't compute strlen in the right mode.  */
3148       while (insn_mode != VOIDmode)
3149         {
3150           icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3151           if (icode != CODE_FOR_nothing)
3152             break;
3153
3154           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3155         }
3156       if (insn_mode == VOIDmode)
3157         return NULL_RTX;
3158
3159       /* Make a place to write the result of the instruction.  */
3160       result = target;
3161       if (! (result != 0
3162              && REG_P (result)
3163              && GET_MODE (result) == insn_mode
3164              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3165         result = gen_reg_rtx (insn_mode);
3166
3167       /* Make a place to hold the source address.  We will not expand
3168          the actual source until we are sure that the expansion will
3169          not fail -- there are trees that cannot be expanded twice.  */
3170       src_reg = gen_reg_rtx (Pmode);
3171
3172       /* Mark the beginning of the strlen sequence so we can emit the
3173          source operand later.  */
3174       before_strlen = get_last_insn ();
3175
3176       char_rtx = const0_rtx;
3177       char_mode = insn_data[(int) icode].operand[2].mode;
3178       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3179                                                             char_mode))
3180         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3181
3182       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3183                              char_rtx, GEN_INT (align));
3184       if (! pat)
3185         return NULL_RTX;
3186       emit_insn (pat);
3187
3188       /* Now that we are assured of success, expand the source.  */
3189       start_sequence ();
3190       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3191       if (pat != src_reg)
3192         emit_move_insn (src_reg, pat);
3193       pat = get_insns ();
3194       end_sequence ();
3195
3196       if (before_strlen)
3197         emit_insn_after (pat, before_strlen);
3198       else
3199         emit_insn_before (pat, get_insns ());
3200
3201       /* Return the value in the proper mode for this function.  */
3202       if (GET_MODE (result) == target_mode)
3203         target = result;
3204       else if (target != 0)
3205         convert_move (target, result, 0);
3206       else
3207         target = convert_to_mode (target_mode, result, 0);
3208
3209       return target;
3210     }
3211 }
3212
3213 /* Expand a call to the strstr builtin.  Return NULL_RTX if we failed the
3214    caller should emit a normal call, otherwise try to get the result
3215    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3216
3217 static rtx
3218 expand_builtin_strstr (tree exp, rtx target, enum machine_mode mode)
3219 {
3220   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3221     {
3222       tree type = TREE_TYPE (exp);
3223       tree result = fold_builtin_strstr (CALL_EXPR_ARG (exp, 0),
3224                                          CALL_EXPR_ARG (exp, 1), type);
3225       if (result)
3226         return expand_expr (result, target, mode, EXPAND_NORMAL);
3227     }
3228   return NULL_RTX;
3229 }
3230
3231 /* Expand a call to the strchr builtin.  Return NULL_RTX if we failed the
3232    caller should emit a normal call, otherwise try to get the result
3233    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3234
3235 static rtx
3236 expand_builtin_strchr (tree exp, rtx target, enum machine_mode mode)
3237 {
3238   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3239     {
3240       tree type = TREE_TYPE (exp);
3241       tree result = fold_builtin_strchr (CALL_EXPR_ARG (exp, 0),
3242                                          CALL_EXPR_ARG (exp, 1), type);
3243       if (result)
3244         return expand_expr (result, target, mode, EXPAND_NORMAL);
3245
3246       /* FIXME: Should use strchrM optab so that ports can optimize this.  */
3247     }
3248   return NULL_RTX;
3249 }
3250
3251 /* Expand a call to the strrchr builtin.  Return NULL_RTX if we failed the
3252    caller should emit a normal call, otherwise try to get the result
3253    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3254
3255 static rtx
3256 expand_builtin_strrchr (tree exp, rtx target, enum machine_mode mode)
3257 {
3258   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3259     {
3260       tree type = TREE_TYPE (exp);
3261       tree result = fold_builtin_strrchr (CALL_EXPR_ARG (exp, 0),
3262                                           CALL_EXPR_ARG (exp, 1), type);
3263       if (result)
3264         return expand_expr (result, target, mode, EXPAND_NORMAL);
3265     }
3266   return NULL_RTX;
3267 }
3268
3269 /* Expand a call to the strpbrk builtin.  Return NULL_RTX if we failed the
3270    caller should emit a normal call, otherwise try to get the result
3271    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3272
3273 static rtx
3274 expand_builtin_strpbrk (tree exp, rtx target, enum machine_mode mode)
3275 {
3276   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3277     {
3278       tree type = TREE_TYPE (exp);
3279       tree result = fold_builtin_strpbrk (CALL_EXPR_ARG (exp, 0),
3280                                           CALL_EXPR_ARG (exp, 1), type);
3281       if (result)
3282         return expand_expr (result, target, mode, EXPAND_NORMAL);
3283     }
3284   return NULL_RTX;
3285 }
3286
3287 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3288    bytes from constant string DATA + OFFSET and return it as target
3289    constant.  */
3290
3291 static rtx
3292 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3293                          enum machine_mode mode)
3294 {
3295   const char *str = (const char *) data;
3296
3297   gcc_assert (offset >= 0
3298               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3299                   <= strlen (str) + 1));
3300
3301   return c_readstr (str + offset, mode);
3302 }
3303
3304 /* Expand a call EXP to the memcpy builtin.
3305    Return NULL_RTX if we failed, the caller should emit a normal call,
3306    otherwise try to get the result in TARGET, if convenient (and in
3307    mode MODE if that's convenient).  */
3308
3309 static rtx
3310 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
3311 {
3312   tree fndecl = get_callee_fndecl (exp);
3313
3314   if (!validate_arglist (exp,
3315                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3316     return NULL_RTX;
3317   else
3318     {
3319       tree dest = CALL_EXPR_ARG (exp, 0);
3320       tree src = CALL_EXPR_ARG (exp, 1);
3321       tree len = CALL_EXPR_ARG (exp, 2);
3322       const char *src_str;
3323       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3324       unsigned int dest_align
3325         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3326       rtx dest_mem, src_mem, dest_addr, len_rtx;
3327       tree result = fold_builtin_memory_op (dest, src, len, 
3328                                             TREE_TYPE (TREE_TYPE (fndecl)),
3329                                             false, /*endp=*/0);
3330       HOST_WIDE_INT expected_size = -1;
3331       unsigned int expected_align = 0;
3332
3333       if (result)
3334         {
3335           while (TREE_CODE (result) == COMPOUND_EXPR)
3336             {
3337               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3338                            EXPAND_NORMAL);
3339               result = TREE_OPERAND (result, 1);
3340             }
3341           return expand_expr (result, target, mode, EXPAND_NORMAL);
3342         }
3343
3344       /* If DEST is not a pointer type, call the normal function.  */
3345       if (dest_align == 0)
3346         return NULL_RTX;
3347
3348       /* If either SRC is not a pointer type, don't do this
3349          operation in-line.  */
3350       if (src_align == 0)
3351         return NULL_RTX;
3352  
3353       stringop_block_profile (exp, &expected_align, &expected_size);
3354       if (expected_align < dest_align)
3355         expected_align = dest_align;
3356       dest_mem = get_memory_rtx (dest, len);
3357       set_mem_align (dest_mem, dest_align);
3358       len_rtx = expand_normal (len);
3359       src_str = c_getstr (src);
3360
3361       /* If SRC is a string constant and block move would be done
3362          by pieces, we can avoid loading the string from memory
3363          and only stored the computed constants.  */
3364       if (src_str
3365           && GET_CODE (len_rtx) == CONST_INT
3366           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3367           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3368                                   (void *) src_str, dest_align, false))
3369         {
3370           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3371                                       builtin_memcpy_read_str,
3372                                       (void *) src_str, dest_align, false, 0);
3373           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3374           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3375           return dest_mem;
3376         }
3377
3378       src_mem = get_memory_rtx (src, len);
3379       set_mem_align (src_mem, src_align);
3380
3381       /* Copy word part most expediently.  */
3382       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3383                                          CALL_EXPR_TAILCALL (exp)
3384                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3385                                          expected_align, expected_size);
3386
3387       if (dest_addr == 0)
3388         {
3389           dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3390           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3391         }
3392       return dest_addr;
3393     }
3394 }
3395
3396 /* Expand a call EXP to the mempcpy builtin.
3397    Return NULL_RTX if we failed; the caller should emit a normal call,
3398    otherwise try to get the result in TARGET, if convenient (and in
3399    mode MODE if that's convenient).  If ENDP is 0 return the
3400    destination pointer, if ENDP is 1 return the end pointer ala
3401    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3402    stpcpy.  */
3403
3404 static rtx
3405 expand_builtin_mempcpy(tree exp, rtx target, enum machine_mode mode)
3406 {
3407   if (!validate_arglist (exp,
3408                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3409     return NULL_RTX;
3410   else
3411     {
3412       tree dest = CALL_EXPR_ARG (exp, 0);
3413       tree src = CALL_EXPR_ARG (exp, 1);
3414       tree len = CALL_EXPR_ARG (exp, 2);
3415       return expand_builtin_mempcpy_args (dest, src, len,
3416                                           TREE_TYPE (exp),
3417                                           target, mode, /*endp=*/ 1);
3418     }
3419 }
3420
3421 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3422    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3423    so that this can also be called without constructing an actual CALL_EXPR.
3424    TYPE is the return type of the call.  The other arguments and return value
3425    are the same as for expand_builtin_mempcpy.  */
3426
3427 static rtx
3428 expand_builtin_mempcpy_args (tree dest, tree src, tree len, tree type,
3429                              rtx target, enum machine_mode mode, int endp)
3430 {
3431     /* If return value is ignored, transform mempcpy into memcpy.  */
3432   if (target == const0_rtx)
3433     {
3434       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3435
3436       if (!fn)
3437         return NULL_RTX;
3438
3439       return expand_expr (build_call_expr (fn, 3, dest, src, len),
3440                           target, mode, EXPAND_NORMAL);
3441     }
3442   else
3443     {
3444       const char *src_str;
3445       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3446       unsigned int dest_align
3447         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3448       rtx dest_mem, src_mem, len_rtx;
3449       tree result = fold_builtin_memory_op (dest, src, len, type, false, endp);
3450
3451       if (result)
3452         {
3453           while (TREE_CODE (result) == COMPOUND_EXPR)
3454             {
3455               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3456                            EXPAND_NORMAL);
3457               result = TREE_OPERAND (result, 1);
3458             }
3459           return expand_expr (result, target, mode, EXPAND_NORMAL);
3460         }
3461
3462       /* If either SRC or DEST is not a pointer type, don't do this
3463          operation in-line.  */
3464       if (dest_align == 0 || src_align == 0)
3465         return NULL_RTX;
3466
3467       /* If LEN is not constant, call the normal function.  */
3468       if (! host_integerp (len, 1))
3469         return NULL_RTX;
3470
3471       len_rtx = expand_normal (len);
3472       src_str = c_getstr (src);
3473
3474       /* If SRC is a string constant and block move would be done
3475          by pieces, we can avoid loading the string from memory
3476          and only stored the computed constants.  */
3477       if (src_str
3478           && GET_CODE (len_rtx) == CONST_INT
3479           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3480           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3481                                   (void *) src_str, dest_align, false))
3482         {
3483           dest_mem = get_memory_rtx (dest, len);
3484           set_mem_align (dest_mem, dest_align);
3485           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3486                                       builtin_memcpy_read_str,
3487                                       (void *) src_str, dest_align,
3488                                       false, endp);
3489           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3490           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3491           return dest_mem;
3492         }
3493
3494       if (GET_CODE (len_rtx) == CONST_INT
3495           && can_move_by_pieces (INTVAL (len_rtx),
3496                                  MIN (dest_align, src_align)))
3497         {
3498           dest_mem = get_memory_rtx (dest, len);
3499           set_mem_align (dest_mem, dest_align);
3500           src_mem = get_memory_rtx (src, len);
3501           set_mem_align (src_mem, src_align);
3502           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3503                                      MIN (dest_align, src_align), endp);
3504           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3505           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3506           return dest_mem;
3507         }
3508
3509       return NULL_RTX;
3510     }
3511 }
3512
3513 /* Expand expression EXP, which is a call to the memmove builtin.  Return 
3514    NULL_RTX if we failed; the caller should emit a normal call.  */
3515
3516 static rtx
3517 expand_builtin_memmove (tree exp, rtx target, enum machine_mode mode, int ignore)
3518 {
3519   if (!validate_arglist (exp,
3520                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3521     return NULL_RTX;
3522   else
3523     {
3524       tree dest = CALL_EXPR_ARG (exp, 0);
3525       tree src = CALL_EXPR_ARG (exp, 1);
3526       tree len = CALL_EXPR_ARG (exp, 2);
3527       return expand_builtin_memmove_args (dest, src, len, TREE_TYPE (exp), 
3528                                           target, mode, ignore);
3529     }
3530 }
3531
3532 /* Helper function to do the actual work for expand_builtin_memmove.  The
3533    arguments to the builtin_memmove call DEST, SRC, and LEN are broken out
3534    so that this can also be called without constructing an actual CALL_EXPR.
3535    TYPE is the return type of the call.  The other arguments and return value
3536    are the same as for expand_builtin_memmove.  */
3537
3538 static rtx
3539 expand_builtin_memmove_args (tree dest, tree src, tree len,
3540                              tree type, rtx target, enum machine_mode mode, 
3541                              int ignore)
3542 {
3543   tree result = fold_builtin_memory_op (dest, src, len, type, ignore, /*endp=*/3);
3544
3545   if (result)
3546     {
3547       STRIP_TYPE_NOPS (result);
3548       while (TREE_CODE (result) == COMPOUND_EXPR)
3549         {
3550           expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3551                        EXPAND_NORMAL);
3552           result = TREE_OPERAND (result, 1);
3553         }
3554       return expand_expr (result, target, mode, EXPAND_NORMAL);
3555     }
3556   
3557   /* Otherwise, call the normal function.  */
3558   return NULL_RTX;
3559 }
3560
3561 /* Expand expression EXP, which is a call to the bcopy builtin.  Return 
3562    NULL_RTX if we failed the caller should emit a normal call.  */
3563
3564 static rtx
3565 expand_builtin_bcopy (tree exp, int ignore)
3566 {
3567   tree type = TREE_TYPE (exp);
3568   tree src, dest, size;
3569
3570   if (!validate_arglist (exp,
3571                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3572     return NULL_RTX;
3573
3574   src = CALL_EXPR_ARG (exp, 0);
3575   dest = CALL_EXPR_ARG (exp, 1);
3576   size = CALL_EXPR_ARG (exp, 2);
3577
3578   /* Transform bcopy(ptr x, ptr y, int z) to memmove(ptr y, ptr x, size_t z).
3579      This is done this way so that if it isn't expanded inline, we fall
3580      back to calling bcopy instead of memmove.  */
3581   return expand_builtin_memmove_args (dest, src,
3582                                       fold_convert (sizetype, size),
3583                                       type, const0_rtx, VOIDmode, 
3584                                       ignore);
3585 }
3586
3587 #ifndef HAVE_movstr
3588 # define HAVE_movstr 0
3589 # define CODE_FOR_movstr CODE_FOR_nothing
3590 #endif
3591
3592 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3593    we failed, the caller should emit a normal call, otherwise try to
3594    get the result in TARGET, if convenient.  If ENDP is 0 return the
3595    destination pointer, if ENDP is 1 return the end pointer ala
3596    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3597    stpcpy.  */
3598
3599 static rtx
3600 expand_movstr (tree dest, tree src, rtx target, int endp)
3601 {
3602   rtx end;
3603   rtx dest_mem;
3604   rtx src_mem;
3605   rtx insn;
3606   const struct insn_data * data;
3607
3608   if (!HAVE_movstr)
3609     return NULL_RTX;
3610
3611   dest_mem = get_memory_rtx (dest, NULL);
3612   src_mem = get_memory_rtx (src, NULL);
3613   if (!endp)
3614     {
3615       target = force_reg (Pmode, XEXP (dest_mem, 0));
3616       dest_mem = replace_equiv_address (dest_mem, target);
3617       end = gen_reg_rtx (Pmode);
3618     }
3619   else
3620     {
3621       if (target == 0 || target == const0_rtx)
3622         {
3623           end = gen_reg_rtx (Pmode);
3624           if (target == 0)
3625             target = end;
3626         }
3627       else
3628         end = target;
3629     }
3630
3631   data = insn_data + CODE_FOR_movstr;
3632
3633   if (data->operand[0].mode != VOIDmode)
3634     end = gen_lowpart (data->operand[0].mode, end);
3635
3636   insn = data->genfun (end, dest_mem, src_mem);
3637
3638   gcc_assert (insn);
3639
3640   emit_insn (insn);
3641
3642   /* movstr is supposed to set end to the address of the NUL
3643      terminator.  If the caller requested a mempcpy-like return value,
3644      adjust it.  */
3645   if (endp == 1 && target != const0_rtx)
3646     {
3647       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3648       emit_move_insn (target, force_operand (tem, NULL_RTX));
3649     }
3650
3651   return target;
3652 }
3653
3654 /* Expand expression EXP, which is a call to the strcpy builtin.  Return 
3655    NULL_RTX if we failed the caller should emit a normal call, otherwise 
3656    try to get the result in TARGET, if convenient (and in mode MODE if that's
3657    convenient).  */
3658
3659 static rtx
3660 expand_builtin_strcpy (tree fndecl, tree exp, rtx target, enum machine_mode mode)
3661 {
3662   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3663    {
3664      tree dest = CALL_EXPR_ARG (exp, 0);
3665      tree src = CALL_EXPR_ARG (exp, 1);
3666      return expand_builtin_strcpy_args (fndecl, dest, src, target, mode);
3667    }
3668    return NULL_RTX;
3669 }
3670
3671 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3672    arguments to the builtin_strcpy call DEST and SRC are broken out
3673    so that this can also be called without constructing an actual CALL_EXPR.
3674    The other arguments and return value are the same as for
3675    expand_builtin_strcpy.  */
3676
3677 static rtx
3678 expand_builtin_strcpy_args (tree fndecl, tree dest, tree src,
3679                             rtx target, enum machine_mode mode)
3680 {
3681   tree result = fold_builtin_strcpy (fndecl, dest, src, 0);
3682   if (result)
3683     return expand_expr (result, target, mode, EXPAND_NORMAL);
3684   return expand_movstr (dest, src, target, /*endp=*/0);
3685
3686 }
3687
3688 /* Expand a call EXP to the stpcpy builtin.
3689    Return NULL_RTX if we failed the caller should emit a normal call,
3690    otherwise try to get the result in TARGET, if convenient (and in
3691    mode MODE if that's convenient).  */
3692
3693 static rtx
3694 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3695 {
3696   tree dst, src;
3697
3698   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3699     return NULL_RTX;
3700
3701   dst = CALL_EXPR_ARG (exp, 0);
3702   src = CALL_EXPR_ARG (exp, 1);
3703
3704   /* If return value is ignored, transform stpcpy into strcpy.  */
3705   if (target == const0_rtx)
3706     {
3707       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3708       if (!fn)
3709         return NULL_RTX;
3710
3711       return expand_expr (build_call_expr (fn, 2, dst, src),
3712                           target, mode, EXPAND_NORMAL);
3713     }
3714   else
3715     {
3716       tree len, lenp1;
3717       rtx ret;
3718
3719       /* Ensure we get an actual string whose length can be evaluated at
3720          compile-time, not an expression containing a string.  This is
3721          because the latter will potentially produce pessimized code
3722          when used to produce the return value.  */
3723       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3724         return expand_movstr (dst, src, target, /*endp=*/2);
3725
3726       lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
3727       ret = expand_builtin_mempcpy_args (dst, src, lenp1, TREE_TYPE (exp),
3728                                          target, mode, /*endp=*/2);
3729
3730       if (ret)
3731         return ret;
3732
3733       if (TREE_CODE (len) == INTEGER_CST)
3734         {
3735           rtx len_rtx = expand_normal (len);
3736
3737           if (GET_CODE (len_rtx) == CONST_INT)
3738             {
3739               ret = expand_builtin_strcpy_args (get_callee_fndecl (exp),
3740                                                 dst, src, target, mode);
3741
3742               if (ret)
3743                 {
3744                   if (! target)
3745                     {
3746                       if (mode != VOIDmode)
3747                         target = gen_reg_rtx (mode);
3748                       else
3749                         target = gen_reg_rtx (GET_MODE (ret));
3750                     }
3751                   if (GET_MODE (target) != GET_MODE (ret))
3752                     ret = gen_lowpart (GET_MODE (target), ret);
3753
3754                   ret = plus_constant (ret, INTVAL (len_rtx));
3755                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3756                   gcc_assert (ret);
3757
3758                   return target;
3759                 }
3760             }
3761         }
3762
3763       return expand_movstr (dst, src, target, /*endp=*/2);
3764     }
3765 }
3766
3767 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3768    bytes from constant string DATA + OFFSET and return it as target
3769    constant.  */
3770
3771 rtx
3772 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3773                           enum machine_mode mode)
3774 {
3775   const char *str = (const char *) data;
3776
3777   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3778     return const0_rtx;
3779
3780   return c_readstr (str + offset, mode);
3781 }
3782
3783 /* Expand expression EXP, which is a call to the strncpy builtin.  Return 
3784    NULL_RTX if we failed the caller should emit a normal call.  */
3785
3786 static rtx
3787 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3788 {
3789   tree fndecl = get_callee_fndecl (exp);
3790
3791   if (validate_arglist (exp,
3792                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3793     {
3794       tree dest = CALL_EXPR_ARG (exp, 0);
3795       tree src = CALL_EXPR_ARG (exp, 1);
3796       tree len = CALL_EXPR_ARG (exp, 2);
3797       tree slen = c_strlen (src, 1);
3798       tree result = fold_builtin_strncpy (fndecl, dest, src, len, slen);
3799
3800       if (result)
3801         {
3802           while (TREE_CODE (result) == COMPOUND_EXPR)
3803             {
3804               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3805                            EXPAND_NORMAL);
3806               result = TREE_OPERAND (result, 1);
3807             }
3808           return expand_expr (result, target, mode, EXPAND_NORMAL);
3809         }
3810
3811       /* We must be passed a constant len and src parameter.  */
3812       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3813         return NULL_RTX;
3814
3815       slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
3816
3817       /* We're required to pad with trailing zeros if the requested
3818          len is greater than strlen(s2)+1.  In that case try to
3819          use store_by_pieces, if it fails, punt.  */
3820       if (tree_int_cst_lt (slen, len))
3821         {
3822           unsigned int dest_align
3823             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3824           const char *p = c_getstr (src);
3825           rtx dest_mem;
3826
3827           if (!p || dest_align == 0 || !host_integerp (len, 1)
3828               || !can_store_by_pieces (tree_low_cst (len, 1),
3829                                        builtin_strncpy_read_str,
3830                                        (void *) p, dest_align, false))
3831             return NULL_RTX;
3832
3833           dest_mem = get_memory_rtx (dest, len);
3834           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3835                            builtin_strncpy_read_str,
3836                            (void *) p, dest_align, false, 0);
3837           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3838           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3839           return dest_mem;
3840         }
3841     }
3842   return NULL_RTX;
3843 }
3844
3845 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3846    bytes from constant string DATA + OFFSET and return it as target
3847    constant.  */
3848
3849 rtx
3850 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3851                          enum machine_mode mode)
3852 {
3853   const char *c = (const char *) data;
3854   char *p = alloca (GET_MODE_SIZE (mode));
3855
3856   memset (p, *c, GET_MODE_SIZE (mode));
3857
3858   return c_readstr (p, mode);
3859 }
3860
3861 /* Callback routine for store_by_pieces.  Return the RTL of a register
3862    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3863    char value given in the RTL register data.  For example, if mode is
3864    4 bytes wide, return the RTL for 0x01010101*data.  */
3865
3866 static rtx
3867 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3868                         enum machine_mode mode)
3869 {
3870   rtx target, coeff;
3871   size_t size;
3872   char *p;
3873
3874   size = GET_MODE_SIZE (mode);
3875   if (size == 1)
3876     return (rtx) data;
3877
3878   p = alloca (size);
3879   memset (p, 1, size);
3880   coeff = c_readstr (p, mode);
3881
3882   target = convert_to_mode (mode, (rtx) data, 1);
3883   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3884   return force_reg (mode, target);
3885 }
3886
3887 /* Expand expression EXP, which is a call to the memset builtin.  Return 
3888    NULL_RTX if we failed the caller should emit a normal call, otherwise 
3889    try to get the result in TARGET, if convenient (and in mode MODE if that's
3890    convenient).  */
3891
3892 static rtx
3893 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3894 {
3895   if (!validate_arglist (exp,
3896                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3897     return NULL_RTX;
3898   else
3899     {
3900       tree dest = CALL_EXPR_ARG (exp, 0);
3901       tree val = CALL_EXPR_ARG (exp, 1);
3902       tree len = CALL_EXPR_ARG (exp, 2);
3903       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3904     }
3905 }
3906
3907 /* Helper function to do the actual work for expand_builtin_memset.  The
3908    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3909    so that this can also be called without constructing an actual CALL_EXPR.
3910    The other arguments and return value are the same as for
3911    expand_builtin_memset.  */
3912
3913 static rtx
3914 expand_builtin_memset_args (tree dest, tree val, tree len,
3915                             rtx target, enum machine_mode mode, tree orig_exp)
3916 {
3917   tree fndecl, fn;
3918   enum built_in_function fcode;
3919   char c;
3920   unsigned int dest_align;
3921   rtx dest_mem, dest_addr, len_rtx;
3922   HOST_WIDE_INT expected_size = -1;
3923   unsigned int expected_align = 0;
3924
3925   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3926
3927   /* If DEST is not a pointer type, don't do this operation in-line.  */
3928   if (dest_align == 0)
3929     return NULL_RTX;
3930
3931   stringop_block_profile (orig_exp, &expected_align, &expected_size);
3932   if (expected_align < dest_align)
3933     expected_align = dest_align;
3934
3935   /* If the LEN parameter is zero, return DEST.  */
3936   if (integer_zerop (len))
3937     {
3938       /* Evaluate and ignore VAL in case it has side-effects.  */
3939       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3940       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3941     }
3942
3943   /* Stabilize the arguments in case we fail.  */
3944   dest = builtin_save_expr (dest);
3945   val = builtin_save_expr (val);
3946   len = builtin_save_expr (len);
3947
3948   len_rtx = expand_normal (len);
3949   dest_mem = get_memory_rtx (dest, len);
3950
3951   if (TREE_CODE (val) != INTEGER_CST)
3952     {
3953       rtx val_rtx;
3954
3955       val_rtx = expand_normal (val);
3956       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3957                                  val_rtx, 0);
3958
3959       /* Assume that we can memset by pieces if we can store
3960        * the coefficients by pieces (in the required modes).
3961        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3962       c = 1;
3963       if (host_integerp (len, 1)
3964           && can_store_by_pieces (tree_low_cst (len, 1),
3965                                   builtin_memset_read_str, &c, dest_align,
3966                                   true))
3967         {
3968           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3969                                val_rtx);
3970           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3971                            builtin_memset_gen_str, val_rtx, dest_align,
3972                            true, 0);
3973         }
3974       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3975                                         dest_align, expected_align,
3976                                         expected_size))
3977         goto do_libcall;
3978       
3979       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3980       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3981       return dest_mem;
3982     }
3983
3984   if (target_char_cast (val, &c))
3985     goto do_libcall;
3986
3987   if (c)
3988     {
3989       if (host_integerp (len, 1)
3990           && can_store_by_pieces (tree_low_cst (len, 1),
3991                                   builtin_memset_read_str, &c, dest_align,
3992                                   true))
3993         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3994                          builtin_memset_read_str, &c, dest_align, true, 0);
3995       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3996                                         dest_align, expected_align,
3997                                         expected_size))
3998         goto do_libcall;
3999       
4000       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4001       dest_mem = convert_memory_address (ptr_mode, dest_mem);
4002       return dest_mem;
4003     }
4004
4005   set_mem_align (dest_mem, dest_align);
4006   dest_addr = clear_storage_hints (dest_mem, len_rtx,
4007                                    CALL_EXPR_TAILCALL (orig_exp)
4008                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
4009                                    expected_align, expected_size);
4010
4011   if (dest_addr == 0)
4012     {
4013       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4014       dest_addr = convert_memory_address (ptr_mode, dest_addr);
4015     }
4016
4017   return dest_addr;
4018
4019  do_libcall:
4020   fndecl = get_callee_fndecl (orig_exp);
4021   fcode = DECL_FUNCTION_CODE (fndecl);
4022   if (fcode == BUILT_IN_MEMSET)
4023     fn = build_call_expr (fndecl, 3, dest, val, len);
4024   else if (fcode == BUILT_IN_BZERO)
4025     fn = build_call_expr (fndecl, 2, dest, len);
4026   else
4027     gcc_unreachable ();
4028   if (TREE_CODE (fn) == CALL_EXPR)
4029     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4030   return expand_call (fn, target, target == const0_rtx);
4031 }
4032
4033 /* Expand expression EXP, which is a call to the bzero builtin.  Return 
4034    NULL_RTX if we failed the caller should emit a normal call.  */
4035
4036 static rtx
4037 expand_builtin_bzero (tree exp)
4038 {
4039   tree dest, size;
4040
4041   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4042     return NULL_RTX;
4043
4044   dest = CALL_EXPR_ARG (exp, 0);
4045   size = CALL_EXPR_ARG (exp, 1);
4046
4047   /* New argument list transforming bzero(ptr x, int y) to
4048      memset(ptr x, int 0, size_t y).   This is done this way
4049      so that if it isn't expanded inline, we fallback to
4050      calling bzero instead of memset.  */
4051
4052   return expand_builtin_memset_args (dest, integer_zero_node,
4053                                      fold_convert (sizetype, size),
4054                                      const0_rtx, VOIDmode, exp);
4055 }
4056
4057 /* Expand a call to the memchr builtin.  Return NULL_RTX if we failed the
4058    caller should emit a normal call, otherwise try to get the result
4059    in TARGET, if convenient (and in mode MODE if that's convenient).  */
4060
4061 static rtx
4062 expand_builtin_memchr (tree exp, rtx target, enum machine_mode mode)
4063 {
4064   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE,
4065                         INTEGER_TYPE, VOID_TYPE))
4066     {
4067       tree type = TREE_TYPE (exp);
4068       tree result = fold_builtin_memchr (CALL_EXPR_ARG (exp, 0),
4069                                          CALL_EXPR_ARG (exp, 1),
4070                                          CALL_EXPR_ARG (exp, 2), type);
4071       if (result)
4072         return expand_expr (result, target, mode, EXPAND_NORMAL);
4073     }
4074   return NULL_RTX;
4075 }
4076
4077 /* Expand expression EXP, which is a call to the memcmp built-in function.
4078    Return NULL_RTX if we failed and the
4079    caller should emit a normal call, otherwise try to get the result in
4080    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4081
4082 static rtx
4083 expand_builtin_memcmp (tree exp, rtx target, enum machine_mode mode)
4084 {
4085   if (!validate_arglist (exp,
4086                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4087     return NULL_RTX;
4088   else
4089     {
4090       tree result = fold_builtin_memcmp (CALL_EXPR_ARG (exp, 0),
4091                                          CALL_EXPR_ARG (exp, 1),
4092                                          CALL_EXPR_ARG (exp, 2));
4093       if (result)
4094         return expand_expr (result, target, mode, EXPAND_NORMAL);
4095     }
4096
4097 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4098   {
4099     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4100     rtx result;
4101     rtx insn;
4102     tree arg1 = CALL_EXPR_ARG (exp, 0);
4103     tree arg2 = CALL_EXPR_ARG (exp, 1);
4104     tree len = CALL_EXPR_ARG (exp, 2);
4105
4106     int arg1_align
4107       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4108     int arg2_align
4109       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4110     enum machine_mode insn_mode;
4111
4112 #ifdef HAVE_cmpmemsi
4113     if (HAVE_cmpmemsi)
4114       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4115     else
4116 #endif
4117 #ifdef HAVE_cmpstrnsi
4118     if (HAVE_cmpstrnsi)
4119       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4120     else
4121 #endif
4122       return NULL_RTX;
4123
4124     /* If we don't have POINTER_TYPE, call the function.  */
4125     if (arg1_align == 0 || arg2_align == 0)
4126       return NULL_RTX;
4127
4128     /* Make a place to write the result of the instruction.  */
4129     result = target;
4130     if (! (result != 0
4131            && REG_P (result) && GET_MODE (result) == insn_mode
4132            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4133       result = gen_reg_rtx (insn_mode);
4134
4135     arg1_rtx = get_memory_rtx (arg1, len);
4136     arg2_rtx = get_memory_rtx (arg2, len);
4137     arg3_rtx = expand_normal (len);
4138
4139     /* Set MEM_SIZE as appropriate.  */
4140     if (GET_CODE (arg3_rtx) == CONST_INT)
4141       {
4142         set_mem_size (arg1_rtx, arg3_rtx);
4143         set_mem_size (arg2_rtx, arg3_rtx);
4144       }
4145
4146 #ifdef HAVE_cmpmemsi
4147     if (HAVE_cmpmemsi)
4148       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4149                            GEN_INT (MIN (arg1_align, arg2_align)));
4150     else
4151 #endif