OSDN Git Service

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