OSDN Git Service

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