OSDN Git Service

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