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 2012 Free Software Foundation, Inc.
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
33 #include "hard-reg-set.h"
36 #include "insn-config.h"
42 #include "typeclass.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"
55 #ifndef PAD_VARARGS_DOWN
56 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
58 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
60 struct target_builtins default_target_builtins;
62 struct target_builtins *this_target_builtins = &default_target_builtins;
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"};
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] =
72 #include "builtins.def"
76 /* Setup an array of _DECL trees, make sure each element is
77 initialized to NULL_TREE. */
78 builtin_info_type builtin_info;
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);
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,
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);
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);
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);
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);
228 /* Return true if NAME starts with __builtin_ or __sync_. */
231 is_builtin_name (const char *name)
233 if (strncmp (name, "__builtin_", 10) == 0)
235 if (strncmp (name, "__sync_", 7) == 0)
237 if (strncmp (name, "__atomic_", 9) == 0)
243 /* Return true if DECL is a function symbol representing a built-in. */
246 is_builtin_fn (tree decl)
248 return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
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". */
257 called_as_built_in (tree node)
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
262 const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
263 return is_builtin_name (name);
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.
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. */
277 get_object_alignment_1 (tree exp, unsigned HOST_WIDE_INT *bitposp)
279 HOST_WIDE_INT bitsize, bitpos;
281 enum machine_mode mode;
282 int unsignedp, volatilep;
283 unsigned int align, inner;
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);
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);
295 && TREE_CODE (exp) != LABEL_DECL)
297 if (TREE_CODE (exp) == FUNCTION_DECL)
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;
306 align = BITS_PER_UNIT;
309 align = DECL_ALIGN (exp);
311 else if (CONSTANT_CLASS_P (exp))
313 align = TYPE_ALIGN (TREE_TYPE (exp));
314 #ifdef CONSTANT_ALIGNMENT
315 align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
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)
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)
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);
335 align = BITS_PER_UNIT;
336 if (TREE_CODE (addr) == SSA_NAME
337 && (pi = SSA_NAME_PTR_INFO (addr)))
339 bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
340 align = MAX (pi->align * BITS_PER_UNIT, align);
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;
346 else if (TREE_CODE (exp) == TARGET_MEM_REF)
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)
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);
359 align = BITS_PER_UNIT;
360 if (TREE_CODE (addr) == SSA_NAME
361 && (pi = SSA_NAME_PTR_INFO (addr)))
363 bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
364 align = MAX (pi->align * BITS_PER_UNIT, align);
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))
372 unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
373 align = MIN (align, (step & -step) * BITS_PER_UNIT);
375 else if (TMR_INDEX (exp))
376 align = BITS_PER_UNIT;
377 if (TMR_INDEX2 (exp))
378 align = BITS_PER_UNIT;
381 align = BITS_PER_UNIT;
383 /* If there is a non-constant offset part extract the maximum
384 alignment that can prevail. */
390 if (TREE_CODE (offset) == PLUS_EXPR)
392 next_offset = TREE_OPERAND (offset, 0);
393 offset = TREE_OPERAND (offset, 1);
397 if (host_integerp (offset, 1))
399 /* Any overflow in calculating offset_bits won't change
402 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
405 inner = MIN (inner, (offset_bits & -offset_bits));
407 else if (TREE_CODE (offset) == MULT_EXPR
408 && host_integerp (TREE_OPERAND (offset, 1), 1))
410 /* Any overflow in calculating offset_factor won't change
412 unsigned offset_factor
413 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
417 inner = MIN (inner, (offset_factor & -offset_factor));
421 inner = MIN (inner, BITS_PER_UNIT);
424 offset = next_offset;
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);
436 /* Return the alignment in bits of EXP, an object. */
439 get_object_alignment (tree exp)
441 unsigned HOST_WIDE_INT bitpos = 0;
444 align = get_object_alignment_1 (exp, &bitpos);
446 /* align and bitpos now specify known low bits of the pointer.
447 ptr & (align - 1) == bitpos. */
450 align = (bitpos & -bitpos);
455 /* Return the alignment of object EXP, also considering its type when we do
456 not know of explicit misalignment. Only handle MEM_REF and TARGET_MEM_REF.
458 ??? Note that, in the general case, the type of an expression is not kept
459 consistent with misalignment information by the front-end, for example when
460 taking the address of a member of a packed structure. However, in most of
461 the cases, expressions have the alignment of their type so we optimistically
462 fall back to this alignment when we cannot compute a misalignment. */
465 get_object_or_type_alignment (tree exp)
467 unsigned HOST_WIDE_INT misalign;
468 unsigned int align = get_object_alignment_1 (exp, &misalign);
470 gcc_assert (TREE_CODE (exp) == MEM_REF || TREE_CODE (exp) == TARGET_MEM_REF);
473 align = (misalign & -misalign);
475 align = MAX (TYPE_ALIGN (TREE_TYPE (exp)), align);
480 /* For a pointer valued expression EXP compute values M and N such that
481 M divides (EXP - N) and such that N < M. Store N in *BITPOSP and return M.
483 If EXP is not a pointer, 0 is returned. */
486 get_pointer_alignment_1 (tree exp, unsigned HOST_WIDE_INT *bitposp)
490 if (TREE_CODE (exp) == ADDR_EXPR)
491 return get_object_alignment_1 (TREE_OPERAND (exp, 0), bitposp);
492 else if (TREE_CODE (exp) == SSA_NAME
493 && POINTER_TYPE_P (TREE_TYPE (exp)))
495 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
499 return BITS_PER_UNIT;
501 *bitposp = pi->misalign * BITS_PER_UNIT;
502 return pi->align * BITS_PER_UNIT;
506 return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
509 /* Return the alignment in bits of EXP, a pointer valued expression.
510 The alignment returned is, by default, the alignment of the thing that
511 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
513 Otherwise, look at the expression to see if we can do better, i.e., if the
514 expression is actually pointing at an object whose alignment is tighter. */
517 get_pointer_alignment (tree exp)
519 unsigned HOST_WIDE_INT bitpos = 0;
522 align = get_pointer_alignment_1 (exp, &bitpos);
524 /* align and bitpos now specify known low bits of the pointer.
525 ptr & (align - 1) == bitpos. */
528 align = (bitpos & -bitpos);
533 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
534 way, because it could contain a zero byte in the middle.
535 TREE_STRING_LENGTH is the size of the character array, not the string.
537 ONLY_VALUE should be nonzero if the result is not going to be emitted
538 into the instruction stream and zero if it is going to be expanded.
539 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
540 is returned, otherwise NULL, since
541 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
542 evaluate the side-effects.
544 The value returned is of type `ssizetype'.
546 Unfortunately, string_constant can't access the values of const char
547 arrays with initializers, so neither can we do so here. */
550 c_strlen (tree src, int only_value)
553 HOST_WIDE_INT offset;
559 if (TREE_CODE (src) == COND_EXPR
560 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
564 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
565 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
566 if (tree_int_cst_equal (len1, len2))
570 if (TREE_CODE (src) == COMPOUND_EXPR
571 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
572 return c_strlen (TREE_OPERAND (src, 1), only_value);
574 loc = EXPR_LOC_OR_HERE (src);
576 src = string_constant (src, &offset_node);
580 max = TREE_STRING_LENGTH (src) - 1;
581 ptr = TREE_STRING_POINTER (src);
583 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
585 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
586 compute the offset to the following null if we don't know where to
587 start searching for it. */
590 for (i = 0; i < max; i++)
594 /* We don't know the starting offset, but we do know that the string
595 has no internal zero bytes. We can assume that the offset falls
596 within the bounds of the string; otherwise, the programmer deserves
597 what he gets. Subtract the offset from the length of the string,
598 and return that. This would perhaps not be valid if we were dealing
599 with named arrays in addition to literal string constants. */
601 return size_diffop_loc (loc, size_int (max), offset_node);
604 /* We have a known offset into the string. Start searching there for
605 a null character if we can represent it as a single HOST_WIDE_INT. */
606 if (offset_node == 0)
608 else if (! host_integerp (offset_node, 0))
611 offset = tree_low_cst (offset_node, 0);
613 /* If the offset is known to be out of bounds, warn, and call strlen at
615 if (offset < 0 || offset > max)
617 /* Suppress multiple warnings for propagated constant strings. */
618 if (! TREE_NO_WARNING (src))
620 warning_at (loc, 0, "offset outside bounds of constant string");
621 TREE_NO_WARNING (src) = 1;
626 /* Use strlen to search for the first zero byte. Since any strings
627 constructed with build_string will have nulls appended, we win even
628 if we get handed something like (char[4])"abcd".
630 Since OFFSET is our starting index into the string, no further
631 calculation is needed. */
632 return ssize_int (strlen (ptr + offset));
635 /* Return a char pointer for a C string if it is a string constant
636 or sum of string constant and integer constant. */
643 src = string_constant (src, &offset_node);
647 if (offset_node == 0)
648 return TREE_STRING_POINTER (src);
649 else if (!host_integerp (offset_node, 1)
650 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
653 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
656 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
657 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
660 c_readstr (const char *str, enum machine_mode mode)
666 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
671 for (i = 0; i < GET_MODE_SIZE (mode); i++)
674 if (WORDS_BIG_ENDIAN)
675 j = GET_MODE_SIZE (mode) - i - 1;
676 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
677 && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
678 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
680 gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
683 ch = (unsigned char) str[i];
684 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
686 return immed_double_const (c[0], c[1], mode);
689 /* Cast a target constant CST to target CHAR and if that value fits into
690 host char type, return zero and put that value into variable pointed to by
694 target_char_cast (tree cst, char *p)
696 unsigned HOST_WIDE_INT val, hostval;
698 if (TREE_CODE (cst) != INTEGER_CST
699 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
702 val = TREE_INT_CST_LOW (cst);
703 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
704 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
707 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
708 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
717 /* Similar to save_expr, but assumes that arbitrary code is not executed
718 in between the multiple evaluations. In particular, we assume that a
719 non-addressable local variable will not be modified. */
722 builtin_save_expr (tree exp)
724 if (TREE_CODE (exp) == SSA_NAME
725 || (TREE_ADDRESSABLE (exp) == 0
726 && (TREE_CODE (exp) == PARM_DECL
727 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
730 return save_expr (exp);
733 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
734 times to get the address of either a higher stack frame, or a return
735 address located within it (depending on FNDECL_CODE). */
738 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
742 #ifdef INITIAL_FRAME_ADDRESS_RTX
743 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
747 /* For a zero count with __builtin_return_address, we don't care what
748 frame address we return, because target-specific definitions will
749 override us. Therefore frame pointer elimination is OK, and using
750 the soft frame pointer is OK.
752 For a nonzero count, or a zero count with __builtin_frame_address,
753 we require a stable offset from the current frame pointer to the
754 previous one, so we must use the hard frame pointer, and
755 we must disable frame pointer elimination. */
756 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
757 tem = frame_pointer_rtx;
760 tem = hard_frame_pointer_rtx;
762 /* Tell reload not to eliminate the frame pointer. */
763 crtl->accesses_prior_frames = 1;
767 /* Some machines need special handling before we can access
768 arbitrary frames. For example, on the SPARC, we must first flush
769 all register windows to the stack. */
770 #ifdef SETUP_FRAME_ADDRESSES
772 SETUP_FRAME_ADDRESSES ();
775 /* On the SPARC, the return address is not in the frame, it is in a
776 register. There is no way to access it off of the current frame
777 pointer, but it can be accessed off the previous frame pointer by
778 reading the value from the register window save area. */
779 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
780 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
784 /* Scan back COUNT frames to the specified frame. */
785 for (i = 0; i < count; i++)
787 /* Assume the dynamic chain pointer is in the word that the
788 frame address points to, unless otherwise specified. */
789 #ifdef DYNAMIC_CHAIN_ADDRESS
790 tem = DYNAMIC_CHAIN_ADDRESS (tem);
792 tem = memory_address (Pmode, tem);
793 tem = gen_frame_mem (Pmode, tem);
794 tem = copy_to_reg (tem);
797 /* For __builtin_frame_address, return what we've got. But, on
798 the SPARC for example, we may have to add a bias. */
799 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
800 #ifdef FRAME_ADDR_RTX
801 return FRAME_ADDR_RTX (tem);
806 /* For __builtin_return_address, get the return address from that frame. */
807 #ifdef RETURN_ADDR_RTX
808 tem = RETURN_ADDR_RTX (count, tem);
810 tem = memory_address (Pmode,
811 plus_constant (tem, GET_MODE_SIZE (Pmode)));
812 tem = gen_frame_mem (Pmode, tem);
817 /* Alias set used for setjmp buffer. */
818 static alias_set_type setjmp_alias_set = -1;
820 /* Construct the leading half of a __builtin_setjmp call. Control will
821 return to RECEIVER_LABEL. This is also called directly by the SJLJ
822 exception handling code. */
825 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
827 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
831 if (setjmp_alias_set == -1)
832 setjmp_alias_set = new_alias_set ();
834 buf_addr = convert_memory_address (Pmode, buf_addr);
836 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
838 /* We store the frame pointer and the address of receiver_label in
839 the buffer and use the rest of it for the stack save area, which
840 is machine-dependent. */
842 mem = gen_rtx_MEM (Pmode, buf_addr);
843 set_mem_alias_set (mem, setjmp_alias_set);
844 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
846 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
847 set_mem_alias_set (mem, setjmp_alias_set);
849 emit_move_insn (validize_mem (mem),
850 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
852 stack_save = gen_rtx_MEM (sa_mode,
853 plus_constant (buf_addr,
854 2 * GET_MODE_SIZE (Pmode)));
855 set_mem_alias_set (stack_save, setjmp_alias_set);
856 emit_stack_save (SAVE_NONLOCAL, &stack_save);
858 /* If there is further processing to do, do it. */
859 #ifdef HAVE_builtin_setjmp_setup
860 if (HAVE_builtin_setjmp_setup)
861 emit_insn (gen_builtin_setjmp_setup (buf_addr));
864 /* We have a nonlocal label. */
865 cfun->has_nonlocal_label = 1;
868 /* Construct the trailing part of a __builtin_setjmp call. This is
869 also called directly by the SJLJ exception handling code. */
872 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
876 /* Clobber the FP when we get here, so we have to make sure it's
877 marked as used by this function. */
878 emit_use (hard_frame_pointer_rtx);
880 /* Mark the static chain as clobbered here so life information
881 doesn't get messed up for it. */
882 chain = targetm.calls.static_chain (current_function_decl, true);
883 if (chain && REG_P (chain))
884 emit_clobber (chain);
886 /* Now put in the code to restore the frame pointer, and argument
887 pointer, if needed. */
888 #ifdef HAVE_nonlocal_goto
889 if (! HAVE_nonlocal_goto)
892 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
893 /* This might change the hard frame pointer in ways that aren't
894 apparent to early optimization passes, so force a clobber. */
895 emit_clobber (hard_frame_pointer_rtx);
898 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
899 if (fixed_regs[ARG_POINTER_REGNUM])
901 #ifdef ELIMINABLE_REGS
903 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
905 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
906 if (elim_regs[i].from == ARG_POINTER_REGNUM
907 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
910 if (i == ARRAY_SIZE (elim_regs))
913 /* Now restore our arg pointer from the address at which it
914 was saved in our stack frame. */
915 emit_move_insn (crtl->args.internal_arg_pointer,
916 copy_to_reg (get_arg_pointer_save_area ()));
921 #ifdef HAVE_builtin_setjmp_receiver
922 if (HAVE_builtin_setjmp_receiver)
923 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
926 #ifdef HAVE_nonlocal_goto_receiver
927 if (HAVE_nonlocal_goto_receiver)
928 emit_insn (gen_nonlocal_goto_receiver ());
933 /* We must not allow the code we just generated to be reordered by
934 scheduling. Specifically, the update of the frame pointer must
935 happen immediately, not later. */
936 emit_insn (gen_blockage ());
939 /* __builtin_longjmp is passed a pointer to an array of five words (not
940 all will be used on all machines). It operates similarly to the C
941 library function of the same name, but is more efficient. Much of
942 the code below is copied from the handling of non-local gotos. */
945 expand_builtin_longjmp (rtx buf_addr, rtx value)
947 rtx fp, lab, stack, insn, last;
948 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
950 /* DRAP is needed for stack realign if longjmp is expanded to current
952 if (SUPPORTS_STACK_ALIGNMENT)
953 crtl->need_drap = true;
955 if (setjmp_alias_set == -1)
956 setjmp_alias_set = new_alias_set ();
958 buf_addr = convert_memory_address (Pmode, buf_addr);
960 buf_addr = force_reg (Pmode, buf_addr);
962 /* We require that the user must pass a second argument of 1, because
963 that is what builtin_setjmp will return. */
964 gcc_assert (value == const1_rtx);
966 last = get_last_insn ();
967 #ifdef HAVE_builtin_longjmp
968 if (HAVE_builtin_longjmp)
969 emit_insn (gen_builtin_longjmp (buf_addr));
973 fp = gen_rtx_MEM (Pmode, buf_addr);
974 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
975 GET_MODE_SIZE (Pmode)));
977 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
978 2 * GET_MODE_SIZE (Pmode)));
979 set_mem_alias_set (fp, setjmp_alias_set);
980 set_mem_alias_set (lab, setjmp_alias_set);
981 set_mem_alias_set (stack, setjmp_alias_set);
983 /* Pick up FP, label, and SP from the block and jump. This code is
984 from expand_goto in stmt.c; see there for detailed comments. */
985 #ifdef HAVE_nonlocal_goto
986 if (HAVE_nonlocal_goto)
987 /* We have to pass a value to the nonlocal_goto pattern that will
988 get copied into the static_chain pointer, but it does not matter
989 what that value is, because builtin_setjmp does not use it. */
990 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
994 lab = copy_to_reg (lab);
996 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
997 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
999 emit_move_insn (hard_frame_pointer_rtx, fp);
1000 emit_stack_restore (SAVE_NONLOCAL, stack);
1002 emit_use (hard_frame_pointer_rtx);
1003 emit_use (stack_pointer_rtx);
1004 emit_indirect_jump (lab);
1008 /* Search backwards and mark the jump insn as a non-local goto.
1009 Note that this precludes the use of __builtin_longjmp to a
1010 __builtin_setjmp target in the same function. However, we've
1011 already cautioned the user that these functions are for
1012 internal exception handling use only. */
1013 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1015 gcc_assert (insn != last);
1019 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1022 else if (CALL_P (insn))
1027 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1028 and the address of the save area. */
1031 expand_builtin_nonlocal_goto (tree exp)
1033 tree t_label, t_save_area;
1034 rtx r_label, r_save_area, r_fp, r_sp, insn;
1036 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1039 t_label = CALL_EXPR_ARG (exp, 0);
1040 t_save_area = CALL_EXPR_ARG (exp, 1);
1042 r_label = expand_normal (t_label);
1043 r_label = convert_memory_address (Pmode, r_label);
1044 r_save_area = expand_normal (t_save_area);
1045 r_save_area = convert_memory_address (Pmode, r_save_area);
1046 /* Copy the address of the save location to a register just in case it was
1047 based on the frame pointer. */
1048 r_save_area = copy_to_reg (r_save_area);
1049 r_fp = gen_rtx_MEM (Pmode, r_save_area);
1050 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
1051 plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
1053 crtl->has_nonlocal_goto = 1;
1055 #ifdef HAVE_nonlocal_goto
1056 /* ??? We no longer need to pass the static chain value, afaik. */
1057 if (HAVE_nonlocal_goto)
1058 emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1062 r_label = copy_to_reg (r_label);
1064 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1065 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1067 /* Restore frame pointer for containing function. */
1068 emit_move_insn (hard_frame_pointer_rtx, r_fp);
1069 emit_stack_restore (SAVE_NONLOCAL, r_sp);
1071 /* USE of hard_frame_pointer_rtx added for consistency;
1072 not clear if really needed. */
1073 emit_use (hard_frame_pointer_rtx);
1074 emit_use (stack_pointer_rtx);
1076 /* If the architecture is using a GP register, we must
1077 conservatively assume that the target function makes use of it.
1078 The prologue of functions with nonlocal gotos must therefore
1079 initialize the GP register to the appropriate value, and we
1080 must then make sure that this value is live at the point
1081 of the jump. (Note that this doesn't necessarily apply
1082 to targets with a nonlocal_goto pattern; they are free
1083 to implement it in their own way. Note also that this is
1084 a no-op if the GP register is a global invariant.) */
1085 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1086 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1087 emit_use (pic_offset_table_rtx);
1089 emit_indirect_jump (r_label);
1092 /* Search backwards to the jump insn and mark it as a
1094 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1098 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1101 else if (CALL_P (insn))
1108 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1109 (not all will be used on all machines) that was passed to __builtin_setjmp.
1110 It updates the stack pointer in that block to correspond to the current
1114 expand_builtin_update_setjmp_buf (rtx buf_addr)
1116 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1118 = gen_rtx_MEM (sa_mode,
1121 plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1123 emit_stack_save (SAVE_NONLOCAL, &stack_save);
1126 /* Expand a call to __builtin_prefetch. For a target that does not support
1127 data prefetch, evaluate the memory address argument in case it has side
1131 expand_builtin_prefetch (tree exp)
1133 tree arg0, arg1, arg2;
1137 if (!validate_arglist (exp, POINTER_TYPE, 0))
1140 arg0 = CALL_EXPR_ARG (exp, 0);
1142 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1143 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1145 nargs = call_expr_nargs (exp);
1147 arg1 = CALL_EXPR_ARG (exp, 1);
1149 arg1 = integer_zero_node;
1151 arg2 = CALL_EXPR_ARG (exp, 2);
1153 arg2 = integer_three_node;
1155 /* Argument 0 is an address. */
1156 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1158 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1159 if (TREE_CODE (arg1) != INTEGER_CST)
1161 error ("second argument to %<__builtin_prefetch%> must be a constant");
1162 arg1 = integer_zero_node;
1164 op1 = expand_normal (arg1);
1165 /* Argument 1 must be either zero or one. */
1166 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1168 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1173 /* Argument 2 (locality) must be a compile-time constant int. */
1174 if (TREE_CODE (arg2) != INTEGER_CST)
1176 error ("third argument to %<__builtin_prefetch%> must be a constant");
1177 arg2 = integer_zero_node;
1179 op2 = expand_normal (arg2);
1180 /* Argument 2 must be 0, 1, 2, or 3. */
1181 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1183 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1187 #ifdef HAVE_prefetch
1190 struct expand_operand ops[3];
1192 create_address_operand (&ops[0], op0);
1193 create_integer_operand (&ops[1], INTVAL (op1));
1194 create_integer_operand (&ops[2], INTVAL (op2));
1195 if (maybe_expand_insn (CODE_FOR_prefetch, 3, ops))
1200 /* Don't do anything with direct references to volatile memory, but
1201 generate code to handle other side effects. */
1202 if (!MEM_P (op0) && side_effects_p (op0))
1206 /* Get a MEM rtx for expression EXP which is the address of an operand
1207 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1208 the maximum length of the block of memory that might be accessed or
1212 get_memory_rtx (tree exp, tree len)
1214 tree orig_exp = exp;
1218 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1219 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1220 if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1221 exp = TREE_OPERAND (exp, 0);
1223 addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1224 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1226 /* Get an expression we can use to find the attributes to assign to MEM.
1227 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1228 we can. First remove any nops. */
1229 while (CONVERT_EXPR_P (exp)
1230 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1231 exp = TREE_OPERAND (exp, 0);
1234 if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1235 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1236 && host_integerp (TREE_OPERAND (exp, 1), 0)
1237 && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1238 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1239 else if (TREE_CODE (exp) == ADDR_EXPR)
1240 exp = TREE_OPERAND (exp, 0);
1241 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1242 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1246 /* Honor attributes derived from exp, except for the alias set
1247 (as builtin stringops may alias with anything) and the size
1248 (as stringops may access multiple array elements). */
1251 set_mem_attributes (mem, exp, 0);
1254 mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1256 /* Allow the string and memory builtins to overflow from one
1257 field into another, see http://gcc.gnu.org/PR23561.
1258 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1259 memory accessed by the string or memory builtin will fit
1260 within the field. */
1261 if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1263 tree mem_expr = MEM_EXPR (mem);
1264 HOST_WIDE_INT offset = -1, length = -1;
1267 while (TREE_CODE (inner) == ARRAY_REF
1268 || CONVERT_EXPR_P (inner)
1269 || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1270 || TREE_CODE (inner) == SAVE_EXPR)
1271 inner = TREE_OPERAND (inner, 0);
1273 gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1275 if (MEM_OFFSET_KNOWN_P (mem))
1276 offset = MEM_OFFSET (mem);
1278 if (offset >= 0 && len && host_integerp (len, 0))
1279 length = tree_low_cst (len, 0);
1281 while (TREE_CODE (inner) == COMPONENT_REF)
1283 tree field = TREE_OPERAND (inner, 1);
1284 gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1285 gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1287 /* Bitfields are generally not byte-addressable. */
1288 gcc_assert (!DECL_BIT_FIELD (field)
1289 || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1290 % BITS_PER_UNIT) == 0
1291 && host_integerp (DECL_SIZE (field), 0)
1292 && (TREE_INT_CST_LOW (DECL_SIZE (field))
1293 % BITS_PER_UNIT) == 0));
1295 /* If we can prove that the memory starting at XEXP (mem, 0) and
1296 ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1297 can keep the COMPONENT_REF in MEM_EXPR. But be careful with
1298 fields without DECL_SIZE_UNIT like flexible array members. */
1300 && DECL_SIZE_UNIT (field)
1301 && host_integerp (DECL_SIZE_UNIT (field), 0))
1304 = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1307 && offset + length <= size)
1312 && host_integerp (DECL_FIELD_OFFSET (field), 0))
1313 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1314 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1322 mem_expr = TREE_OPERAND (mem_expr, 0);
1323 inner = TREE_OPERAND (inner, 0);
1326 if (mem_expr == NULL)
1328 if (mem_expr != MEM_EXPR (mem))
1330 set_mem_expr (mem, mem_expr);
1332 set_mem_offset (mem, offset);
1334 clear_mem_offset (mem);
1337 set_mem_alias_set (mem, 0);
1338 clear_mem_size (mem);
1344 /* Built-in functions to perform an untyped call and return. */
1346 #define apply_args_mode \
1347 (this_target_builtins->x_apply_args_mode)
1348 #define apply_result_mode \
1349 (this_target_builtins->x_apply_result_mode)
1351 /* Return the size required for the block returned by __builtin_apply_args,
1352 and initialize apply_args_mode. */
1355 apply_args_size (void)
1357 static int size = -1;
1360 enum machine_mode mode;
1362 /* The values computed by this function never change. */
1365 /* The first value is the incoming arg-pointer. */
1366 size = GET_MODE_SIZE (Pmode);
1368 /* The second value is the structure value address unless this is
1369 passed as an "invisible" first argument. */
1370 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1371 size += GET_MODE_SIZE (Pmode);
1373 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1374 if (FUNCTION_ARG_REGNO_P (regno))
1376 mode = targetm.calls.get_raw_arg_mode (regno);
1378 gcc_assert (mode != VOIDmode);
1380 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1381 if (size % align != 0)
1382 size = CEIL (size, align) * align;
1383 size += GET_MODE_SIZE (mode);
1384 apply_args_mode[regno] = mode;
1388 apply_args_mode[regno] = VOIDmode;
1394 /* Return the size required for the block returned by __builtin_apply,
1395 and initialize apply_result_mode. */
1398 apply_result_size (void)
1400 static int size = -1;
1402 enum machine_mode mode;
1404 /* The values computed by this function never change. */
1409 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1410 if (targetm.calls.function_value_regno_p (regno))
1412 mode = targetm.calls.get_raw_result_mode (regno);
1414 gcc_assert (mode != VOIDmode);
1416 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1417 if (size % align != 0)
1418 size = CEIL (size, align) * align;
1419 size += GET_MODE_SIZE (mode);
1420 apply_result_mode[regno] = mode;
1423 apply_result_mode[regno] = VOIDmode;
1425 /* Allow targets that use untyped_call and untyped_return to override
1426 the size so that machine-specific information can be stored here. */
1427 #ifdef APPLY_RESULT_SIZE
1428 size = APPLY_RESULT_SIZE;
1434 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1435 /* Create a vector describing the result block RESULT. If SAVEP is true,
1436 the result block is used to save the values; otherwise it is used to
1437 restore the values. */
1440 result_vector (int savep, rtx result)
1442 int regno, size, align, nelts;
1443 enum machine_mode mode;
1445 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1448 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1449 if ((mode = apply_result_mode[regno]) != VOIDmode)
1451 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1452 if (size % align != 0)
1453 size = CEIL (size, align) * align;
1454 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1455 mem = adjust_address (result, mode, size);
1456 savevec[nelts++] = (savep
1457 ? gen_rtx_SET (VOIDmode, mem, reg)
1458 : gen_rtx_SET (VOIDmode, reg, mem));
1459 size += GET_MODE_SIZE (mode);
1461 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1463 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1465 /* Save the state required to perform an untyped call with the same
1466 arguments as were passed to the current function. */
1469 expand_builtin_apply_args_1 (void)
1472 int size, align, regno;
1473 enum machine_mode mode;
1474 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1476 /* Create a block where the arg-pointer, structure value address,
1477 and argument registers can be saved. */
1478 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1480 /* Walk past the arg-pointer and structure value address. */
1481 size = GET_MODE_SIZE (Pmode);
1482 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1483 size += GET_MODE_SIZE (Pmode);
1485 /* Save each register used in calling a function to the block. */
1486 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1487 if ((mode = apply_args_mode[regno]) != VOIDmode)
1489 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1490 if (size % align != 0)
1491 size = CEIL (size, align) * align;
1493 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1495 emit_move_insn (adjust_address (registers, mode, size), tem);
1496 size += GET_MODE_SIZE (mode);
1499 /* Save the arg pointer to the block. */
1500 tem = copy_to_reg (crtl->args.internal_arg_pointer);
1501 #ifdef STACK_GROWS_DOWNWARD
1502 /* We need the pointer as the caller actually passed them to us, not
1503 as we might have pretended they were passed. Make sure it's a valid
1504 operand, as emit_move_insn isn't expected to handle a PLUS. */
1506 = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1509 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1511 size = GET_MODE_SIZE (Pmode);
1513 /* Save the structure value address unless this is passed as an
1514 "invisible" first argument. */
1515 if (struct_incoming_value)
1517 emit_move_insn (adjust_address (registers, Pmode, size),
1518 copy_to_reg (struct_incoming_value));
1519 size += GET_MODE_SIZE (Pmode);
1522 /* Return the address of the block. */
1523 return copy_addr_to_reg (XEXP (registers, 0));
1526 /* __builtin_apply_args returns block of memory allocated on
1527 the stack into which is stored the arg pointer, structure
1528 value address, static chain, and all the registers that might
1529 possibly be used in performing a function call. The code is
1530 moved to the start of the function so the incoming values are
1534 expand_builtin_apply_args (void)
1536 /* Don't do __builtin_apply_args more than once in a function.
1537 Save the result of the first call and reuse it. */
1538 if (apply_args_value != 0)
1539 return apply_args_value;
1541 /* When this function is called, it means that registers must be
1542 saved on entry to this function. So we migrate the
1543 call to the first insn of this function. */
1548 temp = expand_builtin_apply_args_1 ();
1552 apply_args_value = temp;
1554 /* Put the insns after the NOTE that starts the function.
1555 If this is inside a start_sequence, make the outer-level insn
1556 chain current, so the code is placed at the start of the
1557 function. If internal_arg_pointer is a non-virtual pseudo,
1558 it needs to be placed after the function that initializes
1560 push_topmost_sequence ();
1561 if (REG_P (crtl->args.internal_arg_pointer)
1562 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1563 emit_insn_before (seq, parm_birth_insn);
1565 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1566 pop_topmost_sequence ();
1571 /* Perform an untyped call and save the state required to perform an
1572 untyped return of whatever value was returned by the given function. */
1575 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1577 int size, align, regno;
1578 enum machine_mode mode;
1579 rtx incoming_args, result, reg, dest, src, call_insn;
1580 rtx old_stack_level = 0;
1581 rtx call_fusage = 0;
1582 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1584 arguments = convert_memory_address (Pmode, arguments);
1586 /* Create a block where the return registers can be saved. */
1587 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1589 /* Fetch the arg pointer from the ARGUMENTS block. */
1590 incoming_args = gen_reg_rtx (Pmode);
1591 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1592 #ifndef STACK_GROWS_DOWNWARD
1593 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1594 incoming_args, 0, OPTAB_LIB_WIDEN);
1597 /* Push a new argument block and copy the arguments. Do not allow
1598 the (potential) memcpy call below to interfere with our stack
1600 do_pending_stack_adjust ();
1603 /* Save the stack with nonlocal if available. */
1604 #ifdef HAVE_save_stack_nonlocal
1605 if (HAVE_save_stack_nonlocal)
1606 emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1609 emit_stack_save (SAVE_BLOCK, &old_stack_level);
1611 /* Allocate a block of memory onto the stack and copy the memory
1612 arguments to the outgoing arguments address. We can pass TRUE
1613 as the 4th argument because we just saved the stack pointer
1614 and will restore it right after the call. */
1615 allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1617 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1618 may have already set current_function_calls_alloca to true.
1619 current_function_calls_alloca won't be set if argsize is zero,
1620 so we have to guarantee need_drap is true here. */
1621 if (SUPPORTS_STACK_ALIGNMENT)
1622 crtl->need_drap = true;
1624 dest = virtual_outgoing_args_rtx;
1625 #ifndef STACK_GROWS_DOWNWARD
1626 if (CONST_INT_P (argsize))
1627 dest = plus_constant (dest, -INTVAL (argsize));
1629 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1631 dest = gen_rtx_MEM (BLKmode, dest);
1632 set_mem_align (dest, PARM_BOUNDARY);
1633 src = gen_rtx_MEM (BLKmode, incoming_args);
1634 set_mem_align (src, PARM_BOUNDARY);
1635 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1637 /* Refer to the argument block. */
1639 arguments = gen_rtx_MEM (BLKmode, arguments);
1640 set_mem_align (arguments, PARM_BOUNDARY);
1642 /* Walk past the arg-pointer and structure value address. */
1643 size = GET_MODE_SIZE (Pmode);
1645 size += GET_MODE_SIZE (Pmode);
1647 /* Restore each of the registers previously saved. Make USE insns
1648 for each of these registers for use in making the call. */
1649 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1650 if ((mode = apply_args_mode[regno]) != VOIDmode)
1652 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1653 if (size % align != 0)
1654 size = CEIL (size, align) * align;
1655 reg = gen_rtx_REG (mode, regno);
1656 emit_move_insn (reg, adjust_address (arguments, mode, size));
1657 use_reg (&call_fusage, reg);
1658 size += GET_MODE_SIZE (mode);
1661 /* Restore the structure value address unless this is passed as an
1662 "invisible" first argument. */
1663 size = GET_MODE_SIZE (Pmode);
1666 rtx value = gen_reg_rtx (Pmode);
1667 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1668 emit_move_insn (struct_value, value);
1669 if (REG_P (struct_value))
1670 use_reg (&call_fusage, struct_value);
1671 size += GET_MODE_SIZE (Pmode);
1674 /* All arguments and registers used for the call are set up by now! */
1675 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1677 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1678 and we don't want to load it into a register as an optimization,
1679 because prepare_call_address already did it if it should be done. */
1680 if (GET_CODE (function) != SYMBOL_REF)
1681 function = memory_address (FUNCTION_MODE, function);
1683 /* Generate the actual call instruction and save the return value. */
1684 #ifdef HAVE_untyped_call
1685 if (HAVE_untyped_call)
1686 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1687 result, result_vector (1, result)));
1690 #ifdef HAVE_call_value
1691 if (HAVE_call_value)
1695 /* Locate the unique return register. It is not possible to
1696 express a call that sets more than one return register using
1697 call_value; use untyped_call for that. In fact, untyped_call
1698 only needs to save the return registers in the given block. */
1699 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1700 if ((mode = apply_result_mode[regno]) != VOIDmode)
1702 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1704 valreg = gen_rtx_REG (mode, regno);
1707 emit_call_insn (GEN_CALL_VALUE (valreg,
1708 gen_rtx_MEM (FUNCTION_MODE, function),
1709 const0_rtx, NULL_RTX, const0_rtx));
1711 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1717 /* Find the CALL insn we just emitted, and attach the register usage
1719 call_insn = last_call_insn ();
1720 add_function_usage_to (call_insn, call_fusage);
1722 /* Restore the stack. */
1723 #ifdef HAVE_save_stack_nonlocal
1724 if (HAVE_save_stack_nonlocal)
1725 emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1728 emit_stack_restore (SAVE_BLOCK, old_stack_level);
1729 fixup_args_size_notes (call_insn, get_last_insn(), 0);
1733 /* Return the address of the result block. */
1734 result = copy_addr_to_reg (XEXP (result, 0));
1735 return convert_memory_address (ptr_mode, result);
1738 /* Perform an untyped return. */
1741 expand_builtin_return (rtx result)
1743 int size, align, regno;
1744 enum machine_mode mode;
1746 rtx call_fusage = 0;
1748 result = convert_memory_address (Pmode, result);
1750 apply_result_size ();
1751 result = gen_rtx_MEM (BLKmode, result);
1753 #ifdef HAVE_untyped_return
1754 if (HAVE_untyped_return)
1756 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1762 /* Restore the return value and note that each value is used. */
1764 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1765 if ((mode = apply_result_mode[regno]) != VOIDmode)
1767 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1768 if (size % align != 0)
1769 size = CEIL (size, align) * align;
1770 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1771 emit_move_insn (reg, adjust_address (result, mode, size));
1773 push_to_sequence (call_fusage);
1775 call_fusage = get_insns ();
1777 size += GET_MODE_SIZE (mode);
1780 /* Put the USE insns before the return. */
1781 emit_insn (call_fusage);
1783 /* Return whatever values was restored by jumping directly to the end
1785 expand_naked_return ();
1788 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1790 static enum type_class
1791 type_to_class (tree type)
1793 switch (TREE_CODE (type))
1795 case VOID_TYPE: return void_type_class;
1796 case INTEGER_TYPE: return integer_type_class;
1797 case ENUMERAL_TYPE: return enumeral_type_class;
1798 case BOOLEAN_TYPE: return boolean_type_class;
1799 case POINTER_TYPE: return pointer_type_class;
1800 case REFERENCE_TYPE: return reference_type_class;
1801 case OFFSET_TYPE: return offset_type_class;
1802 case REAL_TYPE: return real_type_class;
1803 case COMPLEX_TYPE: return complex_type_class;
1804 case FUNCTION_TYPE: return function_type_class;
1805 case METHOD_TYPE: return method_type_class;
1806 case RECORD_TYPE: return record_type_class;
1808 case QUAL_UNION_TYPE: return union_type_class;
1809 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1810 ? string_type_class : array_type_class);
1811 case LANG_TYPE: return lang_type_class;
1812 default: return no_type_class;
1816 /* Expand a call EXP to __builtin_classify_type. */
1819 expand_builtin_classify_type (tree exp)
1821 if (call_expr_nargs (exp))
1822 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1823 return GEN_INT (no_type_class);
1826 /* This helper macro, meant to be used in mathfn_built_in below,
1827 determines which among a set of three builtin math functions is
1828 appropriate for a given type mode. The `F' and `L' cases are
1829 automatically generated from the `double' case. */
1830 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1831 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1832 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1833 fcodel = BUILT_IN_MATHFN##L ; break;
1834 /* Similar to above, but appends _R after any F/L suffix. */
1835 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1836 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1837 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1838 fcodel = BUILT_IN_MATHFN##L_R ; break;
1840 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1841 if available. If IMPLICIT is true use the implicit builtin declaration,
1842 otherwise use the explicit declaration. If we can't do the conversion,
1846 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit_p)
1848 enum built_in_function fcode, fcodef, fcodel, fcode2;
1852 CASE_MATHFN (BUILT_IN_ACOS)
1853 CASE_MATHFN (BUILT_IN_ACOSH)
1854 CASE_MATHFN (BUILT_IN_ASIN)
1855 CASE_MATHFN (BUILT_IN_ASINH)
1856 CASE_MATHFN (BUILT_IN_ATAN)
1857 CASE_MATHFN (BUILT_IN_ATAN2)
1858 CASE_MATHFN (BUILT_IN_ATANH)
1859 CASE_MATHFN (BUILT_IN_CBRT)
1860 CASE_MATHFN (BUILT_IN_CEIL)
1861 CASE_MATHFN (BUILT_IN_CEXPI)
1862 CASE_MATHFN (BUILT_IN_COPYSIGN)
1863 CASE_MATHFN (BUILT_IN_COS)
1864 CASE_MATHFN (BUILT_IN_COSH)
1865 CASE_MATHFN (BUILT_IN_DREM)
1866 CASE_MATHFN (BUILT_IN_ERF)
1867 CASE_MATHFN (BUILT_IN_ERFC)
1868 CASE_MATHFN (BUILT_IN_EXP)
1869 CASE_MATHFN (BUILT_IN_EXP10)
1870 CASE_MATHFN (BUILT_IN_EXP2)
1871 CASE_MATHFN (BUILT_IN_EXPM1)
1872 CASE_MATHFN (BUILT_IN_FABS)
1873 CASE_MATHFN (BUILT_IN_FDIM)
1874 CASE_MATHFN (BUILT_IN_FLOOR)
1875 CASE_MATHFN (BUILT_IN_FMA)
1876 CASE_MATHFN (BUILT_IN_FMAX)
1877 CASE_MATHFN (BUILT_IN_FMIN)
1878 CASE_MATHFN (BUILT_IN_FMOD)
1879 CASE_MATHFN (BUILT_IN_FREXP)
1880 CASE_MATHFN (BUILT_IN_GAMMA)
1881 CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1882 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1883 CASE_MATHFN (BUILT_IN_HYPOT)
1884 CASE_MATHFN (BUILT_IN_ILOGB)
1885 CASE_MATHFN (BUILT_IN_ICEIL)
1886 CASE_MATHFN (BUILT_IN_IFLOOR)
1887 CASE_MATHFN (BUILT_IN_INF)
1888 CASE_MATHFN (BUILT_IN_IRINT)
1889 CASE_MATHFN (BUILT_IN_IROUND)
1890 CASE_MATHFN (BUILT_IN_ISINF)
1891 CASE_MATHFN (BUILT_IN_J0)
1892 CASE_MATHFN (BUILT_IN_J1)
1893 CASE_MATHFN (BUILT_IN_JN)
1894 CASE_MATHFN (BUILT_IN_LCEIL)
1895 CASE_MATHFN (BUILT_IN_LDEXP)
1896 CASE_MATHFN (BUILT_IN_LFLOOR)
1897 CASE_MATHFN (BUILT_IN_LGAMMA)
1898 CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1899 CASE_MATHFN (BUILT_IN_LLCEIL)
1900 CASE_MATHFN (BUILT_IN_LLFLOOR)
1901 CASE_MATHFN (BUILT_IN_LLRINT)
1902 CASE_MATHFN (BUILT_IN_LLROUND)
1903 CASE_MATHFN (BUILT_IN_LOG)
1904 CASE_MATHFN (BUILT_IN_LOG10)
1905 CASE_MATHFN (BUILT_IN_LOG1P)
1906 CASE_MATHFN (BUILT_IN_LOG2)
1907 CASE_MATHFN (BUILT_IN_LOGB)
1908 CASE_MATHFN (BUILT_IN_LRINT)
1909 CASE_MATHFN (BUILT_IN_LROUND)
1910 CASE_MATHFN (BUILT_IN_MODF)
1911 CASE_MATHFN (BUILT_IN_NAN)
1912 CASE_MATHFN (BUILT_IN_NANS)
1913 CASE_MATHFN (BUILT_IN_NEARBYINT)
1914 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1915 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1916 CASE_MATHFN (BUILT_IN_POW)
1917 CASE_MATHFN (BUILT_IN_POWI)
1918 CASE_MATHFN (BUILT_IN_POW10)
1919 CASE_MATHFN (BUILT_IN_REMAINDER)
1920 CASE_MATHFN (BUILT_IN_REMQUO)
1921 CASE_MATHFN (BUILT_IN_RINT)
1922 CASE_MATHFN (BUILT_IN_ROUND)
1923 CASE_MATHFN (BUILT_IN_SCALB)
1924 CASE_MATHFN (BUILT_IN_SCALBLN)
1925 CASE_MATHFN (BUILT_IN_SCALBN)
1926 CASE_MATHFN (BUILT_IN_SIGNBIT)
1927 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1928 CASE_MATHFN (BUILT_IN_SIN)
1929 CASE_MATHFN (BUILT_IN_SINCOS)
1930 CASE_MATHFN (BUILT_IN_SINH)
1931 CASE_MATHFN (BUILT_IN_SQRT)
1932 CASE_MATHFN (BUILT_IN_TAN)
1933 CASE_MATHFN (BUILT_IN_TANH)
1934 CASE_MATHFN (BUILT_IN_TGAMMA)
1935 CASE_MATHFN (BUILT_IN_TRUNC)
1936 CASE_MATHFN (BUILT_IN_Y0)
1937 CASE_MATHFN (BUILT_IN_Y1)
1938 CASE_MATHFN (BUILT_IN_YN)
1944 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1946 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1948 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1953 if (implicit_p && !builtin_decl_implicit_p (fcode2))
1956 return builtin_decl_explicit (fcode2);
1959 /* Like mathfn_built_in_1(), but always use the implicit array. */
1962 mathfn_built_in (tree type, enum built_in_function fn)
1964 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1967 /* If errno must be maintained, expand the RTL to check if the result,
1968 TARGET, of a built-in function call, EXP, is NaN, and if so set
1972 expand_errno_check (tree exp, rtx target)
1974 rtx lab = gen_label_rtx ();
1976 /* Test the result; if it is NaN, set errno=EDOM because
1977 the argument was not in the domain. */
1978 do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1979 NULL_RTX, NULL_RTX, lab,
1980 /* The jump is very likely. */
1981 REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1984 /* If this built-in doesn't throw an exception, set errno directly. */
1985 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1987 #ifdef GEN_ERRNO_RTX
1988 rtx errno_rtx = GEN_ERRNO_RTX;
1991 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1993 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1999 /* Make sure the library call isn't expanded as a tail call. */
2000 CALL_EXPR_TAILCALL (exp) = 0;
2002 /* We can't set errno=EDOM directly; let the library call do it.
2003 Pop the arguments right away in case the call gets deleted. */
2005 expand_call (exp, target, 0);
2010 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
2011 Return NULL_RTX if a normal call should be emitted rather than expanding
2012 the function in-line. EXP is the expression that is a call to the builtin
2013 function; if convenient, the result should be placed in TARGET.
2014 SUBTARGET may be used as the target for computing one of EXP's operands. */
2017 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
2019 optab builtin_optab;
2021 tree fndecl = get_callee_fndecl (exp);
2022 enum machine_mode mode;
2023 bool errno_set = false;
2026 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2029 arg = CALL_EXPR_ARG (exp, 0);
2031 switch (DECL_FUNCTION_CODE (fndecl))
2033 CASE_FLT_FN (BUILT_IN_SQRT):
2034 errno_set = ! tree_expr_nonnegative_p (arg);
2035 builtin_optab = sqrt_optab;
2037 CASE_FLT_FN (BUILT_IN_EXP):
2038 errno_set = true; builtin_optab = exp_optab; break;
2039 CASE_FLT_FN (BUILT_IN_EXP10):
2040 CASE_FLT_FN (BUILT_IN_POW10):
2041 errno_set = true; builtin_optab = exp10_optab; break;
2042 CASE_FLT_FN (BUILT_IN_EXP2):
2043 errno_set = true; builtin_optab = exp2_optab; break;
2044 CASE_FLT_FN (BUILT_IN_EXPM1):
2045 errno_set = true; builtin_optab = expm1_optab; break;
2046 CASE_FLT_FN (BUILT_IN_LOGB):
2047 errno_set = true; builtin_optab = logb_optab; break;
2048 CASE_FLT_FN (BUILT_IN_LOG):
2049 errno_set = true; builtin_optab = log_optab; break;
2050 CASE_FLT_FN (BUILT_IN_LOG10):
2051 errno_set = true; builtin_optab = log10_optab; break;
2052 CASE_FLT_FN (BUILT_IN_LOG2):
2053 errno_set = true; builtin_optab = log2_optab; break;
2054 CASE_FLT_FN (BUILT_IN_LOG1P):
2055 errno_set = true; builtin_optab = log1p_optab; break;
2056 CASE_FLT_FN (BUILT_IN_ASIN):
2057 builtin_optab = asin_optab; break;
2058 CASE_FLT_FN (BUILT_IN_ACOS):
2059 builtin_optab = acos_optab; break;
2060 CASE_FLT_FN (BUILT_IN_TAN):
2061 builtin_optab = tan_optab; break;
2062 CASE_FLT_FN (BUILT_IN_ATAN):
2063 builtin_optab = atan_optab; break;
2064 CASE_FLT_FN (BUILT_IN_FLOOR):
2065 builtin_optab = floor_optab; break;
2066 CASE_FLT_FN (BUILT_IN_CEIL):
2067 builtin_optab = ceil_optab; break;
2068 CASE_FLT_FN (BUILT_IN_TRUNC):
2069 builtin_optab = btrunc_optab; break;
2070 CASE_FLT_FN (BUILT_IN_ROUND):
2071 builtin_optab = round_optab; break;
2072 CASE_FLT_FN (BUILT_IN_NEARBYINT):
2073 builtin_optab = nearbyint_optab;
2074 if (flag_trapping_math)
2076 /* Else fallthrough and expand as rint. */
2077 CASE_FLT_FN (BUILT_IN_RINT):
2078 builtin_optab = rint_optab; break;
2079 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2080 builtin_optab = significand_optab; break;
2085 /* Make a suitable register to place result in. */
2086 mode = TYPE_MODE (TREE_TYPE (exp));
2088 if (! flag_errno_math || ! HONOR_NANS (mode))
2091 /* Before working hard, check whether the instruction is available. */
2092 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing
2093 && (!errno_set || !optimize_insn_for_size_p ()))
2095 target = gen_reg_rtx (mode);
2097 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2098 need to expand the argument again. This way, we will not perform
2099 side-effects more the once. */
2100 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2102 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2106 /* Compute into TARGET.
2107 Set TARGET to wherever the result comes back. */
2108 target = expand_unop (mode, builtin_optab, op0, target, 0);
2113 expand_errno_check (exp, target);
2115 /* Output the entire sequence. */
2116 insns = get_insns ();
2122 /* If we were unable to expand via the builtin, stop the sequence
2123 (without outputting the insns) and call to the library function
2124 with the stabilized argument list. */
2128 return expand_call (exp, target, target == const0_rtx);
2131 /* Expand a call to the builtin binary math functions (pow and atan2).
2132 Return NULL_RTX if a normal call should be emitted rather than expanding the
2133 function in-line. EXP is the expression that is a call to the builtin
2134 function; if convenient, the result should be placed in TARGET.
2135 SUBTARGET may be used as the target for computing one of EXP's
2139 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2141 optab builtin_optab;
2142 rtx op0, op1, insns;
2143 int op1_type = REAL_TYPE;
2144 tree fndecl = get_callee_fndecl (exp);
2146 enum machine_mode mode;
2147 bool errno_set = true;
2149 switch (DECL_FUNCTION_CODE (fndecl))
2151 CASE_FLT_FN (BUILT_IN_SCALBN):
2152 CASE_FLT_FN (BUILT_IN_SCALBLN):
2153 CASE_FLT_FN (BUILT_IN_LDEXP):
2154 op1_type = INTEGER_TYPE;
2159 if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2162 arg0 = CALL_EXPR_ARG (exp, 0);
2163 arg1 = CALL_EXPR_ARG (exp, 1);
2165 switch (DECL_FUNCTION_CODE (fndecl))
2167 CASE_FLT_FN (BUILT_IN_POW):
2168 builtin_optab = pow_optab; break;
2169 CASE_FLT_FN (BUILT_IN_ATAN2):
2170 builtin_optab = atan2_optab; break;
2171 CASE_FLT_FN (BUILT_IN_SCALB):
2172 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2174 builtin_optab = scalb_optab; break;
2175 CASE_FLT_FN (BUILT_IN_SCALBN):
2176 CASE_FLT_FN (BUILT_IN_SCALBLN):
2177 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2179 /* Fall through... */
2180 CASE_FLT_FN (BUILT_IN_LDEXP):
2181 builtin_optab = ldexp_optab; break;
2182 CASE_FLT_FN (BUILT_IN_FMOD):
2183 builtin_optab = fmod_optab; break;
2184 CASE_FLT_FN (BUILT_IN_REMAINDER):
2185 CASE_FLT_FN (BUILT_IN_DREM):
2186 builtin_optab = remainder_optab; break;
2191 /* Make a suitable register to place result in. */
2192 mode = TYPE_MODE (TREE_TYPE (exp));
2194 /* Before working hard, check whether the instruction is available. */
2195 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2198 target = gen_reg_rtx (mode);
2200 if (! flag_errno_math || ! HONOR_NANS (mode))
2203 if (errno_set && optimize_insn_for_size_p ())
2206 /* Always stabilize the argument list. */
2207 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2208 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2210 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2211 op1 = expand_normal (arg1);
2215 /* Compute into TARGET.
2216 Set TARGET to wherever the result comes back. */
2217 target = expand_binop (mode, builtin_optab, op0, op1,
2218 target, 0, OPTAB_DIRECT);
2220 /* If we were unable to expand via the builtin, stop the sequence
2221 (without outputting the insns) and call to the library function
2222 with the stabilized argument list. */
2226 return expand_call (exp, target, target == const0_rtx);
2230 expand_errno_check (exp, target);
2232 /* Output the entire sequence. */
2233 insns = get_insns ();
2240 /* Expand a call to the builtin trinary math functions (fma).
2241 Return NULL_RTX if a normal call should be emitted rather than expanding the
2242 function in-line. EXP is the expression that is a call to the builtin
2243 function; if convenient, the result should be placed in TARGET.
2244 SUBTARGET may be used as the target for computing one of EXP's
2248 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2250 optab builtin_optab;
2251 rtx op0, op1, op2, insns;
2252 tree fndecl = get_callee_fndecl (exp);
2253 tree arg0, arg1, arg2;
2254 enum machine_mode mode;
2256 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2259 arg0 = CALL_EXPR_ARG (exp, 0);
2260 arg1 = CALL_EXPR_ARG (exp, 1);
2261 arg2 = CALL_EXPR_ARG (exp, 2);
2263 switch (DECL_FUNCTION_CODE (fndecl))
2265 CASE_FLT_FN (BUILT_IN_FMA):
2266 builtin_optab = fma_optab; break;
2271 /* Make a suitable register to place result in. */
2272 mode = TYPE_MODE (TREE_TYPE (exp));
2274 /* Before working hard, check whether the instruction is available. */
2275 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2278 target = gen_reg_rtx (mode);
2280 /* Always stabilize the argument list. */
2281 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2282 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2283 CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2285 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2286 op1 = expand_normal (arg1);
2287 op2 = expand_normal (arg2);
2291 /* Compute into TARGET.
2292 Set TARGET to wherever the result comes back. */
2293 target = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2296 /* If we were unable to expand via the builtin, stop the sequence
2297 (without outputting the insns) and call to the library function
2298 with the stabilized argument list. */
2302 return expand_call (exp, target, target == const0_rtx);
2305 /* Output the entire sequence. */
2306 insns = get_insns ();
2313 /* Expand a call to the builtin sin and cos math functions.
2314 Return NULL_RTX if a normal call should be emitted rather than expanding the
2315 function in-line. EXP is the expression that is a call to the builtin
2316 function; if convenient, the result should be placed in TARGET.
2317 SUBTARGET may be used as the target for computing one of EXP's
2321 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2323 optab builtin_optab;
2325 tree fndecl = get_callee_fndecl (exp);
2326 enum machine_mode mode;
2329 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2332 arg = CALL_EXPR_ARG (exp, 0);
2334 switch (DECL_FUNCTION_CODE (fndecl))
2336 CASE_FLT_FN (BUILT_IN_SIN):
2337 CASE_FLT_FN (BUILT_IN_COS):
2338 builtin_optab = sincos_optab; break;
2343 /* Make a suitable register to place result in. */
2344 mode = TYPE_MODE (TREE_TYPE (exp));
2346 /* Check if sincos insn is available, otherwise fallback
2347 to sin or cos insn. */
2348 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2349 switch (DECL_FUNCTION_CODE (fndecl))
2351 CASE_FLT_FN (BUILT_IN_SIN):
2352 builtin_optab = sin_optab; break;
2353 CASE_FLT_FN (BUILT_IN_COS):
2354 builtin_optab = cos_optab; break;
2359 /* Before working hard, check whether the instruction is available. */
2360 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2362 target = gen_reg_rtx (mode);
2364 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2365 need to expand the argument again. This way, we will not perform
2366 side-effects more the once. */
2367 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2369 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2373 /* Compute into TARGET.
2374 Set TARGET to wherever the result comes back. */
2375 if (builtin_optab == sincos_optab)
2379 switch (DECL_FUNCTION_CODE (fndecl))
2381 CASE_FLT_FN (BUILT_IN_SIN):
2382 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2384 CASE_FLT_FN (BUILT_IN_COS):
2385 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2390 gcc_assert (result);
2394 target = expand_unop (mode, builtin_optab, op0, target, 0);
2399 /* Output the entire sequence. */
2400 insns = get_insns ();
2406 /* If we were unable to expand via the builtin, stop the sequence
2407 (without outputting the insns) and call to the library function
2408 with the stabilized argument list. */
2412 target = expand_call (exp, target, target == const0_rtx);
2417 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2418 return an RTL instruction code that implements the functionality.
2419 If that isn't possible or available return CODE_FOR_nothing. */
2421 static enum insn_code
2422 interclass_mathfn_icode (tree arg, tree fndecl)
2424 bool errno_set = false;
2425 optab builtin_optab = 0;
2426 enum machine_mode mode;
2428 switch (DECL_FUNCTION_CODE (fndecl))
2430 CASE_FLT_FN (BUILT_IN_ILOGB):
2431 errno_set = true; builtin_optab = ilogb_optab; break;
2432 CASE_FLT_FN (BUILT_IN_ISINF):
2433 builtin_optab = isinf_optab; break;
2434 case BUILT_IN_ISNORMAL:
2435 case BUILT_IN_ISFINITE:
2436 CASE_FLT_FN (BUILT_IN_FINITE):
2437 case BUILT_IN_FINITED32:
2438 case BUILT_IN_FINITED64:
2439 case BUILT_IN_FINITED128:
2440 case BUILT_IN_ISINFD32:
2441 case BUILT_IN_ISINFD64:
2442 case BUILT_IN_ISINFD128:
2443 /* These builtins have no optabs (yet). */
2449 /* There's no easy way to detect the case we need to set EDOM. */
2450 if (flag_errno_math && errno_set)
2451 return CODE_FOR_nothing;
2453 /* Optab mode depends on the mode of the input argument. */
2454 mode = TYPE_MODE (TREE_TYPE (arg));
2457 return optab_handler (builtin_optab, mode);
2458 return CODE_FOR_nothing;
2461 /* Expand a call to one of the builtin math functions that operate on
2462 floating point argument and output an integer result (ilogb, isinf,
2464 Return 0 if a normal call should be emitted rather than expanding the
2465 function in-line. EXP is the expression that is a call to the builtin
2466 function; if convenient, the result should be placed in TARGET. */
2469 expand_builtin_interclass_mathfn (tree exp, rtx target)
2471 enum insn_code icode = CODE_FOR_nothing;
2473 tree fndecl = get_callee_fndecl (exp);
2474 enum machine_mode mode;
2477 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2480 arg = CALL_EXPR_ARG (exp, 0);
2481 icode = interclass_mathfn_icode (arg, fndecl);
2482 mode = TYPE_MODE (TREE_TYPE (arg));
2484 if (icode != CODE_FOR_nothing)
2486 struct expand_operand ops[1];
2487 rtx last = get_last_insn ();
2488 tree orig_arg = arg;
2490 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2491 need to expand the argument again. This way, we will not perform
2492 side-effects more the once. */
2493 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2495 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2497 if (mode != GET_MODE (op0))
2498 op0 = convert_to_mode (mode, op0, 0);
2500 create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2501 if (maybe_legitimize_operands (icode, 0, 1, ops)
2502 && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2503 return ops[0].value;
2505 delete_insns_since (last);
2506 CALL_EXPR_ARG (exp, 0) = orig_arg;
2512 /* Expand a call to the builtin sincos math function.
2513 Return NULL_RTX if a normal call should be emitted rather than expanding the
2514 function in-line. EXP is the expression that is a call to the builtin
2518 expand_builtin_sincos (tree exp)
2520 rtx op0, op1, op2, target1, target2;
2521 enum machine_mode mode;
2522 tree arg, sinp, cosp;
2524 location_t loc = EXPR_LOCATION (exp);
2525 tree alias_type, alias_off;
2527 if (!validate_arglist (exp, REAL_TYPE,
2528 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2531 arg = CALL_EXPR_ARG (exp, 0);
2532 sinp = CALL_EXPR_ARG (exp, 1);
2533 cosp = CALL_EXPR_ARG (exp, 2);
2535 /* Make a suitable register to place result in. */
2536 mode = TYPE_MODE (TREE_TYPE (arg));
2538 /* Check if sincos insn is available, otherwise emit the call. */
2539 if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2542 target1 = gen_reg_rtx (mode);
2543 target2 = gen_reg_rtx (mode);
2545 op0 = expand_normal (arg);
2546 alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2547 alias_off = build_int_cst (alias_type, 0);
2548 op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2550 op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2553 /* Compute into target1 and target2.
2554 Set TARGET to wherever the result comes back. */
2555 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2556 gcc_assert (result);
2558 /* Move target1 and target2 to the memory locations indicated
2560 emit_move_insn (op1, target1);
2561 emit_move_insn (op2, target2);
2566 /* Expand a call to the internal cexpi builtin to the sincos math function.
2567 EXP is the expression that is a call to the builtin function; if convenient,
2568 the result should be placed in TARGET. */
2571 expand_builtin_cexpi (tree exp, rtx target)
2573 tree fndecl = get_callee_fndecl (exp);
2575 enum machine_mode mode;
2577 location_t loc = EXPR_LOCATION (exp);
2579 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2582 arg = CALL_EXPR_ARG (exp, 0);
2583 type = TREE_TYPE (arg);
2584 mode = TYPE_MODE (TREE_TYPE (arg));
2586 /* Try expanding via a sincos optab, fall back to emitting a libcall
2587 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2588 is only generated from sincos, cexp or if we have either of them. */
2589 if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2591 op1 = gen_reg_rtx (mode);
2592 op2 = gen_reg_rtx (mode);
2594 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2596 /* Compute into op1 and op2. */
2597 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2599 else if (TARGET_HAS_SINCOS)
2601 tree call, fn = NULL_TREE;
2605 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2606 fn = builtin_decl_explicit (BUILT_IN_SINCOSF);
2607 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2608 fn = builtin_decl_explicit (BUILT_IN_SINCOS);
2609 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2610 fn = builtin_decl_explicit (BUILT_IN_SINCOSL);
2614 op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2615 op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2616 op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2617 op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2618 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2619 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2621 /* Make sure not to fold the sincos call again. */
2622 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2623 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2624 call, 3, arg, top1, top2));
2628 tree call, fn = NULL_TREE, narg;
2629 tree ctype = build_complex_type (type);
2631 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2632 fn = builtin_decl_explicit (BUILT_IN_CEXPF);
2633 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2634 fn = builtin_decl_explicit (BUILT_IN_CEXP);
2635 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2636 fn = builtin_decl_explicit (BUILT_IN_CEXPL);
2640 /* If we don't have a decl for cexp create one. This is the
2641 friendliest fallback if the user calls __builtin_cexpi
2642 without full target C99 function support. */
2643 if (fn == NULL_TREE)
2646 const char *name = NULL;
2648 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2650 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2652 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2655 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2656 fn = build_fn_decl (name, fntype);
2659 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2660 build_real (type, dconst0), arg);
2662 /* Make sure not to fold the cexp call again. */
2663 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2664 return expand_expr (build_call_nary (ctype, call, 1, narg),
2665 target, VOIDmode, EXPAND_NORMAL);
2668 /* Now build the proper return type. */
2669 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2670 make_tree (TREE_TYPE (arg), op2),
2671 make_tree (TREE_TYPE (arg), op1)),
2672 target, VOIDmode, EXPAND_NORMAL);
2675 /* Conveniently construct a function call expression. FNDECL names the
2676 function to be called, N is the number of arguments, and the "..."
2677 parameters are the argument expressions. Unlike build_call_exr
2678 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2681 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2684 tree fntype = TREE_TYPE (fndecl);
2685 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2688 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2690 SET_EXPR_LOCATION (fn, loc);
2694 /* Expand a call to one of the builtin rounding functions gcc defines
2695 as an extension (lfloor and lceil). As these are gcc extensions we
2696 do not need to worry about setting errno to EDOM.
2697 If expanding via optab fails, lower expression to (int)(floor(x)).
2698 EXP is the expression that is a call to the builtin function;
2699 if convenient, the result should be placed in TARGET. */
2702 expand_builtin_int_roundingfn (tree exp, rtx target)
2704 convert_optab builtin_optab;
2705 rtx op0, insns, tmp;
2706 tree fndecl = get_callee_fndecl (exp);
2707 enum built_in_function fallback_fn;
2708 tree fallback_fndecl;
2709 enum machine_mode mode;
2712 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2715 arg = CALL_EXPR_ARG (exp, 0);
2717 switch (DECL_FUNCTION_CODE (fndecl))
2719 CASE_FLT_FN (BUILT_IN_ICEIL):
2720 CASE_FLT_FN (BUILT_IN_LCEIL):
2721 CASE_FLT_FN (BUILT_IN_LLCEIL):
2722 builtin_optab = lceil_optab;
2723 fallback_fn = BUILT_IN_CEIL;
2726 CASE_FLT_FN (BUILT_IN_IFLOOR):
2727 CASE_FLT_FN (BUILT_IN_LFLOOR):
2728 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2729 builtin_optab = lfloor_optab;
2730 fallback_fn = BUILT_IN_FLOOR;
2737 /* Make a suitable register to place result in. */
2738 mode = TYPE_MODE (TREE_TYPE (exp));
2740 target = gen_reg_rtx (mode);
2742 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2743 need to expand the argument again. This way, we will not perform
2744 side-effects more the once. */
2745 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2747 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2751 /* Compute into TARGET. */
2752 if (expand_sfix_optab (target, op0, builtin_optab))
2754 /* Output the entire sequence. */
2755 insns = get_insns ();
2761 /* If we were unable to expand via the builtin, stop the sequence
2762 (without outputting the insns). */
2765 /* Fall back to floating point rounding optab. */
2766 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2768 /* For non-C99 targets we may end up without a fallback fndecl here
2769 if the user called __builtin_lfloor directly. In this case emit
2770 a call to the floor/ceil variants nevertheless. This should result
2771 in the best user experience for not full C99 targets. */
2772 if (fallback_fndecl == NULL_TREE)
2775 const char *name = NULL;
2777 switch (DECL_FUNCTION_CODE (fndecl))
2779 case BUILT_IN_ICEIL:
2780 case BUILT_IN_LCEIL:
2781 case BUILT_IN_LLCEIL:
2784 case BUILT_IN_ICEILF:
2785 case BUILT_IN_LCEILF:
2786 case BUILT_IN_LLCEILF:
2789 case BUILT_IN_ICEILL:
2790 case BUILT_IN_LCEILL:
2791 case BUILT_IN_LLCEILL:
2794 case BUILT_IN_IFLOOR:
2795 case BUILT_IN_LFLOOR:
2796 case BUILT_IN_LLFLOOR:
2799 case BUILT_IN_IFLOORF:
2800 case BUILT_IN_LFLOORF:
2801 case BUILT_IN_LLFLOORF:
2804 case BUILT_IN_IFLOORL:
2805 case BUILT_IN_LFLOORL:
2806 case BUILT_IN_LLFLOORL:
2813 fntype = build_function_type_list (TREE_TYPE (arg),
2814 TREE_TYPE (arg), NULL_TREE);
2815 fallback_fndecl = build_fn_decl (name, fntype);
2818 exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2820 tmp = expand_normal (exp);
2822 /* Truncate the result of floating point optab to integer
2823 via expand_fix (). */
2824 target = gen_reg_rtx (mode);
2825 expand_fix (target, tmp, 0);
2830 /* Expand a call to one of the builtin math functions doing integer
2832 Return 0 if a normal call should be emitted rather than expanding the
2833 function in-line. EXP is the expression that is a call to the builtin
2834 function; if convenient, the result should be placed in TARGET. */
2837 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2839 convert_optab builtin_optab;
2841 tree fndecl = get_callee_fndecl (exp);
2843 enum machine_mode mode;
2844 enum built_in_function fallback_fn = BUILT_IN_NONE;
2846 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2849 arg = CALL_EXPR_ARG (exp, 0);
2851 switch (DECL_FUNCTION_CODE (fndecl))
2853 CASE_FLT_FN (BUILT_IN_IRINT):
2854 fallback_fn = BUILT_IN_LRINT;
2856 CASE_FLT_FN (BUILT_IN_LRINT):
2857 CASE_FLT_FN (BUILT_IN_LLRINT):
2858 builtin_optab = lrint_optab;
2861 CASE_FLT_FN (BUILT_IN_IROUND):
2862 fallback_fn = BUILT_IN_LROUND;
2864 CASE_FLT_FN (BUILT_IN_LROUND):
2865 CASE_FLT_FN (BUILT_IN_LLROUND):
2866 builtin_optab = lround_optab;
2873 /* There's no easy way to detect the case we need to set EDOM. */
2874 if (flag_errno_math && fallback_fn == BUILT_IN_NONE)
2877 /* Make a suitable register to place result in. */
2878 mode = TYPE_MODE (TREE_TYPE (exp));
2880 /* There's no easy way to detect the case we need to set EDOM. */
2881 if (!flag_errno_math)
2883 target = gen_reg_rtx (mode);
2885 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2886 need to expand the argument again. This way, we will not perform
2887 side-effects more the once. */
2888 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2890 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2894 if (expand_sfix_optab (target, op0, builtin_optab))
2896 /* Output the entire sequence. */
2897 insns = get_insns ();
2903 /* If we were unable to expand via the builtin, stop the sequence
2904 (without outputting the insns) and call to the library function
2905 with the stabilized argument list. */
2909 if (fallback_fn != BUILT_IN_NONE)
2911 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2912 targets, (int) round (x) should never be transformed into
2913 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2914 a call to lround in the hope that the target provides at least some
2915 C99 functions. This should result in the best user experience for
2916 not full C99 targets. */
2917 tree fallback_fndecl = mathfn_built_in_1 (TREE_TYPE (arg),
2920 exp = build_call_nofold_loc (EXPR_LOCATION (exp),
2921 fallback_fndecl, 1, arg);
2923 target = expand_call (exp, NULL_RTX, target == const0_rtx);
2924 return convert_to_mode (mode, target, 0);
2927 target = expand_call (exp, target, target == const0_rtx);
2932 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2933 a normal call should be emitted rather than expanding the function
2934 in-line. EXP is the expression that is a call to the builtin
2935 function; if convenient, the result should be placed in TARGET. */
2938 expand_builtin_powi (tree exp, rtx target)
2942 enum machine_mode mode;
2943 enum machine_mode mode2;
2945 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2948 arg0 = CALL_EXPR_ARG (exp, 0);
2949 arg1 = CALL_EXPR_ARG (exp, 1);
2950 mode = TYPE_MODE (TREE_TYPE (exp));
2952 /* Emit a libcall to libgcc. */
2954 /* Mode of the 2nd argument must match that of an int. */
2955 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2957 if (target == NULL_RTX)
2958 target = gen_reg_rtx (mode);
2960 op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
2961 if (GET_MODE (op0) != mode)
2962 op0 = convert_to_mode (mode, op0, 0);
2963 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
2964 if (GET_MODE (op1) != mode2)
2965 op1 = convert_to_mode (mode2, op1, 0);
2967 target = emit_library_call_value (optab_libfunc (powi_optab, mode),
2968 target, LCT_CONST, mode, 2,
2969 op0, mode, op1, mode2);
2974 /* Expand expression EXP which is a call to the strlen builtin. Return
2975 NULL_RTX if we failed the caller should emit a normal call, otherwise
2976 try to get the result in TARGET, if convenient. */
2979 expand_builtin_strlen (tree exp, rtx target,
2980 enum machine_mode target_mode)
2982 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
2986 struct expand_operand ops[4];
2989 tree src = CALL_EXPR_ARG (exp, 0);
2990 rtx src_reg, before_strlen;
2991 enum machine_mode insn_mode = target_mode;
2992 enum insn_code icode = CODE_FOR_nothing;
2995 /* If the length can be computed at compile-time, return it. */
2996 len = c_strlen (src, 0);
2998 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3000 /* If the length can be computed at compile-time and is constant
3001 integer, but there are side-effects in src, evaluate
3002 src for side-effects, then return len.
3003 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3004 can be optimized into: i++; x = 3; */
3005 len = c_strlen (src, 1);
3006 if (len && TREE_CODE (len) == INTEGER_CST)
3008 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3009 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3012 align = get_pointer_alignment (src) / BITS_PER_UNIT;
3014 /* If SRC is not a pointer type, don't do this operation inline. */
3018 /* Bail out if we can't compute strlen in the right mode. */
3019 while (insn_mode != VOIDmode)
3021 icode = optab_handler (strlen_optab, insn_mode);
3022 if (icode != CODE_FOR_nothing)
3025 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3027 if (insn_mode == VOIDmode)
3030 /* Make a place to hold the source address. We will not expand
3031 the actual source until we are sure that the expansion will
3032 not fail -- there are trees that cannot be expanded twice. */
3033 src_reg = gen_reg_rtx (Pmode);
3035 /* Mark the beginning of the strlen sequence so we can emit the
3036 source operand later. */
3037 before_strlen = get_last_insn ();
3039 create_output_operand (&ops[0], target, insn_mode);
3040 create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
3041 create_integer_operand (&ops[2], 0);
3042 create_integer_operand (&ops[3], align);
3043 if (!maybe_expand_insn (icode, 4, ops))
3046 /* Now that we are assured of success, expand the source. */
3048 pat = expand_expr (src, src_reg, Pmode, EXPAND_NORMAL);
3051 #ifdef POINTERS_EXTEND_UNSIGNED
3052 if (GET_MODE (pat) != Pmode)
3053 pat = convert_to_mode (Pmode, pat,
3054 POINTERS_EXTEND_UNSIGNED);
3056 emit_move_insn (src_reg, pat);
3062 emit_insn_after (pat, before_strlen);
3064 emit_insn_before (pat, get_insns ());
3066 /* Return the value in the proper mode for this function. */
3067 if (GET_MODE (ops[0].value) == target_mode)
3068 target = ops[0].value;
3069 else if (target != 0)
3070 convert_move (target, ops[0].value, 0);
3072 target = convert_to_mode (target_mode, ops[0].value, 0);
3078 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3079 bytes from constant string DATA + OFFSET and return it as target
3083 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3084 enum machine_mode mode)
3086 const char *str = (const char *) data;
3088 gcc_assert (offset >= 0
3089 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3090 <= strlen (str) + 1));
3092 return c_readstr (str + offset, mode);
3095 /* Expand a call EXP to the memcpy builtin.
3096 Return NULL_RTX if we failed, the caller should emit a normal call,
3097 otherwise try to get the result in TARGET, if convenient (and in
3098 mode MODE if that's convenient). */
3101 expand_builtin_memcpy (tree exp, rtx target)
3103 if (!validate_arglist (exp,
3104 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3108 tree dest = CALL_EXPR_ARG (exp, 0);
3109 tree src = CALL_EXPR_ARG (exp, 1);
3110 tree len = CALL_EXPR_ARG (exp, 2);
3111 const char *src_str;
3112 unsigned int src_align = get_pointer_alignment (src);
3113 unsigned int dest_align = get_pointer_alignment (dest);
3114 rtx dest_mem, src_mem, dest_addr, len_rtx;
3115 HOST_WIDE_INT expected_size = -1;
3116 unsigned int expected_align = 0;
3118 /* If DEST is not a pointer type, call the normal function. */
3119 if (dest_align == 0)
3122 /* If either SRC is not a pointer type, don't do this
3123 operation in-line. */
3127 if (currently_expanding_gimple_stmt)
3128 stringop_block_profile (currently_expanding_gimple_stmt,
3129 &expected_align, &expected_size);
3131 if (expected_align < dest_align)
3132 expected_align = dest_align;
3133 dest_mem = get_memory_rtx (dest, len);
3134 set_mem_align (dest_mem, dest_align);
3135 len_rtx = expand_normal (len);
3136 src_str = c_getstr (src);
3138 /* If SRC is a string constant and block move would be done
3139 by pieces, we can avoid loading the string from memory
3140 and only stored the computed constants. */
3142 && CONST_INT_P (len_rtx)
3143 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3144 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3145 CONST_CAST (char *, src_str),
3148 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3149 builtin_memcpy_read_str,
3150 CONST_CAST (char *, src_str),
3151 dest_align, false, 0);
3152 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3153 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3157 src_mem = get_memory_rtx (src, len);
3158 set_mem_align (src_mem, src_align);
3160 /* Copy word part most expediently. */
3161 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3162 CALL_EXPR_TAILCALL (exp)
3163 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3164 expected_align, expected_size);
3168 dest_addr = force_operand (XEXP (dest_mem, 0), target);
3169 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3175 /* Expand a call EXP to the mempcpy builtin.
3176 Return NULL_RTX if we failed; the caller should emit a normal call,
3177 otherwise try to get the result in TARGET, if convenient (and in
3178 mode MODE if that's convenient). If ENDP is 0 return the
3179 destination pointer, if ENDP is 1 return the end pointer ala
3180 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3184 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3186 if (!validate_arglist (exp,
3187 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3191 tree dest = CALL_EXPR_ARG (exp, 0);
3192 tree src = CALL_EXPR_ARG (exp, 1);
3193 tree len = CALL_EXPR_ARG (exp, 2);
3194 return expand_builtin_mempcpy_args (dest, src, len,
3195 target, mode, /*endp=*/ 1);
3199 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3200 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3201 so that this can also be called without constructing an actual CALL_EXPR.
3202 The other arguments and return value are the same as for
3203 expand_builtin_mempcpy. */
3206 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3207 rtx target, enum machine_mode mode, int endp)
3209 /* If return value is ignored, transform mempcpy into memcpy. */
3210 if (target == const0_rtx && builtin_decl_implicit_p (BUILT_IN_MEMCPY))
3212 tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
3213 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3215 return expand_expr (result, target, mode, EXPAND_NORMAL);
3219 const char *src_str;
3220 unsigned int src_align = get_pointer_alignment (src);
3221 unsigned int dest_align = get_pointer_alignment (dest);
3222 rtx dest_mem, src_mem, len_rtx;
3224 /* If either SRC or DEST is not a pointer type, don't do this
3225 operation in-line. */
3226 if (dest_align == 0 || src_align == 0)
3229 /* If LEN is not constant, call the normal function. */
3230 if (! host_integerp (len, 1))
3233 len_rtx = expand_normal (len);
3234 src_str = c_getstr (src);
3236 /* If SRC is a string constant and block move would be done
3237 by pieces, we can avoid loading the string from memory
3238 and only stored the computed constants. */
3240 && CONST_INT_P (len_rtx)
3241 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3242 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3243 CONST_CAST (char *, src_str),
3246 dest_mem = get_memory_rtx (dest, len);
3247 set_mem_align (dest_mem, dest_align);
3248 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3249 builtin_memcpy_read_str,
3250 CONST_CAST (char *, src_str),
3251 dest_align, false, endp);
3252 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3253 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3257 if (CONST_INT_P (len_rtx)
3258 && can_move_by_pieces (INTVAL (len_rtx),
3259 MIN (dest_align, src_align)))
3261 dest_mem = get_memory_rtx (dest, len);
3262 set_mem_align (dest_mem, dest_align);
3263 src_mem = get_memory_rtx (src, len);
3264 set_mem_align (src_mem, src_align);
3265 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3266 MIN (dest_align, src_align), endp);
3267 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3268 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3277 # define HAVE_movstr 0
3278 # define CODE_FOR_movstr CODE_FOR_nothing
3281 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3282 we failed, the caller should emit a normal call, otherwise try to
3283 get the result in TARGET, if convenient. If ENDP is 0 return the
3284 destination pointer, if ENDP is 1 return the end pointer ala
3285 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3289 expand_movstr (tree dest, tree src, rtx target, int endp)
3291 struct expand_operand ops[3];
3298 dest_mem = get_memory_rtx (dest, NULL);
3299 src_mem = get_memory_rtx (src, NULL);
3302 target = force_reg (Pmode, XEXP (dest_mem, 0));
3303 dest_mem = replace_equiv_address (dest_mem, target);
3306 create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3307 create_fixed_operand (&ops[1], dest_mem);
3308 create_fixed_operand (&ops[2], src_mem);
3309 expand_insn (CODE_FOR_movstr, 3, ops);
3311 if (endp && target != const0_rtx)
3313 target = ops[0].value;
3314 /* movstr is supposed to set end to the address of the NUL
3315 terminator. If the caller requested a mempcpy-like return value,
3319 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), target), 1);
3320 emit_move_insn (target, force_operand (tem, NULL_RTX));
3326 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3327 NULL_RTX if we failed the caller should emit a normal call, otherwise
3328 try to get the result in TARGET, if convenient (and in mode MODE if that's
3332 expand_builtin_strcpy (tree exp, rtx target)
3334 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3336 tree dest = CALL_EXPR_ARG (exp, 0);
3337 tree src = CALL_EXPR_ARG (exp, 1);
3338 return expand_builtin_strcpy_args (dest, src, target);
3343 /* Helper function to do the actual work for expand_builtin_strcpy. The
3344 arguments to the builtin_strcpy call DEST and SRC are broken out
3345 so that this can also be called without constructing an actual CALL_EXPR.
3346 The other arguments and return value are the same as for
3347 expand_builtin_strcpy. */
3350 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3352 return expand_movstr (dest, src, target, /*endp=*/0);
3355 /* Expand a call EXP to the stpcpy builtin.
3356 Return NULL_RTX if we failed the caller should emit a normal call,
3357 otherwise try to get the result in TARGET, if convenient (and in
3358 mode MODE if that's convenient). */
3361 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3364 location_t loc = EXPR_LOCATION (exp);
3366 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3369 dst = CALL_EXPR_ARG (exp, 0);
3370 src = CALL_EXPR_ARG (exp, 1);
3372 /* If return value is ignored, transform stpcpy into strcpy. */
3373 if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY))
3375 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3376 tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3377 return expand_expr (result, target, mode, EXPAND_NORMAL);
3384 /* Ensure we get an actual string whose length can be evaluated at
3385 compile-time, not an expression containing a string. This is
3386 because the latter will potentially produce pessimized code
3387 when used to produce the return value. */
3388 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3389 return expand_movstr (dst, src, target, /*endp=*/2);
3391 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3392 ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3393 target, mode, /*endp=*/2);
3398 if (TREE_CODE (len) == INTEGER_CST)
3400 rtx len_rtx = expand_normal (len);
3402 if (CONST_INT_P (len_rtx))
3404 ret = expand_builtin_strcpy_args (dst, src, target);
3410 if (mode != VOIDmode)
3411 target = gen_reg_rtx (mode);
3413 target = gen_reg_rtx (GET_MODE (ret));
3415 if (GET_MODE (target) != GET_MODE (ret))
3416 ret = gen_lowpart (GET_MODE (target), ret);
3418 ret = plus_constant (ret, INTVAL (len_rtx));
3419 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3427 return expand_movstr (dst, src, target, /*endp=*/2);
3431 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3432 bytes from constant string DATA + OFFSET and return it as target
3436 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3437 enum machine_mode mode)
3439 const char *str = (const char *) data;
3441 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3444 return c_readstr (str + offset, mode);
3447 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3448 NULL_RTX if we failed the caller should emit a normal call. */
3451 expand_builtin_strncpy (tree exp, rtx target)
3453 location_t loc = EXPR_LOCATION (exp);
3455 if (validate_arglist (exp,
3456 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3458 tree dest = CALL_EXPR_ARG (exp, 0);
3459 tree src = CALL_EXPR_ARG (exp, 1);
3460 tree len = CALL_EXPR_ARG (exp, 2);
3461 tree slen = c_strlen (src, 1);
3463 /* We must be passed a constant len and src parameter. */
3464 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3467 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3469 /* We're required to pad with trailing zeros if the requested
3470 len is greater than strlen(s2)+1. In that case try to
3471 use store_by_pieces, if it fails, punt. */
3472 if (tree_int_cst_lt (slen, len))
3474 unsigned int dest_align = get_pointer_alignment (dest);
3475 const char *p = c_getstr (src);
3478 if (!p || dest_align == 0 || !host_integerp (len, 1)
3479 || !can_store_by_pieces (tree_low_cst (len, 1),
3480 builtin_strncpy_read_str,
3481 CONST_CAST (char *, p),
3485 dest_mem = get_memory_rtx (dest, len);
3486 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3487 builtin_strncpy_read_str,
3488 CONST_CAST (char *, p), dest_align, false, 0);
3489 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3490 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3497 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3498 bytes from constant string DATA + OFFSET and return it as target
3502 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3503 enum machine_mode mode)
3505 const char *c = (const char *) data;
3506 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3508 memset (p, *c, GET_MODE_SIZE (mode));
3510 return c_readstr (p, mode);
3513 /* Callback routine for store_by_pieces. Return the RTL of a register
3514 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3515 char value given in the RTL register data. For example, if mode is
3516 4 bytes wide, return the RTL for 0x01010101*data. */
3519 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3520 enum machine_mode mode)
3526 size = GET_MODE_SIZE (mode);
3530 p = XALLOCAVEC (char, size);
3531 memset (p, 1, size);
3532 coeff = c_readstr (p, mode);
3534 target = convert_to_mode (mode, (rtx) data, 1);
3535 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3536 return force_reg (mode, target);
3539 /* Expand expression EXP, which is a call to the memset builtin. Return
3540 NULL_RTX if we failed the caller should emit a normal call, otherwise
3541 try to get the result in TARGET, if convenient (and in mode MODE if that's
3545 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3547 if (!validate_arglist (exp,
3548 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3552 tree dest = CALL_EXPR_ARG (exp, 0);
3553 tree val = CALL_EXPR_ARG (exp, 1);
3554 tree len = CALL_EXPR_ARG (exp, 2);
3555 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3559 /* Helper function to do the actual work for expand_builtin_memset. The
3560 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3561 so that this can also be called without constructing an actual CALL_EXPR.
3562 The other arguments and return value are the same as for
3563 expand_builtin_memset. */
3566 expand_builtin_memset_args (tree dest, tree val, tree len,
3567 rtx target, enum machine_mode mode, tree orig_exp)
3570 enum built_in_function fcode;
3571 enum machine_mode val_mode;
3573 unsigned int dest_align;
3574 rtx dest_mem, dest_addr, len_rtx;
3575 HOST_WIDE_INT expected_size = -1;
3576 unsigned int expected_align = 0;
3578 dest_align = get_pointer_alignment (dest);
3580 /* If DEST is not a pointer type, don't do this operation in-line. */
3581 if (dest_align == 0)
3584 if (currently_expanding_gimple_stmt)
3585 stringop_block_profile (currently_expanding_gimple_stmt,
3586 &expected_align, &expected_size);
3588 if (expected_align < dest_align)
3589 expected_align = dest_align;
3591 /* If the LEN parameter is zero, return DEST. */
3592 if (integer_zerop (len))
3594 /* Evaluate and ignore VAL in case it has side-effects. */
3595 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3596 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3599 /* Stabilize the arguments in case we fail. */
3600 dest = builtin_save_expr (dest);
3601 val = builtin_save_expr (val);
3602 len = builtin_save_expr (len);
3604 len_rtx = expand_normal (len);
3605 dest_mem = get_memory_rtx (dest, len);
3606 val_mode = TYPE_MODE (unsigned_char_type_node);
3608 if (TREE_CODE (val) != INTEGER_CST)
3612 val_rtx = expand_normal (val);
3613 val_rtx = convert_to_mode (val_mode, val_rtx, 0);
3615 /* Assume that we can memset by pieces if we can store
3616 * the coefficients by pieces (in the required modes).
3617 * We can't pass builtin_memset_gen_str as that emits RTL. */
3619 if (host_integerp (len, 1)
3620 && can_store_by_pieces (tree_low_cst (len, 1),
3621 builtin_memset_read_str, &c, dest_align,
3624 val_rtx = force_reg (val_mode, val_rtx);
3625 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3626 builtin_memset_gen_str, val_rtx, dest_align,
3629 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3630 dest_align, expected_align,
3634 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3635 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3639 if (target_char_cast (val, &c))
3644 if (host_integerp (len, 1)
3645 && can_store_by_pieces (tree_low_cst (len, 1),
3646 builtin_memset_read_str, &c, dest_align,
3648 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3649 builtin_memset_read_str, &c, dest_align, true, 0);
3650 else if (!set_storage_via_setmem (dest_mem, len_rtx,
3651 gen_int_mode (c, val_mode),
3652 dest_align, expected_align,
3656 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3657 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3661 set_mem_align (dest_mem, dest_align);
3662 dest_addr = clear_storage_hints (dest_mem, len_rtx,
3663 CALL_EXPR_TAILCALL (orig_exp)
3664 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3665 expected_align, expected_size);
3669 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3670 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3676 fndecl = get_callee_fndecl (orig_exp);
3677 fcode = DECL_FUNCTION_CODE (fndecl);
3678 if (fcode == BUILT_IN_MEMSET)
3679 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
3681 else if (fcode == BUILT_IN_BZERO)
3682 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
3686 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3687 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3688 return expand_call (fn, target, target == const0_rtx);
3691 /* Expand expression EXP, which is a call to the bzero builtin. Return
3692 NULL_RTX if we failed the caller should emit a normal call. */
3695 expand_builtin_bzero (tree exp)
3698 location_t loc = EXPR_LOCATION (exp);
3700 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3703 dest = CALL_EXPR_ARG (exp, 0);
3704 size = CALL_EXPR_ARG (exp, 1);
3706 /* New argument list transforming bzero(ptr x, int y) to
3707 memset(ptr x, int 0, size_t y). This is done this way
3708 so that if it isn't expanded inline, we fallback to
3709 calling bzero instead of memset. */
3711 return expand_builtin_memset_args (dest, integer_zero_node,
3712 fold_convert_loc (loc,
3713 size_type_node, size),
3714 const0_rtx, VOIDmode, exp);
3717 /* Expand expression EXP, which is a call to the memcmp built-in function.
3718 Return NULL_RTX if we failed and the caller should emit a normal call,
3719 otherwise try to get the result in TARGET, if convenient (and in mode
3720 MODE, if that's convenient). */
3723 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3724 ATTRIBUTE_UNUSED enum machine_mode mode)
3726 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3728 if (!validate_arglist (exp,
3729 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3732 /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3733 implementing memcmp because it will stop if it encounters two
3735 #if defined HAVE_cmpmemsi
3737 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3740 tree arg1 = CALL_EXPR_ARG (exp, 0);
3741 tree arg2 = CALL_EXPR_ARG (exp, 1);
3742 tree len = CALL_EXPR_ARG (exp, 2);
3744 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3745 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3746 enum machine_mode insn_mode;
3749 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3753 /* If we don't have POINTER_TYPE, call the function. */
3754 if (arg1_align == 0 || arg2_align == 0)
3757 /* Make a place to write the result of the instruction. */
3760 && REG_P (result) && GET_MODE (result) == insn_mode
3761 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3762 result = gen_reg_rtx (insn_mode);
3764 arg1_rtx = get_memory_rtx (arg1, len);
3765 arg2_rtx = get_memory_rtx (arg2, len);
3766 arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3768 /* Set MEM_SIZE as appropriate. */
3769 if (CONST_INT_P (arg3_rtx))
3771 set_mem_size (arg1_rtx, INTVAL (arg3_rtx));
3772 set_mem_size (arg2_rtx, INTVAL (arg3_rtx));
3776 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3777 GEN_INT (MIN (arg1_align, arg2_align)));
3784 emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3785 TYPE_MODE (integer_type_node), 3,
3786 XEXP (arg1_rtx, 0), Pmode,
3787 XEXP (arg2_rtx, 0), Pmode,
3788 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3789 TYPE_UNSIGNED (sizetype)),
3790 TYPE_MODE (sizetype));
3792 /* Return the value in the proper mode for this function. */
3793 mode = TYPE_MODE (TREE_TYPE (exp));
3794 if (GET_MODE (result) == mode)
3796 else if (target != 0)
3798 convert_move (target, result, 0);
3802 return convert_to_mode (mode, result, 0);
3804 #endif /* HAVE_cmpmemsi. */
3809 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
3810 if we failed the caller should emit a normal call, otherwise try to get
3811 the result in TARGET, if convenient. */
3814 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
3816 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3819 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3820 if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
3821 || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
3823 rtx arg1_rtx, arg2_rtx;
3824 rtx result, insn = NULL_RTX;
3826 tree arg1 = CALL_EXPR_ARG (exp, 0);
3827 tree arg2 = CALL_EXPR_ARG (exp, 1);
3829 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3830 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3832 /* If we don't have POINTER_TYPE, call the function. */
3833 if (arg1_align == 0 || arg2_align == 0)
3836 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
3837 arg1 = builtin_save_expr (arg1);
3838 arg2 = builtin_save_expr (arg2);
3840 arg1_rtx = get_memory_rtx (arg1, NULL);
3841 arg2_rtx = get_memory_rtx (arg2, NULL);
3843 #ifdef HAVE_cmpstrsi
3844 /* Try to call cmpstrsi. */
3847 enum machine_mode insn_mode
3848 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3850 /* Make a place to write the result of the instruction. */
3853 && REG_P (result) && GET_MODE (result) == insn_mode
3854 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3855 result = gen_reg_rtx (insn_mode);
3857 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
3858 GEN_INT (MIN (arg1_align, arg2_align)));
3861 #ifdef HAVE_cmpstrnsi
3862 /* Try to determine at least one length and call cmpstrnsi. */
3863 if (!insn && HAVE_cmpstrnsi)
3868 enum machine_mode insn_mode
3869 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3870 tree len1 = c_strlen (arg1, 1);
3871 tree len2 = c_strlen (arg2, 1);
3874 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3876 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3878 /* If we don't have a constant length for the first, use the length
3879 of the second, if we know it. We don't require a constant for
3880 this case; some cost analysis could be done if both are available
3881 but neither is constant. For now, assume they're equally cheap,
3882 unless one has side effects. If both strings have constant lengths,
3889 else if (TREE_SIDE_EFFECTS (len1))
3891 else if (TREE_SIDE_EFFECTS (len2))
3893 else if (TREE_CODE (len1) != INTEGER_CST)
3895 else if (TREE_CODE (len2) != INTEGER_CST)
3897 else if (tree_int_cst_lt (len1, len2))
3902 /* If both arguments have side effects, we cannot optimize. */
3903 if (!len || TREE_SIDE_EFFECTS (len))
3906 arg3_rtx = expand_normal (len);
3908 /* Make a place to write the result of the instruction. */
3911 && REG_P (result) && GET_MODE (result) == insn_mode
3912 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3913 result = gen_reg_rtx (insn_mode);
3915 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3916 GEN_INT (MIN (arg1_align, arg2_align)));
3922 enum machine_mode mode;
3925 /* Return the value in the proper mode for this function. */
3926 mode = TYPE_MODE (TREE_TYPE (exp));
3927 if (GET_MODE (result) == mode)
3930 return convert_to_mode (mode, result, 0);
3931 convert_move (target, result, 0);
3935 /* Expand the library call ourselves using a stabilized argument
3936 list to avoid re-evaluating the function's arguments twice. */
3937 #ifdef HAVE_cmpstrnsi
3940 fndecl = get_callee_fndecl (exp);
3941 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
3942 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3943 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3944 return expand_call (fn, target, target == const0_rtx);
3950 /* Expand expression EXP, which is a call to the strncmp builtin. Return
3951 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
3952 the result in TARGET, if convenient. */
3955 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3956 ATTRIBUTE_UNUSED enum machine_mode mode)
3958 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3960 if (!validate_arglist (exp,
3961 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3964 /* If c_strlen can determine an expression for one of the string
3965 lengths, and it doesn't have side effects, then emit cmpstrnsi
3966 using length MIN(strlen(string)+1, arg3). */
3967 #ifdef HAVE_cmpstrnsi
3970 tree len, len1, len2;
3971 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3974 tree arg1 = CALL_EXPR_ARG (exp, 0);
3975 tree arg2 = CALL_EXPR_ARG (exp, 1);
3976 tree arg3 = CALL_EXPR_ARG (exp, 2);
3978 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3979 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3980 enum machine_mode insn_mode
3981 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3983 len1 = c_strlen (arg1, 1);
3984 len2 = c_strlen (arg2, 1);
3987 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
3989 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
3991 /* If we don't have a constant length for the first, use the length
3992 of the second, if we know it. We don't require a constant for
3993 this case; some cost analysis could be done if both are available
3994 but neither is constant. For now, assume they're equally cheap,
3995 unless one has side effects. If both strings have constant lengths,
4002 else if (TREE_SIDE_EFFECTS (len1))
4004 else if (TREE_SIDE_EFFECTS (len2))
4006 else if (TREE_CODE (len1) != INTEGER_CST)
4008 else if (TREE_CODE (len2) != INTEGER_CST)
4010 else if (tree_int_cst_lt (len1, len2))
4015 /* If both arguments have side effects, we cannot optimize. */
4016 if (!len || TREE_SIDE_EFFECTS (len))
4019 /* The actual new length parameter is MIN(len,arg3). */
4020 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4021 fold_convert_loc (loc, TREE_TYPE (len), arg3));
4023 /* If we don't have POINTER_TYPE, call the function. */
4024 if (arg1_align == 0 || arg2_align == 0)
4027 /* Make a place to write the result of the instruction. */
4030 && REG_P (result) && GET_MODE (result) == insn_mode
4031 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4032 result = gen_reg_rtx (insn_mode);
4034 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4035 arg1 = builtin_save_expr (arg1);
4036 arg2 = builtin_save_expr (arg2);
4037 len = builtin_save_expr (len);
4039 arg1_rtx = get_memory_rtx (arg1, len);
4040 arg2_rtx = get_memory_rtx (arg2, len);
4041 arg3_rtx = expand_normal (len);
4042 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4043 GEN_INT (MIN (arg1_align, arg2_align)));
4048 /* Return the value in the proper mode for this function. */
4049 mode = TYPE_MODE (TREE_TYPE (exp));
4050 if (GET_MODE (result) == mode)
4053 return convert_to_mode (mode, result, 0);
4054 convert_move (target, result, 0);
4058 /* Expand the library call ourselves using a stabilized argument
4059 list to avoid re-evaluating the function's arguments twice. */
4060 fndecl = get_callee_fndecl (exp);
4061 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4063 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4064 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4065 return expand_call (fn, target, target == const0_rtx);
4071 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4072 if that's convenient. */
4075 expand_builtin_saveregs (void)
4079 /* Don't do __builtin_saveregs more than once in a function.
4080 Save the result of the first call and reuse it. */
4081 if (saveregs_value != 0)
4082 return saveregs_value;
4084 /* When this function is called, it means that registers must be
4085 saved on entry to this function. So we migrate the call to the
4086 first insn of this function. */
4090 /* Do whatever the machine needs done in this case. */
4091 val = targetm.calls.expand_builtin_saveregs ();
4096 saveregs_value = val;
4098 /* Put the insns after the NOTE that starts the function. If this
4099 is inside a start_sequence, make the outer-level insn chain current, so
4100 the code is placed at the start of the function. */
4101 push_topmost_sequence ();
4102 emit_insn_after (seq, entry_of_function ());
4103 pop_topmost_sequence ();
4108 /* Expand a call to __builtin_next_arg. */
4111 expand_builtin_next_arg (void)
4113 /* Checking arguments is already done in fold_builtin_next_arg
4114 that must be called before this function. */
4115 return expand_binop (ptr_mode, add_optab,
4116 crtl->args.internal_arg_pointer,
4117 crtl->args.arg_offset_rtx,
4118 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4121 /* Make it easier for the backends by protecting the valist argument
4122 from multiple evaluations. */
4125 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4127 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4129 /* The current way of determining the type of valist is completely
4130 bogus. We should have the information on the va builtin instead. */
4132 vatype = targetm.fn_abi_va_list (cfun->decl);
4134 if (TREE_CODE (vatype) == ARRAY_TYPE)
4136 if (TREE_SIDE_EFFECTS (valist))
4137 valist = save_expr (valist);
4139 /* For this case, the backends will be expecting a pointer to
4140 vatype, but it's possible we've actually been given an array
4141 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4143 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4145 tree p1 = build_pointer_type (TREE_TYPE (vatype));
4146 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4151 tree pt = build_pointer_type (vatype);
4155 if (! TREE_SIDE_EFFECTS (valist))
4158 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4159 TREE_SIDE_EFFECTS (valist) = 1;
4162 if (TREE_SIDE_EFFECTS (valist))
4163 valist = save_expr (valist);
4164 valist = fold_build2_loc (loc, MEM_REF,
4165 vatype, valist, build_int_cst (pt, 0));
4171 /* The "standard" definition of va_list is void*. */
4174 std_build_builtin_va_list (void)
4176 return ptr_type_node;
4179 /* The "standard" abi va_list is va_list_type_node. */
4182 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4184 return va_list_type_node;
4187 /* The "standard" type of va_list is va_list_type_node. */
4190 std_canonical_va_list_type (tree type)
4194 if (INDIRECT_REF_P (type))
4195 type = TREE_TYPE (type);
4196 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4197 type = TREE_TYPE (type);
4198 wtype = va_list_type_node;
4200 /* Treat structure va_list types. */
4201 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4202 htype = TREE_TYPE (htype);
4203 else if (TREE_CODE (wtype) == ARRAY_TYPE)
4205 /* If va_list is an array type, the argument may have decayed
4206 to a pointer type, e.g. by being passed to another function.
4207 In that case, unwrap both types so that we can compare the
4208 underlying records. */
4209 if (TREE_CODE (htype) == ARRAY_TYPE
4210 || POINTER_TYPE_P (htype))
4212 wtype = TREE_TYPE (wtype);
4213 htype = TREE_TYPE (htype);
4216 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4217 return va_list_type_node;
4222 /* The "standard" implementation of va_start: just assign `nextarg' to
4226 std_expand_builtin_va_start (tree valist, rtx nextarg)
4228 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4229 convert_move (va_r, nextarg, 0);
4232 /* Expand EXP, a call to __builtin_va_start. */
4235 expand_builtin_va_start (tree exp)
4239 location_t loc = EXPR_LOCATION (exp);
4241 if (call_expr_nargs (exp) < 2)
4243 error_at (loc, "too few arguments to function %<va_start%>");
4247 if (fold_builtin_next_arg (exp, true))
4250 nextarg = expand_builtin_next_arg ();
4251 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4253 if (targetm.expand_builtin_va_start)
4254 targetm.expand_builtin_va_start (valist, nextarg);
4256 std_expand_builtin_va_start (valist, nextarg);
4261 /* The "standard" implementation of va_arg: read the value from the
4262 current (padded) address and increment by the (padded) size. */
4265 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4268 tree addr, t, type_size, rounded_size, valist_tmp;
4269 unsigned HOST_WIDE_INT align, boundary;
4272 #ifdef ARGS_GROW_DOWNWARD
4273 /* All of the alignment and movement below is for args-grow-up machines.
4274 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4275 implement their own specialized gimplify_va_arg_expr routines. */
4279 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4281 type = build_pointer_type (type);
4283 align = PARM_BOUNDARY / BITS_PER_UNIT;
4284 boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
4286 /* When we align parameter on stack for caller, if the parameter
4287 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4288 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
4289 here with caller. */
4290 if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4291 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4293 boundary /= BITS_PER_UNIT;
4295 /* Hoist the valist value into a temporary for the moment. */
4296 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4298 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4299 requires greater alignment, we must perform dynamic alignment. */
4300 if (boundary > align
4301 && !integer_zerop (TYPE_SIZE (type)))
4303 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4304 fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
4305 gimplify_and_add (t, pre_p);
4307 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4308 fold_build2 (BIT_AND_EXPR, TREE_TYPE (valist),
4310 build_int_cst (TREE_TYPE (valist), -boundary)));
4311 gimplify_and_add (t, pre_p);
4316 /* If the actual alignment is less than the alignment of the type,
4317 adjust the type accordingly so that we don't assume strict alignment
4318 when dereferencing the pointer. */
4319 boundary *= BITS_PER_UNIT;
4320 if (boundary < TYPE_ALIGN (type))
4322 type = build_variant_type_copy (type);
4323 TYPE_ALIGN (type) = boundary;
4326 /* Compute the rounded size of the type. */
4327 type_size = size_in_bytes (type);
4328 rounded_size = round_up (type_size, align);
4330 /* Reduce rounded_size so it's sharable with the postqueue. */
4331 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4335 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4337 /* Small args are padded downward. */
4338 t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4339 rounded_size, size_int (align));
4340 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4341 size_binop (MINUS_EXPR, rounded_size, type_size));
4342 addr = fold_build_pointer_plus (addr, t);
4345 /* Compute new value for AP. */
4346 t = fold_build_pointer_plus (valist_tmp, rounded_size);
4347 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4348 gimplify_and_add (t, pre_p);
4350 addr = fold_convert (build_pointer_type (type), addr);
4353 addr = build_va_arg_indirect_ref (addr);
4355 return build_va_arg_indirect_ref (addr);
4358 /* Build an indirect-ref expression over the given TREE, which represents a
4359 piece of a va_arg() expansion. */
4361 build_va_arg_indirect_ref (tree addr)
4363 addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
4365 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4371 /* Return a dummy expression of type TYPE in order to keep going after an
4375 dummy_object (tree type)
4377 tree t = build_int_cst (build_pointer_type (type), 0);
4378 return build2 (MEM_REF, type, t, t);
4381 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4382 builtin function, but a very special sort of operator. */
4384 enum gimplify_status
4385 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4387 tree promoted_type, have_va_type;
4388 tree valist = TREE_OPERAND (*expr_p, 0);
4389 tree type = TREE_TYPE (*expr_p);
4391 location_t loc = EXPR_LOCATION (*expr_p);
4393 /* Verify that valist is of the proper type. */
4394 have_va_type = TREE_TYPE (valist);
4395 if (have_va_type == error_mark_node)
4397 have_va_type = targetm.canonical_va_list_type (have_va_type);
4399 if (have_va_type == NULL_TREE)
4401 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4405 /* Generate a diagnostic for requesting data of a type that cannot
4406 be passed through `...' due to type promotion at the call site. */
4407 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4410 static bool gave_help;
4413 /* Unfortunately, this is merely undefined, rather than a constraint
4414 violation, so we cannot make this an error. If this call is never
4415 executed, the program is still strictly conforming. */
4416 warned = warning_at (loc, 0,
4417 "%qT is promoted to %qT when passed through %<...%>",
4418 type, promoted_type);
4419 if (!gave_help && warned)
4422 inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4423 promoted_type, type);
4426 /* We can, however, treat "undefined" any way we please.
4427 Call abort to encourage the user to fix the program. */
4429 inform (loc, "if this code is reached, the program will abort");
4430 /* Before the abort, allow the evaluation of the va_list
4431 expression to exit or longjmp. */
4432 gimplify_and_add (valist, pre_p);
4433 t = build_call_expr_loc (loc,
4434 builtin_decl_implicit (BUILT_IN_TRAP), 0);
4435 gimplify_and_add (t, pre_p);
4437 /* This is dead code, but go ahead and finish so that the
4438 mode of the result comes out right. */
4439 *expr_p = dummy_object (type);
4444 /* Make it easier for the backends by protecting the valist argument
4445 from multiple evaluations. */
4446 if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4448 /* For this case, the backends will be expecting a pointer to
4449 TREE_TYPE (abi), but it's possible we've
4450 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4452 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4454 tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4455 valist = fold_convert_loc (loc, p1,
4456 build_fold_addr_expr_loc (loc, valist));
4459 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4462 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4464 if (!targetm.gimplify_va_arg_expr)
4465 /* FIXME: Once most targets are converted we should merely
4466 assert this is non-null. */
4469 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4474 /* Expand EXP, a call to __builtin_va_end. */
4477 expand_builtin_va_end (tree exp)
4479 tree valist = CALL_EXPR_ARG (exp, 0);
4481 /* Evaluate for side effects, if needed. I hate macros that don't
4483 if (TREE_SIDE_EFFECTS (valist))
4484 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4489 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4490 builtin rather than just as an assignment in stdarg.h because of the
4491 nastiness of array-type va_list types. */
4494 expand_builtin_va_copy (tree exp)
4497 location_t loc = EXPR_LOCATION (exp);
4499 dst = CALL_EXPR_ARG (exp, 0);
4500 src = CALL_EXPR_ARG (exp, 1);
4502 dst = stabilize_va_list_loc (loc, dst, 1);
4503 src = stabilize_va_list_loc (loc, src, 0);
4505 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4507 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4509 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4510 TREE_SIDE_EFFECTS (t) = 1;
4511 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4515 rtx dstb, srcb, size;
4517 /* Evaluate to pointers. */
4518 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4519 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4520 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4521 NULL_RTX, VOIDmode, EXPAND_NORMAL);
4523 dstb = convert_memory_address (Pmode, dstb);
4524 srcb = convert_memory_address (Pmode, srcb);
4526 /* "Dereference" to BLKmode memories. */
4527 dstb = gen_rtx_MEM (BLKmode, dstb);
4528 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4529 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4530 srcb = gen_rtx_MEM (BLKmode, srcb);
4531 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4532 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4535 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4541 /* Expand a call to one of the builtin functions __builtin_frame_address or
4542 __builtin_return_address. */
4545 expand_builtin_frame_address (tree fndecl, tree exp)
4547 /* The argument must be a nonnegative integer constant.
4548 It counts the number of frames to scan up the stack.
4549 The value is the return address saved in that frame. */
4550 if (call_expr_nargs (exp) == 0)
4551 /* Warning about missing arg was already issued. */
4553 else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4555 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4556 error ("invalid argument to %<__builtin_frame_address%>");
4558 error ("invalid argument to %<__builtin_return_address%>");
4564 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4565 tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4567 /* Some ports cannot access arbitrary stack frames. */
4570 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4571 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4573 warning (0, "unsupported argument to %<__builtin_return_address%>");
4577 /* For __builtin_frame_address, return what we've got. */
4578 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4582 && ! CONSTANT_P (tem))
4583 tem = copy_to_mode_reg (Pmode, tem);
4588 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4589 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4590 is the same as for allocate_dynamic_stack_space. */
4593 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4599 bool alloca_with_align = (DECL_FUNCTION_CODE (get_callee_fndecl (exp))
4600 == BUILT_IN_ALLOCA_WITH_ALIGN);
4602 /* Emit normal call if we use mudflap. */
4607 = (alloca_with_align
4608 ? validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)
4609 : validate_arglist (exp, INTEGER_TYPE, VOID_TYPE));
4614 /* Compute the argument. */
4615 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4617 /* Compute the alignment. */
4618 align = (alloca_with_align
4619 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp, 1))
4620 : BIGGEST_ALIGNMENT);
4622 /* Allocate the desired space. */
4623 result = allocate_dynamic_stack_space (op0, 0, align, cannot_accumulate);
4624 result = convert_memory_address (ptr_mode, result);
4629 /* Expand a call to a bswap builtin with argument ARG0. MODE
4630 is the mode to expand with. */
4633 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4635 enum machine_mode mode;
4639 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4642 arg = CALL_EXPR_ARG (exp, 0);
4643 mode = TYPE_MODE (TREE_TYPE (arg));
4644 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4646 target = expand_unop (mode, bswap_optab, op0, target, 1);
4648 gcc_assert (target);
4650 return convert_to_mode (mode, target, 0);
4653 /* Expand a call to a unary builtin in EXP.
4654 Return NULL_RTX if a normal call should be emitted rather than expanding the
4655 function in-line. If convenient, the result should be placed in TARGET.
4656 SUBTARGET may be used as the target for computing one of EXP's operands. */
4659 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4660 rtx subtarget, optab op_optab)
4664 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4667 /* Compute the argument. */
4668 op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
4670 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
4671 == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
4672 VOIDmode, EXPAND_NORMAL);
4673 /* Compute op, into TARGET if possible.
4674 Set TARGET to wherever the result comes back. */
4675 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4676 op_optab, op0, target, op_optab != clrsb_optab);
4677 gcc_assert (target);
4679 return convert_to_mode (target_mode, target, 0);
4682 /* Expand a call to __builtin_expect. We just return our argument
4683 as the builtin_expect semantic should've been already executed by
4684 tree branch prediction pass. */
4687 expand_builtin_expect (tree exp, rtx target)
4691 if (call_expr_nargs (exp) < 2)
4693 arg = CALL_EXPR_ARG (exp, 0);
4695 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4696 /* When guessing was done, the hints should be already stripped away. */
4697 gcc_assert (!flag_guess_branch_prob
4698 || optimize == 0 || seen_error ());
4702 /* Expand a call to __builtin_assume_aligned. We just return our first
4703 argument as the builtin_assume_aligned semantic should've been already
4707 expand_builtin_assume_aligned (tree exp, rtx target)
4709 if (call_expr_nargs (exp) < 2)
4711 target = expand_expr (CALL_EXPR_ARG (exp, 0), target, VOIDmode,
4713 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 1))
4714 && (call_expr_nargs (exp) < 3
4715 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 2))));
4720 expand_builtin_trap (void)
4724 emit_insn (gen_trap ());
4727 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4731 /* Expand a call to __builtin_unreachable. We do nothing except emit
4732 a barrier saying that control flow will not pass here.
4734 It is the responsibility of the program being compiled to ensure
4735 that control flow does never reach __builtin_unreachable. */
4737 expand_builtin_unreachable (void)
4742 /* Expand EXP, a call to fabs, fabsf or fabsl.
4743 Return NULL_RTX if a normal call should be emitted rather than expanding
4744 the function inline. If convenient, the result should be placed
4745 in TARGET. SUBTARGET may be used as the target for computing
4749 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4751 enum machine_mode mode;
4755 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4758 arg = CALL_EXPR_ARG (exp, 0);
4759 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4760 mode = TYPE_MODE (TREE_TYPE (arg));
4761 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4762 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4765 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4766 Return NULL is a normal call should be emitted rather than expanding the
4767 function inline. If convenient, the result should be placed in TARGET.
4768 SUBTARGET may be used as the target for computing the operand. */
4771 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4776 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4779 arg = CALL_EXPR_ARG (exp, 0);
4780 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4782 arg = CALL_EXPR_ARG (exp, 1);
4783 op1 = expand_normal (arg);
4785 return expand_copysign (op0, op1, target);
4788 /* Create a new constant string literal and return a char* pointer to it.
4789 The STRING_CST value is the LEN characters at STR. */
4791 build_string_literal (int len, const char *str)
4793 tree t, elem, index, type;
4795 t = build_string (len, str);
4796 elem = build_type_variant (char_type_node, 1, 0);
4797 index = build_index_type (size_int (len - 1));
4798 type = build_array_type (elem, index);
4799 TREE_TYPE (t) = type;
4800 TREE_CONSTANT (t) = 1;
4801 TREE_READONLY (t) = 1;
4802 TREE_STATIC (t) = 1;
4804 type = build_pointer_type (elem);
4805 t = build1 (ADDR_EXPR, type,
4806 build4 (ARRAY_REF, elem,
4807 t, integer_zero_node, NULL_TREE, NULL_TREE));
4811 /* Expand a call to __builtin___clear_cache. */
4814 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
4816 #ifndef HAVE_clear_cache
4817 #ifdef CLEAR_INSN_CACHE
4818 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4819 does something. Just do the default expansion to a call to
4823 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4824 does nothing. There is no need to call it. Do nothing. */
4826 #endif /* CLEAR_INSN_CACHE */
4828 /* We have a "clear_cache" insn, and it will handle everything. */
4830 rtx begin_rtx, end_rtx;
4832 /* We must not expand to a library call. If we did, any
4833 fallback library function in libgcc that might contain a call to
4834 __builtin___clear_cache() would recurse infinitely. */
4835 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4837 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4841 if (HAVE_clear_cache)
4843 struct expand_operand ops[2];
4845 begin = CALL_EXPR_ARG (exp, 0);
4846 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
4848 end = CALL_EXPR_ARG (exp, 1);
4849 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
4851 create_address_operand (&ops[0], begin_rtx);
4852 create_address_operand (&ops[1], end_rtx);
4853 if (maybe_expand_insn (CODE_FOR_clear_cache, 2, ops))
4857 #endif /* HAVE_clear_cache */
4860 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
4863 round_trampoline_addr (rtx tramp)
4865 rtx temp, addend, mask;
4867 /* If we don't need too much alignment, we'll have been guaranteed
4868 proper alignment by get_trampoline_type. */
4869 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
4872 /* Round address up to desired boundary. */
4873 temp = gen_reg_rtx (Pmode);
4874 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
4875 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
4877 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
4878 temp, 0, OPTAB_LIB_WIDEN);
4879 tramp = expand_simple_binop (Pmode, AND, temp, mask,
4880 temp, 0, OPTAB_LIB_WIDEN);
4886 expand_builtin_init_trampoline (tree exp, bool onstack)
4888 tree t_tramp, t_func, t_chain;
4889 rtx m_tramp, r_tramp, r_chain, tmp;
4891 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
4892 POINTER_TYPE, VOID_TYPE))
4895 t_tramp = CALL_EXPR_ARG (exp, 0);
4896 t_func = CALL_EXPR_ARG (exp, 1);
4897 t_chain = CALL_EXPR_ARG (exp, 2);
4899 r_tramp = expand_normal (t_tramp);
4900 m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
4901 MEM_NOTRAP_P (m_tramp) = 1;
4903 /* If ONSTACK, the TRAMP argument should be the address of a field
4904 within the local function's FRAME decl. Either way, let's see if
4905 we can fill in the MEM_ATTRs for this memory. */
4906 if (TREE_CODE (t_tramp) == ADDR_EXPR)
4907 set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
4910 /* Creator of a heap trampoline is responsible for making sure the
4911 address is aligned to at least STACK_BOUNDARY. Normally malloc
4912 will ensure this anyhow. */
4913 tmp = round_trampoline_addr (r_tramp);
4916 m_tramp = change_address (m_tramp, BLKmode, tmp);
4917 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
4918 set_mem_size (m_tramp, TRAMPOLINE_SIZE);
4921 /* The FUNC argument should be the address of the nested function.
4922 Extract the actual function decl to pass to the hook. */
4923 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
4924 t_func = TREE_OPERAND (t_func, 0);
4925 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
4927 r_chain = expand_normal (t_chain);
4929 /* Generate insns to initialize the trampoline. */
4930 targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
4934 trampolines_created = 1;
4936 warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
4937 "trampoline generated for nested function %qD", t_func);
4944 expand_builtin_adjust_trampoline (tree exp)
4948 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
4951 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
4952 tramp = round_trampoline_addr (tramp);
4953 if (targetm.calls.trampoline_adjust_address)
4954 tramp = targetm.calls.trampoline_adjust_address (tramp);
4959 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4960 function. The function first checks whether the back end provides
4961 an insn to implement signbit for the respective mode. If not, it
4962 checks whether the floating point format of the value is such that
4963 the sign bit can be extracted. If that is not the case, the
4964 function returns NULL_RTX to indicate that a normal call should be
4965 emitted rather than expanding the function in-line. EXP is the
4966 expression that is a call to the builtin function; if convenient,
4967 the result should be placed in TARGET. */
4969 expand_builtin_signbit (tree exp, rtx target)
4971 const struct real_format *fmt;
4972 enum machine_mode fmode, imode, rmode;
4975 enum insn_code icode;
4977 location_t loc = EXPR_LOCATION (exp);
4979 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4982 arg = CALL_EXPR_ARG (exp, 0);
4983 fmode = TYPE_MODE (TREE_TYPE (arg));
4984 rmode = TYPE_MODE (TREE_TYPE (exp));
4985 fmt = REAL_MODE_FORMAT (fmode);
4987 arg = builtin_save_expr (arg);
4989 /* Expand the argument yielding a RTX expression. */
4990 temp = expand_normal (arg);
4992 /* Check if the back end provides an insn that handles signbit for the
4994 icode = optab_handler (signbit_optab, fmode);
4995 if (icode != CODE_FOR_nothing)
4997 rtx last = get_last_insn ();
4998 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
4999 if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5001 delete_insns_since (last);
5004 /* For floating point formats without a sign bit, implement signbit
5006 bitpos = fmt->signbit_ro;
5009 /* But we can't do this if the format supports signed zero. */
5010 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5013 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5014 build_real (TREE_TYPE (arg), dconst0));
5015 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5018 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5020 imode = int_mode_for_mode (fmode);
5021 if (imode == BLKmode)
5023 temp = gen_lowpart (imode, temp);
5028 /* Handle targets with different FP word orders. */
5029 if (FLOAT_WORDS_BIG_ENDIAN)
5030 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5032 word = bitpos / BITS_PER_WORD;
5033 temp = operand_subword_force (temp, word, fmode);
5034 bitpos = bitpos % BITS_PER_WORD;
5037 /* Force the intermediate word_mode (or narrower) result into a
5038 register. This avoids attempting to create paradoxical SUBREGs
5039 of floating point modes below. */
5040 temp = force_reg (imode, temp);
5042 /* If the bitpos is within the "result mode" lowpart, the operation
5043 can be implement with a single bitwise AND. Otherwise, we need
5044 a right shift and an AND. */
5046 if (bitpos < GET_MODE_BITSIZE (rmode))
5048 double_int mask = double_int_setbit (double_int_zero, bitpos);
5050 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5051 temp = gen_lowpart (rmode, temp);
5052 temp = expand_binop (rmode, and_optab, temp,
5053 immed_double_int_const (mask, rmode),
5054 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5058 /* Perform a logical right shift to place the signbit in the least
5059 significant bit, then truncate the result to the desired mode
5060 and mask just this bit. */
5061 temp = expand_shift (RSHIFT_EXPR, imode, temp, bitpos, NULL_RTX, 1);
5062 temp = gen_lowpart (rmode, temp);
5063 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5064 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5070 /* Expand fork or exec calls. TARGET is the desired target of the
5071 call. EXP is the call. FN is the
5072 identificator of the actual function. IGNORE is nonzero if the
5073 value is to be ignored. */
5076 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5081 /* If we are not profiling, just call the function. */
5082 if (!profile_arc_flag)
5085 /* Otherwise call the wrapper. This should be equivalent for the rest of
5086 compiler, so the code does not diverge, and the wrapper may run the
5087 code necessary for keeping the profiling sane. */
5089 switch (DECL_FUNCTION_CODE (fn))
5092 id = get_identifier ("__gcov_fork");
5095 case BUILT_IN_EXECL:
5096 id = get_identifier ("__gcov_execl");
5099 case BUILT_IN_EXECV:
5100 id = get_identifier ("__gcov_execv");
5103 case BUILT_IN_EXECLP:
5104 id = get_identifier ("__gcov_execlp");
5107 case BUILT_IN_EXECLE:
5108 id = get_identifier ("__gcov_execle");
5111 case BUILT_IN_EXECVP:
5112 id = get_identifier ("__gcov_execvp");
5115 case BUILT_IN_EXECVE:
5116 id = get_identifier ("__gcov_execve");
5123 decl = build_decl (DECL_SOURCE_LOCATION (fn),
5124 FUNCTION_DECL, id, TREE_TYPE (fn));
5125 DECL_EXTERNAL (decl) = 1;
5126 TREE_PUBLIC (decl) = 1;
5127 DECL_ARTIFICIAL (decl) = 1;
5128 TREE_NOTHROW (decl) = 1;
5129 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5130 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5131 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5132 return expand_call (call, target, ignore);
5137 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5138 the pointer in these functions is void*, the tree optimizers may remove
5139 casts. The mode computed in expand_builtin isn't reliable either, due
5140 to __sync_bool_compare_and_swap.
5142 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5143 group of builtins. This gives us log2 of the mode size. */
5145 static inline enum machine_mode
5146 get_builtin_sync_mode (int fcode_diff)
5148 /* The size is not negotiable, so ask not to get BLKmode in return
5149 if the target indicates that a smaller size would be better. */
5150 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5153 /* Expand the memory expression LOC and return the appropriate memory operand
5154 for the builtin_sync operations. */
5157 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5161 addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5162 addr = convert_memory_address (Pmode, addr);
5164 /* Note that we explicitly do not want any alias information for this
5165 memory, so that we kill all other live memories. Otherwise we don't
5166 satisfy the full barrier semantics of the intrinsic. */
5167 mem = validize_mem (gen_rtx_MEM (mode, addr));
5169 /* The alignment needs to be at least according to that of the mode. */
5170 set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5171 get_pointer_alignment (loc)));
5172 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5173 MEM_VOLATILE_P (mem) = 1;
5178 /* Make sure an argument is in the right mode.
5179 EXP is the tree argument.
5180 MODE is the mode it should be in. */
5183 expand_expr_force_mode (tree exp, enum machine_mode mode)
5186 enum machine_mode old_mode;
5188 val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL);
5189 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5190 of CONST_INTs, where we know the old_mode only from the call argument. */
5192 old_mode = GET_MODE (val);
5193 if (old_mode == VOIDmode)
5194 old_mode = TYPE_MODE (TREE_TYPE (exp));
5195 val = convert_modes (mode, old_mode, val, 1);
5200 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5201 EXP is the CALL_EXPR. CODE is the rtx code
5202 that corresponds to the arithmetic or logical operation from the name;
5203 an exception here is that NOT actually means NAND. TARGET is an optional
5204 place for us to store the results; AFTER is true if this is the
5205 fetch_and_xxx form. */
5208 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5209 enum rtx_code code, bool after,
5213 location_t loc = EXPR_LOCATION (exp);
5215 if (code == NOT && warn_sync_nand)
5217 tree fndecl = get_callee_fndecl (exp);
5218 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5220 static bool warned_f_a_n, warned_n_a_f;
5224 case BUILT_IN_SYNC_FETCH_AND_NAND_1:
5225 case BUILT_IN_SYNC_FETCH_AND_NAND_2:
5226 case BUILT_IN_SYNC_FETCH_AND_NAND_4:
5227 case BUILT_IN_SYNC_FETCH_AND_NAND_8:
5228 case BUILT_IN_SYNC_FETCH_AND_NAND_16:
5232 fndecl = builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N);
5233 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5234 warned_f_a_n = true;
5237 case BUILT_IN_SYNC_NAND_AND_FETCH_1:
5238 case BUILT_IN_SYNC_NAND_AND_FETCH_2:
5239 case BUILT_IN_SYNC_NAND_AND_FETCH_4:
5240 case BUILT_IN_SYNC_NAND_AND_FETCH_8:
5241 case BUILT_IN_SYNC_NAND_AND_FETCH_16:
5245 fndecl = builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N);
5246 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5247 warned_n_a_f = true;
5255 /* Expand the operands. */
5256 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5257 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5259 return expand_atomic_fetch_op (target, mem, val, code, MEMMODEL_SEQ_CST,
5263 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5264 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5265 true if this is the boolean form. TARGET is a place for us to store the
5266 results; this is NOT optional if IS_BOOL is true. */
5269 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5270 bool is_bool, rtx target)
5272 rtx old_val, new_val, mem;
5275 /* Expand the operands. */
5276 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5277 old_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5278 new_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5280 pbool = poval = NULL;
5281 if (target != const0_rtx)
5288 if (!expand_atomic_compare_and_swap (pbool, poval, mem, old_val, new_val,
5289 false, MEMMODEL_SEQ_CST,
5296 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5297 general form is actually an atomic exchange, and some targets only
5298 support a reduced form with the second argument being a constant 1.
5299 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5303 expand_builtin_sync_lock_test_and_set (enum machine_mode mode, tree exp,
5308 /* Expand the operands. */
5309 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5310 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5312 return expand_sync_lock_test_and_set (target, mem, val);
5315 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5318 expand_builtin_sync_lock_release (enum machine_mode mode, tree exp)
5322 /* Expand the operands. */
5323 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5325 expand_atomic_store (mem, const0_rtx, MEMMODEL_RELEASE, true);
5328 /* Given an integer representing an ``enum memmodel'', verify its
5329 correctness and return the memory model enum. */
5331 static enum memmodel
5332 get_memmodel (tree exp)
5336 /* If the parameter is not a constant, it's a run time value so we'll just
5337 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5338 if (TREE_CODE (exp) != INTEGER_CST)
5339 return MEMMODEL_SEQ_CST;
5341 op = expand_normal (exp);
5342 if (INTVAL (op) < 0 || INTVAL (op) >= MEMMODEL_LAST)
5344 warning (OPT_Winvalid_memory_model,
5345 "invalid memory model argument to builtin");
5346 return MEMMODEL_SEQ_CST;
5348 return (enum memmodel) INTVAL (op);
5351 /* Expand the __atomic_exchange intrinsic:
5352 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5353 EXP is the CALL_EXPR.
5354 TARGET is an optional place for us to store the results. */
5357 expand_builtin_atomic_exchange (enum machine_mode mode, tree exp, rtx target)
5360 enum memmodel model;
5362 model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5363 if (model == MEMMODEL_CONSUME)
5365 error ("invalid memory model for %<__atomic_exchange%>");
5369 if (!flag_inline_atomics)
5372 /* Expand the operands. */
5373 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5374 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5376 return expand_atomic_exchange (target, mem, val, model);
5379 /* Expand the __atomic_compare_exchange intrinsic:
5380 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5381 TYPE desired, BOOL weak,
5382 enum memmodel success,
5383 enum memmodel failure)
5384 EXP is the CALL_EXPR.
5385 TARGET is an optional place for us to store the results. */
5388 expand_builtin_atomic_compare_exchange (enum machine_mode mode, tree exp,
5391 rtx expect, desired, mem, oldval;
5392 enum memmodel success, failure;
5396 success = get_memmodel (CALL_EXPR_ARG (exp, 4));
5397 failure = get_memmodel (CALL_EXPR_ARG (exp, 5));
5399 if (failure == MEMMODEL_RELEASE || failure == MEMMODEL_ACQ_REL)
5401 error ("invalid failure memory model for %<__atomic_compare_exchange%>");
5405 if (failure > success)
5407 error ("failure memory model cannot be stronger than success "
5408 "memory model for %<__atomic_compare_exchange%>");
5412 if (!flag_inline_atomics)
5415 /* Expand the operands. */
5416 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5418 expect = expand_normal (CALL_EXPR_ARG (exp, 1));
5419 expect = convert_memory_address (Pmode, expect);
5420 desired = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5422 weak = CALL_EXPR_ARG (exp, 3);
5424 if (host_integerp (weak, 0) && tree_low_cst (weak, 0) != 0)
5427 oldval = copy_to_reg (gen_rtx_MEM (mode, expect));
5429 if (!expand_atomic_compare_and_swap ((target == const0_rtx ? NULL : &target),
5430 &oldval, mem, oldval, desired,
5431 is_weak, success, failure))
5434 emit_move_insn (gen_rtx_MEM (mode, expect), oldval);
5438 /* Expand the __atomic_load intrinsic:
5439 TYPE __atomic_load (TYPE *object, enum memmodel)
5440 EXP is the CALL_EXPR.
5441 TARGET is an optional place for us to store the results. */
5444 expand_builtin_atomic_load (enum machine_mode mode, tree exp, rtx target)
5447 enum memmodel model;
5449 model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5450 if (model == MEMMODEL_RELEASE
5451 || model == MEMMODEL_ACQ_REL)
5453 error ("invalid memory model for %<__atomic_load%>");
5457 if (!flag_inline_atomics)
5460 /* Expand the operand. */
5461 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5463 return expand_atomic_load (target, mem, model);
5467 /* Expand the __atomic_store intrinsic:
5468 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5469 EXP is the CALL_EXPR.
5470 TARGET is an optional place for us to store the results. */
5473 expand_builtin_atomic_store (enum machine_mode mode, tree exp)
5476 enum memmodel model;
5478 model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5479 if (model != MEMMODEL_RELAXED
5480 && model != MEMMODEL_SEQ_CST
5481 && model != MEMMODEL_RELEASE)
5483 error ("invalid memory model for %<__atomic_store%>");
5487 if (!flag_inline_atomics)
5490 /* Expand the operands. */
5491 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5492 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5494 return expand_atomic_store (mem, val, model, false);
5497 /* Expand the __atomic_fetch_XXX intrinsic:
5498 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5499 EXP is the CALL_EXPR.
5500 TARGET is an optional place for us to store the results.
5501 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5502 FETCH_AFTER is true if returning the result of the operation.
5503 FETCH_AFTER is false if returning the value before the operation.
5504 IGNORE is true if the result is not used.
5505 EXT_CALL is the correct builtin for an external call if this cannot be
5506 resolved to an instruction sequence. */
5509 expand_builtin_atomic_fetch_op (enum machine_mode mode, tree exp, rtx target,
5510 enum rtx_code code, bool fetch_after,
5511 bool ignore, enum built_in_function ext_call)
5514 enum memmodel model;
5518 model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5520 /* Expand the operands. */
5521 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5522 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5524 /* Only try generating instructions if inlining is turned on. */
5525 if (flag_inline_atomics)
5527 ret = expand_atomic_fetch_op (target, mem, val, code, model, fetch_after);
5532 /* Return if a different routine isn't needed for the library call. */
5533 if (ext_call == BUILT_IN_NONE)
5536 /* Change the call to the specified function. */
5537 fndecl = get_callee_fndecl (exp);
5538 addr = CALL_EXPR_FN (exp);
5541 gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
5542 TREE_OPERAND (addr, 0) = builtin_decl_explicit(ext_call);
5544 /* Expand the call here so we can emit trailing code. */
5545 ret = expand_call (exp, target, ignore);
5547 /* Replace the original function just in case it matters. */
5548 TREE_OPERAND (addr, 0) = fndecl;
5550 /* Then issue the arithmetic correction to return the right result. */
5555 ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true,
5557 ret = expand_simple_unop (mode, NOT, ret, target, true);
5560 ret = expand_simple_binop (mode, code, ret, val, target, true,
5567 #ifndef HAVE_atomic_clear
5568 # define HAVE_atomic_clear 0
5569 # define gen_atomic_clear(x,y) (gcc_unreachable (), NULL_RTX)
5572 /* Expand an atomic clear operation.
5573 void _atomic_clear (BOOL *obj, enum memmodel)
5574 EXP is the call expression. */
5577 expand_builtin_atomic_clear (tree exp)
5579 enum machine_mode mode;
5581 enum memmodel model;
5583 mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5584 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5585 model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5587 if (model == MEMMODEL_ACQUIRE || model == MEMMODEL_ACQ_REL)
5589 error ("invalid memory model for %<__atomic_store%>");
5593 if (HAVE_atomic_clear)
5595 emit_insn (gen_atomic_clear (mem, model));
5599 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5600 Failing that, a store is issued by __atomic_store. The only way this can
5601 fail is if the bool type is larger than a word size. Unlikely, but
5602 handle it anyway for completeness. Assume a single threaded model since
5603 there is no atomic support in this case, and no barriers are required. */
5604 ret = expand_atomic_store (mem, const0_rtx, model, true);
5606 emit_move_insn (mem, const0_rtx);
5610 /* Expand an atomic test_and_set operation.
5611 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5612 EXP is the call expression. */
5615 expand_builtin_atomic_test_and_set (tree exp, rtx target)
5618 enum memmodel model;
5619 enum machine_mode mode;
5621 mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5622 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5623 model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5625 return expand_atomic_test_and_set (target, mem, model);
5629 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5630 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
5633 fold_builtin_atomic_always_lock_free (tree arg0, tree arg1)
5636 enum machine_mode mode;
5637 unsigned int mode_align, type_align;
5639 if (TREE_CODE (arg0) != INTEGER_CST)
5642 size = INTVAL (expand_normal (arg0)) * BITS_PER_UNIT;
5643 mode = mode_for_size (size, MODE_INT, 0);
5644 mode_align = GET_MODE_ALIGNMENT (mode);
5646 if (TREE_CODE (arg1) == INTEGER_CST && INTVAL (expand_normal (arg1)) == 0)
5647 type_align = mode_align;
5650 tree ttype = TREE_TYPE (arg1);
5652 /* This function is usually invoked and folded immediately by the front
5653 end before anything else has a chance to look at it. The pointer
5654 parameter at this point is usually cast to a void *, so check for that
5655 and look past the cast. */
5656 if (TREE_CODE (arg1) == NOP_EXPR && POINTER_TYPE_P (ttype)
5657 && VOID_TYPE_P (TREE_TYPE (ttype)))
5658 arg1 = TREE_OPERAND (arg1, 0);
5660 ttype = TREE_TYPE (arg1);
5661 gcc_assert (POINTER_TYPE_P (ttype));
5663 /* Get the underlying type of the object. */
5664 ttype = TREE_TYPE (ttype);
5665 type_align = TYPE_ALIGN (ttype);
5668 /* If the object has smaller alignment, the the lock free routines cannot
5670 if (type_align < mode_align)
5671 return boolean_false_node;
5673 /* Check if a compare_and_swap pattern exists for the mode which represents
5674 the required size. The pattern is not allowed to fail, so the existence
5675 of the pattern indicates support is present. */
5676 if (can_compare_and_swap_p (mode, true))
5677 return boolean_true_node;
5679 return boolean_false_node;
5682 /* Return true if the parameters to call EXP represent an object which will
5683 always generate lock free instructions. The first argument represents the
5684 size of the object, and the second parameter is a pointer to the object
5685 itself. If NULL is passed for the object, then the result is based on
5686 typical alignment for an object of the specified size. Otherwise return
5690 expand_builtin_atomic_always_lock_free (tree exp)
5693 tree arg0 = CALL_EXPR_ARG (exp, 0);
5694 tree arg1 = CALL_EXPR_ARG (exp, 1);
5696 if (TREE_CODE (arg0) != INTEGER_CST)
5698 error ("non-constant argument 1 to __atomic_always_lock_free");
5702 size = fold_builtin_atomic_always_lock_free (arg0, arg1);
5703 if (size == boolean_true_node)
5708 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5709 is lock free on this architecture. */
5712 fold_builtin_atomic_is_lock_free (tree arg0, tree arg1)
5714 if (!flag_inline_atomics)
5717 /* If it isn't always lock free, don't generate a result. */
5718 if (fold_builtin_atomic_always_lock_free (arg0, arg1) == boolean_true_node)
5719 return boolean_true_node;
5724 /* Return true if the parameters to call EXP represent an object which will
5725 always generate lock free instructions. The first argument represents the
5726 size of the object, and the second parameter is a pointer to the object
5727 itself. If NULL is passed for the object, then the result is based on
5728 typical alignment for an object of the specified size. Otherwise return
5732 expand_builtin_atomic_is_lock_free (tree exp)
5735 tree arg0 = CALL_EXPR_ARG (exp, 0);
5736 tree arg1 = CALL_EXPR_ARG (exp, 1);
5738 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5740 error ("non-integer argument 1 to __atomic_is_lock_free");
5744 if (!flag_inline_atomics)
5747 /* If the value is known at compile time, return the RTX for it. */
5748 size = fold_builtin_atomic_is_lock_free (arg0, arg1);
5749 if (size == boolean_true_node)
5755 /* Expand the __atomic_thread_fence intrinsic:
5756 void __atomic_thread_fence (enum memmodel)
5757 EXP is the CALL_EXPR. */
5760 expand_builtin_atomic_thread_fence (tree exp)
5762 enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5763 expand_mem_thread_fence (model);
5766 /* Expand the __atomic_signal_fence intrinsic:
5767 void __atomic_signal_fence (enum memmodel)
5768 EXP is the CALL_EXPR. */
5771 expand_builtin_atomic_signal_fence (tree exp)
5773 enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5774 expand_mem_signal_fence (model);
5777 /* Expand the __sync_synchronize intrinsic. */
5780 expand_builtin_sync_synchronize (void)
5782 expand_mem_thread_fence (MEMMODEL_SEQ_CST);
5786 /* Expand an expression EXP that calls a built-in function,
5787 with result going to TARGET if that's convenient
5788 (and in mode MODE if that's convenient).
5789 SUBTARGET may be used as the target for computing one of EXP's operands.
5790 IGNORE is nonzero if the value is to be ignored. */
5793 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5796 tree fndecl = get_callee_fndecl (exp);
5797 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5798 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5801 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5802 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5804 /* When not optimizing, generate calls to library functions for a certain
5807 && !called_as_built_in (fndecl)
5808 && fcode != BUILT_IN_ALLOCA
5809 && fcode != BUILT_IN_ALLOCA_WITH_ALIGN
5810 && fcode != BUILT_IN_FREE)
5811 return expand_call (exp, target, ignore);
5813 /* The built-in function expanders test for target == const0_rtx
5814 to determine whether the function's result will be ignored. */
5816 target = const0_rtx;
5818 /* If the result of a pure or const built-in function is ignored, and
5819 none of its arguments are volatile, we can avoid expanding the
5820 built-in call and just evaluate the arguments for side-effects. */
5821 if (target == const0_rtx
5822 && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5823 && !(flags & ECF_LOOPING_CONST_OR_PURE))
5825 bool volatilep = false;
5827 call_expr_arg_iterator iter;
5829 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5830 if (TREE_THIS_VOLATILE (arg))
5838 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5839 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5846 CASE_FLT_FN (BUILT_IN_FABS):
5847 target = expand_builtin_fabs (exp, target, subtarget);
5852 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5853 target = expand_builtin_copysign (exp, target, subtarget);
5858 /* Just do a normal library call if we were unable to fold
5860 CASE_FLT_FN (BUILT_IN_CABS):
5863 CASE_FLT_FN (BUILT_IN_EXP):
5864 CASE_FLT_FN (BUILT_IN_EXP10):
5865 CASE_FLT_FN (BUILT_IN_POW10):
5866 CASE_FLT_FN (BUILT_IN_EXP2):
5867 CASE_FLT_FN (BUILT_IN_EXPM1):
5868 CASE_FLT_FN (BUILT_IN_LOGB):
5869 CASE_FLT_FN (BUILT_IN_LOG):
5870 CASE_FLT_FN (BUILT_IN_LOG10):
5871 CASE_FLT_FN (BUILT_IN_LOG2):
5872 CASE_FLT_FN (BUILT_IN_LOG1P):
5873 CASE_FLT_FN (BUILT_IN_TAN):
5874 CASE_FLT_FN (BUILT_IN_ASIN):
5875 CASE_FLT_FN (BUILT_IN_ACOS):
5876 CASE_FLT_FN (BUILT_IN_ATAN):
5877 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5878 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5879 because of possible accuracy problems. */
5880 if (! flag_unsafe_math_optimizations)
5882 CASE_FLT_FN (BUILT_IN_SQRT):
5883 CASE_FLT_FN (BUILT_IN_FLOOR):
5884 CASE_FLT_FN (BUILT_IN_CEIL):
5885 CASE_FLT_FN (BUILT_IN_TRUNC):
5886 CASE_FLT_FN (BUILT_IN_ROUND):
5887 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5888 CASE_FLT_FN (BUILT_IN_RINT):
5889 target = expand_builtin_mathfn (exp, target, subtarget);
5894 CASE_FLT_FN (BUILT_IN_FMA):
5895 target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5900 CASE_FLT_FN (BUILT_IN_ILOGB):
5901 if (! flag_unsafe_math_optimizations)
5903 CASE_FLT_FN (BUILT_IN_ISINF):
5904 CASE_FLT_FN (BUILT_IN_FINITE):
5905 case BUILT_IN_ISFINITE:
5906 case BUILT_IN_ISNORMAL:
5907 target = expand_builtin_interclass_mathfn (exp, target);
5912 CASE_FLT_FN (BUILT_IN_ICEIL):
5913 CASE_FLT_FN (BUILT_IN_LCEIL):
5914 CASE_FLT_FN (BUILT_IN_LLCEIL):
5915 CASE_FLT_FN (BUILT_IN_LFLOOR):
5916 CASE_FLT_FN (BUILT_IN_IFLOOR):
5917 CASE_FLT_FN (BUILT_IN_LLFLOOR):
5918 target = expand_builtin_int_roundingfn (exp, target);
5923 CASE_FLT_FN (BUILT_IN_IRINT):
5924 CASE_FLT_FN (BUILT_IN_LRINT):
5925 CASE_FLT_FN (BUILT_IN_LLRINT):
5926 CASE_FLT_FN (BUILT_IN_IROUND):
5927 CASE_FLT_FN (BUILT_IN_LROUND):
5928 CASE_FLT_FN (BUILT_IN_LLROUND):
5929 target = expand_builtin_int_roundingfn_2 (exp, target);
5934 CASE_FLT_FN (BUILT_IN_POWI):
5935 target = expand_builtin_powi (exp, target);
5940 CASE_FLT_FN (BUILT_IN_ATAN2):
5941 CASE_FLT_FN (BUILT_IN_LDEXP):
5942 CASE_FLT_FN (BUILT_IN_SCALB):
5943 CASE_FLT_FN (BUILT_IN_SCALBN):
5944 CASE_FLT_FN (BUILT_IN_SCALBLN):
5945 if (! flag_unsafe_math_optimizations)
5948 CASE_FLT_FN (BUILT_IN_FMOD):
5949 CASE_FLT_FN (BUILT_IN_REMAINDER):
5950 CASE_FLT_FN (BUILT_IN_DREM):
5951 CASE_FLT_FN (BUILT_IN_POW):
5952 target = expand_builtin_mathfn_2 (exp, target, subtarget);
5957 CASE_FLT_FN (BUILT_IN_CEXPI):
5958 target = expand_builtin_cexpi (exp, target);
5959 gcc_assert (target);
5962 CASE_FLT_FN (BUILT_IN_SIN):
5963 CASE_FLT_FN (BUILT_IN_COS):
5964 if (! flag_unsafe_math_optimizations)
5966 target = expand_builtin_mathfn_3 (exp, target, subtarget);
5971 CASE_FLT_FN (BUILT_IN_SINCOS):
5972 if (! flag_unsafe_math_optimizations)
5974 target = expand_builtin_sincos (exp);
5979 case BUILT_IN_APPLY_ARGS:
5980 return expand_builtin_apply_args ();
5982 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5983 FUNCTION with a copy of the parameters described by
5984 ARGUMENTS, and ARGSIZE. It returns a block of memory
5985 allocated on the stack into which is stored all the registers
5986 that might possibly be used for returning the result of a
5987 function. ARGUMENTS is the value returned by
5988 __builtin_apply_args. ARGSIZE is the number of bytes of
5989 arguments that must be copied. ??? How should this value be
5990 computed? We'll also need a safe worst case value for varargs
5992 case BUILT_IN_APPLY:
5993 if (!validate_arglist (exp, POINTER_TYPE,
5994 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5995 && !validate_arglist (exp, REFERENCE_TYPE,
5996 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6002 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6003 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6004 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6006 return expand_builtin_apply (ops[0], ops[1], ops[2]);
6009 /* __builtin_return (RESULT) causes the function to return the
6010 value described by RESULT. RESULT is address of the block of
6011 memory returned by __builtin_apply. */
6012 case BUILT_IN_RETURN:
6013 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6014 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6017 case BUILT_IN_SAVEREGS:
6018 return expand_builtin_saveregs ();
6020 case BUILT_IN_VA_ARG_PACK:
6021 /* All valid uses of __builtin_va_arg_pack () are removed during
6023 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
6026 case BUILT_IN_VA_ARG_PACK_LEN:
6027 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6029 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
6032 /* Return the address of the first anonymous stack arg. */
6033 case BUILT_IN_NEXT_ARG:
6034 if (fold_builtin_next_arg (exp, false))
6036 return expand_builtin_next_arg ();
6038 case BUILT_IN_CLEAR_CACHE:
6039 target = expand_builtin___clear_cache (exp);
6044 case BUILT_IN_CLASSIFY_TYPE:
6045 return expand_builtin_classify_type (exp);
6047 case BUILT_IN_CONSTANT_P:
6050 case BUILT_IN_FRAME_ADDRESS:
6051 case BUILT_IN_RETURN_ADDRESS:
6052 return expand_builtin_frame_address (fndecl, exp);
6054 /* Returns the address of the area where the structure is returned.
6056 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6057 if (call_expr_nargs (exp) != 0
6058 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6059 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6062 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6064 case BUILT_IN_ALLOCA:
6065 case BUILT_IN_ALLOCA_WITH_ALIGN:
6066 /* If the allocation stems from the declaration of a variable-sized
6067 object, it cannot accumulate. */
6068 target = expand_builtin_alloca (exp, CALL_ALLOCA_FOR_VAR_P (exp));
6073 case BUILT_IN_STACK_SAVE:
6074 return expand_stack_save ();
6076 case BUILT_IN_STACK_RESTORE:
6077 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6080 case BUILT_IN_BSWAP32:
6081 case BUILT_IN_BSWAP64:
6082 target = expand_builtin_bswap (exp, target, subtarget);
6088 CASE_INT_FN (BUILT_IN_FFS):
6089 case BUILT_IN_FFSIMAX:
6090 target = expand_builtin_unop (target_mode, exp, target,
6091 subtarget, ffs_optab);
6096 CASE_INT_FN (BUILT_IN_CLZ):
6097 case BUILT_IN_CLZIMAX:
6098 target = expand_builtin_unop (target_mode, exp, target,
6099 subtarget, clz_optab);
6104 CASE_INT_FN (BUILT_IN_CTZ):
6105 case BUILT_IN_CTZIMAX:
6106 target = expand_builtin_unop (target_mode, exp, target,
6107 subtarget, ctz_optab);
6112 CASE_INT_FN (BUILT_IN_CLRSB):
6113 case BUILT_IN_CLRSBIMAX:
6114 target = expand_builtin_unop (target_mode, exp, target,
6115 subtarget, clrsb_optab);
6120 CASE_INT_FN (BUILT_IN_POPCOUNT):
6121 case BUILT_IN_POPCOUNTIMAX:
6122 target = expand_builtin_unop (target_mode, exp, target,
6123 subtarget, popcount_optab);
6128 CASE_INT_FN (BUILT_IN_PARITY):
6129 case BUILT_IN_PARITYIMAX:
6130 target = expand_builtin_unop (target_mode, exp, target,
6131 subtarget, parity_optab);
6136 case BUILT_IN_STRLEN:
6137 target = expand_builtin_strlen (exp, target, target_mode);
6142 case BUILT_IN_STRCPY:
6143 target = expand_builtin_strcpy (exp, target);
6148 case BUILT_IN_STRNCPY:
6149 target = expand_builtin_strncpy (exp, target);
6154 case BUILT_IN_STPCPY:
6155 target = expand_builtin_stpcpy (exp, target, mode);
6160 case BUILT_IN_MEMCPY:
6161 target = expand_builtin_memcpy (exp, target);
6166 case BUILT_IN_MEMPCPY:
6167 target = expand_builtin_mempcpy (exp, target, mode);
6172 case BUILT_IN_MEMSET:
6173 target = expand_builtin_memset (exp, target, mode);
6178 case BUILT_IN_BZERO:
6179 target = expand_builtin_bzero (exp);
6184 case BUILT_IN_STRCMP:
6185 target = expand_builtin_strcmp (exp, target);
6190 case BUILT_IN_STRNCMP:
6191 target = expand_builtin_strncmp (exp, target, mode);
6197 case BUILT_IN_MEMCMP:
6198 target = expand_builtin_memcmp (exp, target, mode);
6203 case BUILT_IN_SETJMP:
6204 /* This should have been lowered to the builtins below. */
6207 case BUILT_IN_SETJMP_SETUP:
6208 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6209 and the receiver label. */
6210 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6212 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6213 VOIDmode, EXPAND_NORMAL);
6214 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6215 rtx label_r = label_rtx (label);
6217 /* This is copied from the handling of non-local gotos. */
6218 expand_builtin_setjmp_setup (buf_addr, label_r);
6219 nonlocal_goto_handler_labels
6220 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6221 nonlocal_goto_handler_labels);
6222 /* ??? Do not let expand_label treat us as such since we would
6223 not want to be both on the list of non-local labels and on
6224 the list of forced labels. */
6225 FORCED_LABEL (label) = 0;
6230 case BUILT_IN_SETJMP_DISPATCHER:
6231 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6232 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6234 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6235 rtx label_r = label_rtx (label);
6237 /* Remove the dispatcher label from the list of non-local labels
6238 since the receiver labels have been added to it above. */
6239 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6244 case BUILT_IN_SETJMP_RECEIVER:
6245 /* __builtin_setjmp_receiver is passed the receiver label. */
6246 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6248 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6249 rtx label_r = label_rtx (label);
6251 expand_builtin_setjmp_receiver (label_r);
6256 /* __builtin_longjmp is passed a pointer to an array of five words.
6257 It's similar to the C library longjmp function but works with
6258 __builtin_setjmp above. */
6259 case BUILT_IN_LONGJMP:
6260 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6262 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6263 VOIDmode, EXPAND_NORMAL);
6264 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6266 if (value != const1_rtx)
6268 error ("%<__builtin_longjmp%> second argument must be 1");
6272 expand_builtin_longjmp (buf_addr, value);
6277 case BUILT_IN_NONLOCAL_GOTO:
6278 target = expand_builtin_nonlocal_goto (exp);
6283 /* This updates the setjmp buffer that is its argument with the value
6284 of the current stack pointer. */
6285 case BUILT_IN_UPDATE_SETJMP_BUF:
6286 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6289 = expand_normal (CALL_EXPR_ARG (exp, 0));
6291 expand_builtin_update_setjmp_buf (buf_addr);
6297 expand_builtin_trap ();
6300 case BUILT_IN_UNREACHABLE:
6301 expand_builtin_unreachable ();
6304 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6305 case BUILT_IN_SIGNBITD32:
6306 case BUILT_IN_SIGNBITD64:
6307 case BUILT_IN_SIGNBITD128:
6308 target = expand_builtin_signbit (exp, target);
6313 /* Various hooks for the DWARF 2 __throw routine. */
6314 case BUILT_IN_UNWIND_INIT:
6315 expand_builtin_unwind_init ();
6317 case BUILT_IN_DWARF_CFA:
6318 return virtual_cfa_rtx;
6319 #ifdef DWARF2_UNWIND_INFO
6320 case BUILT_IN_DWARF_SP_COLUMN:
6321 return expand_builtin_dwarf_sp_column ();
6322 case BUILT_IN_INIT_DWARF_REG_SIZES:
6323 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6326 case BUILT_IN_FROB_RETURN_ADDR:
6327 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6328 case BUILT_IN_EXTRACT_RETURN_ADDR:
6329 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6330 case BUILT_IN_EH_RETURN:
6331 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6332 CALL_EXPR_ARG (exp, 1));
6334 #ifdef EH_RETURN_DATA_REGNO
6335 case BUILT_IN_EH_RETURN_DATA_REGNO:
6336 return expand_builtin_eh_return_data_regno (exp);
6338 case BUILT_IN_EXTEND_POINTER:
6339 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6340 case BUILT_IN_EH_POINTER:
6341 return expand_builtin_eh_pointer (exp);
6342 case BUILT_IN_EH_FILTER:
6343 return expand_builtin_eh_filter (exp);
6344 case BUILT_IN_EH_COPY_VALUES:
6345 return expand_builtin_eh_copy_values (exp);
6347 case BUILT_IN_VA_START:
6348 return expand_builtin_va_start (exp);
6349 case BUILT_IN_VA_END:
6350 return expand_builtin_va_end (exp);
6351 case BUILT_IN_VA_COPY:
6352 return expand_builtin_va_copy (exp);
6353 case BUILT_IN_EXPECT:
6354 return expand_builtin_expect (exp, target);
6355 case BUILT_IN_ASSUME_ALIGNED:
6356 return expand_builtin_assume_aligned (exp, target);
6357 case BUILT_IN_PREFETCH:
6358 expand_builtin_prefetch (exp);
6361 case BUILT_IN_INIT_TRAMPOLINE:
6362 return expand_builtin_init_trampoline (exp, true);
6363 case BUILT_IN_INIT_HEAP_TRAMPOLINE:
6364 return expand_builtin_init_trampoline (exp, false);
6365 case BUILT_IN_ADJUST_TRAMPOLINE:
6366 return expand_builtin_adjust_trampoline (exp);
6369 case BUILT_IN_EXECL:
6370 case BUILT_IN_EXECV:
6371 case BUILT_IN_EXECLP:
6372 case BUILT_IN_EXECLE:
6373 case BUILT_IN_EXECVP:
6374 case BUILT_IN_EXECVE:
6375 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6380 case BUILT_IN_SYNC_FETCH_AND_ADD_1:
6381 case BUILT_IN_SYNC_FETCH_AND_ADD_2:
6382 case BUILT_IN_SYNC_FETCH_AND_ADD_4:
6383 case BUILT_IN_SYNC_FETCH_AND_ADD_8:
6384 case BUILT_IN_SYNC_FETCH_AND_ADD_16:
6385 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_ADD_1);
6386 target = expand_builtin_sync_operation (mode, exp, PLUS, false, target);
6391 case BUILT_IN_SYNC_FETCH_AND_SUB_1:
6392 case BUILT_IN_SYNC_FETCH_AND_SUB_2:
6393 case BUILT_IN_SYNC_FETCH_AND_SUB_4:
6394 case BUILT_IN_SYNC_FETCH_AND_SUB_8:
6395 case BUILT_IN_SYNC_FETCH_AND_SUB_16:
6396 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_SUB_1);
6397 target = expand_builtin_sync_operation (mode, exp, MINUS, false, target);
6402 case BUILT_IN_SYNC_FETCH_AND_OR_1:
6403 case BUILT_IN_SYNC_FETCH_AND_OR_2:
6404 case BUILT_IN_SYNC_FETCH_AND_OR_4:
6405 case BUILT_IN_SYNC_FETCH_AND_OR_8:
6406 case BUILT_IN_SYNC_FETCH_AND_OR_16:
6407 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_OR_1);
6408 target = expand_builtin_sync_operation (mode, exp, IOR, false, target);
6413 case BUILT_IN_SYNC_FETCH_AND_AND_1:
6414 case BUILT_IN_SYNC_FETCH_AND_AND_2:
6415 case BUILT_IN_SYNC_FETCH_AND_AND_4:
6416 case BUILT_IN_SYNC_FETCH_AND_AND_8:
6417 case BUILT_IN_SYNC_FETCH_AND_AND_16:
6418 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_AND_1);
6419 target = expand_builtin_sync_operation (mode, exp, AND, false, target);
6424 case BUILT_IN_SYNC_FETCH_AND_XOR_1:
6425 case BUILT_IN_SYNC_FETCH_AND_XOR_2:
6426 case BUILT_IN_SYNC_FETCH_AND_XOR_4:
6427 case BUILT_IN_SYNC_FETCH_AND_XOR_8:
6428 case BUILT_IN_SYNC_FETCH_AND_XOR_16:
6429 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_XOR_1);
6430 target = expand_builtin_sync_operation (mode, exp, XOR, false, target);
6435 case BUILT_IN_SYNC_FETCH_AND_NAND_1:
6436 case BUILT_IN_SYNC_FETCH_AND_NAND_2:
6437 case BUILT_IN_SYNC_FETCH_AND_NAND_4:
6438 case BUILT_IN_SYNC_FETCH_AND_NAND_8:
6439 case BUILT_IN_SYNC_FETCH_AND_NAND_16:
6440 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_NAND_1);
6441 target = expand_builtin_sync_operation (mode, exp, NOT, false, target);
6446 case BUILT_IN_SYNC_ADD_AND_FETCH_1:
6447 case BUILT_IN_SYNC_ADD_AND_FETCH_2:
6448 case BUILT_IN_SYNC_ADD_AND_FETCH_4:
6449 case BUILT_IN_SYNC_ADD_AND_FETCH_8:
6450 case BUILT_IN_SYNC_ADD_AND_FETCH_16:
6451 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_ADD_AND_FETCH_1);
6452 target = expand_builtin_sync_operation (mode, exp, PLUS, true, target);
6457 case BUILT_IN_SYNC_SUB_AND_FETCH_1:
6458 case BUILT_IN_SYNC_SUB_AND_FETCH_2:
6459 case BUILT_IN_SYNC_SUB_AND_FETCH_4:
6460 case BUILT_IN_SYNC_SUB_AND_FETCH_8:
6461 case BUILT_IN_SYNC_SUB_AND_FETCH_16:
6462 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_SUB_AND_FETCH_1);
6463 target = expand_builtin_sync_operation (mode, exp, MINUS, true, target);
6468 case BUILT_IN_SYNC_OR_AND_FETCH_1:
6469 case BUILT_IN_SYNC_OR_AND_FETCH_2:
6470 case BUILT_IN_SYNC_OR_AND_FETCH_4:
6471 case BUILT_IN_SYNC_OR_AND_FETCH_8:
6472 case BUILT_IN_SYNC_OR_AND_FETCH_16:
6473 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_OR_AND_FETCH_1);
6474 target = expand_builtin_sync_operation (mode, exp, IOR, true, target);
6479 case BUILT_IN_SYNC_AND_AND_FETCH_1:
6480 case BUILT_IN_SYNC_AND_AND_FETCH_2:
6481 case BUILT_IN_SYNC_AND_AND_FETCH_4:
6482 case BUILT_IN_SYNC_AND_AND_FETCH_8:
6483 case BUILT_IN_SYNC_AND_AND_FETCH_16:
6484 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_AND_AND_FETCH_1);
6485 target = expand_builtin_sync_operation (mode, exp, AND, true, target);
6490 case BUILT_IN_SYNC_XOR_AND_FETCH_1:
6491 case BUILT_IN_SYNC_XOR_AND_FETCH_2:
6492 case BUILT_IN_SYNC_XOR_AND_FETCH_4:
6493 case BUILT_IN_SYNC_XOR_AND_FETCH_8:
6494 case BUILT_IN_SYNC_XOR_AND_FETCH_16:
6495 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_XOR_AND_FETCH_1);
6496 target = expand_builtin_sync_operation (mode, exp, XOR, true, target);
6501 case BUILT_IN_SYNC_NAND_AND_FETCH_1:
6502 case BUILT_IN_SYNC_NAND_AND_FETCH_2:
6503 case BUILT_IN_SYNC_NAND_AND_FETCH_4:
6504 case BUILT_IN_SYNC_NAND_AND_FETCH_8:
6505 case BUILT_IN_SYNC_NAND_AND_FETCH_16:
6506 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_NAND_AND_FETCH_1);
6507 target = expand_builtin_sync_operation (mode, exp, NOT, true, target);
6512 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1:
6513 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2:
6514 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4:
6515 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8:
6516 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16:
6517 if (mode == VOIDmode)
6518 mode = TYPE_MODE (boolean_type_node);
6519 if (!target || !register_operand (target, mode))
6520 target = gen_reg_rtx (mode);
6522 mode = get_builtin_sync_mode
6523 (fcode - BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1);
6524 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6529 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1:
6530 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2:
6531 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4:
6532 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8:
6533 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16:
6534 mode = get_builtin_sync_mode
6535 (fcode - BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1);
6536 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6541 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1:
6542 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2:
6543 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4:
6544 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8:
6545 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16:
6546 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_TEST_AND_SET_1);
6547 target = expand_builtin_sync_lock_test_and_set (mode, exp, target);
6552 case BUILT_IN_SYNC_LOCK_RELEASE_1:
6553 case BUILT_IN_SYNC_LOCK_RELEASE_2:
6554 case BUILT_IN_SYNC_LOCK_RELEASE_4:
6555 case BUILT_IN_SYNC_LOCK_RELEASE_8:
6556 case BUILT_IN_SYNC_LOCK_RELEASE_16:
6557 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_RELEASE_1);
6558 expand_builtin_sync_lock_release (mode, exp);
6561 case BUILT_IN_SYNC_SYNCHRONIZE:
6562 expand_builtin_sync_synchronize ();
6565 case BUILT_IN_ATOMIC_EXCHANGE_1:
6566 case BUILT_IN_ATOMIC_EXCHANGE_2:
6567 case BUILT_IN_ATOMIC_EXCHANGE_4:
6568 case BUILT_IN_ATOMIC_EXCHANGE_8:
6569 case BUILT_IN_ATOMIC_EXCHANGE_16:
6570 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_EXCHANGE_1);
6571 target = expand_builtin_atomic_exchange (mode, exp, target);
6576 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
6577 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
6578 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
6579 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
6580 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
6582 unsigned int nargs, z;
6586 get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1);
6587 target = expand_builtin_atomic_compare_exchange (mode, exp, target);
6591 /* If this is turned into an external library call, the weak parameter
6592 must be dropped to match the expected parameter list. */
6593 nargs = call_expr_nargs (exp);
6594 vec = VEC_alloc (tree, gc, nargs - 1);
6595 for (z = 0; z < 3; z++)
6596 VEC_quick_push (tree, vec, CALL_EXPR_ARG (exp, z));
6597 /* Skip the boolean weak parameter. */
6598 for (z = 4; z < 6; z++)
6599 VEC_quick_push (tree, vec, CALL_EXPR_ARG (exp, z));
6600 exp = build_call_vec (TREE_TYPE (exp), CALL_EXPR_FN (exp), vec);
6604 case BUILT_IN_ATOMIC_LOAD_1:
6605 case BUILT_IN_ATOMIC_LOAD_2:
6606 case BUILT_IN_ATOMIC_LOAD_4:
6607 case BUILT_IN_ATOMIC_LOAD_8:
6608 case BUILT_IN_ATOMIC_LOAD_16:
6609 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_LOAD_1);
6610 target = expand_builtin_atomic_load (mode, exp, target);
6615 case BUILT_IN_ATOMIC_STORE_1:
6616 case BUILT_IN_ATOMIC_STORE_2:
6617 case BUILT_IN_ATOMIC_STORE_4:
6618 case BUILT_IN_ATOMIC_STORE_8:
6619 case BUILT_IN_ATOMIC_STORE_16:
6620 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_STORE_1);
6621 target = expand_builtin_atomic_store (mode, exp);
6626 case BUILT_IN_ATOMIC_ADD_FETCH_1:
6627 case BUILT_IN_ATOMIC_ADD_FETCH_2:
6628 case BUILT_IN_ATOMIC_ADD_FETCH_4:
6629 case BUILT_IN_ATOMIC_ADD_FETCH_8:
6630 case BUILT_IN_ATOMIC_ADD_FETCH_16:
6632 enum built_in_function lib;
6633 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1);
6634 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_ADD_1 +
6635 (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1));
6636 target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, true,
6642 case BUILT_IN_ATOMIC_SUB_FETCH_1:
6643 case BUILT_IN_ATOMIC_SUB_FETCH_2:
6644 case BUILT_IN_ATOMIC_SUB_FETCH_4:
6645 case BUILT_IN_ATOMIC_SUB_FETCH_8:
6646 case BUILT_IN_ATOMIC_SUB_FETCH_16:
6648 enum built_in_function lib;
6649 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1);
6650 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_SUB_1 +
6651 (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1));
6652 target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, true,
6658 case BUILT_IN_ATOMIC_AND_FETCH_1:
6659 case BUILT_IN_ATOMIC_AND_FETCH_2:
6660 case BUILT_IN_ATOMIC_AND_FETCH_4:
6661 case BUILT_IN_ATOMIC_AND_FETCH_8:
6662 case BUILT_IN_ATOMIC_AND_FETCH_16:
6664 enum built_in_function lib;
6665 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_AND_FETCH_1);
6666 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_AND_1 +
6667 (fcode - BUILT_IN_ATOMIC_AND_FETCH_1));
6668 target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, true,
6674 case BUILT_IN_ATOMIC_NAND_FETCH_1:
6675 case BUILT_IN_ATOMIC_NAND_FETCH_2:
6676 case BUILT_IN_ATOMIC_NAND_FETCH_4:
6677 case BUILT_IN_ATOMIC_NAND_FETCH_8:
6678 case BUILT_IN_ATOMIC_NAND_FETCH_16:
6680 enum built_in_function lib;
6681 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1);
6682 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_NAND_1 +
6683 (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1));
6684 target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, true,
6690 case BUILT_IN_ATOMIC_XOR_FETCH_1:
6691 case BUILT_IN_ATOMIC_XOR_FETCH_2:
6692 case BUILT_IN_ATOMIC_XOR_FETCH_4:
6693 case BUILT_IN_ATOMIC_XOR_FETCH_8:
6694 case BUILT_IN_ATOMIC_XOR_FETCH_16:
6696 enum built_in_function lib;
6697 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1);
6698 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_XOR_1 +
6699 (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1));
6700 target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, true,
6706 case BUILT_IN_ATOMIC_OR_FETCH_1:
6707 case BUILT_IN_ATOMIC_OR_FETCH_2:
6708 case BUILT_IN_ATOMIC_OR_FETCH_4:
6709 case BUILT_IN_ATOMIC_OR_FETCH_8:
6710 case BUILT_IN_ATOMIC_OR_FETCH_16:
6712 enum built_in_function lib;
6713 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_OR_FETCH_1);
6714 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_OR_1 +
6715 (fcode - BUILT_IN_ATOMIC_OR_FETCH_1));
6716 target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, true,
6722 case BUILT_IN_ATOMIC_FETCH_ADD_1:
6723 case BUILT_IN_ATOMIC_FETCH_ADD_2:
6724 case BUILT_IN_ATOMIC_FETCH_ADD_4:
6725 case BUILT_IN_ATOMIC_FETCH_ADD_8:
6726 case BUILT_IN_ATOMIC_FETCH_ADD_16:
6727 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_ADD_1);
6728 target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, false,
6729 ignore, BUILT_IN_NONE);
6734 case BUILT_IN_ATOMIC_FETCH_SUB_1:
6735 case BUILT_IN_ATOMIC_FETCH_SUB_2:
6736 case BUILT_IN_ATOMIC_FETCH_SUB_4:
6737 case BUILT_IN_ATOMIC_FETCH_SUB_8:
6738 case BUILT_IN_ATOMIC_FETCH_SUB_16:
6739 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_SUB_1);
6740 target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, false,
6741 ignore, BUILT_IN_NONE);
6746 case BUILT_IN_ATOMIC_FETCH_AND_1:
6747 case BUILT_IN_ATOMIC_FETCH_AND_2:
6748 case BUILT_IN_ATOMIC_FETCH_AND_4:
6749 case BUILT_IN_ATOMIC_FETCH_AND_8:
6750 case BUILT_IN_ATOMIC_FETCH_AND_16:
6751 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_AND_1);
6752 target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, false,
6753 ignore, BUILT_IN_NONE);
6758 case BUILT_IN_ATOMIC_FETCH_NAND_1:
6759 case BUILT_IN_ATOMIC_FETCH_NAND_2:
6760 case BUILT_IN_ATOMIC_FETCH_NAND_4:
6761 case BUILT_IN_ATOMIC_FETCH_NAND_8:
6762 case BUILT_IN_ATOMIC_FETCH_NAND_16:
6763 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_NAND_1);
6764 target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, false,
6765 ignore, BUILT_IN_NONE);
6770 case BUILT_IN_ATOMIC_FETCH_XOR_1:
6771 case BUILT_IN_ATOMIC_FETCH_XOR_2:
6772 case BUILT_IN_ATOMIC_FETCH_XOR_4:
6773 case BUILT_IN_ATOMIC_FETCH_XOR_8:
6774 case BUILT_IN_ATOMIC_FETCH_XOR_16:
6775 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_XOR_1);
6776 target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, false,
6777 ignore, BUILT_IN_NONE);
6782 case BUILT_IN_ATOMIC_FETCH_OR_1:
6783 case BUILT_IN_ATOMIC_FETCH_OR_2:
6784 case BUILT_IN_ATOMIC_FETCH_OR_4:
6785 case BUILT_IN_ATOMIC_FETCH_OR_8:
6786 case BUILT_IN_ATOMIC_FETCH_OR_16:
6787 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_OR_1);
6788 target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, false,
6789 ignore, BUILT_IN_NONE);
6794 case BUILT_IN_ATOMIC_TEST_AND_SET:
6795 return expand_builtin_atomic_test_and_set (exp, target);
6797 case BUILT_IN_ATOMIC_CLEAR:
6798 return expand_builtin_atomic_clear (exp);
6800 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
6801 return expand_builtin_atomic_always_lock_free (exp);
6803 case BUILT_IN_ATOMIC_IS_LOCK_FREE:
6804 target = expand_builtin_atomic_is_lock_free (exp);
6809 case BUILT_IN_ATOMIC_THREAD_FENCE:
6810 expand_builtin_atomic_thread_fence (exp);
6813 case BUILT_IN_ATOMIC_SIGNAL_FENCE:
6814 expand_builtin_atomic_signal_fence (exp);
6817 case BUILT_IN_OBJECT_SIZE:
6818 return expand_builtin_object_size (exp);
6820 case BUILT_IN_MEMCPY_CHK:
6821 case BUILT_IN_MEMPCPY_CHK:
6822 case BUILT_IN_MEMMOVE_CHK:
6823 case BUILT_IN_MEMSET_CHK:
6824 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6829 case BUILT_IN_STRCPY_CHK:
6830 case BUILT_IN_STPCPY_CHK:
6831 case BUILT_IN_STRNCPY_CHK:
6832 case BUILT_IN_STPNCPY_CHK:
6833 case BUILT_IN_STRCAT_CHK:
6834 case BUILT_IN_STRNCAT_CHK:
6835 case BUILT_IN_SNPRINTF_CHK:
6836 case BUILT_IN_VSNPRINTF_CHK:
6837 maybe_emit_chk_warning (exp, fcode);
6840 case BUILT_IN_SPRINTF_CHK:
6841 case BUILT_IN_VSPRINTF_CHK:
6842 maybe_emit_sprintf_chk_warning (exp, fcode);
6846 if (warn_free_nonheap_object)
6847 maybe_emit_free_warning (exp);
6850 default: /* just do library call, if unknown builtin */
6854 /* The switch statement above can drop through to cause the function
6855 to be called normally. */
6856 return expand_call (exp, target, ignore);
6859 /* Determine whether a tree node represents a call to a built-in
6860 function. If the tree T is a call to a built-in function with
6861 the right number of arguments of the appropriate types, return
6862 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6863 Otherwise the return value is END_BUILTINS. */
6865 enum built_in_function
6866 builtin_mathfn_code (const_tree t)
6868 const_tree fndecl, arg, parmlist;
6869 const_tree argtype, parmtype;
6870 const_call_expr_arg_iterator iter;
6872 if (TREE_CODE (t) != CALL_EXPR
6873 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6874 return END_BUILTINS;
6876 fndecl = get_callee_fndecl (t);
6877 if (fndecl == NULL_TREE
6878 || TREE_CODE (fndecl) != FUNCTION_DECL
6879 || ! DECL_BUILT_IN (fndecl)
6880 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6881 return END_BUILTINS;
6883 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6884 init_const_call_expr_arg_iterator (t, &iter);
6885 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6887 /* If a function doesn't take a variable number of arguments,
6888 the last element in the list will have type `void'. */
6889 parmtype = TREE_VALUE (parmlist);
6890 if (VOID_TYPE_P (parmtype))
6892 if (more_const_call_expr_args_p (&iter))
6893 return END_BUILTINS;
6894 return DECL_FUNCTION_CODE (fndecl);
6897 if (! more_const_call_expr_args_p (&iter))
6898 return END_BUILTINS;
6900 arg = next_const_call_expr_arg (&iter);
6901 argtype = TREE_TYPE (arg);
6903 if (SCALAR_FLOAT_TYPE_P (parmtype))
6905 if (! SCALAR_FLOAT_TYPE_P (argtype))
6906 return END_BUILTINS;
6908 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6910 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6911 return END_BUILTINS;
6913 else if (POINTER_TYPE_P (parmtype))
6915 if (! POINTER_TYPE_P (argtype))
6916 return END_BUILTINS;
6918 else if (INTEGRAL_TYPE_P (parmtype))
6920 if (! INTEGRAL_TYPE_P (argtype))
6921 return END_BUILTINS;
6924 return END_BUILTINS;
6927 /* Variable-length argument list. */
6928 return DECL_FUNCTION_CODE (fndecl);
6931 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6932 evaluate to a constant. */
6935 fold_builtin_constant_p (tree arg)
6937 /* We return 1 for a numeric type that's known to be a constant
6938 value at compile-time or for an aggregate type that's a
6939 literal constant. */
6942 /* If we know this is a constant, emit the constant of one. */
6943 if (CONSTANT_CLASS_P (arg)
6944 || (TREE_CODE (arg) == CONSTRUCTOR
6945 && TREE_CONSTANT (arg)))
6946 return integer_one_node;
6947 if (TREE_CODE (arg) == ADDR_EXPR)
6949 tree op = TREE_OPERAND (arg, 0);
6950 if (TREE_CODE (op) == STRING_CST
6951 || (TREE_CODE (op) == ARRAY_REF
6952 && integer_zerop (TREE_OPERAND (op, 1))
6953 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6954 return integer_one_node;
6957 /* If this expression has side effects, show we don't know it to be a
6958 constant. Likewise if it's a pointer or aggregate type since in
6959 those case we only want literals, since those are only optimized
6960 when generating RTL, not later.
6961 And finally, if we are compiling an initializer, not code, we
6962 need to return a definite result now; there's not going to be any
6963 more optimization done. */
6964 if (TREE_SIDE_EFFECTS (arg)
6965 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6966 || POINTER_TYPE_P (TREE_TYPE (arg))
6968 || folding_initializer)
6969 return integer_zero_node;
6974 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6975 return it as a truthvalue. */
6978 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6980 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6982 fn = builtin_decl_explicit (BUILT_IN_EXPECT);
6983 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6984 ret_type = TREE_TYPE (TREE_TYPE (fn));
6985 pred_type = TREE_VALUE (arg_types);
6986 expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6988 pred = fold_convert_loc (loc, pred_type, pred);
6989 expected = fold_convert_loc (loc, expected_type, expected);
6990 call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6992 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6993 build_int_cst (ret_type, 0));
6996 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6997 NULL_TREE if no simplification is possible. */
7000 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
7002 tree inner, fndecl, inner_arg0;
7003 enum tree_code code;
7005 /* Distribute the expected value over short-circuiting operators.
7006 See through the cast from truthvalue_type_node to long. */
7008 while (TREE_CODE (inner_arg0) == NOP_EXPR
7009 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0))
7010 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0))))
7011 inner_arg0 = TREE_OPERAND (inner_arg0, 0);
7013 /* If this is a builtin_expect within a builtin_expect keep the
7014 inner one. See through a comparison against a constant. It
7015 might have been added to create a thruthvalue. */
7018 if (COMPARISON_CLASS_P (inner)
7019 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
7020 inner = TREE_OPERAND (inner, 0);
7022 if (TREE_CODE (inner) == CALL_EXPR
7023 && (fndecl = get_callee_fndecl (inner))
7024 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
7025 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
7029 code = TREE_CODE (inner);
7030 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
7032 tree op0 = TREE_OPERAND (inner, 0);
7033 tree op1 = TREE_OPERAND (inner, 1);
7035 op0 = build_builtin_expect_predicate (loc, op0, arg1);
7036 op1 = build_builtin_expect_predicate (loc, op1, arg1);
7037 inner = build2 (code, TREE_TYPE (inner), op0, op1);
7039 return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
7042 /* If the argument isn't invariant then there's nothing else we can do. */
7043 if (!TREE_CONSTANT (inner_arg0))
7046 /* If we expect that a comparison against the argument will fold to
7047 a constant return the constant. In practice, this means a true
7048 constant or the address of a non-weak symbol. */
7051 if (TREE_CODE (inner) == ADDR_EXPR)
7055 inner = TREE_OPERAND (inner, 0);
7057 while (TREE_CODE (inner) == COMPONENT_REF
7058 || TREE_CODE (inner) == ARRAY_REF);
7059 if ((TREE_CODE (inner) == VAR_DECL
7060 || TREE_CODE (inner) == FUNCTION_DECL)
7061 && DECL_WEAK (inner))
7065 /* Otherwise, ARG0 already has the proper type for the return value. */
7069 /* Fold a call to __builtin_classify_type with argument ARG. */
7072 fold_builtin_classify_type (tree arg)
7075 return build_int_cst (integer_type_node, no_type_class);
7077 return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg)));
7080 /* Fold a call to __builtin_strlen with argument ARG. */
7083 fold_builtin_strlen (location_t loc, tree type, tree arg)
7085 if (!validate_arg (arg, POINTER_TYPE))
7089 tree len = c_strlen (arg, 0);
7092 return fold_convert_loc (loc, type, len);
7098 /* Fold a call to __builtin_inf or __builtin_huge_val. */
7101 fold_builtin_inf (location_t loc, tree type, int warn)
7103 REAL_VALUE_TYPE real;
7105 /* __builtin_inff is intended to be usable to define INFINITY on all
7106 targets. If an infinity is not available, INFINITY expands "to a
7107 positive constant of type float that overflows at translation
7108 time", footnote "In this case, using INFINITY will violate the
7109 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7110 Thus we pedwarn to ensure this constraint violation is
7112 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7113 pedwarn (loc, 0, "target format does not support infinity");
7116 return build_real (type, real);
7119 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
7122 fold_builtin_nan (tree arg, tree type, int quiet)
7124 REAL_VALUE_TYPE real;
7127 if (!validate_arg (arg, POINTER_TYPE))
7129 str = c_getstr (arg);
7133 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
7136 return build_real (type, real);
7139 /* Return true if the floating point expression T has an integer value.
7140 We also allow +Inf, -Inf and NaN to be considered integer values. */
7143 integer_valued_real_p (tree t)
7145 switch (TREE_CODE (t))
7152 return integer_valued_real_p (TREE_OPERAND (t, 0));
7157 return integer_valued_real_p (TREE_OPERAND (t, 1));
7164 return integer_valued_real_p (TREE_OPERAND (t, 0))
7165 && integer_valued_real_p (TREE_OPERAND (t, 1));
7168 return integer_valued_real_p (TREE_OPERAND (t, 1))
7169 && integer_valued_real_p (TREE_OPERAND (t, 2));
7172 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7176 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7177 if (TREE_CODE (type) == INTEGER_TYPE)
7179 if (TREE_CODE (type) == REAL_TYPE)
7180 return integer_valued_real_p (TREE_OPERAND (t, 0));
7185 switch (builtin_mathfn_code (t))
7187 CASE_FLT_FN (BUILT_IN_CEIL):
7188 CASE_FLT_FN (BUILT_IN_FLOOR):
7189 CASE_FLT_FN (BUILT_IN_NEARBYINT):
7190 CASE_FLT_FN (BUILT_IN_RINT):
7191 CASE_FLT_FN (BUILT_IN_ROUND):
7192 CASE_FLT_FN (BUILT_IN_TRUNC):
7195 CASE_FLT_FN (BUILT_IN_FMIN):
7196 CASE_FLT_FN (BUILT_IN_FMAX):
7197 return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7198 && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7211 /* FNDECL is assumed to be a builtin where truncation can be propagated
7212 across (for instance floor((double)f) == (double)floorf (f).
7213 Do the transformation for a call with argument ARG. */
7216 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
7218 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7220 if (!validate_arg (arg, REAL_TYPE))
7223 /* Integer rounding functions are idempotent. */
7224 if (fcode == builtin_mathfn_code (arg))
7227 /* If argument is already integer valued, and we don't need to worry
7228 about setting errno, there's no need to perform rounding. */
7229 if (! flag_errno_math && integer_valued_real_p (arg))
7234 tree arg0 = strip_float_extensions (arg);
7235 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7236 tree newtype = TREE_TYPE (arg0);
7239 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7240 && (decl = mathfn_built_in (newtype, fcode)))
7241 return fold_convert_loc (loc, ftype,
7242 build_call_expr_loc (loc, decl, 1,
7243 fold_convert_loc (loc,
7250 /* FNDECL is assumed to be builtin which can narrow the FP type of
7251 the argument, for instance lround((double)f) -> lroundf (f).
7252 Do the transformation for a call with argument ARG. */
7255 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
7257 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7259 if (!validate_arg (arg, REAL_TYPE))
7262 /* If argument is already integer valued, and we don't need to worry
7263 about setting errno, there's no need to perform rounding. */
7264 if (! flag_errno_math && integer_valued_real_p (arg))
7265 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7266 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7270 tree ftype = TREE_TYPE (arg);
7271 tree arg0 = strip_float_extensions (arg);
7272 tree newtype = TREE_TYPE (arg0);
7275 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7276 && (decl = mathfn_built_in (newtype, fcode)))
7277 return build_call_expr_loc (loc, decl, 1,
7278 fold_convert_loc (loc, newtype, arg0));
7281 /* Canonicalize iround (x) to lround (x) on ILP32 targets where
7282 sizeof (int) == sizeof (long). */
7283 if (TYPE_PRECISION (integer_type_node)
7284 == TYPE_PRECISION (long_integer_type_node))
7286 tree newfn = NULL_TREE;
7289 CASE_FLT_FN (BUILT_IN_ICEIL):
7290 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7293 CASE_FLT_FN (BUILT_IN_IFLOOR):
7294 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7297 CASE_FLT_FN (BUILT_IN_IROUND):
7298 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7301 CASE_FLT_FN (BUILT_IN_IRINT):
7302 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7311 tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7312 return fold_convert_loc (loc,
7313 TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7317 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7318 sizeof (long long) == sizeof (long). */
7319 if (TYPE_PRECISION (long_long_integer_type_node)
7320 == TYPE_PRECISION (long_integer_type_node))
7322 tree newfn = NULL_TREE;
7325 CASE_FLT_FN (BUILT_IN_LLCEIL):
7326 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7329 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7330 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7333 CASE_FLT_FN (BUILT_IN_LLROUND):
7334 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7337 CASE_FLT_FN (BUILT_IN_LLRINT):
7338 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7347 tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7348 return fold_convert_loc (loc,
7349 TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7356 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7357 return type. Return NULL_TREE if no simplification can be made. */
7360 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7364 if (!validate_arg (arg, COMPLEX_TYPE)
7365 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7368 /* Calculate the result when the argument is a constant. */
7369 if (TREE_CODE (arg) == COMPLEX_CST
7370 && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7374 if (TREE_CODE (arg) == COMPLEX_EXPR)
7376 tree real = TREE_OPERAND (arg, 0);
7377 tree imag = TREE_OPERAND (arg, 1);
7379 /* If either part is zero, cabs is fabs of the other. */
7380 if (real_zerop (real))
7381 return fold_build1_loc (loc, ABS_EXPR, type, imag);
7382 if (real_zerop (imag))
7383 return fold_build1_loc (loc, ABS_EXPR, type, real);
7385 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7386 if (flag_unsafe_math_optimizations
7387 && operand_equal_p (real, imag, OEP_PURE_SAME))
7389 const REAL_VALUE_TYPE sqrt2_trunc
7390 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7392 return fold_build2_loc (loc, MULT_EXPR, type,
7393 fold_build1_loc (loc, ABS_EXPR, type, real),
7394 build_real (type, sqrt2_trunc));
7398 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7399 if (TREE_CODE (arg) == NEGATE_EXPR
7400 || TREE_CODE (arg) == CONJ_EXPR)
7401 return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7403 /* Don't do this when optimizing for size. */
7404 if (flag_unsafe_math_optimizations
7405 && optimize && optimize_function_for_speed_p (cfun))
7407 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7409 if (sqrtfn != NULL_TREE)
7411 tree rpart, ipart, result;
7413 arg = builtin_save_expr (arg);
7415 rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7416 ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7418 rpart = builtin_save_expr (rpart);
7419 ipart = builtin_save_expr (ipart);
7421 result = fold_build2_loc (loc, PLUS_EXPR, type,
7422 fold_build2_loc (loc, MULT_EXPR, type,
7424 fold_build2_loc (loc, MULT_EXPR, type,
7427 return build_call_expr_loc (loc, sqrtfn, 1, result);
7434 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7435 complex tree type of the result. If NEG is true, the imaginary
7436 zero is negative. */
7439 build_complex_cproj (tree type, bool neg)
7441 REAL_VALUE_TYPE rinf, rzero = dconst0;
7445 return build_complex (type, build_real (TREE_TYPE (type), rinf),
7446 build_real (TREE_TYPE (type), rzero));
7449 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7450 return type. Return NULL_TREE if no simplification can be made. */
7453 fold_builtin_cproj (location_t loc, tree arg, tree type)
7455 if (!validate_arg (arg, COMPLEX_TYPE)
7456 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7459 /* If there are no infinities, return arg. */
7460 if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7461 return non_lvalue_loc (loc, arg);
7463 /* Calculate the result when the argument is a constant. */
7464 if (TREE_CODE (arg) == COMPLEX_CST)
7466 const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7467 const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7469 if (real_isinf (real) || real_isinf (imag))
7470 return build_complex_cproj (type, imag->sign);
7474 else if (TREE_CODE (arg) == COMPLEX_EXPR)
7476 tree real = TREE_OPERAND (arg, 0);
7477 tree imag = TREE_OPERAND (arg, 1);
7482 /* If the real part is inf and the imag part is known to be
7483 nonnegative, return (inf + 0i). Remember side-effects are
7484 possible in the imag part. */
7485 if (TREE_CODE (real) == REAL_CST
7486 && real_isinf (TREE_REAL_CST_PTR (real))
7487 && tree_expr_nonnegative_p (imag))
7488 return omit_one_operand_loc (loc, type,
7489 build_complex_cproj (type, false),
7492 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7493 Remember side-effects are possible in the real part. */
7494 if (TREE_CODE (imag) == REAL_CST
7495 && real_isinf (TREE_REAL_CST_PTR (imag)))
7497 omit_one_operand_loc (loc, type,
7498 build_complex_cproj (type, TREE_REAL_CST_PTR
7499 (imag)->sign), arg);
7505 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7506 Return NULL_TREE if no simplification can be made. */
7509 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7512 enum built_in_function fcode;
7515 if (!validate_arg (arg, REAL_TYPE))
7518 /* Calculate the result when the argument is a constant. */
7519 if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7522 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7523 fcode = builtin_mathfn_code (arg);
7524 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7526 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7527 arg = fold_build2_loc (loc, MULT_EXPR, type,
7528 CALL_EXPR_ARG (arg, 0),
7529 build_real (type, dconsthalf));
7530 return build_call_expr_loc (loc, expfn, 1, arg);
7533 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7534 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7536 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7540 tree arg0 = CALL_EXPR_ARG (arg, 0);
7542 /* The inner root was either sqrt or cbrt. */
7543 /* This was a conditional expression but it triggered a bug
7545 REAL_VALUE_TYPE dconstroot;
7546 if (BUILTIN_SQRT_P (fcode))
7547 dconstroot = dconsthalf;
7549 dconstroot = dconst_third ();
7551 /* Adjust for the outer root. */
7552 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7553 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7554 tree_root = build_real (type, dconstroot);
7555 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7559 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7560 if (flag_unsafe_math_optimizations
7561 && (fcode == BUILT_IN_POW
7562 || fcode == BUILT_IN_POWF
7563 || fcode == BUILT_IN_POWL))
7565 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7566 tree arg0 = CALL_EXPR_ARG (arg, 0);
7567 tree arg1 = CALL_EXPR_ARG (arg, 1);
7569 if (!tree_expr_nonnegative_p (arg0))
7570 arg0 = build1 (ABS_EXPR, type, arg0);
7571 narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7572 build_real (type, dconsthalf));
7573 return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7579 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7580 Return NULL_TREE if no simplification can be made. */
7583 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7585 const enum built_in_function fcode = builtin_mathfn_code (arg);
7588 if (!validate_arg (arg, REAL_TYPE))
7591 /* Calculate the result when the argument is a constant. */
7592 if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7595 if (flag_unsafe_math_optimizations)
7597 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7598 if (BUILTIN_EXPONENT_P (fcode))
7600 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7601 const REAL_VALUE_TYPE third_trunc =
7602 real_value_truncate (TYPE_MODE (type), dconst_third ());
7603 arg = fold_build2_loc (loc, MULT_EXPR, type,
7604 CALL_EXPR_ARG (arg, 0),
7605 build_real (type, third_trunc));
7606 return build_call_expr_loc (loc, expfn, 1, arg);
7609 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7610 if (BUILTIN_SQRT_P (fcode))
7612 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7616 tree arg0 = CALL_EXPR_ARG (arg, 0);
7618 REAL_VALUE_TYPE dconstroot = dconst_third ();
7620 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7621 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7622 tree_root = build_real (type, dconstroot);
7623 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7627 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7628 if (BUILTIN_CBRT_P (fcode))
7630 tree arg0 = CALL_EXPR_ARG (arg, 0);
7631 if (tree_expr_nonnegative_p (arg0))
7633 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7638 REAL_VALUE_TYPE dconstroot;
7640 real_arithmetic (&dconstroot, MULT_EXPR,
7641 dconst_third_ptr (), dconst_third_ptr ());
7642 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7643 tree_root = build_real (type, dconstroot);
7644 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7649 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7650 if (fcode == BUILT_IN_POW
7651 || fcode == BUILT_IN_POWF
7652 || fcode == BUILT_IN_POWL)
7654 tree arg00 = CALL_EXPR_ARG (arg, 0);
7655 tree arg01 = CALL_EXPR_ARG (arg, 1);
7656 if (tree_expr_nonnegative_p (arg00))
7658 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7659 const REAL_VALUE_TYPE dconstroot
7660 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7661 tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7662 build_real (type, dconstroot));
7663 return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7670 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7671 TYPE is the type of the return value. Return NULL_TREE if no
7672 simplification can be made. */
7675 fold_builtin_cos (location_t loc,
7676 tree arg, tree type, tree fndecl)
7680 if (!validate_arg (arg, REAL_TYPE))
7683 /* Calculate the result when the argument is a constant. */
7684 if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7687 /* Optimize cos(-x) into cos (x). */
7688 if ((narg = fold_strip_sign_ops (arg)))
7689 return build_call_expr_loc (loc, fndecl, 1, narg);
7694 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7695 Return NULL_TREE if no simplification can be made. */
7698 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7700 if (validate_arg (arg, REAL_TYPE))
7704 /* Calculate the result when the argument is a constant. */
7705 if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7708 /* Optimize cosh(-x) into cosh (x). */
7709 if ((narg = fold_strip_sign_ops (arg)))
7710 return build_call_expr_loc (loc, fndecl, 1, narg);
7716 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7717 argument ARG. TYPE is the type of the return value. Return
7718 NULL_TREE if no simplification can be made. */
7721 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7724 if (validate_arg (arg, COMPLEX_TYPE)
7725 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7729 /* Calculate the result when the argument is a constant. */
7730 if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7733 /* Optimize fn(-x) into fn(x). */
7734 if ((tmp = fold_strip_sign_ops (arg)))
7735 return build_call_expr_loc (loc, fndecl, 1, tmp);
7741 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7742 Return NULL_TREE if no simplification can be made. */
7745 fold_builtin_tan (tree arg, tree type)
7747 enum built_in_function fcode;
7750 if (!validate_arg (arg, REAL_TYPE))
7753 /* Calculate the result when the argument is a constant. */
7754 if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7757 /* Optimize tan(atan(x)) = x. */
7758 fcode = builtin_mathfn_code (arg);
7759 if (flag_unsafe_math_optimizations
7760 && (fcode == BUILT_IN_ATAN
7761 || fcode == BUILT_IN_ATANF
7762 || fcode == BUILT_IN_ATANL))
7763 return CALL_EXPR_ARG (arg, 0);
7768 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7769 NULL_TREE if no simplification can be made. */
7772 fold_builtin_sincos (location_t loc,
7773 tree arg0, tree arg1, tree arg2)
7778 if (!validate_arg (arg0, REAL_TYPE)
7779 || !validate_arg (arg1, POINTER_TYPE)
7780 || !validate_arg (arg2, POINTER_TYPE))
7783 type = TREE_TYPE (arg0);
7785 /* Calculate the result when the argument is a constant. */
7786 if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7789 /* Canonicalize sincos to cexpi. */
7790 if (!TARGET_C99_FUNCTIONS)
7792 fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7796 call = build_call_expr_loc (loc, fn, 1, arg0);
7797 call = builtin_save_expr (call);
7799 return build2 (COMPOUND_EXPR, void_type_node,
7800 build2 (MODIFY_EXPR, void_type_node,
7801 build_fold_indirect_ref_loc (loc, arg1),
7802 build1 (IMAGPART_EXPR, type, call)),
7803 build2 (MODIFY_EXPR, void_type_node,
7804 build_fold_indirect_ref_loc (loc, arg2),
7805 build1 (REALPART_EXPR, type, call)));
7808 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7809 NULL_TREE if no simplification can be made. */
7812 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7815 tree realp, imagp, ifn;
7818 if (!validate_arg (arg0, COMPLEX_TYPE)
7819 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7822 /* Calculate the result when the argument is a constant. */
7823 if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7826 rtype = TREE_TYPE (TREE_TYPE (arg0));
7828 /* In case we can figure out the real part of arg0 and it is constant zero
7830 if (!TARGET_C99_FUNCTIONS)
7832 ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7836 if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7837 && real_zerop (realp))
7839 tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7840 return build_call_expr_loc (loc, ifn, 1, narg);
7843 /* In case we can easily decompose real and imaginary parts split cexp
7844 to exp (r) * cexpi (i). */
7845 if (flag_unsafe_math_optimizations
7848 tree rfn, rcall, icall;
7850 rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7854 imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7858 icall = build_call_expr_loc (loc, ifn, 1, imagp);
7859 icall = builtin_save_expr (icall);
7860 rcall = build_call_expr_loc (loc, rfn, 1, realp);
7861 rcall = builtin_save_expr (rcall);
7862 return fold_build2_loc (loc, COMPLEX_EXPR, type,
7863 fold_build2_loc (loc, MULT_EXPR, rtype,
7865 fold_build1_loc (loc, REALPART_EXPR,
7867 fold_build2_loc (loc, MULT_EXPR, rtype,
7869 fold_build1_loc (loc, IMAGPART_EXPR,
7876 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7877 Return NULL_TREE if no simplification can be made. */
7880 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7882 if (!validate_arg (arg, REAL_TYPE))
7885 /* Optimize trunc of constant value. */
7886 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7888 REAL_VALUE_TYPE r, x;
7889 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7891 x = TREE_REAL_CST (arg);
7892 real_trunc (&r, TYPE_MODE (type), &x);
7893 return build_real (type, r);
7896 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7899 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7900 Return NULL_TREE if no simplification can be made. */
7903 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7905 if (!validate_arg (arg, REAL_TYPE))
7908 /* Optimize floor of constant value. */
7909 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7913 x = TREE_REAL_CST (arg);
7914 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7916 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7919 real_floor (&r, TYPE_MODE (type), &x);
7920 return build_real (type, r);
7924 /* Fold floor (x) where x is nonnegative to trunc (x). */
7925 if (tree_expr_nonnegative_p (arg))
7927 tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7929 return build_call_expr_loc (loc, truncfn, 1, arg);
7932 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7935 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7936 Return NULL_TREE if no simplification can be made. */
7939 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7941 if (!validate_arg (arg, REAL_TYPE))
7944 /* Optimize ceil of constant value. */
7945 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7949 x = TREE_REAL_CST (arg);
7950 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7952 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7955 real_ceil (&r, TYPE_MODE (type), &x);
7956 return build_real (type, r);
7960 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7963 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7964 Return NULL_TREE if no simplification can be made. */
7967 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7969 if (!validate_arg (arg, REAL_TYPE))
7972 /* Optimize round of constant value. */
7973 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7977 x = TREE_REAL_CST (arg);
7978 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7980 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7983 real_round (&r, TYPE_MODE (type), &x);
7984 return build_real (type, r);
7988 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7991 /* Fold function call to builtin lround, lroundf or lroundl (or the
7992 corresponding long long versions) and other rounding functions. ARG
7993 is the argument to the call. Return NULL_TREE if no simplification
7997 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7999 if (!validate_arg (arg, REAL_TYPE))
8002 /* Optimize lround of constant value. */
8003 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8005 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
8007 if (real_isfinite (&x))
8009 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
8010 tree ftype = TREE_TYPE (arg);
8014 switch (DECL_FUNCTION_CODE (fndecl))
8016 CASE_FLT_FN (BUILT_IN_IFLOOR):
8017 CASE_FLT_FN (BUILT_IN_LFLOOR):
8018 CASE_FLT_FN (BUILT_IN_LLFLOOR):
8019 real_floor (&r, TYPE_MODE (ftype), &x);
8022 CASE_FLT_FN (BUILT_IN_ICEIL):
8023 CASE_FLT_FN (BUILT_IN_LCEIL):
8024 CASE_FLT_FN (BUILT_IN_LLCEIL):
8025 real_ceil (&r, TYPE_MODE (ftype), &x);
8028 CASE_FLT_FN (BUILT_IN_IROUND):
8029 CASE_FLT_FN (BUILT_IN_LROUND):
8030 CASE_FLT_FN (BUILT_IN_LLROUND):
8031 real_round (&r, TYPE_MODE (ftype), &x);
8038 real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
8039 if (double_int_fits_to_tree_p (itype, val))
8040 return double_int_to_tree (itype, val);
8044 switch (DECL_FUNCTION_CODE (fndecl))
8046 CASE_FLT_FN (BUILT_IN_LFLOOR):
8047 CASE_FLT_FN (BUILT_IN_LLFLOOR):
8048 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
8049 if (tree_expr_nonnegative_p (arg))
8050 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
8051 TREE_TYPE (TREE_TYPE (fndecl)), arg);
8056 return fold_fixed_mathfn (loc, fndecl, arg);
8059 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8060 and their long and long long variants (i.e. ffsl and ffsll). ARG is
8061 the argument to the call. Return NULL_TREE if no simplification can
8065 fold_builtin_bitop (tree fndecl, tree arg)
8067 if (!validate_arg (arg, INTEGER_TYPE))
8070 /* Optimize for constant argument. */
8071 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8073 HOST_WIDE_INT hi, width, result;
8074 unsigned HOST_WIDE_INT lo;
8077 type = TREE_TYPE (arg);
8078 width = TYPE_PRECISION (type);
8079 lo = TREE_INT_CST_LOW (arg);
8081 /* Clear all the bits that are beyond the type's precision. */
8082 if (width > HOST_BITS_PER_WIDE_INT)
8084 hi = TREE_INT_CST_HIGH (arg);
8085 if (width < 2 * HOST_BITS_PER_WIDE_INT)
8086 hi &= ~((unsigned HOST_WIDE_INT) (-1)
8087 << (width - HOST_BITS_PER_WIDE_INT));
8092 if (width < HOST_BITS_PER_WIDE_INT)
8093 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
8096 switch (DECL_FUNCTION_CODE (fndecl))
8098 CASE_INT_FN (BUILT_IN_FFS):
8100 result = ffs_hwi (lo);
8102 result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
8107 CASE_INT_FN (BUILT_IN_CLZ):
8109 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
8111 result = width - floor_log2 (lo) - 1;
8112 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8116 CASE_INT_FN (BUILT_IN_CTZ):
8118 result = ctz_hwi (lo);
8120 result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
8121 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8125 CASE_INT_FN (BUILT_IN_CLRSB):
8126 if (width > HOST_BITS_PER_WIDE_INT
8127 && (hi & ((unsigned HOST_WIDE_INT) 1
8128 << (width - HOST_BITS_PER_WIDE_INT - 1))) != 0)
8130 hi = ~hi & ~((unsigned HOST_WIDE_INT) (-1)
8131 << (width - HOST_BITS_PER_WIDE_INT - 1));
8134 else if (width <= HOST_BITS_PER_WIDE_INT
8135 && (lo & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8136 lo = ~lo & ~((unsigned HOST_WIDE_INT) (-1) << (width - 1));
8138 result = width - floor_log2 (hi) - 2 - HOST_BITS_PER_WIDE_INT;
8140 result = width - floor_log2 (lo) - 2;
8145 CASE_INT_FN (BUILT_IN_POPCOUNT):
8148 result++, lo &= lo - 1;
8150 result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
8153 CASE_INT_FN (BUILT_IN_PARITY):
8156 result++, lo &= lo - 1;
8158 result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
8166 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
8172 /* Fold function call to builtin_bswap and the long and long long
8173 variants. Return NULL_TREE if no simplification can be made. */
8175 fold_builtin_bswap (tree fndecl, tree arg)
8177 if (! validate_arg (arg, INTEGER_TYPE))
8180 /* Optimize constant value. */
8181 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8183 HOST_WIDE_INT hi, width, r_hi = 0;
8184 unsigned HOST_WIDE_INT lo, r_lo = 0;
8187 type = TREE_TYPE (arg);
8188 width = TYPE_PRECISION (type);
8189 lo = TREE_INT_CST_LOW (arg);
8190 hi = TREE_INT_CST_HIGH (arg);
8192 switch (DECL_FUNCTION_CODE (fndecl))
8194 case BUILT_IN_BSWAP32:
8195 case BUILT_IN_BSWAP64:
8199 for (s = 0; s < width; s += 8)
8201 int d = width - s - 8;
8202 unsigned HOST_WIDE_INT byte;
8204 if (s < HOST_BITS_PER_WIDE_INT)
8205 byte = (lo >> s) & 0xff;
8207 byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
8209 if (d < HOST_BITS_PER_WIDE_INT)
8212 r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
8222 if (width < HOST_BITS_PER_WIDE_INT)
8223 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
8225 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
8231 /* A subroutine of fold_builtin to fold the various logarithmic
8232 functions. Return NULL_TREE if no simplification can me made.
8233 FUNC is the corresponding MPFR logarithm function. */
8236 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
8237 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8239 if (validate_arg (arg, REAL_TYPE))
8241 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8243 const enum built_in_function fcode = builtin_mathfn_code (arg);
8245 /* Calculate the result when the argument is a constant. */
8246 if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
8249 /* Special case, optimize logN(expN(x)) = x. */
8250 if (flag_unsafe_math_optimizations
8251 && ((func == mpfr_log
8252 && (fcode == BUILT_IN_EXP
8253 || fcode == BUILT_IN_EXPF
8254 || fcode == BUILT_IN_EXPL))
8255 || (func == mpfr_log2
8256 && (fcode == BUILT_IN_EXP2
8257 || fcode == BUILT_IN_EXP2F
8258 || fcode == BUILT_IN_EXP2L))
8259 || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
8260 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8262 /* Optimize logN(func()) for various exponential functions. We
8263 want to determine the value "x" and the power "exponent" in
8264 order to transform logN(x**exponent) into exponent*logN(x). */
8265 if (flag_unsafe_math_optimizations)
8267 tree exponent = 0, x = 0;
8271 CASE_FLT_FN (BUILT_IN_EXP):
8272 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
8273 x = build_real (type, real_value_truncate (TYPE_MODE (type),
8275 exponent = CALL_EXPR_ARG (arg, 0);
8277 CASE_FLT_FN (BUILT_IN_EXP2):
8278 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
8279 x = build_real (type, dconst2);
8280 exponent = CALL_EXPR_ARG (arg, 0);
8282 CASE_FLT_FN (BUILT_IN_EXP10):
8283 CASE_FLT_FN (BUILT_IN_POW10):
8284 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
8286 REAL_VALUE_TYPE dconst10;
8287 real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8288 x = build_real (type, dconst10);
8290 exponent = CALL_EXPR_ARG (arg, 0);
8292 CASE_FLT_FN (BUILT_IN_SQRT):
8293 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
8294 x = CALL_EXPR_ARG (arg, 0);
8295 exponent = build_real (type, dconsthalf);
8297 CASE_FLT_FN (BUILT_IN_CBRT):
8298 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
8299 x = CALL_EXPR_ARG (arg, 0);
8300 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8303 CASE_FLT_FN (BUILT_IN_POW):
8304 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
8305 x = CALL_EXPR_ARG (arg, 0);
8306 exponent = CALL_EXPR_ARG (arg, 1);
8312 /* Now perform the optimization. */
8315 tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
8316 return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
8324 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8325 NULL_TREE if no simplification can be made. */
8328 fold_builtin_hypot (location_t loc, tree fndecl,
8329 tree arg0, tree arg1, tree type)
8331 tree res, narg0, narg1;
8333 if (!validate_arg (arg0, REAL_TYPE)
8334 || !validate_arg (arg1, REAL_TYPE))
8337 /* Calculate the result when the argument is a constant. */
8338 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8341 /* If either argument to hypot has a negate or abs, strip that off.
8342 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8343 narg0 = fold_strip_sign_ops (arg0);
8344 narg1 = fold_strip_sign_ops (arg1);
8347 return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
8348 narg1 ? narg1 : arg1);
8351 /* If either argument is zero, hypot is fabs of the other. */
8352 if (real_zerop (arg0))
8353 return fold_build1_loc (loc, ABS_EXPR, type, arg1);
8354 else if (real_zerop (arg1))
8355 return fold_build1_loc (loc, ABS_EXPR, type, arg0);
8357 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8358 if (flag_unsafe_math_optimizations
8359 && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8361 const REAL_VALUE_TYPE sqrt2_trunc
8362 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8363 return fold_build2_loc (loc, MULT_EXPR, type,
8364 fold_build1_loc (loc, ABS_EXPR, type, arg0),
8365 build_real (type, sqrt2_trunc));
8372 /* Fold a builtin function call to pow, powf, or powl. Return
8373 NULL_TREE if no simplification can be made. */
8375 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8379 if (!validate_arg (arg0, REAL_TYPE)
8380 || !validate_arg (arg1, REAL_TYPE))
8383 /* Calculate the result when the argument is a constant. */
8384 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8387 /* Optimize pow(1.0,y) = 1.0. */
8388 if (real_onep (arg0))
8389 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8391 if (TREE_CODE (arg1) == REAL_CST
8392 && !TREE_OVERFLOW (arg1))
8394 REAL_VALUE_TYPE cint;
8398 c = TREE_REAL_CST (arg1);
8400 /* Optimize pow(x,0.0) = 1.0. */
8401 if (REAL_VALUES_EQUAL (c, dconst0))
8402 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8405 /* Optimize pow(x,1.0) = x. */
8406 if (REAL_VALUES_EQUAL (c, dconst1))
8409 /* Optimize pow(x,-1.0) = 1.0/x. */
8410 if (REAL_VALUES_EQUAL (c, dconstm1))
8411 return fold_build2_loc (loc, RDIV_EXPR, type,
8412 build_real (type, dconst1), arg0);
8414 /* Optimize pow(x,0.5) = sqrt(x). */
8415 if (flag_unsafe_math_optimizations
8416 && REAL_VALUES_EQUAL (c, dconsthalf))
8418 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8420 if (sqrtfn != NULL_TREE)
8421 return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8424 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8425 if (flag_unsafe_math_optimizations)
8427 const REAL_VALUE_TYPE dconstroot
8428 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8430 if (REAL_VALUES_EQUAL (c, dconstroot))
8432 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8433 if (cbrtfn != NULL_TREE)
8434 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8438 /* Check for an integer exponent. */
8439 n = real_to_integer (&c);
8440 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8441 if (real_identical (&c, &cint))
8443 /* Attempt to evaluate pow at compile-time, unless this should
8444 raise an exception. */
8445 if (TREE_CODE (arg0) == REAL_CST
8446 && !TREE_OVERFLOW (arg0)
8448 || (!flag_trapping_math && !flag_errno_math)
8449 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8454 x = TREE_REAL_CST (arg0);
8455 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8456 if (flag_unsafe_math_optimizations || !inexact)
8457 return build_real (type, x);
8460 /* Strip sign ops from even integer powers. */
8461 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8463 tree narg0 = fold_strip_sign_ops (arg0);
8465 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8470 if (flag_unsafe_math_optimizations)
8472 const enum built_in_function fcode = builtin_mathfn_code (arg0);
8474 /* Optimize pow(expN(x),y) = expN(x*y). */
8475 if (BUILTIN_EXPONENT_P (fcode))
8477 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8478 tree arg = CALL_EXPR_ARG (arg0, 0);
8479 arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8480 return build_call_expr_loc (loc, expfn, 1, arg);
8483 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8484 if (BUILTIN_SQRT_P (fcode))
8486 tree narg0 = CALL_EXPR_ARG (arg0, 0);
8487 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8488 build_real (type, dconsthalf));
8489 return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8492 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8493 if (BUILTIN_CBRT_P (fcode))
8495 tree arg = CALL_EXPR_ARG (arg0, 0);
8496 if (tree_expr_nonnegative_p (arg))
8498 const REAL_VALUE_TYPE dconstroot
8499 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8500 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8501 build_real (type, dconstroot));
8502 return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8506 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8507 if (fcode == BUILT_IN_POW
8508 || fcode == BUILT_IN_POWF
8509 || fcode == BUILT_IN_POWL)
8511 tree arg00 = CALL_EXPR_ARG (arg0, 0);
8512 if (tree_expr_nonnegative_p (arg00))
8514 tree arg01 = CALL_EXPR_ARG (arg0, 1);
8515 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8516 return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8524 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8525 Return NULL_TREE if no simplification can be made. */
8527 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8528 tree arg0, tree arg1, tree type)
8530 if (!validate_arg (arg0, REAL_TYPE)
8531 || !validate_arg (arg1, INTEGER_TYPE))
8534 /* Optimize pow(1.0,y) = 1.0. */
8535 if (real_onep (arg0))
8536 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8538 if (host_integerp (arg1, 0))
8540 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8542 /* Evaluate powi at compile-time. */
8543 if (TREE_CODE (arg0) == REAL_CST
8544 && !TREE_OVERFLOW (arg0))
8547 x = TREE_REAL_CST (arg0);
8548 real_powi (&x, TYPE_MODE (type), &x, c);
8549 return build_real (type, x);
8552 /* Optimize pow(x,0) = 1.0. */
8554 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8557 /* Optimize pow(x,1) = x. */
8561 /* Optimize pow(x,-1) = 1.0/x. */
8563 return fold_build2_loc (loc, RDIV_EXPR, type,
8564 build_real (type, dconst1), arg0);
8570 /* A subroutine of fold_builtin to fold the various exponent
8571 functions. Return NULL_TREE if no simplification can be made.
8572 FUNC is the corresponding MPFR exponent function. */
8575 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8576 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8578 if (validate_arg (arg, REAL_TYPE))
8580 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8583 /* Calculate the result when the argument is a constant. */
8584 if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8587 /* Optimize expN(logN(x)) = x. */
8588 if (flag_unsafe_math_optimizations)
8590 const enum built_in_function fcode = builtin_mathfn_code (arg);
8592 if ((func == mpfr_exp
8593 && (fcode == BUILT_IN_LOG
8594 || fcode == BUILT_IN_LOGF
8595 || fcode == BUILT_IN_LOGL))
8596 || (func == mpfr_exp2
8597 && (fcode == BUILT_IN_LOG2
8598 || fcode == BUILT_IN_LOG2F
8599 || fcode == BUILT_IN_LOG2L))
8600 || (func == mpfr_exp10
8601 && (fcode == BUILT_IN_LOG10
8602 || fcode == BUILT_IN_LOG10F
8603 || fcode == BUILT_IN_LOG10L)))
8604 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8611 /* Return true if VAR is a VAR_DECL or a component thereof. */
8614 var_decl_component_p (tree var)
8617 while (handled_component_p (inner))
8618 inner = TREE_OPERAND (inner, 0);
8619 return SSA_VAR_P (inner);
8622 /* Fold function call to builtin memset. Return
8623 NULL_TREE if no simplification can be made. */
8626 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8627 tree type, bool ignore)
8629 tree var, ret, etype;
8630 unsigned HOST_WIDE_INT length, cval;
8632 if (! validate_arg (dest, POINTER_TYPE)
8633 || ! validate_arg (c, INTEGER_TYPE)
8634 || ! validate_arg (len, INTEGER_TYPE))
8637 if (! host_integerp (len, 1))
8640 /* If the LEN parameter is zero, return DEST. */
8641 if (integer_zerop (len))
8642 return omit_one_operand_loc (loc, type, dest, c);
8644 if (TREE_CODE (c) != INTEGER_CST || TREE_SIDE_EFFECTS (dest))
8649 if (TREE_CODE (var) != ADDR_EXPR)
8652 var = TREE_OPERAND (var, 0);
8653 if (TREE_THIS_VOLATILE (var))
8656 etype = TREE_TYPE (var);
8657 if (TREE_CODE (etype) == ARRAY_TYPE)
8658 etype = TREE_TYPE (etype);
8660 if (!INTEGRAL_TYPE_P (etype)
8661 && !POINTER_TYPE_P (etype))
8664 if (! var_decl_component_p (var))
8667 length = tree_low_cst (len, 1);
8668 if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8669 || get_pointer_alignment (dest) / BITS_PER_UNIT < length)
8672 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8675 if (integer_zerop (c))
8679 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8682 cval = TREE_INT_CST_LOW (c);
8686 cval |= (cval << 31) << 1;
8689 ret = build_int_cst_type (etype, cval);
8690 var = build_fold_indirect_ref_loc (loc,
8691 fold_convert_loc (loc,
8692 build_pointer_type (etype),
8694 ret = build2 (MODIFY_EXPR, etype, var, ret);
8698 return omit_one_operand_loc (loc, type, dest, ret);
8701 /* Fold function call to builtin memset. Return
8702 NULL_TREE if no simplification can be made. */
8705 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8707 if (! validate_arg (dest, POINTER_TYPE)
8708 || ! validate_arg (size, INTEGER_TYPE))
8714 /* New argument list transforming bzero(ptr x, int y) to
8715 memset(ptr x, int 0, size_t y). This is done this way
8716 so that if it isn't expanded inline, we fallback to
8717 calling bzero instead of memset. */
8719 return fold_builtin_memset (loc, dest, integer_zero_node,
8720 fold_convert_loc (loc, size_type_node, size),
8721 void_type_node, ignore);
8724 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8725 NULL_TREE if no simplification can be made.
8726 If ENDP is 0, return DEST (like memcpy).
8727 If ENDP is 1, return DEST+LEN (like mempcpy).
8728 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8729 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8733 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8734 tree len, tree type, bool ignore, int endp)
8736 tree destvar, srcvar, expr;
8738 if (! validate_arg (dest, POINTER_TYPE)
8739 || ! validate_arg (src, POINTER_TYPE)
8740 || ! validate_arg (len, INTEGER_TYPE))
8743 /* If the LEN parameter is zero, return DEST. */
8744 if (integer_zerop (len))
8745 return omit_one_operand_loc (loc, type, dest, src);
8747 /* If SRC and DEST are the same (and not volatile), return
8748 DEST{,+LEN,+LEN-1}. */
8749 if (operand_equal_p (src, dest, 0))
8753 tree srctype, desttype;
8754 unsigned int src_align, dest_align;
8759 src_align = get_pointer_alignment (src);
8760 dest_align = get_pointer_alignment (dest);
8762 /* Both DEST and SRC must be pointer types.
8763 ??? This is what old code did. Is the testing for pointer types
8766 If either SRC is readonly or length is 1, we can use memcpy. */
8767 if (!dest_align || !src_align)
8769 if (readonly_data_expr (src)
8770 || (host_integerp (len, 1)
8771 && (MIN (src_align, dest_align) / BITS_PER_UNIT
8772 >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8774 tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8777 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8780 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8781 if (TREE_CODE (src) == ADDR_EXPR
8782 && TREE_CODE (dest) == ADDR_EXPR)
8784 tree src_base, dest_base, fn;
8785 HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8786 HOST_WIDE_INT size = -1;
8787 HOST_WIDE_INT maxsize = -1;
8789 srcvar = TREE_OPERAND (src, 0);
8790 src_base = get_ref_base_and_extent (srcvar, &src_offset,
8792 destvar = TREE_OPERAND (dest, 0);
8793 dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8795 if (host_integerp (len, 1))
8796 maxsize = tree_low_cst (len, 1);
8799 src_offset /= BITS_PER_UNIT;
8800 dest_offset /= BITS_PER_UNIT;
8801 if (SSA_VAR_P (src_base)
8802 && SSA_VAR_P (dest_base))
8804 if (operand_equal_p (src_base, dest_base, 0)
8805 && ranges_overlap_p (src_offset, maxsize,
8806 dest_offset, maxsize))
8809 else if (TREE_CODE (src_base) == MEM_REF
8810 && TREE_CODE (dest_base) == MEM_REF)
8813 if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8814 TREE_OPERAND (dest_base, 0), 0))
8816 off = double_int_add (mem_ref_offset (src_base),
8817 shwi_to_double_int (src_offset));
8818 if (!double_int_fits_in_shwi_p (off))
8820 src_offset = off.low;
8821 off = double_int_add (mem_ref_offset (dest_base),
8822 shwi_to_double_int (dest_offset));
8823 if (!double_int_fits_in_shwi_p (off))
8825 dest_offset = off.low;
8826 if (ranges_overlap_p (src_offset, maxsize,
8827 dest_offset, maxsize))
8833 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8836 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8839 /* If the destination and source do not alias optimize into
8841 if ((is_gimple_min_invariant (dest)
8842 || TREE_CODE (dest) == SSA_NAME)
8843 && (is_gimple_min_invariant (src)
8844 || TREE_CODE (src) == SSA_NAME))
8847 ao_ref_init_from_ptr_and_size (&destr, dest, len);
8848 ao_ref_init_from_ptr_and_size (&srcr, src, len);
8849 if (!refs_may_alias_p_1 (&destr, &srcr, false))
8852 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8855 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8862 if (!host_integerp (len, 0))
8865 This logic lose for arguments like (type *)malloc (sizeof (type)),
8866 since we strip the casts of up to VOID return value from malloc.
8867 Perhaps we ought to inherit type from non-VOID argument here? */
8870 if (!POINTER_TYPE_P (TREE_TYPE (src))
8871 || !POINTER_TYPE_P (TREE_TYPE (dest)))
8873 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8874 if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8876 tree tem = TREE_OPERAND (src, 0);
8878 if (tem != TREE_OPERAND (src, 0))
8879 src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8881 if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8883 tree tem = TREE_OPERAND (dest, 0);
8885 if (tem != TREE_OPERAND (dest, 0))
8886 dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8888 srctype = TREE_TYPE (TREE_TYPE (src));
8889 if (TREE_CODE (srctype) == ARRAY_TYPE
8890 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8892 srctype = TREE_TYPE (srctype);
8894 src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8896 desttype = TREE_TYPE (TREE_TYPE (dest));
8897 if (TREE_CODE (desttype) == ARRAY_TYPE
8898 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8900 desttype = TREE_TYPE (desttype);
8902 dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8904 if (TREE_ADDRESSABLE (srctype)
8905 || TREE_ADDRESSABLE (desttype))
8908 src_align = get_pointer_alignment (src);
8909 dest_align = get_pointer_alignment (dest);
8910 if (dest_align < TYPE_ALIGN (desttype)
8911 || src_align < TYPE_ALIGN (srctype))
8915 dest = builtin_save_expr (dest);
8917 /* Build accesses at offset zero with a ref-all character type. */
8918 off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8919 ptr_mode, true), 0);
8922 STRIP_NOPS (destvar);
8923 if (TREE_CODE (destvar) == ADDR_EXPR
8924 && var_decl_component_p (TREE_OPERAND (destvar, 0))
8925 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8926 destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8928 destvar = NULL_TREE;
8931 STRIP_NOPS (srcvar);
8932 if (TREE_CODE (srcvar) == ADDR_EXPR
8933 && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8934 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8937 || src_align >= TYPE_ALIGN (desttype))
8938 srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8940 else if (!STRICT_ALIGNMENT)
8942 srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8944 srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8952 if (srcvar == NULL_TREE && destvar == NULL_TREE)
8955 if (srcvar == NULL_TREE)
8958 if (src_align >= TYPE_ALIGN (desttype))
8959 srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8962 if (STRICT_ALIGNMENT)
8964 srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8966 srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8969 else if (destvar == NULL_TREE)
8972 if (dest_align >= TYPE_ALIGN (srctype))
8973 destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8976 if (STRICT_ALIGNMENT)
8978 desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8980 destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8984 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8990 if (endp == 0 || endp == 3)
8991 return omit_one_operand_loc (loc, type, dest, expr);
8997 len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
9000 dest = fold_build_pointer_plus_loc (loc, dest, len);
9001 dest = fold_convert_loc (loc, type, dest);
9003 dest = omit_one_operand_loc (loc, type, dest, expr);
9007 /* Fold function call to builtin strcpy with arguments DEST and SRC.
9008 If LEN is not NULL, it represents the length of the string to be
9009 copied. Return NULL_TREE if no simplification can be made. */
9012 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
9016 if (!validate_arg (dest, POINTER_TYPE)
9017 || !validate_arg (src, POINTER_TYPE))
9020 /* If SRC and DEST are the same (and not volatile), return DEST. */
9021 if (operand_equal_p (src, dest, 0))
9022 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
9024 if (optimize_function_for_size_p (cfun))
9027 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9033 len = c_strlen (src, 1);
9034 if (! len || TREE_SIDE_EFFECTS (len))
9038 len = fold_convert_loc (loc, size_type_node, len);
9039 len = size_binop_loc (loc, PLUS_EXPR, len, build_int_cst (size_type_node, 1));
9040 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
9041 build_call_expr_loc (loc, fn, 3, dest, src, len));
9044 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
9045 Return NULL_TREE if no simplification can be made. */
9048 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
9050 tree fn, len, lenp1, call, type;
9052 if (!validate_arg (dest, POINTER_TYPE)
9053 || !validate_arg (src, POINTER_TYPE))
9056 len = c_strlen (src, 1);
9058 || TREE_CODE (len) != INTEGER_CST)
9061 if (optimize_function_for_size_p (cfun)
9062 /* If length is zero it's small enough. */
9063 && !integer_zerop (len))
9066 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9070 lenp1 = size_binop_loc (loc, PLUS_EXPR,
9071 fold_convert_loc (loc, size_type_node, len),
9072 build_int_cst (size_type_node, 1));
9073 /* We use dest twice in building our expression. Save it from
9074 multiple expansions. */
9075 dest = builtin_save_expr (dest);
9076 call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
9078 type = TREE_TYPE (TREE_TYPE (fndecl));
9079 dest = fold_build_pointer_plus_loc (loc, dest, len);
9080 dest = fold_convert_loc (loc, type, dest);
9081 dest = omit_one_operand_loc (loc, type, dest, call);
9085 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
9086 If SLEN is not NULL, it represents the length of the source string.
9087 Return NULL_TREE if no simplification can be made. */
9090 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
9091 tree src, tree len, tree slen)
9095 if (!validate_arg (dest, POINTER_TYPE)
9096 || !validate_arg (src, POINTER_TYPE)
9097 || !validate_arg (len, INTEGER_TYPE))
9100 /* If the LEN parameter is zero, return DEST. */
9101 if (integer_zerop (len))
9102 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
9104 /* We can't compare slen with len as constants below if len is not a
9106 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
9110 slen = c_strlen (src, 1);
9112 /* Now, we must be passed a constant src ptr parameter. */
9113 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
9116 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
9118 /* We do not support simplification of this case, though we do
9119 support it when expanding trees into RTL. */
9120 /* FIXME: generate a call to __builtin_memset. */
9121 if (tree_int_cst_lt (slen, len))
9124 /* OK transform into builtin memcpy. */
9125 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9129 len = fold_convert_loc (loc, size_type_node, len);
9130 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
9131 build_call_expr_loc (loc, fn, 3, dest, src, len));
9134 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
9135 arguments to the call, and TYPE is its return type.
9136 Return NULL_TREE if no simplification can be made. */
9139 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
9141 if (!validate_arg (arg1, POINTER_TYPE)
9142 || !validate_arg (arg2, INTEGER_TYPE)
9143 || !validate_arg (len, INTEGER_TYPE))
9149 if (TREE_CODE (arg2) != INTEGER_CST
9150 || !host_integerp (len, 1))
9153 p1 = c_getstr (arg1);
9154 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
9160 if (target_char_cast (arg2, &c))
9163 r = (const char *) memchr (p1, c, tree_low_cst (len, 1));
9166 return build_int_cst (TREE_TYPE (arg1), 0);
9168 tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
9169 return fold_convert_loc (loc, type, tem);
9175 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
9176 Return NULL_TREE if no simplification can be made. */
9179 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
9181 const char *p1, *p2;
9183 if (!validate_arg (arg1, POINTER_TYPE)
9184 || !validate_arg (arg2, POINTER_TYPE)
9185 || !validate_arg (len, INTEGER_TYPE))
9188 /* If the LEN parameter is zero, return zero. */
9189 if (integer_zerop (len))
9190 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9193 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9194 if (operand_equal_p (arg1, arg2, 0))
9195 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9197 p1 = c_getstr (arg1);
9198 p2 = c_getstr (arg2);
9200 /* If all arguments are constant, and the value of len is not greater
9201 than the lengths of arg1 and arg2, evaluate at compile-time. */
9202 if (host_integerp (len, 1) && p1 && p2
9203 && compare_tree_int (len, strlen (p1) + 1) <= 0
9204 && compare_tree_int (len, strlen (p2) + 1) <= 0)
9206 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
9209 return integer_one_node;
9211 return integer_minus_one_node;
9213 return integer_zero_node;
9216 /* If len parameter is one, return an expression corresponding to
9217 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9218 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9220 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9221 tree cst_uchar_ptr_node
9222 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9225 = fold_convert_loc (loc, integer_type_node,
9226 build1 (INDIRECT_REF, cst_uchar_node,
9227 fold_convert_loc (loc,
9231 = fold_convert_loc (loc, integer_type_node,
9232 build1 (INDIRECT_REF, cst_uchar_node,
9233 fold_convert_loc (loc,
9236 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9242 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
9243 Return NULL_TREE if no simplification can be made. */
9246 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
9248 const char *p1, *p2;
9250 if (!validate_arg (arg1, POINTER_TYPE)
9251 || !validate_arg (arg2, POINTER_TYPE))
9254 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9255 if (operand_equal_p (arg1, arg2, 0))
9256 return integer_zero_node;
9258 p1 = c_getstr (arg1);
9259 p2 = c_getstr (arg2);
9263 const int i = strcmp (p1, p2);
9265 return integer_minus_one_node;
9267 return integer_one_node;
9269 return integer_zero_node;
9272 /* If the second arg is "", return *(const unsigned char*)arg1. */
9273 if (p2 && *p2 == '\0')
9275 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9276 tree cst_uchar_ptr_node
9277 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9279 return fold_convert_loc (loc, integer_type_node,
9280 build1 (INDIRECT_REF, cst_uchar_node,
9281 fold_convert_loc (loc,
9286 /* If the first arg is "", return -*(const unsigned char*)arg2. */
9287 if (p1 && *p1 == '\0')
9289 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9290 tree cst_uchar_ptr_node
9291 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9294 = fold_convert_loc (loc, integer_type_node,
9295 build1 (INDIRECT_REF, cst_uchar_node,
9296 fold_convert_loc (loc,
9299 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9305 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9306 Return NULL_TREE if no simplification can be made. */
9309 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
9311 const char *p1, *p2;
9313 if (!validate_arg (arg1, POINTER_TYPE)
9314 || !validate_arg (arg2, POINTER_TYPE)
9315 || !validate_arg (len, INTEGER_TYPE))
9318 /* If the LEN parameter is zero, return zero. */
9319 if (integer_zerop (len))
9320 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9323 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9324 if (operand_equal_p (arg1, arg2, 0))
9325 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9327 p1 = c_getstr (arg1);
9328 p2 = c_getstr (arg2);
9330 if (host_integerp (len, 1) && p1 && p2)
9332 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9334 return integer_one_node;
9336 return integer_minus_one_node;
9338 return integer_zero_node;
9341 /* If the second arg is "", and the length is greater than zero,
9342 return *(const unsigned char*)arg1. */
9343 if (p2 && *p2 == '\0'
9344 && TREE_CODE (len) == INTEGER_CST
9345 && tree_int_cst_sgn (len) == 1)
9347 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9348 tree cst_uchar_ptr_node
9349 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9351 return fold_convert_loc (loc, integer_type_node,
9352 build1 (INDIRECT_REF, cst_uchar_node,
9353 fold_convert_loc (loc,
9358 /* If the first arg is "", and the length is greater than zero,
9359 return -*(const unsigned char*)arg2. */
9360 if (p1 && *p1 == '\0'
9361 && TREE_CODE (len) == INTEGER_CST
9362 && tree_int_cst_sgn (len) == 1)
9364 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9365 tree cst_uchar_ptr_node
9366 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9368 tree temp = fold_convert_loc (loc, integer_type_node,
9369 build1 (INDIRECT_REF, cst_uchar_node,
9370 fold_convert_loc (loc,
9373 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9376 /* If len parameter is one, return an expression corresponding to
9377 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9378 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9380 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9381 tree cst_uchar_ptr_node
9382 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9384 tree ind1 = fold_convert_loc (loc, integer_type_node,
9385 build1 (INDIRECT_REF, cst_uchar_node,
9386 fold_convert_loc (loc,
9389 tree ind2 = fold_convert_loc (loc, integer_type_node,
9390 build1 (INDIRECT_REF, cst_uchar_node,
9391 fold_convert_loc (loc,
9394 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9400 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9401 ARG. Return NULL_TREE if no simplification can be made. */
9404 fold_builtin_signbit (location_t loc, tree arg, tree type)
9406 if (!validate_arg (arg, REAL_TYPE))
9409 /* If ARG is a compile-time constant, determine the result. */
9410 if (TREE_CODE (arg) == REAL_CST
9411 && !TREE_OVERFLOW (arg))
9415 c = TREE_REAL_CST (arg);
9416 return (REAL_VALUE_NEGATIVE (c)
9417 ? build_one_cst (type)
9418 : build_zero_cst (type));
9421 /* If ARG is non-negative, the result is always zero. */
9422 if (tree_expr_nonnegative_p (arg))
9423 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9425 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9426 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9427 return fold_convert (type,
9428 fold_build2_loc (loc, LT_EXPR, boolean_type_node, arg,
9429 build_real (TREE_TYPE (arg), dconst0)));
9434 /* Fold function call to builtin copysign, copysignf or copysignl with
9435 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9439 fold_builtin_copysign (location_t loc, tree fndecl,
9440 tree arg1, tree arg2, tree type)
9444 if (!validate_arg (arg1, REAL_TYPE)
9445 || !validate_arg (arg2, REAL_TYPE))
9448 /* copysign(X,X) is X. */
9449 if (operand_equal_p (arg1, arg2, 0))
9450 return fold_convert_loc (loc, type, arg1);
9452 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9453 if (TREE_CODE (arg1) == REAL_CST
9454 && TREE_CODE (arg2) == REAL_CST
9455 && !TREE_OVERFLOW (arg1)
9456 && !TREE_OVERFLOW (arg2))
9458 REAL_VALUE_TYPE c1, c2;
9460 c1 = TREE_REAL_CST (arg1);
9461 c2 = TREE_REAL_CST (arg2);
9462 /* c1.sign := c2.sign. */
9463 real_copysign (&c1, &c2);
9464 return build_real (type, c1);
9467 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9468 Remember to evaluate Y for side-effects. */
9469 if (tree_expr_nonnegative_p (arg2))
9470 return omit_one_operand_loc (loc, type,
9471 fold_build1_loc (loc, ABS_EXPR, type, arg1),
9474 /* Strip sign changing operations for the first argument. */
9475 tem = fold_strip_sign_ops (arg1);
9477 return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9482 /* Fold a call to builtin isascii with argument ARG. */
9485 fold_builtin_isascii (location_t loc, tree arg)
9487 if (!validate_arg (arg, INTEGER_TYPE))
9491 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9492 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9493 build_int_cst (integer_type_node,
9494 ~ (unsigned HOST_WIDE_INT) 0x7f));
9495 return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9496 arg, integer_zero_node);
9500 /* Fold a call to builtin toascii with argument ARG. */
9503 fold_builtin_toascii (location_t loc, tree arg)
9505 if (!validate_arg (arg, INTEGER_TYPE))
9508 /* Transform toascii(c) -> (c & 0x7f). */
9509 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9510 build_int_cst (integer_type_node, 0x7f));
9513 /* Fold a call to builtin isdigit with argument ARG. */
9516 fold_builtin_isdigit (location_t loc, tree arg)
9518 if (!validate_arg (arg, INTEGER_TYPE))
9522 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9523 /* According to the C standard, isdigit is unaffected by locale.
9524 However, it definitely is affected by the target character set. */
9525 unsigned HOST_WIDE_INT target_digit0
9526 = lang_hooks.to_target_charset ('0');
9528 if (target_digit0 == 0)
9531 arg = fold_convert_loc (loc, unsigned_type_node, arg);
9532 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9533 build_int_cst (unsigned_type_node, target_digit0));
9534 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9535 build_int_cst (unsigned_type_node, 9));
9539 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9542 fold_builtin_fabs (location_t loc, tree arg, tree type)
9544 if (!validate_arg (arg, REAL_TYPE))
9547 arg = fold_convert_loc (loc, type, arg);
9548 if (TREE_CODE (arg) == REAL_CST)
9549 return fold_abs_const (arg, type);
9550 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9553 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9556 fold_builtin_abs (location_t loc, tree arg, tree type)
9558 if (!validate_arg (arg, INTEGER_TYPE))
9561 arg = fold_convert_loc (loc, type, arg);
9562 if (TREE_CODE (arg) == INTEGER_CST)
9563 return fold_abs_const (arg, type);
9564 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9567 /* Fold a fma operation with arguments ARG[012]. */
9570 fold_fma (location_t loc ATTRIBUTE_UNUSED,
9571 tree type, tree arg0, tree arg1, tree arg2)
9573 if (TREE_CODE (arg0) == REAL_CST
9574 && TREE_CODE (arg1) == REAL_CST
9575 && TREE_CODE (arg2) == REAL_CST)
9576 return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
9581 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
9584 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
9586 if (validate_arg (arg0, REAL_TYPE)
9587 && validate_arg(arg1, REAL_TYPE)
9588 && validate_arg(arg2, REAL_TYPE))
9590 tree tem = fold_fma (loc, type, arg0, arg1, arg2);
9594 /* ??? Only expand to FMA_EXPR if it's directly supported. */
9595 if (optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
9596 return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
9601 /* Fold a call to builtin fmin or fmax. */
9604 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9605 tree type, bool max)
9607 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9609 /* Calculate the result when the argument is a constant. */
9610 tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9615 /* If either argument is NaN, return the other one. Avoid the
9616 transformation if we get (and honor) a signalling NaN. Using
9617 omit_one_operand() ensures we create a non-lvalue. */
9618 if (TREE_CODE (arg0) == REAL_CST
9619 && real_isnan (&TREE_REAL_CST (arg0))
9620 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9621 || ! TREE_REAL_CST (arg0).signalling))
9622 return omit_one_operand_loc (loc, type, arg1, arg0);
9623 if (TREE_CODE (arg1) == REAL_CST
9624 && real_isnan (&TREE_REAL_CST (arg1))
9625 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9626 || ! TREE_REAL_CST (arg1).signalling))
9627 return omit_one_operand_loc (loc, type, arg0, arg1);
9629 /* Transform fmin/fmax(x,x) -> x. */
9630 if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9631 return omit_one_operand_loc (loc, type, arg0, arg1);
9633 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9634 functions to return the numeric arg if the other one is NaN.
9635 These tree codes don't honor that, so only transform if
9636 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9637 handled, so we don't have to worry about it either. */
9638 if (flag_finite_math_only)
9639 return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9640 fold_convert_loc (loc, type, arg0),
9641 fold_convert_loc (loc, type, arg1));
9646 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9649 fold_builtin_carg (location_t loc, tree arg, tree type)
9651 if (validate_arg (arg, COMPLEX_TYPE)
9652 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9654 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9658 tree new_arg = builtin_save_expr (arg);
9659 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9660 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9661 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9668 /* Fold a call to builtin logb/ilogb. */
9671 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9673 if (! validate_arg (arg, REAL_TYPE))
9678 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9680 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9686 /* If arg is Inf or NaN and we're logb, return it. */
9687 if (TREE_CODE (rettype) == REAL_TYPE)
9688 return fold_convert_loc (loc, rettype, arg);
9689 /* Fall through... */
9691 /* Zero may set errno and/or raise an exception for logb, also
9692 for ilogb we don't know FP_ILOGB0. */
9695 /* For normal numbers, proceed iff radix == 2. In GCC,
9696 normalized significands are in the range [0.5, 1.0). We
9697 want the exponent as if they were [1.0, 2.0) so get the
9698 exponent and subtract 1. */
9699 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9700 return fold_convert_loc (loc, rettype,
9701 build_int_cst (integer_type_node,
9702 REAL_EXP (value)-1));
9710 /* Fold a call to builtin significand, if radix == 2. */
9713 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9715 if (! validate_arg (arg, REAL_TYPE))
9720 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9722 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9729 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9730 return fold_convert_loc (loc, rettype, arg);
9732 /* For normal numbers, proceed iff radix == 2. */
9733 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9735 REAL_VALUE_TYPE result = *value;
9736 /* In GCC, normalized significands are in the range [0.5,
9737 1.0). We want them to be [1.0, 2.0) so set the
9739 SET_REAL_EXP (&result, 1);
9740 return build_real (rettype, result);
9749 /* Fold a call to builtin frexp, we can assume the base is 2. */
9752 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9754 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9759 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9762 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9764 /* Proceed if a valid pointer type was passed in. */
9765 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9767 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9773 /* For +-0, return (*exp = 0, +-0). */
9774 exp = integer_zero_node;
9779 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9780 return omit_one_operand_loc (loc, rettype, arg0, arg1);
9783 /* Since the frexp function always expects base 2, and in
9784 GCC normalized significands are already in the range
9785 [0.5, 1.0), we have exactly what frexp wants. */
9786 REAL_VALUE_TYPE frac_rvt = *value;
9787 SET_REAL_EXP (&frac_rvt, 0);
9788 frac = build_real (rettype, frac_rvt);
9789 exp = build_int_cst (integer_type_node, REAL_EXP (value));
9796 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9797 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9798 TREE_SIDE_EFFECTS (arg1) = 1;
9799 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9805 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9806 then we can assume the base is two. If it's false, then we have to
9807 check the mode of the TYPE parameter in certain cases. */
9810 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9811 tree type, bool ldexp)
9813 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9818 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9819 if (real_zerop (arg0) || integer_zerop (arg1)
9820 || (TREE_CODE (arg0) == REAL_CST
9821 && !real_isfinite (&TREE_REAL_CST (arg0))))
9822 return omit_one_operand_loc (loc, type, arg0, arg1);
9824 /* If both arguments are constant, then try to evaluate it. */
9825 if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9826 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9827 && host_integerp (arg1, 0))
9829 /* Bound the maximum adjustment to twice the range of the
9830 mode's valid exponents. Use abs to ensure the range is
9831 positive as a sanity check. */
9832 const long max_exp_adj = 2 *
9833 labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9834 - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9836 /* Get the user-requested adjustment. */
9837 const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9839 /* The requested adjustment must be inside this range. This
9840 is a preliminary cap to avoid things like overflow, we
9841 may still fail to compute the result for other reasons. */
9842 if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9844 REAL_VALUE_TYPE initial_result;
9846 real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9848 /* Ensure we didn't overflow. */
9849 if (! real_isinf (&initial_result))
9851 const REAL_VALUE_TYPE trunc_result
9852 = real_value_truncate (TYPE_MODE (type), initial_result);
9854 /* Only proceed if the target mode can hold the
9856 if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9857 return build_real (type, trunc_result);
9866 /* Fold a call to builtin modf. */
9869 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9871 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9876 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9879 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9881 /* Proceed if a valid pointer type was passed in. */
9882 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9884 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9885 REAL_VALUE_TYPE trunc, frac;
9891 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9892 trunc = frac = *value;
9895 /* For +-Inf, return (*arg1 = arg0, +-0). */
9897 frac.sign = value->sign;
9901 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9902 real_trunc (&trunc, VOIDmode, value);
9903 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9904 /* If the original number was negative and already
9905 integral, then the fractional part is -0.0. */
9906 if (value->sign && frac.cl == rvc_zero)
9907 frac.sign = value->sign;
9911 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9912 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9913 build_real (rettype, trunc));
9914 TREE_SIDE_EFFECTS (arg1) = 1;
9915 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9916 build_real (rettype, frac));
9922 /* Given a location LOC, an interclass builtin function decl FNDECL
9923 and its single argument ARG, return an folded expression computing
9924 the same, or NULL_TREE if we either couldn't or didn't want to fold
9925 (the latter happen if there's an RTL instruction available). */
9928 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9930 enum machine_mode mode;
9932 if (!validate_arg (arg, REAL_TYPE))
9935 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9938 mode = TYPE_MODE (TREE_TYPE (arg));
9940 /* If there is no optab, try generic code. */
9941 switch (DECL_FUNCTION_CODE (fndecl))
9945 CASE_FLT_FN (BUILT_IN_ISINF):
9947 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9948 tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
9949 tree const type = TREE_TYPE (arg);
9953 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9954 real_from_string (&r, buf);
9955 result = build_call_expr (isgr_fn, 2,
9956 fold_build1_loc (loc, ABS_EXPR, type, arg),
9957 build_real (type, r));
9960 CASE_FLT_FN (BUILT_IN_FINITE):
9961 case BUILT_IN_ISFINITE:
9963 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9964 tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
9965 tree const type = TREE_TYPE (arg);
9969 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9970 real_from_string (&r, buf);
9971 result = build_call_expr (isle_fn, 2,
9972 fold_build1_loc (loc, ABS_EXPR, type, arg),
9973 build_real (type, r));
9974 /*result = fold_build2_loc (loc, UNGT_EXPR,
9975 TREE_TYPE (TREE_TYPE (fndecl)),
9976 fold_build1_loc (loc, ABS_EXPR, type, arg),
9977 build_real (type, r));
9978 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9979 TREE_TYPE (TREE_TYPE (fndecl)),
9983 case BUILT_IN_ISNORMAL:
9985 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9986 islessequal(fabs(x),DBL_MAX). */
9987 tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
9988 tree const isge_fn = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL);
9989 tree const type = TREE_TYPE (arg);
9990 REAL_VALUE_TYPE rmax, rmin;
9993 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9994 real_from_string (&rmax, buf);
9995 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9996 real_from_string (&rmin, buf);
9997 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9998 result = build_call_expr (isle_fn, 2, arg,
9999 build_real (type, rmax));
10000 result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
10001 build_call_expr (isge_fn, 2, arg,
10002 build_real (type, rmin)));
10012 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
10013 ARG is the argument for the call. */
10016 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
10018 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10021 if (!validate_arg (arg, REAL_TYPE))
10024 switch (builtin_index)
10026 case BUILT_IN_ISINF:
10027 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10028 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
10030 if (TREE_CODE (arg) == REAL_CST)
10032 r = TREE_REAL_CST (arg);
10033 if (real_isinf (&r))
10034 return real_compare (GT_EXPR, &r, &dconst0)
10035 ? integer_one_node : integer_minus_one_node;
10037 return integer_zero_node;
10042 case BUILT_IN_ISINF_SIGN:
10044 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
10045 /* In a boolean context, GCC will fold the inner COND_EXPR to
10046 1. So e.g. "if (isinf_sign(x))" would be folded to just
10047 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
10048 tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
10049 tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF);
10050 tree tmp = NULL_TREE;
10052 arg = builtin_save_expr (arg);
10054 if (signbit_fn && isinf_fn)
10056 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
10057 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
10059 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
10060 signbit_call, integer_zero_node);
10061 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
10062 isinf_call, integer_zero_node);
10064 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
10065 integer_minus_one_node, integer_one_node);
10066 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
10068 integer_zero_node);
10074 case BUILT_IN_ISFINITE:
10075 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
10076 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10077 return omit_one_operand_loc (loc, type, integer_one_node, arg);
10079 if (TREE_CODE (arg) == REAL_CST)
10081 r = TREE_REAL_CST (arg);
10082 return real_isfinite (&r) ? integer_one_node : integer_zero_node;
10087 case BUILT_IN_ISNAN:
10088 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
10089 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
10091 if (TREE_CODE (arg) == REAL_CST)
10093 r = TREE_REAL_CST (arg);
10094 return real_isnan (&r) ? integer_one_node : integer_zero_node;
10097 arg = builtin_save_expr (arg);
10098 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
10101 gcc_unreachable ();
10105 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
10106 This builtin will generate code to return the appropriate floating
10107 point classification depending on the value of the floating point
10108 number passed in. The possible return values must be supplied as
10109 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
10110 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
10111 one floating point argument which is "type generic". */
10114 fold_builtin_fpclassify (location_t loc, tree exp)
10116 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
10117 arg, type, res, tmp;
10118 enum machine_mode mode;
10122 /* Verify the required arguments in the original call. */
10123 if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
10124 INTEGER_TYPE, INTEGER_TYPE,
10125 INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
10128 fp_nan = CALL_EXPR_ARG (exp, 0);
10129 fp_infinite = CALL_EXPR_ARG (exp, 1);
10130 fp_normal = CALL_EXPR_ARG (exp, 2);
10131 fp_subnormal = CALL_EXPR_ARG (exp, 3);
10132 fp_zero = CALL_EXPR_ARG (exp, 4);
10133 arg = CALL_EXPR_ARG (exp, 5);
10134 type = TREE_TYPE (arg);
10135 mode = TYPE_MODE (type);
10136 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
10138 /* fpclassify(x) ->
10139 isnan(x) ? FP_NAN :
10140 (fabs(x) == Inf ? FP_INFINITE :
10141 (fabs(x) >= DBL_MIN ? FP_NORMAL :
10142 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
10144 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
10145 build_real (type, dconst0));
10146 res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
10147 tmp, fp_zero, fp_subnormal);
10149 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
10150 real_from_string (&r, buf);
10151 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
10152 arg, build_real (type, r));
10153 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
10155 if (HONOR_INFINITIES (mode))
10158 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
10159 build_real (type, r));
10160 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
10164 if (HONOR_NANS (mode))
10166 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
10167 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
10173 /* Fold a call to an unordered comparison function such as
10174 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
10175 being called and ARG0 and ARG1 are the arguments for the call.
10176 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
10177 the opposite of the desired result. UNORDERED_CODE is used
10178 for modes that can hold NaNs and ORDERED_CODE is used for
10182 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
10183 enum tree_code unordered_code,
10184 enum tree_code ordered_code)
10186 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10187 enum tree_code code;
10189 enum tree_code code0, code1;
10190 tree cmp_type = NULL_TREE;
10192 type0 = TREE_TYPE (arg0);
10193 type1 = TREE_TYPE (arg1);
10195 code0 = TREE_CODE (type0);
10196 code1 = TREE_CODE (type1);
10198 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
10199 /* Choose the wider of two real types. */
10200 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
10202 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
10204 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
10207 arg0 = fold_convert_loc (loc, cmp_type, arg0);
10208 arg1 = fold_convert_loc (loc, cmp_type, arg1);
10210 if (unordered_code == UNORDERED_EXPR)
10212 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
10213 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
10214 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
10217 code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
10219 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
10220 fold_build2_loc (loc, code, type, arg0, arg1));
10223 /* Fold a call to built-in function FNDECL with 0 arguments.
10224 IGNORE is true if the result of the function call is ignored. This
10225 function returns NULL_TREE if no simplification was possible. */
10228 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
10230 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10231 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10234 CASE_FLT_FN (BUILT_IN_INF):
10235 case BUILT_IN_INFD32:
10236 case BUILT_IN_INFD64:
10237 case BUILT_IN_INFD128:
10238 return fold_builtin_inf (loc, type, true);
10240 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
10241 return fold_builtin_inf (loc, type, false);
10243 case BUILT_IN_CLASSIFY_TYPE:
10244 return fold_builtin_classify_type (NULL_TREE);
10252 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
10253 IGNORE is true if the result of the function call is ignored. This
10254 function returns NULL_TREE if no simplification was possible. */
10257 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
10259 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10260 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10263 case BUILT_IN_CONSTANT_P:
10265 tree val = fold_builtin_constant_p (arg0);
10267 /* Gimplification will pull the CALL_EXPR for the builtin out of
10268 an if condition. When not optimizing, we'll not CSE it back.
10269 To avoid link error types of regressions, return false now. */
10270 if (!val && !optimize)
10271 val = integer_zero_node;
10276 case BUILT_IN_CLASSIFY_TYPE:
10277 return fold_builtin_classify_type (arg0);
10279 case BUILT_IN_STRLEN:
10280 return fold_builtin_strlen (loc, type, arg0);
10282 CASE_FLT_FN (BUILT_IN_FABS):
10283 return fold_builtin_fabs (loc, arg0, type);
10286 case BUILT_IN_LABS:
10287 case BUILT_IN_LLABS:
10288 case BUILT_IN_IMAXABS:
10289 return fold_builtin_abs (loc, arg0, type);
10291 CASE_FLT_FN (BUILT_IN_CONJ):
10292 if (validate_arg (arg0, COMPLEX_TYPE)
10293 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10294 return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
10297 CASE_FLT_FN (BUILT_IN_CREAL):
10298 if (validate_arg (arg0, COMPLEX_TYPE)
10299 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10300 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
10303 CASE_FLT_FN (BUILT_IN_CIMAG):
10304 if (validate_arg (arg0, COMPLEX_TYPE)
10305 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10306 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
10309 CASE_FLT_FN (BUILT_IN_CCOS):
10310 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
10312 CASE_FLT_FN (BUILT_IN_CCOSH):
10313 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
10315 CASE_FLT_FN (BUILT_IN_CPROJ):
10316 return fold_builtin_cproj(loc, arg0, type);
10318 CASE_FLT_FN (BUILT_IN_CSIN):
10319 if (validate_arg (arg0, COMPLEX_TYPE)
10320 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10321 return do_mpc_arg1 (arg0, type, mpc_sin);
10324 CASE_FLT_FN (BUILT_IN_CSINH):
10325 if (validate_arg (arg0, COMPLEX_TYPE)
10326 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10327 return do_mpc_arg1 (arg0, type, mpc_sinh);
10330 CASE_FLT_FN (BUILT_IN_CTAN):
10331 if (validate_arg (arg0, COMPLEX_TYPE)
10332 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10333 return do_mpc_arg1 (arg0, type, mpc_tan);
10336 CASE_FLT_FN (BUILT_IN_CTANH):
10337 if (validate_arg (arg0, COMPLEX_TYPE)
10338 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10339 return do_mpc_arg1 (arg0, type, mpc_tanh);
10342 CASE_FLT_FN (BUILT_IN_CLOG):
10343 if (validate_arg (arg0, COMPLEX_TYPE)
10344 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10345 return do_mpc_arg1 (arg0, type, mpc_log);
10348 CASE_FLT_FN (BUILT_IN_CSQRT):
10349 if (validate_arg (arg0, COMPLEX_TYPE)
10350 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10351 return do_mpc_arg1 (arg0, type, mpc_sqrt);
10354 CASE_FLT_FN (BUILT_IN_CASIN):
10355 if (validate_arg (arg0, COMPLEX_TYPE)
10356 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10357 return do_mpc_arg1 (arg0, type, mpc_asin);
10360 CASE_FLT_FN (BUILT_IN_CACOS):
10361 if (validate_arg (arg0, COMPLEX_TYPE)
10362 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10363 return do_mpc_arg1 (arg0, type, mpc_acos);
10366 CASE_FLT_FN (BUILT_IN_CATAN):
10367 if (validate_arg (arg0, COMPLEX_TYPE)
10368 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10369 return do_mpc_arg1 (arg0, type, mpc_atan);
10372 CASE_FLT_FN (BUILT_IN_CASINH):
10373 if (validate_arg (arg0, COMPLEX_TYPE)
10374 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10375 return do_mpc_arg1 (arg0, type, mpc_asinh);
10378 CASE_FLT_FN (BUILT_IN_CACOSH):
10379 if (validate_arg (arg0, COMPLEX_TYPE)
10380 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10381 return do_mpc_arg1 (arg0, type, mpc_acosh);
10384 CASE_FLT_FN (BUILT_IN_CATANH):
10385 if (validate_arg (arg0, COMPLEX_TYPE)
10386 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10387 return do_mpc_arg1 (arg0, type, mpc_atanh);
10390 CASE_FLT_FN (BUILT_IN_CABS):
10391 return fold_builtin_cabs (loc, arg0, type, fndecl);
10393 CASE_FLT_FN (BUILT_IN_CARG):
10394 return fold_builtin_carg (loc, arg0, type);
10396 CASE_FLT_FN (BUILT_IN_SQRT):
10397 return fold_builtin_sqrt (loc, arg0, type);
10399 CASE_FLT_FN (BUILT_IN_CBRT):
10400 return fold_builtin_cbrt (loc, arg0, type);
10402 CASE_FLT_FN (BUILT_IN_ASIN):
10403 if (validate_arg (arg0, REAL_TYPE))
10404 return do_mpfr_arg1 (arg0, type, mpfr_asin,
10405 &dconstm1, &dconst1, true);
10408 CASE_FLT_FN (BUILT_IN_ACOS):
10409 if (validate_arg (arg0, REAL_TYPE))
10410 return do_mpfr_arg1 (arg0, type, mpfr_acos,
10411 &dconstm1, &dconst1, true);
10414 CASE_FLT_FN (BUILT_IN_ATAN):
10415 if (validate_arg (arg0, REAL_TYPE))
10416 return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10419 CASE_FLT_FN (BUILT_IN_ASINH):
10420 if (validate_arg (arg0, REAL_TYPE))
10421 return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10424 CASE_FLT_FN (BUILT_IN_ACOSH):
10425 if (validate_arg (arg0, REAL_TYPE))
10426 return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10427 &dconst1, NULL, true);
10430 CASE_FLT_FN (BUILT_IN_ATANH):
10431 if (validate_arg (arg0, REAL_TYPE))
10432 return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10433 &dconstm1, &dconst1, false);
10436 CASE_FLT_FN (BUILT_IN_SIN):
10437 if (validate_arg (arg0, REAL_TYPE))
10438 return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10441 CASE_FLT_FN (BUILT_IN_COS):
10442 return fold_builtin_cos (loc, arg0, type, fndecl);
10444 CASE_FLT_FN (BUILT_IN_TAN):
10445 return fold_builtin_tan (arg0, type);
10447 CASE_FLT_FN (BUILT_IN_CEXP):
10448 return fold_builtin_cexp (loc, arg0, type);
10450 CASE_FLT_FN (BUILT_IN_CEXPI):
10451 if (validate_arg (arg0, REAL_TYPE))
10452 return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10455 CASE_FLT_FN (BUILT_IN_SINH):
10456 if (validate_arg (arg0, REAL_TYPE))
10457 return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10460 CASE_FLT_FN (BUILT_IN_COSH):
10461 return fold_builtin_cosh (loc, arg0, type, fndecl);
10463 CASE_FLT_FN (BUILT_IN_TANH):
10464 if (validate_arg (arg0, REAL_TYPE))
10465 return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10468 CASE_FLT_FN (BUILT_IN_ERF):
10469 if (validate_arg (arg0, REAL_TYPE))
10470 return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10473 CASE_FLT_FN (BUILT_IN_ERFC):
10474 if (validate_arg (arg0, REAL_TYPE))
10475 return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10478 CASE_FLT_FN (BUILT_IN_TGAMMA):
10479 if (validate_arg (arg0, REAL_TYPE))
10480 return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10483 CASE_FLT_FN (BUILT_IN_EXP):
10484 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10486 CASE_FLT_FN (BUILT_IN_EXP2):
10487 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10489 CASE_FLT_FN (BUILT_IN_EXP10):
10490 CASE_FLT_FN (BUILT_IN_POW10):
10491 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10493 CASE_FLT_FN (BUILT_IN_EXPM1):
10494 if (validate_arg (arg0, REAL_TYPE))
10495 return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10498 CASE_FLT_FN (BUILT_IN_LOG):
10499 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10501 CASE_FLT_FN (BUILT_IN_LOG2):
10502 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10504 CASE_FLT_FN (BUILT_IN_LOG10):
10505 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10507 CASE_FLT_FN (BUILT_IN_LOG1P):
10508 if (validate_arg (arg0, REAL_TYPE))
10509 return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10510 &dconstm1, NULL, false);
10513 CASE_FLT_FN (BUILT_IN_J0):
10514 if (validate_arg (arg0, REAL_TYPE))
10515 return do_mpfr_arg1 (arg0, type, mpfr_j0,
10519 CASE_FLT_FN (BUILT_IN_J1):
10520 if (validate_arg (arg0, REAL_TYPE))
10521 return do_mpfr_arg1 (arg0, type, mpfr_j1,
10525 CASE_FLT_FN (BUILT_IN_Y0):
10526 if (validate_arg (arg0, REAL_TYPE))
10527 return do_mpfr_arg1 (arg0, type, mpfr_y0,
10528 &dconst0, NULL, false);
10531 CASE_FLT_FN (BUILT_IN_Y1):
10532 if (validate_arg (arg0, REAL_TYPE))
10533 return do_mpfr_arg1 (arg0, type, mpfr_y1,
10534 &dconst0, NULL, false);
10537 CASE_FLT_FN (BUILT_IN_NAN):
10538 case BUILT_IN_NAND32:
10539 case BUILT_IN_NAND64:
10540 case BUILT_IN_NAND128:
10541 return fold_builtin_nan (arg0, type, true);
10543 CASE_FLT_FN (BUILT_IN_NANS):
10544 return fold_builtin_nan (arg0, type, false);
10546 CASE_FLT_FN (BUILT_IN_FLOOR):
10547 return fold_builtin_floor (loc, fndecl, arg0);
10549 CASE_FLT_FN (BUILT_IN_CEIL):
10550 return fold_builtin_ceil (loc, fndecl, arg0);
10552 CASE_FLT_FN (BUILT_IN_TRUNC):
10553 return fold_builtin_trunc (loc, fndecl, arg0);
10555 CASE_FLT_FN (BUILT_IN_ROUND):
10556 return fold_builtin_round (loc, fndecl, arg0);
10558 CASE_FLT_FN (BUILT_IN_NEARBYINT):
10559 CASE_FLT_FN (BUILT_IN_RINT):
10560 return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10562 CASE_FLT_FN (BUILT_IN_ICEIL):
10563 CASE_FLT_FN (BUILT_IN_LCEIL):
10564 CASE_FLT_FN (BUILT_IN_LLCEIL):
10565 CASE_FLT_FN (BUILT_IN_LFLOOR):
10566 CASE_FLT_FN (BUILT_IN_IFLOOR):
10567 CASE_FLT_FN (BUILT_IN_LLFLOOR):
10568 CASE_FLT_FN (BUILT_IN_IROUND):
10569 CASE_FLT_FN (BUILT_IN_LROUND):
10570 CASE_FLT_FN (BUILT_IN_LLROUND):
10571 return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10573 CASE_FLT_FN (BUILT_IN_IRINT):
10574 CASE_FLT_FN (BUILT_IN_LRINT):
10575 CASE_FLT_FN (BUILT_IN_LLRINT):
10576 return fold_fixed_mathfn (loc, fndecl, arg0);
10578 case BUILT_IN_BSWAP32:
10579 case BUILT_IN_BSWAP64:
10580 return fold_builtin_bswap (fndecl, arg0);
10582 CASE_INT_FN (BUILT_IN_FFS):
10583 CASE_INT_FN (BUILT_IN_CLZ):
10584 CASE_INT_FN (BUILT_IN_CTZ):
10585 CASE_INT_FN (BUILT_IN_CLRSB):
10586 CASE_INT_FN (BUILT_IN_POPCOUNT):
10587 CASE_INT_FN (BUILT_IN_PARITY):
10588 return fold_builtin_bitop (fndecl, arg0);
10590 CASE_FLT_FN (BUILT_IN_SIGNBIT):
10591 return fold_builtin_signbit (loc, arg0, type);
10593 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10594 return fold_builtin_significand (loc, arg0, type);
10596 CASE_FLT_FN (BUILT_IN_ILOGB):
10597 CASE_FLT_FN (BUILT_IN_LOGB):
10598 return fold_builtin_logb (loc, arg0, type);
10600 case BUILT_IN_ISASCII:
10601 return fold_builtin_isascii (loc, arg0);
10603 case BUILT_IN_TOASCII:
10604 return fold_builtin_toascii (loc, arg0);
10606 case BUILT_IN_ISDIGIT:
10607 return fold_builtin_isdigit (loc, arg0);
10609 CASE_FLT_FN (BUILT_IN_FINITE):
10610 case BUILT_IN_FINITED32:
10611 case BUILT_IN_FINITED64:
10612 case BUILT_IN_FINITED128:
10613 case BUILT_IN_ISFINITE:
10615 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10618 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10621 CASE_FLT_FN (BUILT_IN_ISINF):
10622 case BUILT_IN_ISINFD32:
10623 case BUILT_IN_ISINFD64:
10624 case BUILT_IN_ISINFD128:
10626 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10629 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10632 case BUILT_IN_ISNORMAL:
10633 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10635 case BUILT_IN_ISINF_SIGN:
10636 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10638 CASE_FLT_FN (BUILT_IN_ISNAN):
10639 case BUILT_IN_ISNAND32:
10640 case BUILT_IN_ISNAND64:
10641 case BUILT_IN_ISNAND128:
10642 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10644 case BUILT_IN_PRINTF:
10645 case BUILT_IN_PRINTF_UNLOCKED:
10646 case BUILT_IN_VPRINTF:
10647 return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10649 case BUILT_IN_FREE:
10650 if (integer_zerop (arg0))
10651 return build_empty_stmt (loc);
10662 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10663 IGNORE is true if the result of the function call is ignored. This
10664 function returns NULL_TREE if no simplification was possible. */
10667 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10669 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10670 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10674 CASE_FLT_FN (BUILT_IN_JN):
10675 if (validate_arg (arg0, INTEGER_TYPE)
10676 && validate_arg (arg1, REAL_TYPE))
10677 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10680 CASE_FLT_FN (BUILT_IN_YN):
10681 if (validate_arg (arg0, INTEGER_TYPE)
10682 && validate_arg (arg1, REAL_TYPE))
10683 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10687 CASE_FLT_FN (BUILT_IN_DREM):
10688 CASE_FLT_FN (BUILT_IN_REMAINDER):
10689 if (validate_arg (arg0, REAL_TYPE)
10690 && validate_arg(arg1, REAL_TYPE))
10691 return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10694 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10695 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10696 if (validate_arg (arg0, REAL_TYPE)
10697 && validate_arg(arg1, POINTER_TYPE))
10698 return do_mpfr_lgamma_r (arg0, arg1, type);
10701 CASE_FLT_FN (BUILT_IN_ATAN2):
10702 if (validate_arg (arg0, REAL_TYPE)
10703 && validate_arg(arg1, REAL_TYPE))
10704 return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10707 CASE_FLT_FN (BUILT_IN_FDIM):
10708 if (validate_arg (arg0, REAL_TYPE)
10709 && validate_arg(arg1, REAL_TYPE))
10710 return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10713 CASE_FLT_FN (BUILT_IN_HYPOT):
10714 return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10716 CASE_FLT_FN (BUILT_IN_CPOW):
10717 if (validate_arg (arg0, COMPLEX_TYPE)
10718 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10719 && validate_arg (arg1, COMPLEX_TYPE)
10720 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10721 return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10724 CASE_FLT_FN (BUILT_IN_LDEXP):
10725 return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10726 CASE_FLT_FN (BUILT_IN_SCALBN):
10727 CASE_FLT_FN (BUILT_IN_SCALBLN):
10728 return fold_builtin_load_exponent (loc, arg0, arg1,
10729 type, /*ldexp=*/false);
10731 CASE_FLT_FN (BUILT_IN_FREXP):
10732 return fold_builtin_frexp (loc, arg0, arg1, type);
10734 CASE_FLT_FN (BUILT_IN_MODF):
10735 return fold_builtin_modf (loc, arg0, arg1, type);
10737 case BUILT_IN_BZERO:
10738 return fold_builtin_bzero (loc, arg0, arg1, ignore);
10740 case BUILT_IN_FPUTS:
10741 return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10743 case BUILT_IN_FPUTS_UNLOCKED:
10744 return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10746 case BUILT_IN_STRSTR:
10747 return fold_builtin_strstr (loc, arg0, arg1, type);
10749 case BUILT_IN_STRCAT:
10750 return fold_builtin_strcat (loc, arg0, arg1);
10752 case BUILT_IN_STRSPN:
10753 return fold_builtin_strspn (loc, arg0, arg1);
10755 case BUILT_IN_STRCSPN:
10756 return fold_builtin_strcspn (loc, arg0, arg1);
10758 case BUILT_IN_STRCHR:
10759 case BUILT_IN_INDEX:
10760 return fold_builtin_strchr (loc, arg0, arg1, type);
10762 case BUILT_IN_STRRCHR:
10763 case BUILT_IN_RINDEX:
10764 return fold_builtin_strrchr (loc, arg0, arg1, type);
10766 case BUILT_IN_STRCPY:
10767 return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10769 case BUILT_IN_STPCPY:
10772 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
10776 return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10779 return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10782 case BUILT_IN_STRCMP:
10783 return fold_builtin_strcmp (loc, arg0, arg1);
10785 case BUILT_IN_STRPBRK:
10786 return fold_builtin_strpbrk (loc, arg0, arg1, type);
10788 case BUILT_IN_EXPECT:
10789 return fold_builtin_expect (loc, arg0, arg1);
10791 CASE_FLT_FN (BUILT_IN_POW):
10792 return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10794 CASE_FLT_FN (BUILT_IN_POWI):
10795 return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10797 CASE_FLT_FN (BUILT_IN_COPYSIGN):
10798 return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10800 CASE_FLT_FN (BUILT_IN_FMIN):
10801 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10803 CASE_FLT_FN (BUILT_IN_FMAX):
10804 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10806 case BUILT_IN_ISGREATER:
10807 return fold_builtin_unordered_cmp (loc, fndecl,
10808 arg0, arg1, UNLE_EXPR, LE_EXPR);
10809 case BUILT_IN_ISGREATEREQUAL:
10810 return fold_builtin_unordered_cmp (loc, fndecl,
10811 arg0, arg1, UNLT_EXPR, LT_EXPR);
10812 case BUILT_IN_ISLESS:
10813 return fold_builtin_unordered_cmp (loc, fndecl,
10814 arg0, arg1, UNGE_EXPR, GE_EXPR);
10815 case BUILT_IN_ISLESSEQUAL:
10816 return fold_builtin_unordered_cmp (loc, fndecl,
10817 arg0, arg1, UNGT_EXPR, GT_EXPR);
10818 case BUILT_IN_ISLESSGREATER:
10819 return fold_builtin_unordered_cmp (loc, fndecl,
10820 arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10821 case BUILT_IN_ISUNORDERED:
10822 return fold_builtin_unordered_cmp (loc, fndecl,
10823 arg0, arg1, UNORDERED_EXPR,
10826 /* We do the folding for va_start in the expander. */
10827 case BUILT_IN_VA_START:
10830 case BUILT_IN_SPRINTF:
10831 return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10833 case BUILT_IN_OBJECT_SIZE:
10834 return fold_builtin_object_size (arg0, arg1);
10836 case BUILT_IN_PRINTF:
10837 case BUILT_IN_PRINTF_UNLOCKED:
10838 case BUILT_IN_VPRINTF:
10839 return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10841 case BUILT_IN_PRINTF_CHK:
10842 case BUILT_IN_VPRINTF_CHK:
10843 if (!validate_arg (arg0, INTEGER_TYPE)
10844 || TREE_SIDE_EFFECTS (arg0))
10847 return fold_builtin_printf (loc, fndecl,
10848 arg1, NULL_TREE, ignore, fcode);
10851 case BUILT_IN_FPRINTF:
10852 case BUILT_IN_FPRINTF_UNLOCKED:
10853 case BUILT_IN_VFPRINTF:
10854 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10857 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
10858 return fold_builtin_atomic_always_lock_free (arg0, arg1);
10860 case BUILT_IN_ATOMIC_IS_LOCK_FREE:
10861 return fold_builtin_atomic_is_lock_free (arg0, arg1);
10869 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10870 and ARG2. IGNORE is true if the result of the function call is ignored.
10871 This function returns NULL_TREE if no simplification was possible. */
10874 fold_builtin_3 (location_t loc, tree fndecl,
10875 tree arg0, tree arg1, tree arg2, bool ignore)
10877 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10878 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10882 CASE_FLT_FN (BUILT_IN_SINCOS):
10883 return fold_builtin_sincos (loc, arg0, arg1, arg2);
10885 CASE_FLT_FN (BUILT_IN_FMA):
10886 return fold_builtin_fma (loc, arg0, arg1, arg2, type);
10889 CASE_FLT_FN (BUILT_IN_REMQUO):
10890 if (validate_arg (arg0, REAL_TYPE)
10891 && validate_arg(arg1, REAL_TYPE)
10892 && validate_arg(arg2, POINTER_TYPE))
10893 return do_mpfr_remquo (arg0, arg1, arg2);
10896 case BUILT_IN_MEMSET:
10897 return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10899 case BUILT_IN_BCOPY:
10900 return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10901 void_type_node, true, /*endp=*/3);
10903 case BUILT_IN_MEMCPY:
10904 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10905 type, ignore, /*endp=*/0);
10907 case BUILT_IN_MEMPCPY:
10908 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10909 type, ignore, /*endp=*/1);
10911 case BUILT_IN_MEMMOVE:
10912 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10913 type, ignore, /*endp=*/3);
10915 case BUILT_IN_STRNCAT:
10916 return fold_builtin_strncat (loc, arg0, arg1, arg2);
10918 case BUILT_IN_STRNCPY:
10919 return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10921 case BUILT_IN_STRNCMP:
10922 return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10924 case BUILT_IN_MEMCHR:
10925 return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10927 case BUILT_IN_BCMP:
10928 case BUILT_IN_MEMCMP:
10929 return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10931 case BUILT_IN_SPRINTF:
10932 return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10934 case BUILT_IN_SNPRINTF:
10935 return fold_builtin_snprintf (loc, arg0, arg1, arg2, NULL_TREE, ignore);
10937 case BUILT_IN_STRCPY_CHK:
10938 case BUILT_IN_STPCPY_CHK:
10939 return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10942 case BUILT_IN_STRCAT_CHK:
10943 return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10945 case BUILT_IN_PRINTF_CHK:
10946 case BUILT_IN_VPRINTF_CHK:
10947 if (!validate_arg (arg0, INTEGER_TYPE)
10948 || TREE_SIDE_EFFECTS (arg0))
10951 return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10954 case BUILT_IN_FPRINTF:
10955 case BUILT_IN_FPRINTF_UNLOCKED:
10956 case BUILT_IN_VFPRINTF:
10957 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10960 case BUILT_IN_FPRINTF_CHK:
10961 case BUILT_IN_VFPRINTF_CHK:
10962 if (!validate_arg (arg1, INTEGER_TYPE)
10963 || TREE_SIDE_EFFECTS (arg1))
10966 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10975 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10976 ARG2, and ARG3. IGNORE is true if the result of the function call is
10977 ignored. This function returns NULL_TREE if no simplification was
10981 fold_builtin_4 (location_t loc, tree fndecl,
10982 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10984 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10988 case BUILT_IN_MEMCPY_CHK:
10989 case BUILT_IN_MEMPCPY_CHK:
10990 case BUILT_IN_MEMMOVE_CHK:
10991 case BUILT_IN_MEMSET_CHK:
10992 return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10994 DECL_FUNCTION_CODE (fndecl));
10996 case BUILT_IN_STRNCPY_CHK:
10997 case BUILT_IN_STPNCPY_CHK:
10998 return fold_builtin_stxncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE,
11001 case BUILT_IN_STRNCAT_CHK:
11002 return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
11004 case BUILT_IN_SNPRINTF:
11005 return fold_builtin_snprintf (loc, arg0, arg1, arg2, arg3, ignore);
11007 case BUILT_IN_FPRINTF_CHK:
11008 case BUILT_IN_VFPRINTF_CHK:
11009 if (!validate_arg (arg1, INTEGER_TYPE)
11010 || TREE_SIDE_EFFECTS (arg1))
11013 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
11023 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
11024 arguments, where NARGS <= 4. IGNORE is true if the result of the
11025 function call is ignored. This function returns NULL_TREE if no
11026 simplification was possible. Note that this only folds builtins with
11027 fixed argument patterns. Foldings that do varargs-to-varargs
11028 transformations, or that match calls with more than 4 arguments,
11029 need to be handled with fold_builtin_varargs instead. */
11031 #define MAX_ARGS_TO_FOLD_BUILTIN 4
11034 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
11036 tree ret = NULL_TREE;
11041 ret = fold_builtin_0 (loc, fndecl, ignore);
11044 ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
11047 ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
11050 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
11053 ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
11061 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
11062 SET_EXPR_LOCATION (ret, loc);
11063 TREE_NO_WARNING (ret) = 1;
11069 /* Builtins with folding operations that operate on "..." arguments
11070 need special handling; we need to store the arguments in a convenient
11071 data structure before attempting any folding. Fortunately there are
11072 only a few builtins that fall into this category. FNDECL is the
11073 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
11074 result of the function call is ignored. */
11077 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
11078 bool ignore ATTRIBUTE_UNUSED)
11080 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
11081 tree ret = NULL_TREE;
11085 case BUILT_IN_SPRINTF_CHK:
11086 case BUILT_IN_VSPRINTF_CHK:
11087 ret = fold_builtin_sprintf_chk (loc, exp, fcode);
11090 case BUILT_IN_SNPRINTF_CHK:
11091 case BUILT_IN_VSNPRINTF_CHK:
11092 ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
11095 case BUILT_IN_FPCLASSIFY:
11096 ret = fold_builtin_fpclassify (loc, exp);
11104 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
11105 SET_EXPR_LOCATION (ret, loc);
11106 TREE_NO_WARNING (ret) = 1;
11112 /* Return true if FNDECL shouldn't be folded right now.
11113 If a built-in function has an inline attribute always_inline
11114 wrapper, defer folding it after always_inline functions have
11115 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
11116 might not be performed. */
11119 avoid_folding_inline_builtin (tree fndecl)
11121 return (DECL_DECLARED_INLINE_P (fndecl)
11122 && DECL_DISREGARD_INLINE_LIMITS (fndecl)
11124 && !cfun->always_inline_functions_inlined
11125 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
11128 /* A wrapper function for builtin folding that prevents warnings for
11129 "statement without effect" and the like, caused by removing the
11130 call node earlier than the warning is generated. */
11133 fold_call_expr (location_t loc, tree exp, bool ignore)
11135 tree ret = NULL_TREE;
11136 tree fndecl = get_callee_fndecl (exp);
11138 && TREE_CODE (fndecl) == FUNCTION_DECL
11139 && DECL_BUILT_IN (fndecl)
11140 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
11141 yet. Defer folding until we see all the arguments
11142 (after inlining). */
11143 && !CALL_EXPR_VA_ARG_PACK (exp))
11145 int nargs = call_expr_nargs (exp);
11147 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
11148 instead last argument is __builtin_va_arg_pack (). Defer folding
11149 even in that case, until arguments are finalized. */
11150 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
11152 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
11154 && TREE_CODE (fndecl2) == FUNCTION_DECL
11155 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11156 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11160 if (avoid_folding_inline_builtin (fndecl))
11163 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11164 return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
11165 CALL_EXPR_ARGP (exp), ignore);
11168 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
11170 tree *args = CALL_EXPR_ARGP (exp);
11171 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
11174 ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
11182 /* Conveniently construct a function call expression. FNDECL names the
11183 function to be called and N arguments are passed in the array
11187 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
11189 tree fntype = TREE_TYPE (fndecl);
11190 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11192 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
11195 /* Conveniently construct a function call expression. FNDECL names the
11196 function to be called and the arguments are passed in the vector
11200 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
11202 return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
11203 VEC_address (tree, vec));
11207 /* Conveniently construct a function call expression. FNDECL names the
11208 function to be called, N is the number of arguments, and the "..."
11209 parameters are the argument expressions. */
11212 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
11215 tree *argarray = XALLOCAVEC (tree, n);
11219 for (i = 0; i < n; i++)
11220 argarray[i] = va_arg (ap, tree);
11222 return build_call_expr_loc_array (loc, fndecl, n, argarray);
11225 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
11226 varargs macros aren't supported by all bootstrap compilers. */
11229 build_call_expr (tree fndecl, int n, ...)
11232 tree *argarray = XALLOCAVEC (tree, n);
11236 for (i = 0; i < n; i++)
11237 argarray[i] = va_arg (ap, tree);
11239 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
11242 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
11243 N arguments are passed in the array ARGARRAY. */
11246 fold_builtin_call_array (location_t loc, tree type,
11251 tree ret = NULL_TREE;
11254 if (TREE_CODE (fn) == ADDR_EXPR)
11256 tree fndecl = TREE_OPERAND (fn, 0);
11257 if (TREE_CODE (fndecl) == FUNCTION_DECL
11258 && DECL_BUILT_IN (fndecl))
11260 /* If last argument is __builtin_va_arg_pack (), arguments to this
11261 function are not finalized yet. Defer folding until they are. */
11262 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
11264 tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
11266 && TREE_CODE (fndecl2) == FUNCTION_DECL
11267 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11268 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11269 return build_call_array_loc (loc, type, fn, n, argarray);
11271 if (avoid_folding_inline_builtin (fndecl))
11272 return build_call_array_loc (loc, type, fn, n, argarray);
11273 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11275 ret = targetm.fold_builtin (fndecl, n, argarray, false);
11279 return build_call_array_loc (loc, type, fn, n, argarray);
11281 else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
11283 /* First try the transformations that don't require consing up
11285 ret = fold_builtin_n (loc, fndecl, argarray, n, false);
11290 /* If we got this far, we need to build an exp. */
11291 exp = build_call_array_loc (loc, type, fn, n, argarray);
11292 ret = fold_builtin_varargs (loc, fndecl, exp, false);
11293 return ret ? ret : exp;
11297 return build_call_array_loc (loc, type, fn, n, argarray);
11300 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11301 list ARGS along with N new arguments in NEWARGS. SKIP is the number
11302 of arguments in ARGS to be omitted. OLDNARGS is the number of
11303 elements in ARGS. */
11306 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
11307 int skip, tree fndecl, int n, va_list newargs)
11309 int nargs = oldnargs - skip + n;
11316 buffer = XALLOCAVEC (tree, nargs);
11317 for (i = 0; i < n; i++)
11318 buffer[i] = va_arg (newargs, tree);
11319 for (j = skip; j < oldnargs; j++, i++)
11320 buffer[i] = args[j];
11323 buffer = args + skip;
11325 return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
11328 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11329 list ARGS along with N new arguments specified as the "..."
11330 parameters. SKIP is the number of arguments in ARGS to be omitted.
11331 OLDNARGS is the number of elements in ARGS. */
11334 rewrite_call_expr_array (location_t loc, int oldnargs, tree *args,
11335 int skip, tree fndecl, int n, ...)
11341 t = rewrite_call_expr_valist (loc, oldnargs, args, skip, fndecl, n, ap);
11347 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
11348 along with N new arguments specified as the "..." parameters. SKIP
11349 is the number of arguments in EXP to be omitted. This function is used
11350 to do varargs-to-varargs transformations. */
11353 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
11359 t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
11360 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
11366 /* Validate a single argument ARG against a tree code CODE representing
11370 validate_arg (const_tree arg, enum tree_code code)
11374 else if (code == POINTER_TYPE)
11375 return POINTER_TYPE_P (TREE_TYPE (arg));
11376 else if (code == INTEGER_TYPE)
11377 return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11378 return code == TREE_CODE (TREE_TYPE (arg));
11381 /* This function validates the types of a function call argument list
11382 against a specified list of tree_codes. If the last specifier is a 0,
11383 that represents an ellipses, otherwise the last specifier must be a
11386 This is the GIMPLE version of validate_arglist. Eventually we want to
11387 completely convert builtins.c to work from GIMPLEs and the tree based
11388 validate_arglist will then be removed. */
11391 validate_gimple_arglist (const_gimple call, ...)
11393 enum tree_code code;
11399 va_start (ap, call);
11404 code = (enum tree_code) va_arg (ap, int);
11408 /* This signifies an ellipses, any further arguments are all ok. */
11412 /* This signifies an endlink, if no arguments remain, return
11413 true, otherwise return false. */
11414 res = (i == gimple_call_num_args (call));
11417 /* If no parameters remain or the parameter's code does not
11418 match the specified code, return false. Otherwise continue
11419 checking any remaining arguments. */
11420 arg = gimple_call_arg (call, i++);
11421 if (!validate_arg (arg, code))
11428 /* We need gotos here since we can only have one VA_CLOSE in a
11436 /* This function validates the types of a function call argument list
11437 against a specified list of tree_codes. If the last specifier is a 0,
11438 that represents an ellipses, otherwise the last specifier must be a
11442 validate_arglist (const_tree callexpr, ...)
11444 enum tree_code code;
11447 const_call_expr_arg_iterator iter;
11450 va_start (ap, callexpr);
11451 init_const_call_expr_arg_iterator (callexpr, &iter);
11455 code = (enum tree_code) va_arg (ap, int);
11459 /* This signifies an ellipses, any further arguments are all ok. */
11463 /* This signifies an endlink, if no arguments remain, return
11464 true, otherwise return false. */
11465 res = !more_const_call_expr_args_p (&iter);
11468 /* If no parameters remain or the parameter's code does not
11469 match the specified code, return false. Otherwise continue
11470 checking any remaining arguments. */
11471 arg = next_const_call_expr_arg (&iter);
11472 if (!validate_arg (arg, code))
11479 /* We need gotos here since we can only have one VA_CLOSE in a
11487 /* Default target-specific builtin expander that does nothing. */
11490 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11491 rtx target ATTRIBUTE_UNUSED,
11492 rtx subtarget ATTRIBUTE_UNUSED,
11493 enum machine_mode mode ATTRIBUTE_UNUSED,
11494 int ignore ATTRIBUTE_UNUSED)
11499 /* Returns true is EXP represents data that would potentially reside
11500 in a readonly section. */
11503 readonly_data_expr (tree exp)
11507 if (TREE_CODE (exp) != ADDR_EXPR)
11510 exp = get_base_address (TREE_OPERAND (exp, 0));
11514 /* Make sure we call decl_readonly_section only for trees it
11515 can handle (since it returns true for everything it doesn't
11517 if (TREE_CODE (exp) == STRING_CST
11518 || TREE_CODE (exp) == CONSTRUCTOR
11519 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11520 return decl_readonly_section (exp, 0);
11525 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11526 to the call, and TYPE is its return type.
11528 Return NULL_TREE if no simplification was possible, otherwise return the
11529 simplified form of the call as a tree.
11531 The simplified form may be a constant or other expression which
11532 computes the same value, but in a more efficient manner (including
11533 calls to other builtin functions).
11535 The call may contain arguments which need to be evaluated, but
11536 which are not useful to determine the result of the call. In
11537 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11538 COMPOUND_EXPR will be an argument which must be evaluated.
11539 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11540 COMPOUND_EXPR in the chain will contain the tree for the simplified
11541 form of the builtin function call. */
11544 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11546 if (!validate_arg (s1, POINTER_TYPE)
11547 || !validate_arg (s2, POINTER_TYPE))
11552 const char *p1, *p2;
11554 p2 = c_getstr (s2);
11558 p1 = c_getstr (s1);
11561 const char *r = strstr (p1, p2);
11565 return build_int_cst (TREE_TYPE (s1), 0);
11567 /* Return an offset into the constant string argument. */
11568 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11569 return fold_convert_loc (loc, type, tem);
11572 /* The argument is const char *, and the result is char *, so we need
11573 a type conversion here to avoid a warning. */
11575 return fold_convert_loc (loc, type, s1);
11580 fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11584 /* New argument list transforming strstr(s1, s2) to
11585 strchr(s1, s2[0]). */
11586 return build_call_expr_loc (loc, fn, 2, s1,
11587 build_int_cst (integer_type_node, p2[0]));
11591 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11592 the call, and TYPE is its return type.
11594 Return NULL_TREE if no simplification was possible, otherwise return the
11595 simplified form of the call as a tree.
11597 The simplified form may be a constant or other expression which
11598 computes the same value, but in a more efficient manner (including
11599 calls to other builtin functions).
11601 The call may contain arguments which need to be evaluated, but
11602 which are not useful to determine the result of the call. In
11603 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11604 COMPOUND_EXPR will be an argument which must be evaluated.
11605 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11606 COMPOUND_EXPR in the chain will contain the tree for the simplified
11607 form of the builtin function call. */
11610 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11612 if (!validate_arg (s1, POINTER_TYPE)
11613 || !validate_arg (s2, INTEGER_TYPE))
11619 if (TREE_CODE (s2) != INTEGER_CST)
11622 p1 = c_getstr (s1);
11629 if (target_char_cast (s2, &c))
11632 r = strchr (p1, c);
11635 return build_int_cst (TREE_TYPE (s1), 0);
11637 /* Return an offset into the constant string argument. */
11638 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11639 return fold_convert_loc (loc, type, tem);
11645 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11646 the call, and TYPE is its return type.
11648 Return NULL_TREE if no simplification was possible, otherwise return the
11649 simplified form of the call as a tree.
11651 The simplified form may be a constant or other expression which
11652 computes the same value, but in a more efficient manner (including
11653 calls to other builtin functions).
11655 The call may contain arguments which need to be evaluated, but
11656 which are not useful to determine the result of the call. In
11657 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11658 COMPOUND_EXPR will be an argument which must be evaluated.
11659 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11660 COMPOUND_EXPR in the chain will contain the tree for the simplified
11661 form of the builtin function call. */
11664 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11666 if (!validate_arg (s1, POINTER_TYPE)
11667 || !validate_arg (s2, INTEGER_TYPE))
11674 if (TREE_CODE (s2) != INTEGER_CST)
11677 p1 = c_getstr (s1);
11684 if (target_char_cast (s2, &c))
11687 r = strrchr (p1, c);
11690 return build_int_cst (TREE_TYPE (s1), 0);
11692 /* Return an offset into the constant string argument. */
11693 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11694 return fold_convert_loc (loc, type, tem);
11697 if (! integer_zerop (s2))
11700 fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11704 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11705 return build_call_expr_loc (loc, fn, 2, s1, s2);
11709 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11710 to the call, and TYPE is its return type.
11712 Return NULL_TREE if no simplification was possible, otherwise return the
11713 simplified form of the call as a tree.
11715 The simplified form may be a constant or other expression which
11716 computes the same value, but in a more efficient manner (including
11717 calls to other builtin functions).
11719 The call may contain arguments which need to be evaluated, but
11720 which are not useful to determine the result of the call. In
11721 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11722 COMPOUND_EXPR will be an argument which must be evaluated.
11723 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11724 COMPOUND_EXPR in the chain will contain the tree for the simplified
11725 form of the builtin function call. */
11728 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11730 if (!validate_arg (s1, POINTER_TYPE)
11731 || !validate_arg (s2, POINTER_TYPE))
11736 const char *p1, *p2;
11738 p2 = c_getstr (s2);
11742 p1 = c_getstr (s1);
11745 const char *r = strpbrk (p1, p2);
11749 return build_int_cst (TREE_TYPE (s1), 0);
11751 /* Return an offset into the constant string argument. */
11752 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11753 return fold_convert_loc (loc, type, tem);
11757 /* strpbrk(x, "") == NULL.
11758 Evaluate and ignore s1 in case it had side-effects. */
11759 return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11762 return NULL_TREE; /* Really call strpbrk. */
11764 fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11768 /* New argument list transforming strpbrk(s1, s2) to
11769 strchr(s1, s2[0]). */
11770 return build_call_expr_loc (loc, fn, 2, s1,
11771 build_int_cst (integer_type_node, p2[0]));
11775 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11778 Return NULL_TREE if no simplification was possible, otherwise return the
11779 simplified form of the call as a tree.
11781 The simplified form may be a constant or other expression which
11782 computes the same value, but in a more efficient manner (including
11783 calls to other builtin functions).
11785 The call may contain arguments which need to be evaluated, but
11786 which are not useful to determine the result of the call. In
11787 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11788 COMPOUND_EXPR will be an argument which must be evaluated.
11789 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11790 COMPOUND_EXPR in the chain will contain the tree for the simplified
11791 form of the builtin function call. */
11794 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11796 if (!validate_arg (dst, POINTER_TYPE)
11797 || !validate_arg (src, POINTER_TYPE))
11801 const char *p = c_getstr (src);
11803 /* If the string length is zero, return the dst parameter. */
11804 if (p && *p == '\0')
11807 if (optimize_insn_for_speed_p ())
11809 /* See if we can store by pieces into (dst + strlen(dst)). */
11811 tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
11812 tree strcpy_fn = builtin_decl_implicit (BUILT_IN_STRCPY);
11814 if (!strlen_fn || !strcpy_fn)
11817 /* If we don't have a movstr we don't want to emit an strcpy
11818 call. We have to do that if the length of the source string
11819 isn't computable (in that case we can use memcpy probably
11820 later expanding to a sequence of mov instructions). If we
11821 have movstr instructions we can emit strcpy calls. */
11824 tree len = c_strlen (src, 1);
11825 if (! len || TREE_SIDE_EFFECTS (len))
11829 /* Stabilize the argument list. */
11830 dst = builtin_save_expr (dst);
11832 /* Create strlen (dst). */
11833 newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11834 /* Create (dst p+ strlen (dst)). */
11836 newdst = fold_build_pointer_plus_loc (loc, dst, newdst);
11837 newdst = builtin_save_expr (newdst);
11839 call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11840 return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11846 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11847 arguments to the call.
11849 Return NULL_TREE if no simplification was possible, otherwise return the
11850 simplified form of the call as a tree.
11852 The simplified form may be a constant or other expression which
11853 computes the same value, but in a more efficient manner (including
11854 calls to other builtin functions).
11856 The call may contain arguments which need to be evaluated, but
11857 which are not useful to determine the result of the call. In
11858 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11859 COMPOUND_EXPR will be an argument which must be evaluated.
11860 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11861 COMPOUND_EXPR in the chain will contain the tree for the simplified
11862 form of the builtin function call. */
11865 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11867 if (!validate_arg (dst, POINTER_TYPE)
11868 || !validate_arg (src, POINTER_TYPE)
11869 || !validate_arg (len, INTEGER_TYPE))
11873 const char *p = c_getstr (src);
11875 /* If the requested length is zero, or the src parameter string
11876 length is zero, return the dst parameter. */
11877 if (integer_zerop (len) || (p && *p == '\0'))
11878 return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11880 /* If the requested len is greater than or equal to the string
11881 length, call strcat. */
11882 if (TREE_CODE (len) == INTEGER_CST && p
11883 && compare_tree_int (len, strlen (p)) >= 0)
11885 tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);
11887 /* If the replacement _DECL isn't initialized, don't do the
11892 return build_call_expr_loc (loc, fn, 2, dst, src);
11898 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11901 Return NULL_TREE if no simplification was possible, otherwise return the
11902 simplified form of the call as a tree.
11904 The simplified form may be a constant or other expression which
11905 computes the same value, but in a more efficient manner (including
11906 calls to other builtin functions).
11908 The call may contain arguments which need to be evaluated, but
11909 which are not useful to determine the result of the call. In
11910 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11911 COMPOUND_EXPR will be an argument which must be evaluated.
11912 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11913 COMPOUND_EXPR in the chain will contain the tree for the simplified
11914 form of the builtin function call. */
11917 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11919 if (!validate_arg (s1, POINTER_TYPE)
11920 || !validate_arg (s2, POINTER_TYPE))
11924 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11926 /* If both arguments are constants, evaluate at compile-time. */
11929 const size_t r = strspn (p1, p2);
11930 return build_int_cst (size_type_node, r);
11933 /* If either argument is "", return NULL_TREE. */
11934 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11935 /* Evaluate and ignore both arguments in case either one has
11937 return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11943 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11946 Return NULL_TREE if no simplification was possible, otherwise return the
11947 simplified form of the call as a tree.
11949 The simplified form may be a constant or other expression which
11950 computes the same value, but in a more efficient manner (including
11951 calls to other builtin functions).
11953 The call may contain arguments which need to be evaluated, but
11954 which are not useful to determine the result of the call. In
11955 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11956 COMPOUND_EXPR will be an argument which must be evaluated.
11957 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11958 COMPOUND_EXPR in the chain will contain the tree for the simplified
11959 form of the builtin function call. */
11962 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11964 if (!validate_arg (s1, POINTER_TYPE)
11965 || !validate_arg (s2, POINTER_TYPE))
11969 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11971 /* If both arguments are constants, evaluate at compile-time. */
11974 const size_t r = strcspn (p1, p2);
11975 return build_int_cst (size_type_node, r);
11978 /* If the first argument is "", return NULL_TREE. */
11979 if (p1 && *p1 == '\0')
11981 /* Evaluate and ignore argument s2 in case it has
11983 return omit_one_operand_loc (loc, size_type_node,
11984 size_zero_node, s2);
11987 /* If the second argument is "", return __builtin_strlen(s1). */
11988 if (p2 && *p2 == '\0')
11990 tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
11992 /* If the replacement _DECL isn't initialized, don't do the
11997 return build_call_expr_loc (loc, fn, 1, s1);
12003 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
12004 to the call. IGNORE is true if the value returned
12005 by the builtin will be ignored. UNLOCKED is true is true if this
12006 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
12007 the known length of the string. Return NULL_TREE if no simplification
12011 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
12012 bool ignore, bool unlocked, tree len)
12014 /* If we're using an unlocked function, assume the other unlocked
12015 functions exist explicitly. */
12016 tree const fn_fputc = (unlocked
12017 ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED)
12018 : builtin_decl_implicit (BUILT_IN_FPUTC));
12019 tree const fn_fwrite = (unlocked
12020 ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED)
12021 : builtin_decl_implicit (BUILT_IN_FWRITE));
12023 /* If the return value is used, don't do the transformation. */
12027 /* Verify the arguments in the original call. */
12028 if (!validate_arg (arg0, POINTER_TYPE)
12029 || !validate_arg (arg1, POINTER_TYPE))
12033 len = c_strlen (arg0, 0);
12035 /* Get the length of the string passed to fputs. If the length
12036 can't be determined, punt. */
12038 || TREE_CODE (len) != INTEGER_CST)
12041 switch (compare_tree_int (len, 1))
12043 case -1: /* length is 0, delete the call entirely . */
12044 return omit_one_operand_loc (loc, integer_type_node,
12045 integer_zero_node, arg1);;
12047 case 0: /* length is 1, call fputc. */
12049 const char *p = c_getstr (arg0);
12054 return build_call_expr_loc (loc, fn_fputc, 2,
12056 (integer_type_node, p[0]), arg1);
12062 case 1: /* length is greater than 1, call fwrite. */
12064 /* If optimizing for size keep fputs. */
12065 if (optimize_function_for_size_p (cfun))
12067 /* New argument list transforming fputs(string, stream) to
12068 fwrite(string, 1, len, stream). */
12070 return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
12071 size_one_node, len, arg1);
12076 gcc_unreachable ();
12081 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
12082 produced. False otherwise. This is done so that we don't output the error
12083 or warning twice or three times. */
12086 fold_builtin_next_arg (tree exp, bool va_start_p)
12088 tree fntype = TREE_TYPE (current_function_decl);
12089 int nargs = call_expr_nargs (exp);
12092 if (!stdarg_p (fntype))
12094 error ("%<va_start%> used in function with fixed args");
12100 if (va_start_p && (nargs != 2))
12102 error ("wrong number of arguments to function %<va_start%>");
12105 arg = CALL_EXPR_ARG (exp, 1);
12107 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
12108 when we checked the arguments and if needed issued a warning. */
12113 /* Evidently an out of date version of <stdarg.h>; can't validate
12114 va_start's second argument, but can still work as intended. */
12115 warning (0, "%<__builtin_next_arg%> called without an argument");
12118 else if (nargs > 1)
12120 error ("wrong number of arguments to function %<__builtin_next_arg%>");
12123 arg = CALL_EXPR_ARG (exp, 0);
12126 if (TREE_CODE (arg) == SSA_NAME)
12127 arg = SSA_NAME_VAR (arg);
12129 /* We destructively modify the call to be __builtin_va_start (ap, 0)
12130 or __builtin_next_arg (0) the first time we see it, after checking
12131 the arguments and if needed issuing a warning. */
12132 if (!integer_zerop (arg))
12134 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
12136 /* Strip off all nops for the sake of the comparison. This
12137 is not quite the same as STRIP_NOPS. It does more.
12138 We must also strip off INDIRECT_EXPR for C++ reference
12140 while (CONVERT_EXPR_P (arg)
12141 || TREE_CODE (arg) == INDIRECT_REF)
12142 arg = TREE_OPERAND (arg, 0);
12143 if (arg != last_parm)
12145 /* FIXME: Sometimes with the tree optimizers we can get the
12146 not the last argument even though the user used the last
12147 argument. We just warn and set the arg to be the last
12148 argument so that we will get wrong-code because of
12150 warning (0, "second parameter of %<va_start%> not last named argument");
12153 /* Undefined by C99 7.15.1.4p4 (va_start):
12154 "If the parameter parmN is declared with the register storage
12155 class, with a function or array type, or with a type that is
12156 not compatible with the type that results after application of
12157 the default argument promotions, the behavior is undefined."
12159 else if (DECL_REGISTER (arg))
12160 warning (0, "undefined behaviour when second parameter of "
12161 "%<va_start%> is declared with %<register%> storage");
12163 /* We want to verify the second parameter just once before the tree
12164 optimizers are run and then avoid keeping it in the tree,
12165 as otherwise we could warn even for correct code like:
12166 void foo (int i, ...)
12167 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
12169 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
12171 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
12177 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
12178 ORIG may be null if this is a 2-argument call. We don't attempt to
12179 simplify calls with more than 3 arguments.
12181 Return NULL_TREE if no simplification was possible, otherwise return the
12182 simplified form of the call as a tree. If IGNORED is true, it means that
12183 the caller does not use the returned value of the function. */
12186 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
12187 tree orig, int ignored)
12190 const char *fmt_str = NULL;
12192 /* Verify the required arguments in the original call. We deal with two
12193 types of sprintf() calls: 'sprintf (str, fmt)' and
12194 'sprintf (dest, "%s", orig)'. */
12195 if (!validate_arg (dest, POINTER_TYPE)
12196 || !validate_arg (fmt, POINTER_TYPE))
12198 if (orig && !validate_arg (orig, POINTER_TYPE))
12201 /* Check whether the format is a literal string constant. */
12202 fmt_str = c_getstr (fmt);
12203 if (fmt_str == NULL)
12207 retval = NULL_TREE;
12209 if (!init_target_chars ())
12212 /* If the format doesn't contain % args or %%, use strcpy. */
12213 if (strchr (fmt_str, target_percent) == NULL)
12215 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12220 /* Don't optimize sprintf (buf, "abc", ptr++). */
12224 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
12225 'format' is known to contain no % formats. */
12226 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
12228 retval = build_int_cst (integer_type_node, strlen (fmt_str));
12231 /* If the format is "%s", use strcpy if the result isn't used. */
12232 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12235 fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12240 /* Don't crash on sprintf (str1, "%s"). */
12244 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
12247 retval = c_strlen (orig, 1);
12248 if (!retval || TREE_CODE (retval) != INTEGER_CST)
12251 call = build_call_expr_loc (loc, fn, 2, dest, orig);
12254 if (call && retval)
12256 retval = fold_convert_loc
12257 (loc, TREE_TYPE (TREE_TYPE (builtin_decl_implicit (BUILT_IN_SPRINTF))),
12259 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12265 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
12266 FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
12267 attempt to simplify calls with more than 4 arguments.
12269 Return NULL_TREE if no simplification was possible, otherwise return the
12270 simplified form of the call as a tree. If IGNORED is true, it means that
12271 the caller does not use the returned value of the function. */
12274 fold_builtin_snprintf (location_t loc, tree dest, tree destsize, tree fmt,
12275 tree orig, int ignored)
12278 const char *fmt_str = NULL;
12279 unsigned HOST_WIDE_INT destlen;
12281 /* Verify the required arguments in the original call. We deal with two
12282 types of snprintf() calls: 'snprintf (str, cst, fmt)' and
12283 'snprintf (dest, cst, "%s", orig)'. */
12284 if (!validate_arg (dest, POINTER_TYPE)
12285 || !validate_arg (destsize, INTEGER_TYPE)
12286 || !validate_arg (fmt, POINTER_TYPE))
12288 if (orig && !validate_arg (orig, POINTER_TYPE))
12291 if (!host_integerp (destsize, 1))
12294 /* Check whether the format is a literal string constant. */
12295 fmt_str = c_getstr (fmt);
12296 if (fmt_str == NULL)
12300 retval = NULL_TREE;
12302 if (!init_target_chars ())
12305 destlen = tree_low_cst (destsize, 1);
12307 /* If the format doesn't contain % args or %%, use strcpy. */
12308 if (strchr (fmt_str, target_percent) == NULL)
12310 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12311 size_t len = strlen (fmt_str);
12313 /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
12317 /* We could expand this as
12318 memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
12320 memcpy (str, fmt_with_nul_at_cstm1, cst);
12321 but in the former case that might increase code size
12322 and in the latter case grow .rodata section too much.
12323 So punt for now. */
12324 if (len >= destlen)
12330 /* Convert snprintf (str, cst, fmt) into strcpy (str, fmt) when
12331 'format' is known to contain no % formats and
12332 strlen (fmt) < cst. */
12333 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
12336 retval = build_int_cst (integer_type_node, strlen (fmt_str));
12339 /* If the format is "%s", use strcpy if the result isn't used. */
12340 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12342 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12343 unsigned HOST_WIDE_INT origlen;
12345 /* Don't crash on snprintf (str1, cst, "%s"). */
12349 retval = c_strlen (orig, 1);
12350 if (!retval || !host_integerp (retval, 1))
12353 origlen = tree_low_cst (retval, 1);
12354 /* We could expand this as
12355 memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
12357 memcpy (str1, str2_with_nul_at_cstm1, cst);
12358 but in the former case that might increase code size
12359 and in the latter case grow .rodata section too much.
12360 So punt for now. */
12361 if (origlen >= destlen)
12364 /* Convert snprintf (str1, cst, "%s", str2) into
12365 strcpy (str1, str2) if strlen (str2) < cst. */
12369 call = build_call_expr_loc (loc, fn, 2, dest, orig);
12372 retval = NULL_TREE;
12375 if (call && retval)
12377 tree fn = builtin_decl_explicit (BUILT_IN_SNPRINTF);
12378 retval = fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fn)), retval);
12379 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12385 /* Expand a call EXP to __builtin_object_size. */
12388 expand_builtin_object_size (tree exp)
12391 int object_size_type;
12392 tree fndecl = get_callee_fndecl (exp);
12394 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
12396 error ("%Kfirst argument of %D must be a pointer, second integer constant",
12398 expand_builtin_trap ();
12402 ost = CALL_EXPR_ARG (exp, 1);
12405 if (TREE_CODE (ost) != INTEGER_CST
12406 || tree_int_cst_sgn (ost) < 0
12407 || compare_tree_int (ost, 3) > 0)
12409 error ("%Klast argument of %D is not integer constant between 0 and 3",
12411 expand_builtin_trap ();
12415 object_size_type = tree_low_cst (ost, 0);
12417 return object_size_type < 2 ? constm1_rtx : const0_rtx;
12420 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12421 FCODE is the BUILT_IN_* to use.
12422 Return NULL_RTX if we failed; the caller should emit a normal call,
12423 otherwise try to get the result in TARGET, if convenient (and in
12424 mode MODE if that's convenient). */
12427 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
12428 enum built_in_function fcode)
12430 tree dest, src, len, size;
12432 if (!validate_arglist (exp,
12434 fcode == BUILT_IN_MEMSET_CHK
12435 ? INTEGER_TYPE : POINTER_TYPE,
12436 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
12439 dest = CALL_EXPR_ARG (exp, 0);
12440 src = CALL_EXPR_ARG (exp, 1);
12441 len = CALL_EXPR_ARG (exp, 2);
12442 size = CALL_EXPR_ARG (exp, 3);
12444 if (! host_integerp (size, 1))
12447 if (host_integerp (len, 1) || integer_all_onesp (size))
12451 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
12453 warning_at (tree_nonartificial_location (exp),
12454 0, "%Kcall to %D will always overflow destination buffer",
12455 exp, get_callee_fndecl (exp));
12460 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12461 mem{cpy,pcpy,move,set} is available. */
12464 case BUILT_IN_MEMCPY_CHK:
12465 fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
12467 case BUILT_IN_MEMPCPY_CHK:
12468 fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
12470 case BUILT_IN_MEMMOVE_CHK:
12471 fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
12473 case BUILT_IN_MEMSET_CHK:
12474 fn = builtin_decl_explicit (BUILT_IN_MEMSET);
12483 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
12484 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12485 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12486 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12488 else if (fcode == BUILT_IN_MEMSET_CHK)
12492 unsigned int dest_align = get_pointer_alignment (dest);
12494 /* If DEST is not a pointer type, call the normal function. */
12495 if (dest_align == 0)
12498 /* If SRC and DEST are the same (and not volatile), do nothing. */
12499 if (operand_equal_p (src, dest, 0))
12503 if (fcode != BUILT_IN_MEMPCPY_CHK)
12505 /* Evaluate and ignore LEN in case it has side-effects. */
12506 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12507 return expand_expr (dest, target, mode, EXPAND_NORMAL);
12510 expr = fold_build_pointer_plus (dest, len);
12511 return expand_expr (expr, target, mode, EXPAND_NORMAL);
12514 /* __memmove_chk special case. */
12515 if (fcode == BUILT_IN_MEMMOVE_CHK)
12517 unsigned int src_align = get_pointer_alignment (src);
12519 if (src_align == 0)
12522 /* If src is categorized for a readonly section we can use
12523 normal __memcpy_chk. */
12524 if (readonly_data_expr (src))
12526 tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12529 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
12530 dest, src, len, size);
12531 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12532 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12533 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12540 /* Emit warning if a buffer overflow is detected at compile time. */
12543 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12547 location_t loc = tree_nonartificial_location (exp);
12551 case BUILT_IN_STRCPY_CHK:
12552 case BUILT_IN_STPCPY_CHK:
12553 /* For __strcat_chk the warning will be emitted only if overflowing
12554 by at least strlen (dest) + 1 bytes. */
12555 case BUILT_IN_STRCAT_CHK:
12556 len = CALL_EXPR_ARG (exp, 1);
12557 size = CALL_EXPR_ARG (exp, 2);
12560 case BUILT_IN_STRNCAT_CHK:
12561 case BUILT_IN_STRNCPY_CHK:
12562 case BUILT_IN_STPNCPY_CHK:
12563 len = CALL_EXPR_ARG (exp, 2);
12564 size = CALL_EXPR_ARG (exp, 3);
12566 case BUILT_IN_SNPRINTF_CHK:
12567 case BUILT_IN_VSNPRINTF_CHK:
12568 len = CALL_EXPR_ARG (exp, 1);
12569 size = CALL_EXPR_ARG (exp, 3);
12572 gcc_unreachable ();
12578 if (! host_integerp (size, 1) || integer_all_onesp (size))
12583 len = c_strlen (len, 1);
12584 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12587 else if (fcode == BUILT_IN_STRNCAT_CHK)
12589 tree src = CALL_EXPR_ARG (exp, 1);
12590 if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12592 src = c_strlen (src, 1);
12593 if (! src || ! host_integerp (src, 1))
12595 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12596 exp, get_callee_fndecl (exp));
12599 else if (tree_int_cst_lt (src, size))
12602 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12605 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12606 exp, get_callee_fndecl (exp));
12609 /* Emit warning if a buffer overflow is detected at compile time
12610 in __sprintf_chk/__vsprintf_chk calls. */
12613 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12615 tree size, len, fmt;
12616 const char *fmt_str;
12617 int nargs = call_expr_nargs (exp);
12619 /* Verify the required arguments in the original call. */
12623 size = CALL_EXPR_ARG (exp, 2);
12624 fmt = CALL_EXPR_ARG (exp, 3);
12626 if (! host_integerp (size, 1) || integer_all_onesp (size))
12629 /* Check whether the format is a literal string constant. */
12630 fmt_str = c_getstr (fmt);
12631 if (fmt_str == NULL)
12634 if (!init_target_chars ())
12637 /* If the format doesn't contain % args or %%, we know its size. */
12638 if (strchr (fmt_str, target_percent) == 0)
12639 len = build_int_cstu (size_type_node, strlen (fmt_str));
12640 /* If the format is "%s" and first ... argument is a string literal,
12642 else if (fcode == BUILT_IN_SPRINTF_CHK
12643 && strcmp (fmt_str, target_percent_s) == 0)
12649 arg = CALL_EXPR_ARG (exp, 4);
12650 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12653 len = c_strlen (arg, 1);
12654 if (!len || ! host_integerp (len, 1))
12660 if (! tree_int_cst_lt (len, size))
12661 warning_at (tree_nonartificial_location (exp),
12662 0, "%Kcall to %D will always overflow destination buffer",
12663 exp, get_callee_fndecl (exp));
12666 /* Emit warning if a free is called with address of a variable. */
12669 maybe_emit_free_warning (tree exp)
12671 tree arg = CALL_EXPR_ARG (exp, 0);
12674 if (TREE_CODE (arg) != ADDR_EXPR)
12677 arg = get_base_address (TREE_OPERAND (arg, 0));
12678 if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12681 if (SSA_VAR_P (arg))
12682 warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
12683 "%Kattempt to free a non-heap object %qD", exp, arg);
12685 warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
12686 "%Kattempt to free a non-heap object", exp);
12689 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12693 fold_builtin_object_size (tree ptr, tree ost)
12695 unsigned HOST_WIDE_INT bytes;
12696 int object_size_type;
12698 if (!validate_arg (ptr, POINTER_TYPE)
12699 || !validate_arg (ost, INTEGER_TYPE))
12704 if (TREE_CODE (ost) != INTEGER_CST
12705 || tree_int_cst_sgn (ost) < 0
12706 || compare_tree_int (ost, 3) > 0)
12709 object_size_type = tree_low_cst (ost, 0);
12711 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12712 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12713 and (size_t) 0 for types 2 and 3. */
12714 if (TREE_SIDE_EFFECTS (ptr))
12715 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12717 if (TREE_CODE (ptr) == ADDR_EXPR)
12719 bytes = compute_builtin_object_size (ptr, object_size_type);
12720 if (double_int_fits_to_tree_p (size_type_node,
12721 uhwi_to_double_int (bytes)))
12722 return build_int_cstu (size_type_node, bytes);
12724 else if (TREE_CODE (ptr) == SSA_NAME)
12726 /* If object size is not known yet, delay folding until
12727 later. Maybe subsequent passes will help determining
12729 bytes = compute_builtin_object_size (ptr, object_size_type);
12730 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12731 && double_int_fits_to_tree_p (size_type_node,
12732 uhwi_to_double_int (bytes)))
12733 return build_int_cstu (size_type_node, bytes);
12739 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12740 DEST, SRC, LEN, and SIZE are the arguments to the call.
12741 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12742 code of the builtin. If MAXLEN is not NULL, it is maximum length
12743 passed as third argument. */
12746 fold_builtin_memory_chk (location_t loc, tree fndecl,
12747 tree dest, tree src, tree len, tree size,
12748 tree maxlen, bool ignore,
12749 enum built_in_function fcode)
12753 if (!validate_arg (dest, POINTER_TYPE)
12754 || !validate_arg (src,
12755 (fcode == BUILT_IN_MEMSET_CHK
12756 ? INTEGER_TYPE : POINTER_TYPE))
12757 || !validate_arg (len, INTEGER_TYPE)
12758 || !validate_arg (size, INTEGER_TYPE))
12761 /* If SRC and DEST are the same (and not volatile), return DEST
12762 (resp. DEST+LEN for __mempcpy_chk). */
12763 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12765 if (fcode != BUILT_IN_MEMPCPY_CHK)
12766 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12770 tree temp = fold_build_pointer_plus_loc (loc, dest, len);
12771 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12775 if (! host_integerp (size, 1))
12778 if (! integer_all_onesp (size))
12780 if (! host_integerp (len, 1))
12782 /* If LEN is not constant, try MAXLEN too.
12783 For MAXLEN only allow optimizing into non-_ocs function
12784 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12785 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12787 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12789 /* (void) __mempcpy_chk () can be optimized into
12790 (void) __memcpy_chk (). */
12791 fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12795 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12803 if (tree_int_cst_lt (size, maxlen))
12808 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12809 mem{cpy,pcpy,move,set} is available. */
12812 case BUILT_IN_MEMCPY_CHK:
12813 fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
12815 case BUILT_IN_MEMPCPY_CHK:
12816 fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
12818 case BUILT_IN_MEMMOVE_CHK:
12819 fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
12821 case BUILT_IN_MEMSET_CHK:
12822 fn = builtin_decl_explicit (BUILT_IN_MEMSET);
12831 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12834 /* Fold a call to the __st[rp]cpy_chk builtin.
12835 DEST, SRC, and SIZE are the arguments to the call.
12836 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12837 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12838 strings passed as second argument. */
12841 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12842 tree src, tree size,
12843 tree maxlen, bool ignore,
12844 enum built_in_function fcode)
12848 if (!validate_arg (dest, POINTER_TYPE)
12849 || !validate_arg (src, POINTER_TYPE)
12850 || !validate_arg (size, INTEGER_TYPE))
12853 /* If SRC and DEST are the same (and not volatile), return DEST. */
12854 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12855 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12857 if (! host_integerp (size, 1))
12860 if (! integer_all_onesp (size))
12862 len = c_strlen (src, 1);
12863 if (! len || ! host_integerp (len, 1))
12865 /* If LEN is not constant, try MAXLEN too.
12866 For MAXLEN only allow optimizing into non-_ocs function
12867 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12868 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12870 if (fcode == BUILT_IN_STPCPY_CHK)
12875 /* If return value of __stpcpy_chk is ignored,
12876 optimize into __strcpy_chk. */
12877 fn = builtin_decl_explicit (BUILT_IN_STRCPY_CHK);
12881 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12884 if (! len || TREE_SIDE_EFFECTS (len))
12887 /* If c_strlen returned something, but not a constant,
12888 transform __strcpy_chk into __memcpy_chk. */
12889 fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12893 len = fold_convert_loc (loc, size_type_node, len);
12894 len = size_binop_loc (loc, PLUS_EXPR, len,
12895 build_int_cst (size_type_node, 1));
12896 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12897 build_call_expr_loc (loc, fn, 4,
12898 dest, src, len, size));
12904 if (! tree_int_cst_lt (maxlen, size))
12908 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12909 fn = builtin_decl_explicit (fcode == BUILT_IN_STPCPY_CHK
12910 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY);
12914 return build_call_expr_loc (loc, fn, 2, dest, src);
12917 /* Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE
12918 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12919 length passed as third argument. IGNORE is true if return value can be
12920 ignored. FCODE is the BUILT_IN_* code of the builtin. */
12923 fold_builtin_stxncpy_chk (location_t loc, tree dest, tree src,
12924 tree len, tree size, tree maxlen, bool ignore,
12925 enum built_in_function fcode)
12929 if (!validate_arg (dest, POINTER_TYPE)
12930 || !validate_arg (src, POINTER_TYPE)
12931 || !validate_arg (len, INTEGER_TYPE)
12932 || !validate_arg (size, INTEGER_TYPE))
12935 if (fcode == BUILT_IN_STPNCPY_CHK && ignore)
12937 /* If return value of __stpncpy_chk is ignored,
12938 optimize into __strncpy_chk. */
12939 fn = builtin_decl_explicit (BUILT_IN_STRNCPY_CHK);
12941 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12944 if (! host_integerp (size, 1))
12947 if (! integer_all_onesp (size))
12949 if (! host_integerp (len, 1))
12951 /* If LEN is not constant, try MAXLEN too.
12952 For MAXLEN only allow optimizing into non-_ocs function
12953 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12954 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12960 if (tree_int_cst_lt (size, maxlen))
12964 /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available. */
12965 fn = builtin_decl_explicit (fcode == BUILT_IN_STPNCPY_CHK
12966 ? BUILT_IN_STPNCPY : BUILT_IN_STRNCPY);
12970 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12973 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12974 are the arguments to the call. */
12977 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12978 tree src, tree size)
12983 if (!validate_arg (dest, POINTER_TYPE)
12984 || !validate_arg (src, POINTER_TYPE)
12985 || !validate_arg (size, INTEGER_TYPE))
12988 p = c_getstr (src);
12989 /* If the SRC parameter is "", return DEST. */
12990 if (p && *p == '\0')
12991 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12993 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12996 /* If __builtin_strcat_chk is used, assume strcat is available. */
12997 fn = builtin_decl_explicit (BUILT_IN_STRCAT);
13001 return build_call_expr_loc (loc, fn, 2, dest, src);
13004 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
13008 fold_builtin_strncat_chk (location_t loc, tree fndecl,
13009 tree dest, tree src, tree len, tree size)
13014 if (!validate_arg (dest, POINTER_TYPE)
13015 || !validate_arg (src, POINTER_TYPE)
13016 || !validate_arg (size, INTEGER_TYPE)
13017 || !validate_arg (size, INTEGER_TYPE))
13020 p = c_getstr (src);
13021 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
13022 if (p && *p == '\0')
13023 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
13024 else if (integer_zerop (len))
13025 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
13027 if (! host_integerp (size, 1))
13030 if (! integer_all_onesp (size))
13032 tree src_len = c_strlen (src, 1);
13034 && host_integerp (src_len, 1)
13035 && host_integerp (len, 1)
13036 && ! tree_int_cst_lt (len, src_len))
13038 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
13039 fn = builtin_decl_explicit (BUILT_IN_STRCAT_CHK);
13043 return build_call_expr_loc (loc, fn, 3, dest, src, size);
13048 /* If __builtin_strncat_chk is used, assume strncat is available. */
13049 fn = builtin_decl_explicit (BUILT_IN_STRNCAT);
13053 return build_call_expr_loc (loc, fn, 3, dest, src, len);
13056 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
13057 Return NULL_TREE if a normal call should be emitted rather than
13058 expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
13059 or BUILT_IN_VSPRINTF_CHK. */
13062 fold_builtin_sprintf_chk_1 (location_t loc, int nargs, tree *args,
13063 enum built_in_function fcode)
13065 tree dest, size, len, fn, fmt, flag;
13066 const char *fmt_str;
13068 /* Verify the required arguments in the original call. */
13072 if (!validate_arg (dest, POINTER_TYPE))
13075 if (!validate_arg (flag, INTEGER_TYPE))
13078 if (!validate_arg (size, INTEGER_TYPE))
13081 if (!validate_arg (fmt, POINTER_TYPE))
13084 if (! host_integerp (size, 1))
13089 if (!init_target_chars ())
13092 /* Check whether the format is a literal string constant. */
13093 fmt_str = c_getstr (fmt);
13094 if (fmt_str != NULL)
13096 /* If the format doesn't contain % args or %%, we know the size. */
13097 if (strchr (fmt_str, target_percent) == 0)
13099 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13100 len = build_int_cstu (size_type_node, strlen (fmt_str));
13102 /* If the format is "%s" and first ... argument is a string literal,
13103 we know the size too. */
13104 else if (fcode == BUILT_IN_SPRINTF_CHK
13105 && strcmp (fmt_str, target_percent_s) == 0)
13112 if (validate_arg (arg, POINTER_TYPE))
13114 len = c_strlen (arg, 1);
13115 if (! len || ! host_integerp (len, 1))
13122 if (! integer_all_onesp (size))
13124 if (! len || ! tree_int_cst_lt (len, size))
13128 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13129 or if format doesn't contain % chars or is "%s". */
13130 if (! integer_zerop (flag))
13132 if (fmt_str == NULL)
13134 if (strchr (fmt_str, target_percent) != NULL
13135 && strcmp (fmt_str, target_percent_s))
13139 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
13140 fn = builtin_decl_explicit (fcode == BUILT_IN_VSPRINTF_CHK
13141 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF);
13145 return rewrite_call_expr_array (loc, nargs, args, 4, fn, 2, dest, fmt);
13148 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
13149 a normal call should be emitted rather than expanding the function
13150 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13153 fold_builtin_sprintf_chk (location_t loc, tree exp,
13154 enum built_in_function fcode)
13156 return fold_builtin_sprintf_chk_1 (loc, call_expr_nargs (exp),
13157 CALL_EXPR_ARGP (exp), fcode);
13160 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
13161 NULL_TREE if a normal call should be emitted rather than expanding
13162 the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13163 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13164 passed as second argument. */
13167 fold_builtin_snprintf_chk_1 (location_t loc, int nargs, tree *args,
13168 tree maxlen, enum built_in_function fcode)
13170 tree dest, size, len, fn, fmt, flag;
13171 const char *fmt_str;
13173 /* Verify the required arguments in the original call. */
13177 if (!validate_arg (dest, POINTER_TYPE))
13180 if (!validate_arg (len, INTEGER_TYPE))
13183 if (!validate_arg (flag, INTEGER_TYPE))
13186 if (!validate_arg (size, INTEGER_TYPE))
13189 if (!validate_arg (fmt, POINTER_TYPE))
13192 if (! host_integerp (size, 1))
13195 if (! integer_all_onesp (size))
13197 if (! host_integerp (len, 1))
13199 /* If LEN is not constant, try MAXLEN too.
13200 For MAXLEN only allow optimizing into non-_ocs function
13201 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
13202 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13208 if (tree_int_cst_lt (size, maxlen))
13212 if (!init_target_chars ())
13215 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13216 or if format doesn't contain % chars or is "%s". */
13217 if (! integer_zerop (flag))
13219 fmt_str = c_getstr (fmt);
13220 if (fmt_str == NULL)
13222 if (strchr (fmt_str, target_percent) != NULL
13223 && strcmp (fmt_str, target_percent_s))
13227 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13229 fn = builtin_decl_explicit (fcode == BUILT_IN_VSNPRINTF_CHK
13230 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF);
13234 return rewrite_call_expr_array (loc, nargs, args, 5, fn, 3, dest, len, fmt);
13237 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
13238 a normal call should be emitted rather than expanding the function
13239 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13240 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13241 passed as second argument. */
13244 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
13245 enum built_in_function fcode)
13247 return fold_builtin_snprintf_chk_1 (loc, call_expr_nargs (exp),
13248 CALL_EXPR_ARGP (exp), maxlen, fcode);
13251 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
13252 FMT and ARG are the arguments to the call; we don't fold cases with
13253 more than 2 arguments, and ARG may be null if this is a 1-argument case.
13255 Return NULL_TREE if no simplification was possible, otherwise return the
13256 simplified form of the call as a tree. FCODE is the BUILT_IN_*
13257 code of the function to be simplified. */
13260 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
13261 tree arg, bool ignore,
13262 enum built_in_function fcode)
13264 tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
13265 const char *fmt_str = NULL;
13267 /* If the return value is used, don't do the transformation. */
13271 /* Verify the required arguments in the original call. */
13272 if (!validate_arg (fmt, POINTER_TYPE))
13275 /* Check whether the format is a literal string constant. */
13276 fmt_str = c_getstr (fmt);
13277 if (fmt_str == NULL)
13280 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
13282 /* If we're using an unlocked function, assume the other
13283 unlocked functions exist explicitly. */
13284 fn_putchar = builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED);
13285 fn_puts = builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED);
13289 fn_putchar = builtin_decl_implicit (BUILT_IN_PUTCHAR);
13290 fn_puts = builtin_decl_implicit (BUILT_IN_PUTS);
13293 if (!init_target_chars ())
13296 if (strcmp (fmt_str, target_percent_s) == 0
13297 || strchr (fmt_str, target_percent) == NULL)
13301 if (strcmp (fmt_str, target_percent_s) == 0)
13303 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13306 if (!arg || !validate_arg (arg, POINTER_TYPE))
13309 str = c_getstr (arg);
13315 /* The format specifier doesn't contain any '%' characters. */
13316 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
13322 /* If the string was "", printf does nothing. */
13323 if (str[0] == '\0')
13324 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13326 /* If the string has length of 1, call putchar. */
13327 if (str[1] == '\0')
13329 /* Given printf("c"), (where c is any one character,)
13330 convert "c"[0] to an int and pass that to the replacement
13332 newarg = build_int_cst (integer_type_node, str[0]);
13334 call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
13338 /* If the string was "string\n", call puts("string"). */
13339 size_t len = strlen (str);
13340 if ((unsigned char)str[len - 1] == target_newline
13341 && (size_t) (int) len == len
13345 tree offset_node, string_cst;
13347 /* Create a NUL-terminated string that's one char shorter
13348 than the original, stripping off the trailing '\n'. */
13349 newarg = build_string_literal (len, str);
13350 string_cst = string_constant (newarg, &offset_node);
13351 gcc_checking_assert (string_cst
13352 && (TREE_STRING_LENGTH (string_cst)
13354 && integer_zerop (offset_node)
13356 TREE_STRING_POINTER (string_cst)[len - 1]
13357 == target_newline);
13358 /* build_string_literal creates a new STRING_CST,
13359 modify it in place to avoid double copying. */
13360 newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst));
13361 newstr[len - 1] = '\0';
13363 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
13366 /* We'd like to arrange to call fputs(string,stdout) here,
13367 but we need stdout and don't have a way to get it yet. */
13372 /* The other optimizations can be done only on the non-va_list variants. */
13373 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13376 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
13377 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
13379 if (!arg || !validate_arg (arg, POINTER_TYPE))
13382 call = build_call_expr_loc (loc, fn_puts, 1, arg);
13385 /* If the format specifier was "%c", call __builtin_putchar(arg). */
13386 else if (strcmp (fmt_str, target_percent_c) == 0)
13388 if (!arg || !validate_arg (arg, INTEGER_TYPE))
13391 call = build_call_expr_loc (loc, fn_putchar, 1, arg);
13397 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13400 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13401 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
13402 more than 3 arguments, and ARG may be null in the 2-argument case.
13404 Return NULL_TREE if no simplification was possible, otherwise return the
13405 simplified form of the call as a tree. FCODE is the BUILT_IN_*
13406 code of the function to be simplified. */
13409 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
13410 tree fmt, tree arg, bool ignore,
13411 enum built_in_function fcode)
13413 tree fn_fputc, fn_fputs, call = NULL_TREE;
13414 const char *fmt_str = NULL;
13416 /* If the return value is used, don't do the transformation. */
13420 /* Verify the required arguments in the original call. */
13421 if (!validate_arg (fp, POINTER_TYPE))
13423 if (!validate_arg (fmt, POINTER_TYPE))
13426 /* Check whether the format is a literal string constant. */
13427 fmt_str = c_getstr (fmt);
13428 if (fmt_str == NULL)
13431 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
13433 /* If we're using an unlocked function, assume the other
13434 unlocked functions exist explicitly. */
13435 fn_fputc = builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED);
13436 fn_fputs = builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED);
13440 fn_fputc = builtin_decl_implicit (BUILT_IN_FPUTC);
13441 fn_fputs = builtin_decl_implicit (BUILT_IN_FPUTS);
13444 if (!init_target_chars ())
13447 /* If the format doesn't contain % args or %%, use strcpy. */
13448 if (strchr (fmt_str, target_percent) == NULL)
13450 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
13454 /* If the format specifier was "", fprintf does nothing. */
13455 if (fmt_str[0] == '\0')
13457 /* If FP has side-effects, just wait until gimplification is
13459 if (TREE_SIDE_EFFECTS (fp))
13462 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13465 /* When "string" doesn't contain %, replace all cases of
13466 fprintf (fp, string) with fputs (string, fp). The fputs
13467 builtin will take care of special cases like length == 1. */
13469 call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
13472 /* The other optimizations can be done only on the non-va_list variants. */
13473 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
13476 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
13477 else if (strcmp (fmt_str, target_percent_s) == 0)
13479 if (!arg || !validate_arg (arg, POINTER_TYPE))
13482 call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
13485 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
13486 else if (strcmp (fmt_str, target_percent_c) == 0)
13488 if (!arg || !validate_arg (arg, INTEGER_TYPE))
13491 call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
13496 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13499 /* Initialize format string characters in the target charset. */
13502 init_target_chars (void)
13507 target_newline = lang_hooks.to_target_charset ('\n');
13508 target_percent = lang_hooks.to_target_charset ('%');
13509 target_c = lang_hooks.to_target_charset ('c');
13510 target_s = lang_hooks.to_target_charset ('s');
13511 if (target_newline == 0 || target_percent == 0 || target_c == 0
13515 target_percent_c[0] = target_percent;
13516 target_percent_c[1] = target_c;
13517 target_percent_c[2] = '\0';
13519 target_percent_s[0] = target_percent;
13520 target_percent_s[1] = target_s;
13521 target_percent_s[2] = '\0';
13523 target_percent_s_newline[0] = target_percent;
13524 target_percent_s_newline[1] = target_s;
13525 target_percent_s_newline[2] = target_newline;
13526 target_percent_s_newline[3] = '\0';
13533 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
13534 and no overflow/underflow occurred. INEXACT is true if M was not
13535 exactly calculated. TYPE is the tree type for the result. This
13536 function assumes that you cleared the MPFR flags and then
13537 calculated M to see if anything subsequently set a flag prior to
13538 entering this function. Return NULL_TREE if any checks fail. */
13541 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13543 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13544 overflow/underflow occurred. If -frounding-math, proceed iff the
13545 result of calling FUNC was exact. */
13546 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13547 && (!flag_rounding_math || !inexact))
13549 REAL_VALUE_TYPE rr;
13551 real_from_mpfr (&rr, m, type, GMP_RNDN);
13552 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13553 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13554 but the mpft_t is not, then we underflowed in the
13556 if (real_isfinite (&rr)
13557 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13559 REAL_VALUE_TYPE rmode;
13561 real_convert (&rmode, TYPE_MODE (type), &rr);
13562 /* Proceed iff the specified mode can hold the value. */
13563 if (real_identical (&rmode, &rr))
13564 return build_real (type, rmode);
13570 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
13571 number and no overflow/underflow occurred. INEXACT is true if M
13572 was not exactly calculated. TYPE is the tree type for the result.
13573 This function assumes that you cleared the MPFR flags and then
13574 calculated M to see if anything subsequently set a flag prior to
13575 entering this function. Return NULL_TREE if any checks fail, if
13576 FORCE_CONVERT is true, then bypass the checks. */
13579 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13581 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13582 overflow/underflow occurred. If -frounding-math, proceed iff the
13583 result of calling FUNC was exact. */
13585 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13586 && !mpfr_overflow_p () && !mpfr_underflow_p ()
13587 && (!flag_rounding_math || !inexact)))
13589 REAL_VALUE_TYPE re, im;
13591 real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
13592 real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
13593 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13594 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13595 but the mpft_t is not, then we underflowed in the
13598 || (real_isfinite (&re) && real_isfinite (&im)
13599 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13600 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13602 REAL_VALUE_TYPE re_mode, im_mode;
13604 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13605 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13606 /* Proceed iff the specified mode can hold the value. */
13608 || (real_identical (&re_mode, &re)
13609 && real_identical (&im_mode, &im)))
13610 return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13611 build_real (TREE_TYPE (type), im_mode));
13617 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13618 FUNC on it and return the resulting value as a tree with type TYPE.
13619 If MIN and/or MAX are not NULL, then the supplied ARG must be
13620 within those bounds. If INCLUSIVE is true, then MIN/MAX are
13621 acceptable values, otherwise they are not. The mpfr precision is
13622 set to the precision of TYPE. We assume that function FUNC returns
13623 zero if the result could be calculated exactly within the requested
13627 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13628 const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13631 tree result = NULL_TREE;
13635 /* To proceed, MPFR must exactly represent the target floating point
13636 format, which only happens when the target base equals two. */
13637 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13638 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13640 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13642 if (real_isfinite (ra)
13643 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13644 && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13646 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13647 const int prec = fmt->p;
13648 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13652 mpfr_init2 (m, prec);
13653 mpfr_from_real (m, ra, GMP_RNDN);
13654 mpfr_clear_flags ();
13655 inexact = func (m, m, rnd);
13656 result = do_mpfr_ckconv (m, type, inexact);
13664 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13665 FUNC on it and return the resulting value as a tree with type TYPE.
13666 The mpfr precision is set to the precision of TYPE. We assume that
13667 function FUNC returns zero if the result could be calculated
13668 exactly within the requested precision. */
13671 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13672 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13674 tree result = NULL_TREE;
13679 /* To proceed, MPFR must exactly represent the target floating point
13680 format, which only happens when the target base equals two. */
13681 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13682 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13683 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13685 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13686 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13688 if (real_isfinite (ra1) && real_isfinite (ra2))
13690 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13691 const int prec = fmt->p;
13692 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13696 mpfr_inits2 (prec, m1, m2, NULL);
13697 mpfr_from_real (m1, ra1, GMP_RNDN);
13698 mpfr_from_real (m2, ra2, GMP_RNDN);
13699 mpfr_clear_flags ();
13700 inexact = func (m1, m1, m2, rnd);
13701 result = do_mpfr_ckconv (m1, type, inexact);
13702 mpfr_clears (m1, m2, NULL);
13709 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13710 FUNC on it and return the resulting value as a tree with type TYPE.
13711 The mpfr precision is set to the precision of TYPE. We assume that
13712 function FUNC returns zero if the result could be calculated
13713 exactly within the requested precision. */
13716 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13717 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13719 tree result = NULL_TREE;
13725 /* To proceed, MPFR must exactly represent the target floating point
13726 format, which only happens when the target base equals two. */
13727 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13728 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13729 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13730 && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13732 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13733 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13734 const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13736 if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13738 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13739 const int prec = fmt->p;
13740 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13744 mpfr_inits2 (prec, m1, m2, m3, NULL);
13745 mpfr_from_real (m1, ra1, GMP_RNDN);
13746 mpfr_from_real (m2, ra2, GMP_RNDN);
13747 mpfr_from_real (m3, ra3, GMP_RNDN);
13748 mpfr_clear_flags ();
13749 inexact = func (m1, m1, m2, m3, rnd);
13750 result = do_mpfr_ckconv (m1, type, inexact);
13751 mpfr_clears (m1, m2, m3, NULL);
13758 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13759 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13760 If ARG_SINP and ARG_COSP are NULL then the result is returned
13761 as a complex value.
13762 The type is taken from the type of ARG and is used for setting the
13763 precision of the calculation and results. */
13766 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13768 tree const type = TREE_TYPE (arg);
13769 tree result = NULL_TREE;
13773 /* To proceed, MPFR must exactly represent the target floating point
13774 format, which only happens when the target base equals two. */
13775 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13776 && TREE_CODE (arg) == REAL_CST
13777 && !TREE_OVERFLOW (arg))
13779 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13781 if (real_isfinite (ra))
13783 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13784 const int prec = fmt->p;
13785 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13786 tree result_s, result_c;
13790 mpfr_inits2 (prec, m, ms, mc, NULL);
13791 mpfr_from_real (m, ra, GMP_RNDN);
13792 mpfr_clear_flags ();
13793 inexact = mpfr_sin_cos (ms, mc, m, rnd);
13794 result_s = do_mpfr_ckconv (ms, type, inexact);
13795 result_c = do_mpfr_ckconv (mc, type, inexact);
13796 mpfr_clears (m, ms, mc, NULL);
13797 if (result_s && result_c)
13799 /* If we are to return in a complex value do so. */
13800 if (!arg_sinp && !arg_cosp)
13801 return build_complex (build_complex_type (type),
13802 result_c, result_s);
13804 /* Dereference the sin/cos pointer arguments. */
13805 arg_sinp = build_fold_indirect_ref (arg_sinp);
13806 arg_cosp = build_fold_indirect_ref (arg_cosp);
13807 /* Proceed if valid pointer type were passed in. */
13808 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13809 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13811 /* Set the values. */
13812 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13814 TREE_SIDE_EFFECTS (result_s) = 1;
13815 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13817 TREE_SIDE_EFFECTS (result_c) = 1;
13818 /* Combine the assignments into a compound expr. */
13819 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13820 result_s, result_c));
13828 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13829 two-argument mpfr order N Bessel function FUNC on them and return
13830 the resulting value as a tree with type TYPE. The mpfr precision
13831 is set to the precision of TYPE. We assume that function FUNC
13832 returns zero if the result could be calculated exactly within the
13833 requested precision. */
13835 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13836 int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13837 const REAL_VALUE_TYPE *min, bool inclusive)
13839 tree result = NULL_TREE;
13844 /* To proceed, MPFR must exactly represent the target floating point
13845 format, which only happens when the target base equals two. */
13846 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13847 && host_integerp (arg1, 0)
13848 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13850 const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13851 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13854 && real_isfinite (ra)
13855 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13857 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13858 const int prec = fmt->p;
13859 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13863 mpfr_init2 (m, prec);
13864 mpfr_from_real (m, ra, GMP_RNDN);
13865 mpfr_clear_flags ();
13866 inexact = func (m, n, m, rnd);
13867 result = do_mpfr_ckconv (m, type, inexact);
13875 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13876 the pointer *(ARG_QUO) and return the result. The type is taken
13877 from the type of ARG0 and is used for setting the precision of the
13878 calculation and results. */
13881 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13883 tree const type = TREE_TYPE (arg0);
13884 tree result = NULL_TREE;
13889 /* To proceed, MPFR must exactly represent the target floating point
13890 format, which only happens when the target base equals two. */
13891 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13892 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13893 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13895 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13896 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13898 if (real_isfinite (ra0) && real_isfinite (ra1))
13900 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13901 const int prec = fmt->p;
13902 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13907 mpfr_inits2 (prec, m0, m1, NULL);
13908 mpfr_from_real (m0, ra0, GMP_RNDN);
13909 mpfr_from_real (m1, ra1, GMP_RNDN);
13910 mpfr_clear_flags ();
13911 mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13912 /* Remquo is independent of the rounding mode, so pass
13913 inexact=0 to do_mpfr_ckconv(). */
13914 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13915 mpfr_clears (m0, m1, NULL);
13918 /* MPFR calculates quo in the host's long so it may
13919 return more bits in quo than the target int can hold
13920 if sizeof(host long) > sizeof(target int). This can
13921 happen even for native compilers in LP64 mode. In
13922 these cases, modulo the quo value with the largest
13923 number that the target int can hold while leaving one
13924 bit for the sign. */
13925 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13926 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13928 /* Dereference the quo pointer argument. */
13929 arg_quo = build_fold_indirect_ref (arg_quo);
13930 /* Proceed iff a valid pointer type was passed in. */
13931 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13933 /* Set the value. */
13935 = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo,
13936 build_int_cst (TREE_TYPE (arg_quo),
13938 TREE_SIDE_EFFECTS (result_quo) = 1;
13939 /* Combine the quo assignment with the rem. */
13940 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13941 result_quo, result_rem));
13949 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13950 resulting value as a tree with type TYPE. The mpfr precision is
13951 set to the precision of TYPE. We assume that this mpfr function
13952 returns zero if the result could be calculated exactly within the
13953 requested precision. In addition, the integer pointer represented
13954 by ARG_SG will be dereferenced and set to the appropriate signgam
13958 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13960 tree result = NULL_TREE;
13964 /* To proceed, MPFR must exactly represent the target floating point
13965 format, which only happens when the target base equals two. Also
13966 verify ARG is a constant and that ARG_SG is an int pointer. */
13967 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13968 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13969 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13970 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13972 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13974 /* In addition to NaN and Inf, the argument cannot be zero or a
13975 negative integer. */
13976 if (real_isfinite (ra)
13977 && ra->cl != rvc_zero
13978 && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13980 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13981 const int prec = fmt->p;
13982 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13987 mpfr_init2 (m, prec);
13988 mpfr_from_real (m, ra, GMP_RNDN);
13989 mpfr_clear_flags ();
13990 inexact = mpfr_lgamma (m, &sg, m, rnd);
13991 result_lg = do_mpfr_ckconv (m, type, inexact);
13997 /* Dereference the arg_sg pointer argument. */
13998 arg_sg = build_fold_indirect_ref (arg_sg);
13999 /* Assign the signgam value into *arg_sg. */
14000 result_sg = fold_build2 (MODIFY_EXPR,
14001 TREE_TYPE (arg_sg), arg_sg,
14002 build_int_cst (TREE_TYPE (arg_sg), sg));
14003 TREE_SIDE_EFFECTS (result_sg) = 1;
14004 /* Combine the signgam assignment with the lgamma result. */
14005 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
14006 result_sg, result_lg));
14014 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
14015 function FUNC on it and return the resulting value as a tree with
14016 type TYPE. The mpfr precision is set to the precision of TYPE. We
14017 assume that function FUNC returns zero if the result could be
14018 calculated exactly within the requested precision. */
14021 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
14023 tree result = NULL_TREE;
14027 /* To proceed, MPFR must exactly represent the target floating point
14028 format, which only happens when the target base equals two. */
14029 if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
14030 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
14031 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
14033 const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
14034 const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
14036 if (real_isfinite (re) && real_isfinite (im))
14038 const struct real_format *const fmt =
14039 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
14040 const int prec = fmt->p;
14041 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
14042 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
14046 mpc_init2 (m, prec);
14047 mpfr_from_real (mpc_realref(m), re, rnd);
14048 mpfr_from_real (mpc_imagref(m), im, rnd);
14049 mpfr_clear_flags ();
14050 inexact = func (m, m, crnd);
14051 result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
14059 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
14060 mpc function FUNC on it and return the resulting value as a tree
14061 with type TYPE. The mpfr precision is set to the precision of
14062 TYPE. We assume that function FUNC returns zero if the result
14063 could be calculated exactly within the requested precision. If
14064 DO_NONFINITE is true, then fold expressions containing Inf or NaN
14065 in the arguments and/or results. */
14068 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
14069 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
14071 tree result = NULL_TREE;
14076 /* To proceed, MPFR must exactly represent the target floating point
14077 format, which only happens when the target base equals two. */
14078 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
14079 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
14080 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
14081 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
14082 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
14084 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
14085 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
14086 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
14087 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
14090 || (real_isfinite (re0) && real_isfinite (im0)
14091 && real_isfinite (re1) && real_isfinite (im1)))
14093 const struct real_format *const fmt =
14094 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
14095 const int prec = fmt->p;
14096 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
14097 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
14101 mpc_init2 (m0, prec);
14102 mpc_init2 (m1, prec);
14103 mpfr_from_real (mpc_realref(m0), re0, rnd);
14104 mpfr_from_real (mpc_imagref(m0), im0, rnd);
14105 mpfr_from_real (mpc_realref(m1), re1, rnd);
14106 mpfr_from_real (mpc_imagref(m1), im1, rnd);
14107 mpfr_clear_flags ();
14108 inexact = func (m0, m0, m1, crnd);
14109 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
14118 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
14119 a normal call should be emitted rather than expanding the function
14120 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
14123 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
14125 int nargs = gimple_call_num_args (stmt);
14127 return fold_builtin_sprintf_chk_1 (gimple_location (stmt), nargs,
14129 ? gimple_call_arg_ptr (stmt, 0)
14130 : &error_mark_node), fcode);
14133 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
14134 a normal call should be emitted rather than expanding the function
14135 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
14136 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
14137 passed as second argument. */
14140 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
14141 enum built_in_function fcode)
14143 int nargs = gimple_call_num_args (stmt);
14145 return fold_builtin_snprintf_chk_1 (gimple_location (stmt), nargs,
14147 ? gimple_call_arg_ptr (stmt, 0)
14148 : &error_mark_node), maxlen, fcode);
14151 /* Builtins with folding operations that operate on "..." arguments
14152 need special handling; we need to store the arguments in a convenient
14153 data structure before attempting any folding. Fortunately there are
14154 only a few builtins that fall into this category. FNDECL is the
14155 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
14156 result of the function call is ignored. */
14159 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
14160 bool ignore ATTRIBUTE_UNUSED)
14162 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
14163 tree ret = NULL_TREE;
14167 case BUILT_IN_SPRINTF_CHK:
14168 case BUILT_IN_VSPRINTF_CHK:
14169 ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
14172 case BUILT_IN_SNPRINTF_CHK:
14173 case BUILT_IN_VSNPRINTF_CHK:
14174 ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
14181 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
14182 TREE_NO_WARNING (ret) = 1;
14188 /* A wrapper function for builtin folding that prevents warnings for
14189 "statement without effect" and the like, caused by removing the
14190 call node earlier than the warning is generated. */
14193 fold_call_stmt (gimple stmt, bool ignore)
14195 tree ret = NULL_TREE;
14196 tree fndecl = gimple_call_fndecl (stmt);
14197 location_t loc = gimple_location (stmt);
14199 && TREE_CODE (fndecl) == FUNCTION_DECL
14200 && DECL_BUILT_IN (fndecl)
14201 && !gimple_call_va_arg_pack_p (stmt))
14203 int nargs = gimple_call_num_args (stmt);
14204 tree *args = (nargs > 0
14205 ? gimple_call_arg_ptr (stmt, 0)
14206 : &error_mark_node);
14208 if (avoid_folding_inline_builtin (fndecl))
14210 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
14212 return targetm.fold_builtin (fndecl, nargs, args, ignore);
14216 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
14217 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
14219 ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
14222 /* Propagate location information from original call to
14223 expansion of builtin. Otherwise things like
14224 maybe_emit_chk_warning, that operate on the expansion
14225 of a builtin, will use the wrong location information. */
14226 if (gimple_has_location (stmt))
14228 tree realret = ret;
14229 if (TREE_CODE (ret) == NOP_EXPR)
14230 realret = TREE_OPERAND (ret, 0);
14231 if (CAN_HAVE_LOCATION_P (realret)
14232 && !EXPR_HAS_LOCATION (realret))
14233 SET_EXPR_LOCATION (realret, loc);
14243 /* Look up the function in builtin_decl that corresponds to DECL
14244 and set ASMSPEC as its user assembler name. DECL must be a
14245 function decl that declares a builtin. */
14248 set_builtin_user_assembler_name (tree decl, const char *asmspec)
14251 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
14252 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
14255 builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
14256 set_user_assembler_name (builtin, asmspec);
14257 switch (DECL_FUNCTION_CODE (decl))
14259 case BUILT_IN_MEMCPY:
14260 init_block_move_fn (asmspec);
14261 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
14263 case BUILT_IN_MEMSET:
14264 init_block_clear_fn (asmspec);
14265 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
14267 case BUILT_IN_MEMMOVE:
14268 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
14270 case BUILT_IN_MEMCMP:
14271 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
14273 case BUILT_IN_ABORT:
14274 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
14277 if (INT_TYPE_SIZE < BITS_PER_WORD)
14279 set_user_assembler_libfunc ("ffs", asmspec);
14280 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
14281 MODE_INT, 0), "ffs");
14289 /* Return true if DECL is a builtin that expands to a constant or similarly
14292 is_simple_builtin (tree decl)
14294 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
14295 switch (DECL_FUNCTION_CODE (decl))
14297 /* Builtins that expand to constants. */
14298 case BUILT_IN_CONSTANT_P:
14299 case BUILT_IN_EXPECT:
14300 case BUILT_IN_OBJECT_SIZE:
14301 case BUILT_IN_UNREACHABLE:
14302 /* Simple register moves or loads from stack. */
14303 case BUILT_IN_ASSUME_ALIGNED:
14304 case BUILT_IN_RETURN_ADDRESS:
14305 case BUILT_IN_EXTRACT_RETURN_ADDR:
14306 case BUILT_IN_FROB_RETURN_ADDR:
14307 case BUILT_IN_RETURN:
14308 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
14309 case BUILT_IN_FRAME_ADDRESS:
14310 case BUILT_IN_VA_END:
14311 case BUILT_IN_STACK_SAVE:
14312 case BUILT_IN_STACK_RESTORE:
14313 /* Exception state returns or moves registers around. */
14314 case BUILT_IN_EH_FILTER:
14315 case BUILT_IN_EH_POINTER:
14316 case BUILT_IN_EH_COPY_VALUES:
14326 /* Return true if DECL is a builtin that is not expensive, i.e., they are
14327 most probably expanded inline into reasonably simple code. This is a
14328 superset of is_simple_builtin. */
14330 is_inexpensive_builtin (tree decl)
14334 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
14336 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
14337 switch (DECL_FUNCTION_CODE (decl))
14340 case BUILT_IN_ALLOCA:
14341 case BUILT_IN_ALLOCA_WITH_ALIGN:
14342 case BUILT_IN_BSWAP32:
14343 case BUILT_IN_BSWAP64:
14345 case BUILT_IN_CLZIMAX:
14346 case BUILT_IN_CLZL:
14347 case BUILT_IN_CLZLL:
14349 case BUILT_IN_CTZIMAX:
14350 case BUILT_IN_CTZL:
14351 case BUILT_IN_CTZLL:
14353 case BUILT_IN_FFSIMAX:
14354 case BUILT_IN_FFSL:
14355 case BUILT_IN_FFSLL:
14356 case BUILT_IN_IMAXABS:
14357 case BUILT_IN_FINITE:
14358 case BUILT_IN_FINITEF:
14359 case BUILT_IN_FINITEL:
14360 case BUILT_IN_FINITED32:
14361 case BUILT_IN_FINITED64:
14362 case BUILT_IN_FINITED128:
14363 case BUILT_IN_FPCLASSIFY:
14364 case BUILT_IN_ISFINITE:
14365 case BUILT_IN_ISINF_SIGN:
14366 case BUILT_IN_ISINF:
14367 case BUILT_IN_ISINFF:
14368 case BUILT_IN_ISINFL:
14369 case BUILT_IN_ISINFD32:
14370 case BUILT_IN_ISINFD64:
14371 case BUILT_IN_ISINFD128:
14372 case BUILT_IN_ISNAN:
14373 case BUILT_IN_ISNANF:
14374 case BUILT_IN_ISNANL:
14375 case BUILT_IN_ISNAND32:
14376 case BUILT_IN_ISNAND64:
14377 case BUILT_IN_ISNAND128:
14378 case BUILT_IN_ISNORMAL:
14379 case BUILT_IN_ISGREATER:
14380 case BUILT_IN_ISGREATEREQUAL:
14381 case BUILT_IN_ISLESS:
14382 case BUILT_IN_ISLESSEQUAL:
14383 case BUILT_IN_ISLESSGREATER:
14384 case BUILT_IN_ISUNORDERED:
14385 case BUILT_IN_VA_ARG_PACK:
14386 case BUILT_IN_VA_ARG_PACK_LEN:
14387 case BUILT_IN_VA_COPY:
14388 case BUILT_IN_TRAP:
14389 case BUILT_IN_SAVEREGS:
14390 case BUILT_IN_POPCOUNTL:
14391 case BUILT_IN_POPCOUNTLL:
14392 case BUILT_IN_POPCOUNTIMAX:
14393 case BUILT_IN_POPCOUNT:
14394 case BUILT_IN_PARITYL:
14395 case BUILT_IN_PARITYLL:
14396 case BUILT_IN_PARITYIMAX:
14397 case BUILT_IN_PARITY:
14398 case BUILT_IN_LABS:
14399 case BUILT_IN_LLABS:
14400 case BUILT_IN_PREFETCH:
14404 return is_simple_builtin (decl);