OSDN Git Service

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