OSDN Git Service

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