OSDN Git Service

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