1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
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 tree built_in_decls[(int) END_BUILTINS];
79 /* Declarations used when constructing the builtin implicitly in the compiler.
80 It may be NULL_TREE when this is invalid (for instance runtime is not
81 required to implement the function call in all cases). */
82 tree implicit_built_in_decls[(int) END_BUILTINS];
84 static const char *c_getstr (tree);
85 static rtx c_readstr (const char *, enum machine_mode);
86 static int target_char_cast (tree, char *);
87 static rtx get_memory_rtx (tree, tree);
88 static int apply_args_size (void);
89 static int apply_result_size (void);
90 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
91 static rtx result_vector (int, rtx);
93 static void expand_builtin_update_setjmp_buf (rtx);
94 static void expand_builtin_prefetch (tree);
95 static rtx expand_builtin_apply_args (void);
96 static rtx expand_builtin_apply_args_1 (void);
97 static rtx expand_builtin_apply (rtx, rtx, rtx);
98 static void expand_builtin_return (rtx);
99 static enum type_class type_to_class (tree);
100 static rtx expand_builtin_classify_type (tree);
101 static void expand_errno_check (tree, rtx);
102 static rtx expand_builtin_mathfn (tree, rtx, rtx);
103 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
104 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
105 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
106 static rtx expand_builtin_interclass_mathfn (tree, rtx);
107 static rtx expand_builtin_sincos (tree);
108 static rtx expand_builtin_cexpi (tree, rtx);
109 static rtx expand_builtin_int_roundingfn (tree, rtx);
110 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
111 static rtx expand_builtin_next_arg (void);
112 static rtx expand_builtin_va_start (tree);
113 static rtx expand_builtin_va_end (tree);
114 static rtx expand_builtin_va_copy (tree);
115 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
116 static rtx expand_builtin_strcmp (tree, rtx);
117 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
118 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
119 static rtx expand_builtin_memcpy (tree, rtx);
120 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
121 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
122 enum machine_mode, int);
123 static rtx expand_builtin_strcpy (tree, rtx);
124 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
125 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
126 static rtx expand_builtin_strncpy (tree, rtx);
127 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
128 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
129 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
130 static rtx expand_builtin_bzero (tree);
131 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
132 static rtx expand_builtin_alloca (tree, bool);
133 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
134 static rtx expand_builtin_frame_address (tree, tree);
135 static tree stabilize_va_list_loc (location_t, tree, int);
136 static rtx expand_builtin_expect (tree, rtx);
137 static tree fold_builtin_constant_p (tree);
138 static tree fold_builtin_expect (location_t, tree, tree);
139 static tree fold_builtin_classify_type (tree);
140 static tree fold_builtin_strlen (location_t, tree, tree);
141 static tree fold_builtin_inf (location_t, tree, int);
142 static tree fold_builtin_nan (tree, tree, int);
143 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
144 static bool validate_arg (const_tree, enum tree_code code);
145 static bool integer_valued_real_p (tree);
146 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
147 static bool readonly_data_expr (tree);
148 static rtx expand_builtin_fabs (tree, rtx, rtx);
149 static rtx expand_builtin_signbit (tree, rtx);
150 static tree fold_builtin_sqrt (location_t, tree, tree);
151 static tree fold_builtin_cbrt (location_t, tree, tree);
152 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
153 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
154 static tree fold_builtin_cos (location_t, tree, tree, tree);
155 static tree fold_builtin_cosh (location_t, tree, tree, tree);
156 static tree fold_builtin_tan (tree, tree);
157 static tree fold_builtin_trunc (location_t, tree, tree);
158 static tree fold_builtin_floor (location_t, tree, tree);
159 static tree fold_builtin_ceil (location_t, tree, tree);
160 static tree fold_builtin_round (location_t, tree, tree);
161 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
162 static tree fold_builtin_bitop (tree, tree);
163 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
164 static tree fold_builtin_strchr (location_t, tree, tree, tree);
165 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
166 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
167 static tree fold_builtin_strcmp (location_t, tree, tree);
168 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
169 static tree fold_builtin_signbit (location_t, tree, tree);
170 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
171 static tree fold_builtin_isascii (location_t, tree);
172 static tree fold_builtin_toascii (location_t, tree);
173 static tree fold_builtin_isdigit (location_t, tree);
174 static tree fold_builtin_fabs (location_t, tree, tree);
175 static tree fold_builtin_abs (location_t, tree, tree);
176 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
178 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
179 static tree fold_builtin_0 (location_t, tree, bool);
180 static tree fold_builtin_1 (location_t, tree, tree, bool);
181 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
182 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
183 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
184 static tree fold_builtin_varargs (location_t, tree, tree, bool);
186 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
187 static tree fold_builtin_strstr (location_t, tree, tree, tree);
188 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
189 static tree fold_builtin_strcat (location_t, tree, tree);
190 static tree fold_builtin_strncat (location_t, tree, tree, tree);
191 static tree fold_builtin_strspn (location_t, tree, tree);
192 static tree fold_builtin_strcspn (location_t, tree, tree);
193 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
194 static tree fold_builtin_snprintf (location_t, tree, tree, tree, tree, int);
196 static rtx expand_builtin_object_size (tree);
197 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
198 enum built_in_function);
199 static void maybe_emit_chk_warning (tree, enum built_in_function);
200 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
201 static void maybe_emit_free_warning (tree);
202 static tree fold_builtin_object_size (tree, tree);
203 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
204 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
205 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
206 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
207 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
208 enum built_in_function);
209 static bool init_target_chars (void);
211 static unsigned HOST_WIDE_INT target_newline;
212 static unsigned HOST_WIDE_INT target_percent;
213 static unsigned HOST_WIDE_INT target_c;
214 static unsigned HOST_WIDE_INT target_s;
215 static char target_percent_c[3];
216 static char target_percent_s[3];
217 static char target_percent_s_newline[4];
218 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
219 const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
220 static tree do_mpfr_arg2 (tree, tree, tree,
221 int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
222 static tree do_mpfr_arg3 (tree, tree, tree, tree,
223 int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
224 static tree do_mpfr_sincos (tree, tree, tree);
225 static tree do_mpfr_bessel_n (tree, tree, tree,
226 int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
227 const REAL_VALUE_TYPE *, bool);
228 static tree do_mpfr_remquo (tree, tree, tree);
229 static tree do_mpfr_lgamma_r (tree, tree, tree);
231 /* Return true if NAME starts with __builtin_ or __sync_. */
234 is_builtin_name (const char *name)
236 if (strncmp (name, "__builtin_", 10) == 0)
238 if (strncmp (name, "__sync_", 7) == 0)
244 /* Return true if DECL is a function symbol representing a built-in. */
247 is_builtin_fn (tree decl)
249 return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
253 /* Return true if NODE should be considered for inline expansion regardless
254 of the optimization level. This means whenever a function is invoked with
255 its "internal" name, which normally contains the prefix "__builtin". */
258 called_as_built_in (tree node)
260 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
261 we want the name used to call the function, not the name it
263 const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
264 return is_builtin_name (name);
267 /* Return the alignment in bits of EXP, an object.
268 Don't return more than MAX_ALIGN no matter what. */
271 get_object_alignment (tree exp, unsigned int max_align)
273 HOST_WIDE_INT bitsize, bitpos;
275 enum machine_mode mode;
276 int unsignedp, volatilep;
277 unsigned int align, inner;
279 /* Get the innermost object and the constant (bitpos) and possibly
280 variable (offset) offset of the access. */
281 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
282 &mode, &unsignedp, &volatilep, true);
284 /* Extract alignment information from the innermost object and
285 possibly adjust bitpos and offset. */
286 if (TREE_CODE (exp) == CONST_DECL)
287 exp = DECL_INITIAL (exp);
289 && TREE_CODE (exp) != LABEL_DECL)
290 align = DECL_ALIGN (exp);
291 else if (CONSTANT_CLASS_P (exp))
293 align = TYPE_ALIGN (TREE_TYPE (exp));
294 #ifdef CONSTANT_ALIGNMENT
295 align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
298 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
299 align = TYPE_ALIGN (TREE_TYPE (exp));
300 else if (TREE_CODE (exp) == INDIRECT_REF)
301 align = TYPE_ALIGN (TREE_TYPE (exp));
302 else if (TREE_CODE (exp) == MEM_REF)
304 tree addr = TREE_OPERAND (exp, 0);
305 struct ptr_info_def *pi;
306 if (TREE_CODE (addr) == BIT_AND_EXPR
307 && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
309 align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
310 & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
311 align *= BITS_PER_UNIT;
312 addr = TREE_OPERAND (addr, 0);
315 align = BITS_PER_UNIT;
316 if (TREE_CODE (addr) == SSA_NAME
317 && (pi = SSA_NAME_PTR_INFO (addr)))
319 bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
320 align = MAX (pi->align * BITS_PER_UNIT, align);
322 else if (TREE_CODE (addr) == ADDR_EXPR)
323 align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
325 bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
327 else if (TREE_CODE (exp) == TARGET_MEM_REF)
329 struct ptr_info_def *pi;
330 tree addr = TMR_BASE (exp);
331 if (TREE_CODE (addr) == BIT_AND_EXPR
332 && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
334 align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
335 & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
336 align *= BITS_PER_UNIT;
337 addr = TREE_OPERAND (addr, 0);
340 align = BITS_PER_UNIT;
341 if (TREE_CODE (addr) == SSA_NAME
342 && (pi = SSA_NAME_PTR_INFO (addr)))
344 bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
345 align = MAX (pi->align * BITS_PER_UNIT, align);
347 else if (TREE_CODE (addr) == ADDR_EXPR)
348 align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
350 if (TMR_OFFSET (exp))
351 bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
352 if (TMR_INDEX (exp) && TMR_STEP (exp))
354 unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
355 align = MIN (align, (step & -step) * BITS_PER_UNIT);
357 else if (TMR_INDEX (exp))
358 align = BITS_PER_UNIT;
359 if (TMR_INDEX2 (exp))
360 align = BITS_PER_UNIT;
363 align = BITS_PER_UNIT;
365 /* If there is a non-constant offset part extract the maximum
366 alignment that can prevail. */
372 if (TREE_CODE (offset) == PLUS_EXPR)
374 next_offset = TREE_OPERAND (offset, 0);
375 offset = TREE_OPERAND (offset, 1);
379 if (host_integerp (offset, 1))
381 /* Any overflow in calculating offset_bits won't change
384 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
387 inner = MIN (inner, (offset_bits & -offset_bits));
389 else if (TREE_CODE (offset) == MULT_EXPR
390 && host_integerp (TREE_OPERAND (offset, 1), 1))
392 /* Any overflow in calculating offset_factor won't change
394 unsigned offset_factor
395 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
399 inner = MIN (inner, (offset_factor & -offset_factor));
403 inner = MIN (inner, BITS_PER_UNIT);
406 offset = next_offset;
409 /* Alignment is innermost object alignment adjusted by the constant
410 and non-constant offset parts. */
411 align = MIN (align, inner);
412 bitpos = bitpos & (align - 1);
414 /* align and bitpos now specify known low bits of the pointer.
415 ptr & (align - 1) == bitpos. */
418 align = (bitpos & -bitpos);
420 return MIN (align, max_align);
423 /* Returns true iff we can trust that alignment information has been
424 calculated properly. */
427 can_trust_pointer_alignment (void)
429 /* We rely on TER to compute accurate alignment information. */
430 return (optimize && flag_tree_ter);
433 /* Return the alignment in bits of EXP, a pointer valued expression.
434 But don't return more than MAX_ALIGN no matter what.
435 The alignment returned is, by default, the alignment of the thing that
436 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
438 Otherwise, look at the expression to see if we can do better, i.e., if the
439 expression is actually pointing at an object whose alignment is tighter. */
442 get_pointer_alignment (tree exp, unsigned int max_align)
446 if (TREE_CODE (exp) == ADDR_EXPR)
447 return get_object_alignment (TREE_OPERAND (exp, 0), max_align);
448 else if (TREE_CODE (exp) == SSA_NAME
449 && POINTER_TYPE_P (TREE_TYPE (exp)))
451 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
454 return BITS_PER_UNIT;
455 if (pi->misalign != 0)
456 align = (pi->misalign & -pi->misalign);
459 return MIN (max_align, align * BITS_PER_UNIT);
462 return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
465 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
466 way, because it could contain a zero byte in the middle.
467 TREE_STRING_LENGTH is the size of the character array, not the string.
469 ONLY_VALUE should be nonzero if the result is not going to be emitted
470 into the instruction stream and zero if it is going to be expanded.
471 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
472 is returned, otherwise NULL, since
473 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
474 evaluate the side-effects.
476 The value returned is of type `ssizetype'.
478 Unfortunately, string_constant can't access the values of const char
479 arrays with initializers, so neither can we do so here. */
482 c_strlen (tree src, int only_value)
485 HOST_WIDE_INT offset;
491 if (TREE_CODE (src) == COND_EXPR
492 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
496 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
497 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
498 if (tree_int_cst_equal (len1, len2))
502 if (TREE_CODE (src) == COMPOUND_EXPR
503 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
504 return c_strlen (TREE_OPERAND (src, 1), only_value);
506 loc = EXPR_LOC_OR_HERE (src);
508 src = string_constant (src, &offset_node);
512 max = TREE_STRING_LENGTH (src) - 1;
513 ptr = TREE_STRING_POINTER (src);
515 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
517 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
518 compute the offset to the following null if we don't know where to
519 start searching for it. */
522 for (i = 0; i < max; i++)
526 /* We don't know the starting offset, but we do know that the string
527 has no internal zero bytes. We can assume that the offset falls
528 within the bounds of the string; otherwise, the programmer deserves
529 what he gets. Subtract the offset from the length of the string,
530 and return that. This would perhaps not be valid if we were dealing
531 with named arrays in addition to literal string constants. */
533 return size_diffop_loc (loc, size_int (max), offset_node);
536 /* We have a known offset into the string. Start searching there for
537 a null character if we can represent it as a single HOST_WIDE_INT. */
538 if (offset_node == 0)
540 else if (! host_integerp (offset_node, 0))
543 offset = tree_low_cst (offset_node, 0);
545 /* If the offset is known to be out of bounds, warn, and call strlen at
547 if (offset < 0 || offset > max)
549 /* Suppress multiple warnings for propagated constant strings. */
550 if (! TREE_NO_WARNING (src))
552 warning_at (loc, 0, "offset outside bounds of constant string");
553 TREE_NO_WARNING (src) = 1;
558 /* Use strlen to search for the first zero byte. Since any strings
559 constructed with build_string will have nulls appended, we win even
560 if we get handed something like (char[4])"abcd".
562 Since OFFSET is our starting index into the string, no further
563 calculation is needed. */
564 return ssize_int (strlen (ptr + offset));
567 /* Return a char pointer for a C string if it is a string constant
568 or sum of string constant and integer constant. */
575 src = string_constant (src, &offset_node);
579 if (offset_node == 0)
580 return TREE_STRING_POINTER (src);
581 else if (!host_integerp (offset_node, 1)
582 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
585 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
588 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
589 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
592 c_readstr (const char *str, enum machine_mode mode)
598 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
603 for (i = 0; i < GET_MODE_SIZE (mode); i++)
606 if (WORDS_BIG_ENDIAN)
607 j = GET_MODE_SIZE (mode) - i - 1;
608 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
609 && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
610 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
612 gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
615 ch = (unsigned char) str[i];
616 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
618 return immed_double_const (c[0], c[1], mode);
621 /* Cast a target constant CST to target CHAR and if that value fits into
622 host char type, return zero and put that value into variable pointed to by
626 target_char_cast (tree cst, char *p)
628 unsigned HOST_WIDE_INT val, hostval;
630 if (TREE_CODE (cst) != INTEGER_CST
631 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
634 val = TREE_INT_CST_LOW (cst);
635 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
636 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
639 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
640 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
649 /* Similar to save_expr, but assumes that arbitrary code is not executed
650 in between the multiple evaluations. In particular, we assume that a
651 non-addressable local variable will not be modified. */
654 builtin_save_expr (tree exp)
656 if (TREE_CODE (exp) == SSA_NAME
657 || (TREE_ADDRESSABLE (exp) == 0
658 && (TREE_CODE (exp) == PARM_DECL
659 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
662 return save_expr (exp);
665 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
666 times to get the address of either a higher stack frame, or a return
667 address located within it (depending on FNDECL_CODE). */
670 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
674 #ifdef INITIAL_FRAME_ADDRESS_RTX
675 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
679 /* For a zero count with __builtin_return_address, we don't care what
680 frame address we return, because target-specific definitions will
681 override us. Therefore frame pointer elimination is OK, and using
682 the soft frame pointer is OK.
684 For a nonzero count, or a zero count with __builtin_frame_address,
685 we require a stable offset from the current frame pointer to the
686 previous one, so we must use the hard frame pointer, and
687 we must disable frame pointer elimination. */
688 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
689 tem = frame_pointer_rtx;
692 tem = hard_frame_pointer_rtx;
694 /* Tell reload not to eliminate the frame pointer. */
695 crtl->accesses_prior_frames = 1;
699 /* Some machines need special handling before we can access
700 arbitrary frames. For example, on the SPARC, we must first flush
701 all register windows to the stack. */
702 #ifdef SETUP_FRAME_ADDRESSES
704 SETUP_FRAME_ADDRESSES ();
707 /* On the SPARC, the return address is not in the frame, it is in a
708 register. There is no way to access it off of the current frame
709 pointer, but it can be accessed off the previous frame pointer by
710 reading the value from the register window save area. */
711 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
712 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
716 /* Scan back COUNT frames to the specified frame. */
717 for (i = 0; i < count; i++)
719 /* Assume the dynamic chain pointer is in the word that the
720 frame address points to, unless otherwise specified. */
721 #ifdef DYNAMIC_CHAIN_ADDRESS
722 tem = DYNAMIC_CHAIN_ADDRESS (tem);
724 tem = memory_address (Pmode, tem);
725 tem = gen_frame_mem (Pmode, tem);
726 tem = copy_to_reg (tem);
729 /* For __builtin_frame_address, return what we've got. But, on
730 the SPARC for example, we may have to add a bias. */
731 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
732 #ifdef FRAME_ADDR_RTX
733 return FRAME_ADDR_RTX (tem);
738 /* For __builtin_return_address, get the return address from that frame. */
739 #ifdef RETURN_ADDR_RTX
740 tem = RETURN_ADDR_RTX (count, tem);
742 tem = memory_address (Pmode,
743 plus_constant (tem, GET_MODE_SIZE (Pmode)));
744 tem = gen_frame_mem (Pmode, tem);
749 /* Alias set used for setjmp buffer. */
750 static alias_set_type setjmp_alias_set = -1;
752 /* Construct the leading half of a __builtin_setjmp call. Control will
753 return to RECEIVER_LABEL. This is also called directly by the SJLJ
754 exception handling code. */
757 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
759 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
763 if (setjmp_alias_set == -1)
764 setjmp_alias_set = new_alias_set ();
766 buf_addr = convert_memory_address (Pmode, buf_addr);
768 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
770 /* We store the frame pointer and the address of receiver_label in
771 the buffer and use the rest of it for the stack save area, which
772 is machine-dependent. */
774 mem = gen_rtx_MEM (Pmode, buf_addr);
775 set_mem_alias_set (mem, setjmp_alias_set);
776 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
778 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
779 set_mem_alias_set (mem, setjmp_alias_set);
781 emit_move_insn (validize_mem (mem),
782 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
784 stack_save = gen_rtx_MEM (sa_mode,
785 plus_constant (buf_addr,
786 2 * GET_MODE_SIZE (Pmode)));
787 set_mem_alias_set (stack_save, setjmp_alias_set);
788 emit_stack_save (SAVE_NONLOCAL, &stack_save);
790 /* If there is further processing to do, do it. */
791 #ifdef HAVE_builtin_setjmp_setup
792 if (HAVE_builtin_setjmp_setup)
793 emit_insn (gen_builtin_setjmp_setup (buf_addr));
796 /* Tell optimize_save_area_alloca that extra work is going to
797 need to go on during alloca. */
798 cfun->calls_setjmp = 1;
800 /* We have a nonlocal label. */
801 cfun->has_nonlocal_label = 1;
804 /* Construct the trailing part of a __builtin_setjmp call. This is
805 also called directly by the SJLJ exception handling code. */
808 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
812 /* Clobber the FP when we get here, so we have to make sure it's
813 marked as used by this function. */
814 emit_use (hard_frame_pointer_rtx);
816 /* Mark the static chain as clobbered here so life information
817 doesn't get messed up for it. */
818 chain = targetm.calls.static_chain (current_function_decl, true);
819 if (chain && REG_P (chain))
820 emit_clobber (chain);
822 /* Now put in the code to restore the frame pointer, and argument
823 pointer, if needed. */
824 #ifdef HAVE_nonlocal_goto
825 if (! HAVE_nonlocal_goto)
828 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
829 /* This might change the hard frame pointer in ways that aren't
830 apparent to early optimization passes, so force a clobber. */
831 emit_clobber (hard_frame_pointer_rtx);
834 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
835 if (fixed_regs[ARG_POINTER_REGNUM])
837 #ifdef ELIMINABLE_REGS
839 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
841 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
842 if (elim_regs[i].from == ARG_POINTER_REGNUM
843 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
846 if (i == ARRAY_SIZE (elim_regs))
849 /* Now restore our arg pointer from the address at which it
850 was saved in our stack frame. */
851 emit_move_insn (crtl->args.internal_arg_pointer,
852 copy_to_reg (get_arg_pointer_save_area ()));
857 #ifdef HAVE_builtin_setjmp_receiver
858 if (HAVE_builtin_setjmp_receiver)
859 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
862 #ifdef HAVE_nonlocal_goto_receiver
863 if (HAVE_nonlocal_goto_receiver)
864 emit_insn (gen_nonlocal_goto_receiver ());
869 /* We must not allow the code we just generated to be reordered by
870 scheduling. Specifically, the update of the frame pointer must
871 happen immediately, not later. */
872 emit_insn (gen_blockage ());
875 /* __builtin_longjmp is passed a pointer to an array of five words (not
876 all will be used on all machines). It operates similarly to the C
877 library function of the same name, but is more efficient. Much of
878 the code below is copied from the handling of non-local gotos. */
881 expand_builtin_longjmp (rtx buf_addr, rtx value)
883 rtx fp, lab, stack, insn, last;
884 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
886 /* DRAP is needed for stack realign if longjmp is expanded to current
888 if (SUPPORTS_STACK_ALIGNMENT)
889 crtl->need_drap = true;
891 if (setjmp_alias_set == -1)
892 setjmp_alias_set = new_alias_set ();
894 buf_addr = convert_memory_address (Pmode, buf_addr);
896 buf_addr = force_reg (Pmode, buf_addr);
898 /* We require that the user must pass a second argument of 1, because
899 that is what builtin_setjmp will return. */
900 gcc_assert (value == const1_rtx);
902 last = get_last_insn ();
903 #ifdef HAVE_builtin_longjmp
904 if (HAVE_builtin_longjmp)
905 emit_insn (gen_builtin_longjmp (buf_addr));
909 fp = gen_rtx_MEM (Pmode, buf_addr);
910 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
911 GET_MODE_SIZE (Pmode)));
913 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
914 2 * GET_MODE_SIZE (Pmode)));
915 set_mem_alias_set (fp, setjmp_alias_set);
916 set_mem_alias_set (lab, setjmp_alias_set);
917 set_mem_alias_set (stack, setjmp_alias_set);
919 /* Pick up FP, label, and SP from the block and jump. This code is
920 from expand_goto in stmt.c; see there for detailed comments. */
921 #ifdef HAVE_nonlocal_goto
922 if (HAVE_nonlocal_goto)
923 /* We have to pass a value to the nonlocal_goto pattern that will
924 get copied into the static_chain pointer, but it does not matter
925 what that value is, because builtin_setjmp does not use it. */
926 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
930 lab = copy_to_reg (lab);
932 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
933 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
935 emit_move_insn (hard_frame_pointer_rtx, fp);
936 emit_stack_restore (SAVE_NONLOCAL, stack);
938 emit_use (hard_frame_pointer_rtx);
939 emit_use (stack_pointer_rtx);
940 emit_indirect_jump (lab);
944 /* Search backwards and mark the jump insn as a non-local goto.
945 Note that this precludes the use of __builtin_longjmp to a
946 __builtin_setjmp target in the same function. However, we've
947 already cautioned the user that these functions are for
948 internal exception handling use only. */
949 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
951 gcc_assert (insn != last);
955 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
958 else if (CALL_P (insn))
963 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
964 and the address of the save area. */
967 expand_builtin_nonlocal_goto (tree exp)
969 tree t_label, t_save_area;
970 rtx r_label, r_save_area, r_fp, r_sp, insn;
972 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
975 t_label = CALL_EXPR_ARG (exp, 0);
976 t_save_area = CALL_EXPR_ARG (exp, 1);
978 r_label = expand_normal (t_label);
979 r_label = convert_memory_address (Pmode, r_label);
980 r_save_area = expand_normal (t_save_area);
981 r_save_area = convert_memory_address (Pmode, r_save_area);
982 /* Copy the address of the save location to a register just in case it was based
983 on the frame pointer. */
984 r_save_area = copy_to_reg (r_save_area);
985 r_fp = gen_rtx_MEM (Pmode, r_save_area);
986 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
987 plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
989 crtl->has_nonlocal_goto = 1;
991 #ifdef HAVE_nonlocal_goto
992 /* ??? We no longer need to pass the static chain value, afaik. */
993 if (HAVE_nonlocal_goto)
994 emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
998 r_label = copy_to_reg (r_label);
1000 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1001 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1003 /* Restore frame pointer for containing function.
1004 This sets the actual hard register used for the frame pointer
1005 to the location of the function's incoming static chain info.
1006 The non-local goto handler will then adjust it to contain the
1007 proper value and reload the argument pointer, if needed. */
1008 emit_move_insn (hard_frame_pointer_rtx, r_fp);
1009 emit_stack_restore (SAVE_NONLOCAL, r_sp);
1011 /* USE of hard_frame_pointer_rtx added for consistency;
1012 not clear if really needed. */
1013 emit_use (hard_frame_pointer_rtx);
1014 emit_use (stack_pointer_rtx);
1016 /* If the architecture is using a GP register, we must
1017 conservatively assume that the target function makes use of it.
1018 The prologue of functions with nonlocal gotos must therefore
1019 initialize the GP register to the appropriate value, and we
1020 must then make sure that this value is live at the point
1021 of the jump. (Note that this doesn't necessarily apply
1022 to targets with a nonlocal_goto pattern; they are free
1023 to implement it in their own way. Note also that this is
1024 a no-op if the GP register is a global invariant.) */
1025 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1026 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1027 emit_use (pic_offset_table_rtx);
1029 emit_indirect_jump (r_label);
1032 /* Search backwards to the jump insn and mark it as a
1034 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1038 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1041 else if (CALL_P (insn))
1048 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1049 (not all will be used on all machines) that was passed to __builtin_setjmp.
1050 It updates the stack pointer in that block to correspond to the current
1054 expand_builtin_update_setjmp_buf (rtx buf_addr)
1056 enum machine_mode sa_mode = Pmode;
1060 #ifdef HAVE_save_stack_nonlocal
1061 if (HAVE_save_stack_nonlocal)
1062 sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1064 #ifdef STACK_SAVEAREA_MODE
1065 sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1069 = gen_rtx_MEM (sa_mode,
1072 plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1076 emit_insn (gen_setjmp ());
1079 emit_stack_save (SAVE_NONLOCAL, &stack_save);
1082 /* Expand a call to __builtin_prefetch. For a target that does not support
1083 data prefetch, evaluate the memory address argument in case it has side
1087 expand_builtin_prefetch (tree exp)
1089 tree arg0, arg1, arg2;
1093 if (!validate_arglist (exp, POINTER_TYPE, 0))
1096 arg0 = CALL_EXPR_ARG (exp, 0);
1098 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1099 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1101 nargs = call_expr_nargs (exp);
1103 arg1 = CALL_EXPR_ARG (exp, 1);
1105 arg1 = integer_zero_node;
1107 arg2 = CALL_EXPR_ARG (exp, 2);
1109 arg2 = integer_three_node;
1111 /* Argument 0 is an address. */
1112 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1114 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1115 if (TREE_CODE (arg1) != INTEGER_CST)
1117 error ("second argument to %<__builtin_prefetch%> must be a constant");
1118 arg1 = integer_zero_node;
1120 op1 = expand_normal (arg1);
1121 /* Argument 1 must be either zero or one. */
1122 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1124 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1129 /* Argument 2 (locality) must be a compile-time constant int. */
1130 if (TREE_CODE (arg2) != INTEGER_CST)
1132 error ("third argument to %<__builtin_prefetch%> must be a constant");
1133 arg2 = integer_zero_node;
1135 op2 = expand_normal (arg2);
1136 /* Argument 2 must be 0, 1, 2, or 3. */
1137 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1139 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1143 #ifdef HAVE_prefetch
1146 struct expand_operand ops[3];
1148 create_address_operand (&ops[0], op0);
1149 create_integer_operand (&ops[1], INTVAL (op1));
1150 create_integer_operand (&ops[2], INTVAL (op2));
1151 if (maybe_expand_insn (CODE_FOR_prefetch, 3, ops))
1156 /* Don't do anything with direct references to volatile memory, but
1157 generate code to handle other side effects. */
1158 if (!MEM_P (op0) && side_effects_p (op0))
1162 /* Get a MEM rtx for expression EXP which is the address of an operand
1163 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1164 the maximum length of the block of memory that might be accessed or
1168 get_memory_rtx (tree exp, tree len)
1170 tree orig_exp = exp;
1174 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1175 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1176 if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1177 exp = TREE_OPERAND (exp, 0);
1179 addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1180 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1182 /* Get an expression we can use to find the attributes to assign to MEM.
1183 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1184 we can. First remove any nops. */
1185 while (CONVERT_EXPR_P (exp)
1186 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1187 exp = TREE_OPERAND (exp, 0);
1190 if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1191 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1192 && host_integerp (TREE_OPERAND (exp, 1), 0)
1193 && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1194 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1195 else if (TREE_CODE (exp) == ADDR_EXPR)
1196 exp = TREE_OPERAND (exp, 0);
1197 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1198 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1202 /* Honor attributes derived from exp, except for the alias set
1203 (as builtin stringops may alias with anything) and the size
1204 (as stringops may access multiple array elements). */
1207 set_mem_attributes (mem, exp, 0);
1210 mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1212 /* Allow the string and memory builtins to overflow from one
1213 field into another, see http://gcc.gnu.org/PR23561.
1214 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1215 memory accessed by the string or memory builtin will fit
1216 within the field. */
1217 if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1219 tree mem_expr = MEM_EXPR (mem);
1220 HOST_WIDE_INT offset = -1, length = -1;
1223 while (TREE_CODE (inner) == ARRAY_REF
1224 || CONVERT_EXPR_P (inner)
1225 || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1226 || TREE_CODE (inner) == SAVE_EXPR)
1227 inner = TREE_OPERAND (inner, 0);
1229 gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1231 if (MEM_OFFSET (mem)
1232 && CONST_INT_P (MEM_OFFSET (mem)))
1233 offset = INTVAL (MEM_OFFSET (mem));
1235 if (offset >= 0 && len && host_integerp (len, 0))
1236 length = tree_low_cst (len, 0);
1238 while (TREE_CODE (inner) == COMPONENT_REF)
1240 tree field = TREE_OPERAND (inner, 1);
1241 gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1242 gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1244 /* Bitfields are generally not byte-addressable. */
1245 gcc_assert (!DECL_BIT_FIELD (field)
1246 || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1247 % BITS_PER_UNIT) == 0
1248 && host_integerp (DECL_SIZE (field), 0)
1249 && (TREE_INT_CST_LOW (DECL_SIZE (field))
1250 % BITS_PER_UNIT) == 0));
1252 /* If we can prove that the memory starting at XEXP (mem, 0) and
1253 ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1254 can keep the COMPONENT_REF in MEM_EXPR. But be careful with
1255 fields without DECL_SIZE_UNIT like flexible array members. */
1257 && DECL_SIZE_UNIT (field)
1258 && host_integerp (DECL_SIZE_UNIT (field), 0))
1261 = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1264 && offset + length <= size)
1269 && host_integerp (DECL_FIELD_OFFSET (field), 0))
1270 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1271 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1279 mem_expr = TREE_OPERAND (mem_expr, 0);
1280 inner = TREE_OPERAND (inner, 0);
1283 if (mem_expr == NULL)
1285 if (mem_expr != MEM_EXPR (mem))
1287 set_mem_expr (mem, mem_expr);
1288 set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1291 set_mem_alias_set (mem, 0);
1292 set_mem_size (mem, NULL_RTX);
1298 /* Built-in functions to perform an untyped call and return. */
1300 #define apply_args_mode \
1301 (this_target_builtins->x_apply_args_mode)
1302 #define apply_result_mode \
1303 (this_target_builtins->x_apply_result_mode)
1305 /* Return the size required for the block returned by __builtin_apply_args,
1306 and initialize apply_args_mode. */
1309 apply_args_size (void)
1311 static int size = -1;
1314 enum machine_mode mode;
1316 /* The values computed by this function never change. */
1319 /* The first value is the incoming arg-pointer. */
1320 size = GET_MODE_SIZE (Pmode);
1322 /* The second value is the structure value address unless this is
1323 passed as an "invisible" first argument. */
1324 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1325 size += GET_MODE_SIZE (Pmode);
1327 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1328 if (FUNCTION_ARG_REGNO_P (regno))
1330 mode = targetm.calls.get_raw_arg_mode (regno);
1332 gcc_assert (mode != VOIDmode);
1334 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1335 if (size % align != 0)
1336 size = CEIL (size, align) * align;
1337 size += GET_MODE_SIZE (mode);
1338 apply_args_mode[regno] = mode;
1342 apply_args_mode[regno] = VOIDmode;
1348 /* Return the size required for the block returned by __builtin_apply,
1349 and initialize apply_result_mode. */
1352 apply_result_size (void)
1354 static int size = -1;
1356 enum machine_mode mode;
1358 /* The values computed by this function never change. */
1363 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1364 if (targetm.calls.function_value_regno_p (regno))
1366 mode = targetm.calls.get_raw_result_mode (regno);
1368 gcc_assert (mode != VOIDmode);
1370 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1371 if (size % align != 0)
1372 size = CEIL (size, align) * align;
1373 size += GET_MODE_SIZE (mode);
1374 apply_result_mode[regno] = mode;
1377 apply_result_mode[regno] = VOIDmode;
1379 /* Allow targets that use untyped_call and untyped_return to override
1380 the size so that machine-specific information can be stored here. */
1381 #ifdef APPLY_RESULT_SIZE
1382 size = APPLY_RESULT_SIZE;
1388 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1389 /* Create a vector describing the result block RESULT. If SAVEP is true,
1390 the result block is used to save the values; otherwise it is used to
1391 restore the values. */
1394 result_vector (int savep, rtx result)
1396 int regno, size, align, nelts;
1397 enum machine_mode mode;
1399 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1402 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1403 if ((mode = apply_result_mode[regno]) != VOIDmode)
1405 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1406 if (size % align != 0)
1407 size = CEIL (size, align) * align;
1408 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1409 mem = adjust_address (result, mode, size);
1410 savevec[nelts++] = (savep
1411 ? gen_rtx_SET (VOIDmode, mem, reg)
1412 : gen_rtx_SET (VOIDmode, reg, mem));
1413 size += GET_MODE_SIZE (mode);
1415 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1417 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1419 /* Save the state required to perform an untyped call with the same
1420 arguments as were passed to the current function. */
1423 expand_builtin_apply_args_1 (void)
1426 int size, align, regno;
1427 enum machine_mode mode;
1428 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1430 /* Create a block where the arg-pointer, structure value address,
1431 and argument registers can be saved. */
1432 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1434 /* Walk past the arg-pointer and structure value address. */
1435 size = GET_MODE_SIZE (Pmode);
1436 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1437 size += GET_MODE_SIZE (Pmode);
1439 /* Save each register used in calling a function to the block. */
1440 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1441 if ((mode = apply_args_mode[regno]) != VOIDmode)
1443 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1444 if (size % align != 0)
1445 size = CEIL (size, align) * align;
1447 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1449 emit_move_insn (adjust_address (registers, mode, size), tem);
1450 size += GET_MODE_SIZE (mode);
1453 /* Save the arg pointer to the block. */
1454 tem = copy_to_reg (crtl->args.internal_arg_pointer);
1455 #ifdef STACK_GROWS_DOWNWARD
1456 /* We need the pointer as the caller actually passed them to us, not
1457 as we might have pretended they were passed. Make sure it's a valid
1458 operand, as emit_move_insn isn't expected to handle a PLUS. */
1460 = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1463 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1465 size = GET_MODE_SIZE (Pmode);
1467 /* Save the structure value address unless this is passed as an
1468 "invisible" first argument. */
1469 if (struct_incoming_value)
1471 emit_move_insn (adjust_address (registers, Pmode, size),
1472 copy_to_reg (struct_incoming_value));
1473 size += GET_MODE_SIZE (Pmode);
1476 /* Return the address of the block. */
1477 return copy_addr_to_reg (XEXP (registers, 0));
1480 /* __builtin_apply_args returns block of memory allocated on
1481 the stack into which is stored the arg pointer, structure
1482 value address, static chain, and all the registers that might
1483 possibly be used in performing a function call. The code is
1484 moved to the start of the function so the incoming values are
1488 expand_builtin_apply_args (void)
1490 /* Don't do __builtin_apply_args more than once in a function.
1491 Save the result of the first call and reuse it. */
1492 if (apply_args_value != 0)
1493 return apply_args_value;
1495 /* When this function is called, it means that registers must be
1496 saved on entry to this function. So we migrate the
1497 call to the first insn of this function. */
1502 temp = expand_builtin_apply_args_1 ();
1506 apply_args_value = temp;
1508 /* Put the insns after the NOTE that starts the function.
1509 If this is inside a start_sequence, make the outer-level insn
1510 chain current, so the code is placed at the start of the
1511 function. If internal_arg_pointer is a non-virtual pseudo,
1512 it needs to be placed after the function that initializes
1514 push_topmost_sequence ();
1515 if (REG_P (crtl->args.internal_arg_pointer)
1516 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1517 emit_insn_before (seq, parm_birth_insn);
1519 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1520 pop_topmost_sequence ();
1525 /* Perform an untyped call and save the state required to perform an
1526 untyped return of whatever value was returned by the given function. */
1529 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1531 int size, align, regno;
1532 enum machine_mode mode;
1533 rtx incoming_args, result, reg, dest, src, call_insn;
1534 rtx old_stack_level = 0;
1535 rtx call_fusage = 0;
1536 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1538 arguments = convert_memory_address (Pmode, arguments);
1540 /* Create a block where the return registers can be saved. */
1541 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1543 /* Fetch the arg pointer from the ARGUMENTS block. */
1544 incoming_args = gen_reg_rtx (Pmode);
1545 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1546 #ifndef STACK_GROWS_DOWNWARD
1547 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1548 incoming_args, 0, OPTAB_LIB_WIDEN);
1551 /* Push a new argument block and copy the arguments. Do not allow
1552 the (potential) memcpy call below to interfere with our stack
1554 do_pending_stack_adjust ();
1557 /* Save the stack with nonlocal if available. */
1558 #ifdef HAVE_save_stack_nonlocal
1559 if (HAVE_save_stack_nonlocal)
1560 emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1563 emit_stack_save (SAVE_BLOCK, &old_stack_level);
1565 /* Allocate a block of memory onto the stack and copy the memory
1566 arguments to the outgoing arguments address. We can pass TRUE
1567 as the 4th argument because we just saved the stack pointer
1568 and will restore it right after the call. */
1569 allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1571 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1572 may have already set current_function_calls_alloca to true.
1573 current_function_calls_alloca won't be set if argsize is zero,
1574 so we have to guarantee need_drap is true here. */
1575 if (SUPPORTS_STACK_ALIGNMENT)
1576 crtl->need_drap = true;
1578 dest = virtual_outgoing_args_rtx;
1579 #ifndef STACK_GROWS_DOWNWARD
1580 if (CONST_INT_P (argsize))
1581 dest = plus_constant (dest, -INTVAL (argsize));
1583 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1585 dest = gen_rtx_MEM (BLKmode, dest);
1586 set_mem_align (dest, PARM_BOUNDARY);
1587 src = gen_rtx_MEM (BLKmode, incoming_args);
1588 set_mem_align (src, PARM_BOUNDARY);
1589 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1591 /* Refer to the argument block. */
1593 arguments = gen_rtx_MEM (BLKmode, arguments);
1594 set_mem_align (arguments, PARM_BOUNDARY);
1596 /* Walk past the arg-pointer and structure value address. */
1597 size = GET_MODE_SIZE (Pmode);
1599 size += GET_MODE_SIZE (Pmode);
1601 /* Restore each of the registers previously saved. Make USE insns
1602 for each of these registers for use in making the call. */
1603 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1604 if ((mode = apply_args_mode[regno]) != VOIDmode)
1606 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1607 if (size % align != 0)
1608 size = CEIL (size, align) * align;
1609 reg = gen_rtx_REG (mode, regno);
1610 emit_move_insn (reg, adjust_address (arguments, mode, size));
1611 use_reg (&call_fusage, reg);
1612 size += GET_MODE_SIZE (mode);
1615 /* Restore the structure value address unless this is passed as an
1616 "invisible" first argument. */
1617 size = GET_MODE_SIZE (Pmode);
1620 rtx value = gen_reg_rtx (Pmode);
1621 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1622 emit_move_insn (struct_value, value);
1623 if (REG_P (struct_value))
1624 use_reg (&call_fusage, struct_value);
1625 size += GET_MODE_SIZE (Pmode);
1628 /* All arguments and registers used for the call are set up by now! */
1629 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1631 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1632 and we don't want to load it into a register as an optimization,
1633 because prepare_call_address already did it if it should be done. */
1634 if (GET_CODE (function) != SYMBOL_REF)
1635 function = memory_address (FUNCTION_MODE, function);
1637 /* Generate the actual call instruction and save the return value. */
1638 #ifdef HAVE_untyped_call
1639 if (HAVE_untyped_call)
1640 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1641 result, result_vector (1, result)));
1644 #ifdef HAVE_call_value
1645 if (HAVE_call_value)
1649 /* Locate the unique return register. It is not possible to
1650 express a call that sets more than one return register using
1651 call_value; use untyped_call for that. In fact, untyped_call
1652 only needs to save the return registers in the given block. */
1653 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1654 if ((mode = apply_result_mode[regno]) != VOIDmode)
1656 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1658 valreg = gen_rtx_REG (mode, regno);
1661 emit_call_insn (GEN_CALL_VALUE (valreg,
1662 gen_rtx_MEM (FUNCTION_MODE, function),
1663 const0_rtx, NULL_RTX, const0_rtx));
1665 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1671 /* Find the CALL insn we just emitted, and attach the register usage
1673 call_insn = last_call_insn ();
1674 add_function_usage_to (call_insn, call_fusage);
1676 /* Restore the stack. */
1677 #ifdef HAVE_save_stack_nonlocal
1678 if (HAVE_save_stack_nonlocal)
1679 emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1682 emit_stack_restore (SAVE_BLOCK, old_stack_level);
1686 /* Return the address of the result block. */
1687 result = copy_addr_to_reg (XEXP (result, 0));
1688 return convert_memory_address (ptr_mode, result);
1691 /* Perform an untyped return. */
1694 expand_builtin_return (rtx result)
1696 int size, align, regno;
1697 enum machine_mode mode;
1699 rtx call_fusage = 0;
1701 result = convert_memory_address (Pmode, result);
1703 apply_result_size ();
1704 result = gen_rtx_MEM (BLKmode, result);
1706 #ifdef HAVE_untyped_return
1707 if (HAVE_untyped_return)
1709 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1715 /* Restore the return value and note that each value is used. */
1717 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1718 if ((mode = apply_result_mode[regno]) != VOIDmode)
1720 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1721 if (size % align != 0)
1722 size = CEIL (size, align) * align;
1723 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1724 emit_move_insn (reg, adjust_address (result, mode, size));
1726 push_to_sequence (call_fusage);
1728 call_fusage = get_insns ();
1730 size += GET_MODE_SIZE (mode);
1733 /* Put the USE insns before the return. */
1734 emit_insn (call_fusage);
1736 /* Return whatever values was restored by jumping directly to the end
1738 expand_naked_return ();
1741 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1743 static enum type_class
1744 type_to_class (tree type)
1746 switch (TREE_CODE (type))
1748 case VOID_TYPE: return void_type_class;
1749 case INTEGER_TYPE: return integer_type_class;
1750 case ENUMERAL_TYPE: return enumeral_type_class;
1751 case BOOLEAN_TYPE: return boolean_type_class;
1752 case POINTER_TYPE: return pointer_type_class;
1753 case REFERENCE_TYPE: return reference_type_class;
1754 case OFFSET_TYPE: return offset_type_class;
1755 case REAL_TYPE: return real_type_class;
1756 case COMPLEX_TYPE: return complex_type_class;
1757 case FUNCTION_TYPE: return function_type_class;
1758 case METHOD_TYPE: return method_type_class;
1759 case RECORD_TYPE: return record_type_class;
1761 case QUAL_UNION_TYPE: return union_type_class;
1762 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1763 ? string_type_class : array_type_class);
1764 case LANG_TYPE: return lang_type_class;
1765 default: return no_type_class;
1769 /* Expand a call EXP to __builtin_classify_type. */
1772 expand_builtin_classify_type (tree exp)
1774 if (call_expr_nargs (exp))
1775 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1776 return GEN_INT (no_type_class);
1779 /* This helper macro, meant to be used in mathfn_built_in below,
1780 determines which among a set of three builtin math functions is
1781 appropriate for a given type mode. The `F' and `L' cases are
1782 automatically generated from the `double' case. */
1783 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1784 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1785 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1786 fcodel = BUILT_IN_MATHFN##L ; break;
1787 /* Similar to above, but appends _R after any F/L suffix. */
1788 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1789 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1790 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1791 fcodel = BUILT_IN_MATHFN##L_R ; break;
1793 /* Return mathematic function equivalent to FN but operating directly
1794 on TYPE, if available. If IMPLICIT is true find the function in
1795 implicit_built_in_decls[], otherwise use built_in_decls[]. If we
1796 can't do the conversion, return zero. */
1799 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1801 tree const *const fn_arr
1802 = implicit ? implicit_built_in_decls : built_in_decls;
1803 enum built_in_function fcode, fcodef, fcodel;
1807 CASE_MATHFN (BUILT_IN_ACOS)
1808 CASE_MATHFN (BUILT_IN_ACOSH)
1809 CASE_MATHFN (BUILT_IN_ASIN)
1810 CASE_MATHFN (BUILT_IN_ASINH)
1811 CASE_MATHFN (BUILT_IN_ATAN)
1812 CASE_MATHFN (BUILT_IN_ATAN2)
1813 CASE_MATHFN (BUILT_IN_ATANH)
1814 CASE_MATHFN (BUILT_IN_CBRT)
1815 CASE_MATHFN (BUILT_IN_CEIL)
1816 CASE_MATHFN (BUILT_IN_CEXPI)
1817 CASE_MATHFN (BUILT_IN_COPYSIGN)
1818 CASE_MATHFN (BUILT_IN_COS)
1819 CASE_MATHFN (BUILT_IN_COSH)
1820 CASE_MATHFN (BUILT_IN_DREM)
1821 CASE_MATHFN (BUILT_IN_ERF)
1822 CASE_MATHFN (BUILT_IN_ERFC)
1823 CASE_MATHFN (BUILT_IN_EXP)
1824 CASE_MATHFN (BUILT_IN_EXP10)
1825 CASE_MATHFN (BUILT_IN_EXP2)
1826 CASE_MATHFN (BUILT_IN_EXPM1)
1827 CASE_MATHFN (BUILT_IN_FABS)
1828 CASE_MATHFN (BUILT_IN_FDIM)
1829 CASE_MATHFN (BUILT_IN_FLOOR)
1830 CASE_MATHFN (BUILT_IN_FMA)
1831 CASE_MATHFN (BUILT_IN_FMAX)
1832 CASE_MATHFN (BUILT_IN_FMIN)
1833 CASE_MATHFN (BUILT_IN_FMOD)
1834 CASE_MATHFN (BUILT_IN_FREXP)
1835 CASE_MATHFN (BUILT_IN_GAMMA)
1836 CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1837 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1838 CASE_MATHFN (BUILT_IN_HYPOT)
1839 CASE_MATHFN (BUILT_IN_ILOGB)
1840 CASE_MATHFN (BUILT_IN_INF)
1841 CASE_MATHFN (BUILT_IN_ISINF)
1842 CASE_MATHFN (BUILT_IN_J0)
1843 CASE_MATHFN (BUILT_IN_J1)
1844 CASE_MATHFN (BUILT_IN_JN)
1845 CASE_MATHFN (BUILT_IN_LCEIL)
1846 CASE_MATHFN (BUILT_IN_LDEXP)
1847 CASE_MATHFN (BUILT_IN_LFLOOR)
1848 CASE_MATHFN (BUILT_IN_LGAMMA)
1849 CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1850 CASE_MATHFN (BUILT_IN_LLCEIL)
1851 CASE_MATHFN (BUILT_IN_LLFLOOR)
1852 CASE_MATHFN (BUILT_IN_LLRINT)
1853 CASE_MATHFN (BUILT_IN_LLROUND)
1854 CASE_MATHFN (BUILT_IN_LOG)
1855 CASE_MATHFN (BUILT_IN_LOG10)
1856 CASE_MATHFN (BUILT_IN_LOG1P)
1857 CASE_MATHFN (BUILT_IN_LOG2)
1858 CASE_MATHFN (BUILT_IN_LOGB)
1859 CASE_MATHFN (BUILT_IN_LRINT)
1860 CASE_MATHFN (BUILT_IN_LROUND)
1861 CASE_MATHFN (BUILT_IN_MODF)
1862 CASE_MATHFN (BUILT_IN_NAN)
1863 CASE_MATHFN (BUILT_IN_NANS)
1864 CASE_MATHFN (BUILT_IN_NEARBYINT)
1865 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1866 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1867 CASE_MATHFN (BUILT_IN_POW)
1868 CASE_MATHFN (BUILT_IN_POWI)
1869 CASE_MATHFN (BUILT_IN_POW10)
1870 CASE_MATHFN (BUILT_IN_REMAINDER)
1871 CASE_MATHFN (BUILT_IN_REMQUO)
1872 CASE_MATHFN (BUILT_IN_RINT)
1873 CASE_MATHFN (BUILT_IN_ROUND)
1874 CASE_MATHFN (BUILT_IN_SCALB)
1875 CASE_MATHFN (BUILT_IN_SCALBLN)
1876 CASE_MATHFN (BUILT_IN_SCALBN)
1877 CASE_MATHFN (BUILT_IN_SIGNBIT)
1878 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1879 CASE_MATHFN (BUILT_IN_SIN)
1880 CASE_MATHFN (BUILT_IN_SINCOS)
1881 CASE_MATHFN (BUILT_IN_SINH)
1882 CASE_MATHFN (BUILT_IN_SQRT)
1883 CASE_MATHFN (BUILT_IN_TAN)
1884 CASE_MATHFN (BUILT_IN_TANH)
1885 CASE_MATHFN (BUILT_IN_TGAMMA)
1886 CASE_MATHFN (BUILT_IN_TRUNC)
1887 CASE_MATHFN (BUILT_IN_Y0)
1888 CASE_MATHFN (BUILT_IN_Y1)
1889 CASE_MATHFN (BUILT_IN_YN)
1895 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1896 return fn_arr[fcode];
1897 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1898 return fn_arr[fcodef];
1899 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1900 return fn_arr[fcodel];
1905 /* Like mathfn_built_in_1(), but always use the implicit array. */
1908 mathfn_built_in (tree type, enum built_in_function fn)
1910 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1913 /* If errno must be maintained, expand the RTL to check if the result,
1914 TARGET, of a built-in function call, EXP, is NaN, and if so set
1918 expand_errno_check (tree exp, rtx target)
1920 rtx lab = gen_label_rtx ();
1922 /* Test the result; if it is NaN, set errno=EDOM because
1923 the argument was not in the domain. */
1924 do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1925 NULL_RTX, NULL_RTX, lab,
1926 /* The jump is very likely. */
1927 REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1930 /* If this built-in doesn't throw an exception, set errno directly. */
1931 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1933 #ifdef GEN_ERRNO_RTX
1934 rtx errno_rtx = GEN_ERRNO_RTX;
1937 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1939 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1945 /* Make sure the library call isn't expanded as a tail call. */
1946 CALL_EXPR_TAILCALL (exp) = 0;
1948 /* We can't set errno=EDOM directly; let the library call do it.
1949 Pop the arguments right away in case the call gets deleted. */
1951 expand_call (exp, target, 0);
1956 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1957 Return NULL_RTX if a normal call should be emitted rather than expanding
1958 the function in-line. EXP is the expression that is a call to the builtin
1959 function; if convenient, the result should be placed in TARGET.
1960 SUBTARGET may be used as the target for computing one of EXP's operands. */
1963 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1965 optab builtin_optab;
1967 tree fndecl = get_callee_fndecl (exp);
1968 enum machine_mode mode;
1969 bool errno_set = false;
1972 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1975 arg = CALL_EXPR_ARG (exp, 0);
1977 switch (DECL_FUNCTION_CODE (fndecl))
1979 CASE_FLT_FN (BUILT_IN_SQRT):
1980 errno_set = ! tree_expr_nonnegative_p (arg);
1981 builtin_optab = sqrt_optab;
1983 CASE_FLT_FN (BUILT_IN_EXP):
1984 errno_set = true; builtin_optab = exp_optab; break;
1985 CASE_FLT_FN (BUILT_IN_EXP10):
1986 CASE_FLT_FN (BUILT_IN_POW10):
1987 errno_set = true; builtin_optab = exp10_optab; break;
1988 CASE_FLT_FN (BUILT_IN_EXP2):
1989 errno_set = true; builtin_optab = exp2_optab; break;
1990 CASE_FLT_FN (BUILT_IN_EXPM1):
1991 errno_set = true; builtin_optab = expm1_optab; break;
1992 CASE_FLT_FN (BUILT_IN_LOGB):
1993 errno_set = true; builtin_optab = logb_optab; break;
1994 CASE_FLT_FN (BUILT_IN_LOG):
1995 errno_set = true; builtin_optab = log_optab; break;
1996 CASE_FLT_FN (BUILT_IN_LOG10):
1997 errno_set = true; builtin_optab = log10_optab; break;
1998 CASE_FLT_FN (BUILT_IN_LOG2):
1999 errno_set = true; builtin_optab = log2_optab; break;
2000 CASE_FLT_FN (BUILT_IN_LOG1P):
2001 errno_set = true; builtin_optab = log1p_optab; break;
2002 CASE_FLT_FN (BUILT_IN_ASIN):
2003 builtin_optab = asin_optab; break;
2004 CASE_FLT_FN (BUILT_IN_ACOS):
2005 builtin_optab = acos_optab; break;
2006 CASE_FLT_FN (BUILT_IN_TAN):
2007 builtin_optab = tan_optab; break;
2008 CASE_FLT_FN (BUILT_IN_ATAN):
2009 builtin_optab = atan_optab; break;
2010 CASE_FLT_FN (BUILT_IN_FLOOR):
2011 builtin_optab = floor_optab; break;
2012 CASE_FLT_FN (BUILT_IN_CEIL):
2013 builtin_optab = ceil_optab; break;
2014 CASE_FLT_FN (BUILT_IN_TRUNC):
2015 builtin_optab = btrunc_optab; break;
2016 CASE_FLT_FN (BUILT_IN_ROUND):
2017 builtin_optab = round_optab; break;
2018 CASE_FLT_FN (BUILT_IN_NEARBYINT):
2019 builtin_optab = nearbyint_optab;
2020 if (flag_trapping_math)
2022 /* Else fallthrough and expand as rint. */
2023 CASE_FLT_FN (BUILT_IN_RINT):
2024 builtin_optab = rint_optab; break;
2025 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2026 builtin_optab = significand_optab; break;
2031 /* Make a suitable register to place result in. */
2032 mode = TYPE_MODE (TREE_TYPE (exp));
2034 if (! flag_errno_math || ! HONOR_NANS (mode))
2037 /* Before working hard, check whether the instruction is available. */
2038 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing
2039 && (!errno_set || !optimize_insn_for_size_p ()))
2041 target = gen_reg_rtx (mode);
2043 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2044 need to expand the argument again. This way, we will not perform
2045 side-effects more the once. */
2046 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2048 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2052 /* Compute into TARGET.
2053 Set TARGET to wherever the result comes back. */
2054 target = expand_unop (mode, builtin_optab, op0, target, 0);
2059 expand_errno_check (exp, target);
2061 /* Output the entire sequence. */
2062 insns = get_insns ();
2068 /* If we were unable to expand via the builtin, stop the sequence
2069 (without outputting the insns) and call to the library function
2070 with the stabilized argument list. */
2074 return expand_call (exp, target, target == const0_rtx);
2077 /* Expand a call to the builtin binary math functions (pow and atan2).
2078 Return NULL_RTX if a normal call should be emitted rather than expanding the
2079 function in-line. EXP is the expression that is a call to the builtin
2080 function; if convenient, the result should be placed in TARGET.
2081 SUBTARGET may be used as the target for computing one of EXP's
2085 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2087 optab builtin_optab;
2088 rtx op0, op1, insns;
2089 int op1_type = REAL_TYPE;
2090 tree fndecl = get_callee_fndecl (exp);
2092 enum machine_mode mode;
2093 bool errno_set = true;
2095 switch (DECL_FUNCTION_CODE (fndecl))
2097 CASE_FLT_FN (BUILT_IN_SCALBN):
2098 CASE_FLT_FN (BUILT_IN_SCALBLN):
2099 CASE_FLT_FN (BUILT_IN_LDEXP):
2100 op1_type = INTEGER_TYPE;
2105 if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2108 arg0 = CALL_EXPR_ARG (exp, 0);
2109 arg1 = CALL_EXPR_ARG (exp, 1);
2111 switch (DECL_FUNCTION_CODE (fndecl))
2113 CASE_FLT_FN (BUILT_IN_POW):
2114 builtin_optab = pow_optab; break;
2115 CASE_FLT_FN (BUILT_IN_ATAN2):
2116 builtin_optab = atan2_optab; break;
2117 CASE_FLT_FN (BUILT_IN_SCALB):
2118 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2120 builtin_optab = scalb_optab; break;
2121 CASE_FLT_FN (BUILT_IN_SCALBN):
2122 CASE_FLT_FN (BUILT_IN_SCALBLN):
2123 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2125 /* Fall through... */
2126 CASE_FLT_FN (BUILT_IN_LDEXP):
2127 builtin_optab = ldexp_optab; break;
2128 CASE_FLT_FN (BUILT_IN_FMOD):
2129 builtin_optab = fmod_optab; break;
2130 CASE_FLT_FN (BUILT_IN_REMAINDER):
2131 CASE_FLT_FN (BUILT_IN_DREM):
2132 builtin_optab = remainder_optab; break;
2137 /* Make a suitable register to place result in. */
2138 mode = TYPE_MODE (TREE_TYPE (exp));
2140 /* Before working hard, check whether the instruction is available. */
2141 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2144 target = gen_reg_rtx (mode);
2146 if (! flag_errno_math || ! HONOR_NANS (mode))
2149 if (errno_set && optimize_insn_for_size_p ())
2152 /* Always stabilize the argument list. */
2153 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2154 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2156 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2157 op1 = expand_normal (arg1);
2161 /* Compute into TARGET.
2162 Set TARGET to wherever the result comes back. */
2163 target = expand_binop (mode, builtin_optab, op0, op1,
2164 target, 0, OPTAB_DIRECT);
2166 /* If we were unable to expand via the builtin, stop the sequence
2167 (without outputting the insns) and call to the library function
2168 with the stabilized argument list. */
2172 return expand_call (exp, target, target == const0_rtx);
2176 expand_errno_check (exp, target);
2178 /* Output the entire sequence. */
2179 insns = get_insns ();
2186 /* Expand a call to the builtin trinary math functions (fma).
2187 Return NULL_RTX if a normal call should be emitted rather than expanding the
2188 function in-line. EXP is the expression that is a call to the builtin
2189 function; if convenient, the result should be placed in TARGET.
2190 SUBTARGET may be used as the target for computing one of EXP's
2194 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2196 optab builtin_optab;
2197 rtx op0, op1, op2, insns;
2198 tree fndecl = get_callee_fndecl (exp);
2199 tree arg0, arg1, arg2;
2200 enum machine_mode mode;
2202 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2205 arg0 = CALL_EXPR_ARG (exp, 0);
2206 arg1 = CALL_EXPR_ARG (exp, 1);
2207 arg2 = CALL_EXPR_ARG (exp, 2);
2209 switch (DECL_FUNCTION_CODE (fndecl))
2211 CASE_FLT_FN (BUILT_IN_FMA):
2212 builtin_optab = fma_optab; break;
2217 /* Make a suitable register to place result in. */
2218 mode = TYPE_MODE (TREE_TYPE (exp));
2220 /* Before working hard, check whether the instruction is available. */
2221 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2224 target = gen_reg_rtx (mode);
2226 /* Always stabilize the argument list. */
2227 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2228 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2229 CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2231 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2232 op1 = expand_normal (arg1);
2233 op2 = expand_normal (arg2);
2237 /* Compute into TARGET.
2238 Set TARGET to wherever the result comes back. */
2239 target = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2242 /* If we were unable to expand via the builtin, stop the sequence
2243 (without outputting the insns) and call to the library function
2244 with the stabilized argument list. */
2248 return expand_call (exp, target, target == const0_rtx);
2251 /* Output the entire sequence. */
2252 insns = get_insns ();
2259 /* Expand a call to the builtin sin and cos math functions.
2260 Return NULL_RTX if a normal call should be emitted rather than expanding the
2261 function in-line. EXP is the expression that is a call to the builtin
2262 function; if convenient, the result should be placed in TARGET.
2263 SUBTARGET may be used as the target for computing one of EXP's
2267 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2269 optab builtin_optab;
2271 tree fndecl = get_callee_fndecl (exp);
2272 enum machine_mode mode;
2275 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2278 arg = CALL_EXPR_ARG (exp, 0);
2280 switch (DECL_FUNCTION_CODE (fndecl))
2282 CASE_FLT_FN (BUILT_IN_SIN):
2283 CASE_FLT_FN (BUILT_IN_COS):
2284 builtin_optab = sincos_optab; break;
2289 /* Make a suitable register to place result in. */
2290 mode = TYPE_MODE (TREE_TYPE (exp));
2292 /* Check if sincos insn is available, otherwise fallback
2293 to sin or cos insn. */
2294 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2295 switch (DECL_FUNCTION_CODE (fndecl))
2297 CASE_FLT_FN (BUILT_IN_SIN):
2298 builtin_optab = sin_optab; break;
2299 CASE_FLT_FN (BUILT_IN_COS):
2300 builtin_optab = cos_optab; break;
2305 /* Before working hard, check whether the instruction is available. */
2306 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2308 target = gen_reg_rtx (mode);
2310 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2311 need to expand the argument again. This way, we will not perform
2312 side-effects more the once. */
2313 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2315 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2319 /* Compute into TARGET.
2320 Set TARGET to wherever the result comes back. */
2321 if (builtin_optab == sincos_optab)
2325 switch (DECL_FUNCTION_CODE (fndecl))
2327 CASE_FLT_FN (BUILT_IN_SIN):
2328 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2330 CASE_FLT_FN (BUILT_IN_COS):
2331 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2336 gcc_assert (result);
2340 target = expand_unop (mode, builtin_optab, op0, target, 0);
2345 /* Output the entire sequence. */
2346 insns = get_insns ();
2352 /* If we were unable to expand via the builtin, stop the sequence
2353 (without outputting the insns) and call to the library function
2354 with the stabilized argument list. */
2358 target = expand_call (exp, target, target == const0_rtx);
2363 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2364 return an RTL instruction code that implements the functionality.
2365 If that isn't possible or available return CODE_FOR_nothing. */
2367 static enum insn_code
2368 interclass_mathfn_icode (tree arg, tree fndecl)
2370 bool errno_set = false;
2371 optab builtin_optab = 0;
2372 enum machine_mode mode;
2374 switch (DECL_FUNCTION_CODE (fndecl))
2376 CASE_FLT_FN (BUILT_IN_ILOGB):
2377 errno_set = true; builtin_optab = ilogb_optab; break;
2378 CASE_FLT_FN (BUILT_IN_ISINF):
2379 builtin_optab = isinf_optab; break;
2380 case BUILT_IN_ISNORMAL:
2381 case BUILT_IN_ISFINITE:
2382 CASE_FLT_FN (BUILT_IN_FINITE):
2383 case BUILT_IN_FINITED32:
2384 case BUILT_IN_FINITED64:
2385 case BUILT_IN_FINITED128:
2386 case BUILT_IN_ISINFD32:
2387 case BUILT_IN_ISINFD64:
2388 case BUILT_IN_ISINFD128:
2389 /* These builtins have no optabs (yet). */
2395 /* There's no easy way to detect the case we need to set EDOM. */
2396 if (flag_errno_math && errno_set)
2397 return CODE_FOR_nothing;
2399 /* Optab mode depends on the mode of the input argument. */
2400 mode = TYPE_MODE (TREE_TYPE (arg));
2403 return optab_handler (builtin_optab, mode);
2404 return CODE_FOR_nothing;
2407 /* Expand a call to one of the builtin math functions that operate on
2408 floating point argument and output an integer result (ilogb, isinf,
2410 Return 0 if a normal call should be emitted rather than expanding the
2411 function in-line. EXP is the expression that is a call to the builtin
2412 function; if convenient, the result should be placed in TARGET. */
2415 expand_builtin_interclass_mathfn (tree exp, rtx target)
2417 enum insn_code icode = CODE_FOR_nothing;
2419 tree fndecl = get_callee_fndecl (exp);
2420 enum machine_mode mode;
2423 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2426 arg = CALL_EXPR_ARG (exp, 0);
2427 icode = interclass_mathfn_icode (arg, fndecl);
2428 mode = TYPE_MODE (TREE_TYPE (arg));
2430 if (icode != CODE_FOR_nothing)
2432 struct expand_operand ops[1];
2433 rtx last = get_last_insn ();
2434 tree orig_arg = arg;
2436 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2437 need to expand the argument again. This way, we will not perform
2438 side-effects more the once. */
2439 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2441 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2443 if (mode != GET_MODE (op0))
2444 op0 = convert_to_mode (mode, op0, 0);
2446 create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2447 if (maybe_legitimize_operands (icode, 0, 1, ops)
2448 && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2449 return ops[0].value;
2451 delete_insns_since (last);
2452 CALL_EXPR_ARG (exp, 0) = orig_arg;
2458 /* Expand a call to the builtin sincos math function.
2459 Return NULL_RTX if a normal call should be emitted rather than expanding the
2460 function in-line. EXP is the expression that is a call to the builtin
2464 expand_builtin_sincos (tree exp)
2466 rtx op0, op1, op2, target1, target2;
2467 enum machine_mode mode;
2468 tree arg, sinp, cosp;
2470 location_t loc = EXPR_LOCATION (exp);
2471 tree alias_type, alias_off;
2473 if (!validate_arglist (exp, REAL_TYPE,
2474 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2477 arg = CALL_EXPR_ARG (exp, 0);
2478 sinp = CALL_EXPR_ARG (exp, 1);
2479 cosp = CALL_EXPR_ARG (exp, 2);
2481 /* Make a suitable register to place result in. */
2482 mode = TYPE_MODE (TREE_TYPE (arg));
2484 /* Check if sincos insn is available, otherwise emit the call. */
2485 if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2488 target1 = gen_reg_rtx (mode);
2489 target2 = gen_reg_rtx (mode);
2491 op0 = expand_normal (arg);
2492 alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2493 alias_off = build_int_cst (alias_type, 0);
2494 op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2496 op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2499 /* Compute into target1 and target2.
2500 Set TARGET to wherever the result comes back. */
2501 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2502 gcc_assert (result);
2504 /* Move target1 and target2 to the memory locations indicated
2506 emit_move_insn (op1, target1);
2507 emit_move_insn (op2, target2);
2512 /* Expand a call to the internal cexpi builtin to the sincos math function.
2513 EXP is the expression that is a call to the builtin function; if convenient,
2514 the result should be placed in TARGET. */
2517 expand_builtin_cexpi (tree exp, rtx target)
2519 tree fndecl = get_callee_fndecl (exp);
2521 enum machine_mode mode;
2523 location_t loc = EXPR_LOCATION (exp);
2525 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2528 arg = CALL_EXPR_ARG (exp, 0);
2529 type = TREE_TYPE (arg);
2530 mode = TYPE_MODE (TREE_TYPE (arg));
2532 /* Try expanding via a sincos optab, fall back to emitting a libcall
2533 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2534 is only generated from sincos, cexp or if we have either of them. */
2535 if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2537 op1 = gen_reg_rtx (mode);
2538 op2 = gen_reg_rtx (mode);
2540 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2542 /* Compute into op1 and op2. */
2543 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2545 else if (TARGET_HAS_SINCOS)
2547 tree call, fn = NULL_TREE;
2551 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2552 fn = built_in_decls[BUILT_IN_SINCOSF];
2553 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2554 fn = built_in_decls[BUILT_IN_SINCOS];
2555 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2556 fn = built_in_decls[BUILT_IN_SINCOSL];
2560 op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2561 op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2562 op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2563 op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2564 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2565 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2567 /* Make sure not to fold the sincos call again. */
2568 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2569 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2570 call, 3, arg, top1, top2));
2574 tree call, fn = NULL_TREE, narg;
2575 tree ctype = build_complex_type (type);
2577 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2578 fn = built_in_decls[BUILT_IN_CEXPF];
2579 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2580 fn = built_in_decls[BUILT_IN_CEXP];
2581 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2582 fn = built_in_decls[BUILT_IN_CEXPL];
2586 /* If we don't have a decl for cexp create one. This is the
2587 friendliest fallback if the user calls __builtin_cexpi
2588 without full target C99 function support. */
2589 if (fn == NULL_TREE)
2592 const char *name = NULL;
2594 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2596 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2598 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2601 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2602 fn = build_fn_decl (name, fntype);
2605 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2606 build_real (type, dconst0), arg);
2608 /* Make sure not to fold the cexp call again. */
2609 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2610 return expand_expr (build_call_nary (ctype, call, 1, narg),
2611 target, VOIDmode, EXPAND_NORMAL);
2614 /* Now build the proper return type. */
2615 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2616 make_tree (TREE_TYPE (arg), op2),
2617 make_tree (TREE_TYPE (arg), op1)),
2618 target, VOIDmode, EXPAND_NORMAL);
2621 /* Conveniently construct a function call expression. FNDECL names the
2622 function to be called, N is the number of arguments, and the "..."
2623 parameters are the argument expressions. Unlike build_call_exr
2624 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2627 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2630 tree fntype = TREE_TYPE (fndecl);
2631 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2634 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2636 SET_EXPR_LOCATION (fn, loc);
2640 /* Expand a call to one of the builtin rounding functions gcc defines
2641 as an extension (lfloor and lceil). As these are gcc extensions we
2642 do not need to worry about setting errno to EDOM.
2643 If expanding via optab fails, lower expression to (int)(floor(x)).
2644 EXP is the expression that is a call to the builtin function;
2645 if convenient, the result should be placed in TARGET. */
2648 expand_builtin_int_roundingfn (tree exp, rtx target)
2650 convert_optab builtin_optab;
2651 rtx op0, insns, tmp;
2652 tree fndecl = get_callee_fndecl (exp);
2653 enum built_in_function fallback_fn;
2654 tree fallback_fndecl;
2655 enum machine_mode mode;
2658 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2661 arg = CALL_EXPR_ARG (exp, 0);
2663 switch (DECL_FUNCTION_CODE (fndecl))
2665 CASE_FLT_FN (BUILT_IN_LCEIL):
2666 CASE_FLT_FN (BUILT_IN_LLCEIL):
2667 builtin_optab = lceil_optab;
2668 fallback_fn = BUILT_IN_CEIL;
2671 CASE_FLT_FN (BUILT_IN_LFLOOR):
2672 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2673 builtin_optab = lfloor_optab;
2674 fallback_fn = BUILT_IN_FLOOR;
2681 /* Make a suitable register to place result in. */
2682 mode = TYPE_MODE (TREE_TYPE (exp));
2684 target = gen_reg_rtx (mode);
2686 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2687 need to expand the argument again. This way, we will not perform
2688 side-effects more the once. */
2689 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2691 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2695 /* Compute into TARGET. */
2696 if (expand_sfix_optab (target, op0, builtin_optab))
2698 /* Output the entire sequence. */
2699 insns = get_insns ();
2705 /* If we were unable to expand via the builtin, stop the sequence
2706 (without outputting the insns). */
2709 /* Fall back to floating point rounding optab. */
2710 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2712 /* For non-C99 targets we may end up without a fallback fndecl here
2713 if the user called __builtin_lfloor directly. In this case emit
2714 a call to the floor/ceil variants nevertheless. This should result
2715 in the best user experience for not full C99 targets. */
2716 if (fallback_fndecl == NULL_TREE)
2719 const char *name = NULL;
2721 switch (DECL_FUNCTION_CODE (fndecl))
2723 case BUILT_IN_LCEIL:
2724 case BUILT_IN_LLCEIL:
2727 case BUILT_IN_LCEILF:
2728 case BUILT_IN_LLCEILF:
2731 case BUILT_IN_LCEILL:
2732 case BUILT_IN_LLCEILL:
2735 case BUILT_IN_LFLOOR:
2736 case BUILT_IN_LLFLOOR:
2739 case BUILT_IN_LFLOORF:
2740 case BUILT_IN_LLFLOORF:
2743 case BUILT_IN_LFLOORL:
2744 case BUILT_IN_LLFLOORL:
2751 fntype = build_function_type_list (TREE_TYPE (arg),
2752 TREE_TYPE (arg), NULL_TREE);
2753 fallback_fndecl = build_fn_decl (name, fntype);
2756 exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2758 tmp = expand_normal (exp);
2760 /* Truncate the result of floating point optab to integer
2761 via expand_fix (). */
2762 target = gen_reg_rtx (mode);
2763 expand_fix (target, tmp, 0);
2768 /* Expand a call to one of the builtin math functions doing integer
2770 Return 0 if a normal call should be emitted rather than expanding the
2771 function in-line. EXP is the expression that is a call to the builtin
2772 function; if convenient, the result should be placed in TARGET. */
2775 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2777 convert_optab builtin_optab;
2779 tree fndecl = get_callee_fndecl (exp);
2781 enum machine_mode mode;
2783 /* There's no easy way to detect the case we need to set EDOM. */
2784 if (flag_errno_math)
2787 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2790 arg = CALL_EXPR_ARG (exp, 0);
2792 switch (DECL_FUNCTION_CODE (fndecl))
2794 CASE_FLT_FN (BUILT_IN_LRINT):
2795 CASE_FLT_FN (BUILT_IN_LLRINT):
2796 builtin_optab = lrint_optab; break;
2797 CASE_FLT_FN (BUILT_IN_LROUND):
2798 CASE_FLT_FN (BUILT_IN_LLROUND):
2799 builtin_optab = lround_optab; break;
2804 /* Make a suitable register to place result in. */
2805 mode = TYPE_MODE (TREE_TYPE (exp));
2807 target = gen_reg_rtx (mode);
2809 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2810 need to expand the argument again. This way, we will not perform
2811 side-effects more the once. */
2812 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2814 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2818 if (expand_sfix_optab (target, op0, builtin_optab))
2820 /* Output the entire sequence. */
2821 insns = get_insns ();
2827 /* If we were unable to expand via the builtin, stop the sequence
2828 (without outputting the insns) and call to the library function
2829 with the stabilized argument list. */
2832 target = expand_call (exp, target, target == const0_rtx);
2837 /* To evaluate powi(x,n), the floating point value x raised to the
2838 constant integer exponent n, we use a hybrid algorithm that
2839 combines the "window method" with look-up tables. For an
2840 introduction to exponentiation algorithms and "addition chains",
2841 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2842 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2843 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2844 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2846 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2847 multiplications to inline before calling the system library's pow
2848 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2849 so this default never requires calling pow, powf or powl. */
2851 #ifndef POWI_MAX_MULTS
2852 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2855 /* The size of the "optimal power tree" lookup table. All
2856 exponents less than this value are simply looked up in the
2857 powi_table below. This threshold is also used to size the
2858 cache of pseudo registers that hold intermediate results. */
2859 #define POWI_TABLE_SIZE 256
2861 /* The size, in bits of the window, used in the "window method"
2862 exponentiation algorithm. This is equivalent to a radix of
2863 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2864 #define POWI_WINDOW_SIZE 3
2866 /* The following table is an efficient representation of an
2867 "optimal power tree". For each value, i, the corresponding
2868 value, j, in the table states than an optimal evaluation
2869 sequence for calculating pow(x,i) can be found by evaluating
2870 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2871 100 integers is given in Knuth's "Seminumerical algorithms". */
2873 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2875 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2876 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2877 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2878 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2879 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2880 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2881 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2882 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2883 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2884 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2885 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2886 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2887 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2888 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2889 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2890 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2891 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2892 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2893 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2894 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2895 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2896 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2897 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2898 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2899 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2900 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2901 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2902 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2903 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2904 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2905 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2906 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2910 /* Return the number of multiplications required to calculate
2911 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2912 subroutine of powi_cost. CACHE is an array indicating
2913 which exponents have already been calculated. */
2916 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2918 /* If we've already calculated this exponent, then this evaluation
2919 doesn't require any additional multiplications. */
2924 return powi_lookup_cost (n - powi_table[n], cache)
2925 + powi_lookup_cost (powi_table[n], cache) + 1;
2928 /* Return the number of multiplications required to calculate
2929 powi(x,n) for an arbitrary x, given the exponent N. This
2930 function needs to be kept in sync with expand_powi below. */
2933 powi_cost (HOST_WIDE_INT n)
2935 bool cache[POWI_TABLE_SIZE];
2936 unsigned HOST_WIDE_INT digit;
2937 unsigned HOST_WIDE_INT val;
2943 /* Ignore the reciprocal when calculating the cost. */
2944 val = (n < 0) ? -n : n;
2946 /* Initialize the exponent cache. */
2947 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2952 while (val >= POWI_TABLE_SIZE)
2956 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2957 result += powi_lookup_cost (digit, cache)
2958 + POWI_WINDOW_SIZE + 1;
2959 val >>= POWI_WINDOW_SIZE;
2968 return result + powi_lookup_cost (val, cache);
2971 /* Recursive subroutine of expand_powi. This function takes the array,
2972 CACHE, of already calculated exponents and an exponent N and returns
2973 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2976 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2978 unsigned HOST_WIDE_INT digit;
2982 if (n < POWI_TABLE_SIZE)
2987 target = gen_reg_rtx (mode);
2990 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2991 op1 = expand_powi_1 (mode, powi_table[n], cache);
2995 target = gen_reg_rtx (mode);
2996 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2997 op0 = expand_powi_1 (mode, n - digit, cache);
2998 op1 = expand_powi_1 (mode, digit, cache);
3002 target = gen_reg_rtx (mode);
3003 op0 = expand_powi_1 (mode, n >> 1, cache);
3007 result = expand_mult (mode, op0, op1, target, 0);
3008 if (result != target)
3009 emit_move_insn (target, result);
3013 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
3014 floating point operand in mode MODE, and N is the exponent. This
3015 function needs to be kept in sync with powi_cost above. */
3018 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
3020 rtx cache[POWI_TABLE_SIZE];
3024 return CONST1_RTX (mode);
3026 memset (cache, 0, sizeof (cache));
3029 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
3031 /* If the original exponent was negative, reciprocate the result. */
3033 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3034 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3039 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
3040 cbrts. Return NULL_RTX if no simplification can be made or expand the tree
3041 if we can simplify it. */
3043 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
3046 if (TREE_CODE (arg1) == REAL_CST
3047 && !TREE_OVERFLOW (arg1)
3048 && flag_unsafe_math_optimizations)
3050 enum machine_mode mode = TYPE_MODE (type);
3051 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
3052 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
3053 REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
3054 tree op = NULL_TREE;
3058 /* Optimize pow (x, 0.5) into sqrt. */
3059 if (REAL_VALUES_EQUAL (c, dconsthalf))
3060 op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3062 /* Don't do this optimization if we don't have a sqrt insn. */
3063 else if (optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)
3065 REAL_VALUE_TYPE dconst1_4 = dconst1;
3066 REAL_VALUE_TYPE dconst3_4;
3067 SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
3069 real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
3070 SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3072 /* Optimize pow (x, 0.25) into sqrt (sqrt (x)). Assume on most
3073 machines that a builtin sqrt instruction is smaller than a
3074 call to pow with 0.25, so do this optimization even if
3076 if (REAL_VALUES_EQUAL (c, dconst1_4))
3078 op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3079 op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3082 /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3083 are optimizing for space. */
3084 else if (optimize_insn_for_speed_p ()
3085 && !TREE_SIDE_EFFECTS (arg0)
3086 && REAL_VALUES_EQUAL (c, dconst3_4))
3088 tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3089 tree sqrt2 = builtin_save_expr (sqrt1);
3090 tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3091 op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3096 /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3097 cbrt/sqrts instead of pow (x, 1./6.). */
3099 && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3101 /* First try 1/3. */
3102 REAL_VALUE_TYPE dconst1_3
3103 = real_value_truncate (mode, dconst_third ());
3105 if (REAL_VALUES_EQUAL (c, dconst1_3))
3106 op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3109 else if (optimize_insn_for_speed_p ()
3110 && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)
3112 REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3113 SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3115 if (REAL_VALUES_EQUAL (c, dconst1_6))
3117 op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3118 op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3124 return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3130 /* Expand a call to the pow built-in mathematical function. Return NULL_RTX if
3131 a normal call should be emitted rather than expanding the function
3132 in-line. EXP is the expression that is a call to the builtin
3133 function; if convenient, the result should be placed in TARGET. */
3136 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3140 tree type = TREE_TYPE (exp);
3141 REAL_VALUE_TYPE cint, c, c2;
3144 enum machine_mode mode = TYPE_MODE (type);
3146 if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3149 arg0 = CALL_EXPR_ARG (exp, 0);
3150 arg1 = CALL_EXPR_ARG (exp, 1);
3152 if (TREE_CODE (arg1) != REAL_CST
3153 || TREE_OVERFLOW (arg1))
3154 return expand_builtin_mathfn_2 (exp, target, subtarget);
3156 /* Handle constant exponents. */
3158 /* For integer valued exponents we can expand to an optimal multiplication
3159 sequence using expand_powi. */
3160 c = TREE_REAL_CST (arg1);
3161 n = real_to_integer (&c);
3162 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3163 if (real_identical (&c, &cint)
3164 && ((n >= -1 && n <= 2)
3165 || (flag_unsafe_math_optimizations
3166 && optimize_insn_for_speed_p ()
3167 && powi_cost (n) <= POWI_MAX_MULTS)))
3169 op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3172 op = force_reg (mode, op);
3173 op = expand_powi (op, mode, n);
3178 narg0 = builtin_save_expr (arg0);
3180 /* If the exponent is not integer valued, check if it is half of an integer.
3181 In this case we can expand to sqrt (x) * x**(n/2). */
3182 fn = mathfn_built_in (type, BUILT_IN_SQRT);
3183 if (fn != NULL_TREE)
3185 real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3186 n = real_to_integer (&c2);
3187 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3188 if (real_identical (&c2, &cint)
3189 && ((flag_unsafe_math_optimizations
3190 && optimize_insn_for_speed_p ()
3191 && powi_cost (n/2) <= POWI_MAX_MULTS)
3192 /* Even the c == 0.5 case cannot be done unconditionally
3193 when we need to preserve signed zeros, as
3194 pow (-0, 0.5) is +0, while sqrt(-0) is -0. */
3195 || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3196 /* For c == 1.5 we can assume that x * sqrt (x) is always
3197 smaller than pow (x, 1.5) if sqrt will not be expanded
3200 && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3202 tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3204 /* Use expand_expr in case the newly built call expression
3205 was folded to a non-call. */
3206 op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3209 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3210 op2 = force_reg (mode, op2);
3211 op2 = expand_powi (op2, mode, abs (n / 2));
3212 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3213 0, OPTAB_LIB_WIDEN);
3214 /* If the original exponent was negative, reciprocate the
3217 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3218 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3224 /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3226 op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3231 /* Try if the exponent is a third of an integer. In this case
3232 we can expand to x**(n/3) * cbrt(x)**(n%3). As cbrt (x) is
3233 different from pow (x, 1./3.) due to rounding and behavior
3234 with negative x we need to constrain this transformation to
3235 unsafe math and positive x or finite math. */
3236 fn = mathfn_built_in (type, BUILT_IN_CBRT);
3238 && flag_unsafe_math_optimizations
3239 && (tree_expr_nonnegative_p (arg0)
3240 || !HONOR_NANS (mode)))
3242 REAL_VALUE_TYPE dconst3;
3243 real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3244 real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3245 real_round (&c2, mode, &c2);
3246 n = real_to_integer (&c2);
3247 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3248 real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3249 real_convert (&c2, mode, &c2);
3250 if (real_identical (&c2, &c)
3251 && ((optimize_insn_for_speed_p ()
3252 && powi_cost (n/3) <= POWI_MAX_MULTS)
3255 tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3257 op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3258 if (abs (n) % 3 == 2)
3259 op = expand_simple_binop (mode, MULT, op, op, op,
3260 0, OPTAB_LIB_WIDEN);
3263 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3264 op2 = force_reg (mode, op2);
3265 op2 = expand_powi (op2, mode, abs (n / 3));
3266 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3267 0, OPTAB_LIB_WIDEN);
3268 /* If the original exponent was negative, reciprocate the
3271 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3272 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3278 /* Fall back to optab expansion. */
3279 return expand_builtin_mathfn_2 (exp, target, subtarget);
3282 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
3283 a normal call should be emitted rather than expanding the function
3284 in-line. EXP is the expression that is a call to the builtin
3285 function; if convenient, the result should be placed in TARGET. */
3288 expand_builtin_powi (tree exp, rtx target)
3292 enum machine_mode mode;
3293 enum machine_mode mode2;
3295 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3298 arg0 = CALL_EXPR_ARG (exp, 0);
3299 arg1 = CALL_EXPR_ARG (exp, 1);
3300 mode = TYPE_MODE (TREE_TYPE (exp));
3302 /* Handle constant power. */
3304 if (TREE_CODE (arg1) == INTEGER_CST
3305 && !TREE_OVERFLOW (arg1))
3307 HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3309 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3310 Otherwise, check the number of multiplications required. */
3311 if ((TREE_INT_CST_HIGH (arg1) == 0
3312 || TREE_INT_CST_HIGH (arg1) == -1)
3313 && ((n >= -1 && n <= 2)
3314 || (optimize_insn_for_speed_p ()
3315 && powi_cost (n) <= POWI_MAX_MULTS)))
3317 op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
3318 op0 = force_reg (mode, op0);
3319 return expand_powi (op0, mode, n);
3323 /* Emit a libcall to libgcc. */
3325 /* Mode of the 2nd argument must match that of an int. */
3326 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3328 if (target == NULL_RTX)
3329 target = gen_reg_rtx (mode);
3331 op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
3332 if (GET_MODE (op0) != mode)
3333 op0 = convert_to_mode (mode, op0, 0);
3334 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3335 if (GET_MODE (op1) != mode2)
3336 op1 = convert_to_mode (mode2, op1, 0);
3338 target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3339 target, LCT_CONST, mode, 2,
3340 op0, mode, op1, mode2);
3345 /* Expand expression EXP which is a call to the strlen builtin. Return
3346 NULL_RTX if we failed the caller should emit a normal call, otherwise
3347 try to get the result in TARGET, if convenient. */
3350 expand_builtin_strlen (tree exp, rtx target,
3351 enum machine_mode target_mode)
3353 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3357 struct expand_operand ops[4];
3360 tree src = CALL_EXPR_ARG (exp, 0);
3361 rtx src_reg, before_strlen;
3362 enum machine_mode insn_mode = target_mode;
3363 enum insn_code icode = CODE_FOR_nothing;
3366 /* If the length can be computed at compile-time, return it. */
3367 len = c_strlen (src, 0);
3369 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3371 /* If the length can be computed at compile-time and is constant
3372 integer, but there are side-effects in src, evaluate
3373 src for side-effects, then return len.
3374 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3375 can be optimized into: i++; x = 3; */
3376 len = c_strlen (src, 1);
3377 if (len && TREE_CODE (len) == INTEGER_CST)
3379 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3380 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3383 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3385 /* If SRC is not a pointer type, don't do this operation inline. */
3389 /* Bail out if we can't compute strlen in the right mode. */
3390 while (insn_mode != VOIDmode)
3392 icode = optab_handler (strlen_optab, insn_mode);
3393 if (icode != CODE_FOR_nothing)
3396 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3398 if (insn_mode == VOIDmode)
3401 /* Make a place to hold the source address. We will not expand
3402 the actual source until we are sure that the expansion will
3403 not fail -- there are trees that cannot be expanded twice. */
3404 src_reg = gen_reg_rtx (Pmode);
3406 /* Mark the beginning of the strlen sequence so we can emit the
3407 source operand later. */
3408 before_strlen = get_last_insn ();
3410 create_output_operand (&ops[0], target, insn_mode);
3411 create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
3412 create_integer_operand (&ops[2], 0);
3413 create_integer_operand (&ops[3], align);
3414 if (!maybe_expand_insn (icode, 4, ops))
3417 /* Now that we are assured of success, expand the source. */
3419 pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3421 emit_move_insn (src_reg, pat);
3426 emit_insn_after (pat, before_strlen);
3428 emit_insn_before (pat, get_insns ());
3430 /* Return the value in the proper mode for this function. */
3431 if (GET_MODE (ops[0].value) == target_mode)
3432 target = ops[0].value;
3433 else if (target != 0)
3434 convert_move (target, ops[0].value, 0);
3436 target = convert_to_mode (target_mode, ops[0].value, 0);
3442 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3443 bytes from constant string DATA + OFFSET and return it as target
3447 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3448 enum machine_mode mode)
3450 const char *str = (const char *) data;
3452 gcc_assert (offset >= 0
3453 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3454 <= strlen (str) + 1));
3456 return c_readstr (str + offset, mode);
3459 /* Expand a call EXP to the memcpy builtin.
3460 Return NULL_RTX if we failed, the caller should emit a normal call,
3461 otherwise try to get the result in TARGET, if convenient (and in
3462 mode MODE if that's convenient). */
3465 expand_builtin_memcpy (tree exp, rtx target)
3467 if (!validate_arglist (exp,
3468 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3472 tree dest = CALL_EXPR_ARG (exp, 0);
3473 tree src = CALL_EXPR_ARG (exp, 1);
3474 tree len = CALL_EXPR_ARG (exp, 2);
3475 const char *src_str;
3476 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3477 unsigned int dest_align
3478 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3479 rtx dest_mem, src_mem, dest_addr, len_rtx;
3480 HOST_WIDE_INT expected_size = -1;
3481 unsigned int expected_align = 0;
3483 /* If DEST is not a pointer type, call the normal function. */
3484 if (dest_align == 0)
3487 /* If either SRC is not a pointer type, don't do this
3488 operation in-line. */
3492 if (currently_expanding_gimple_stmt)
3493 stringop_block_profile (currently_expanding_gimple_stmt,
3494 &expected_align, &expected_size);
3496 if (expected_align < dest_align)
3497 expected_align = dest_align;
3498 dest_mem = get_memory_rtx (dest, len);
3499 set_mem_align (dest_mem, dest_align);
3500 len_rtx = expand_normal (len);
3501 src_str = c_getstr (src);
3503 /* If SRC is a string constant and block move would be done
3504 by pieces, we can avoid loading the string from memory
3505 and only stored the computed constants. */
3507 && CONST_INT_P (len_rtx)
3508 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3509 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3510 CONST_CAST (char *, src_str),
3513 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3514 builtin_memcpy_read_str,
3515 CONST_CAST (char *, src_str),
3516 dest_align, false, 0);
3517 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3518 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3522 src_mem = get_memory_rtx (src, len);
3523 set_mem_align (src_mem, src_align);
3525 /* Copy word part most expediently. */
3526 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3527 CALL_EXPR_TAILCALL (exp)
3528 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3529 expected_align, expected_size);
3533 dest_addr = force_operand (XEXP (dest_mem, 0), target);
3534 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3540 /* Expand a call EXP to the mempcpy builtin.
3541 Return NULL_RTX if we failed; the caller should emit a normal call,
3542 otherwise try to get the result in TARGET, if convenient (and in
3543 mode MODE if that's convenient). If ENDP is 0 return the
3544 destination pointer, if ENDP is 1 return the end pointer ala
3545 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3549 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3551 if (!validate_arglist (exp,
3552 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3556 tree dest = CALL_EXPR_ARG (exp, 0);
3557 tree src = CALL_EXPR_ARG (exp, 1);
3558 tree len = CALL_EXPR_ARG (exp, 2);
3559 return expand_builtin_mempcpy_args (dest, src, len,
3560 target, mode, /*endp=*/ 1);
3564 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3565 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3566 so that this can also be called without constructing an actual CALL_EXPR.
3567 The other arguments and return value are the same as for
3568 expand_builtin_mempcpy. */
3571 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3572 rtx target, enum machine_mode mode, int endp)
3574 /* If return value is ignored, transform mempcpy into memcpy. */
3575 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3577 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3578 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3580 return expand_expr (result, target, mode, EXPAND_NORMAL);
3584 const char *src_str;
3585 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3586 unsigned int dest_align
3587 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3588 rtx dest_mem, src_mem, len_rtx;
3590 /* If either SRC or DEST is not a pointer type, don't do this
3591 operation in-line. */
3592 if (dest_align == 0 || src_align == 0)
3595 /* If LEN is not constant, call the normal function. */
3596 if (! host_integerp (len, 1))
3599 len_rtx = expand_normal (len);
3600 src_str = c_getstr (src);
3602 /* If SRC is a string constant and block move would be done
3603 by pieces, we can avoid loading the string from memory
3604 and only stored the computed constants. */
3606 && CONST_INT_P (len_rtx)
3607 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3608 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3609 CONST_CAST (char *, src_str),
3612 dest_mem = get_memory_rtx (dest, len);
3613 set_mem_align (dest_mem, dest_align);
3614 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3615 builtin_memcpy_read_str,
3616 CONST_CAST (char *, src_str),
3617 dest_align, false, endp);
3618 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3619 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3623 if (CONST_INT_P (len_rtx)
3624 && can_move_by_pieces (INTVAL (len_rtx),
3625 MIN (dest_align, src_align)))
3627 dest_mem = get_memory_rtx (dest, len);
3628 set_mem_align (dest_mem, dest_align);
3629 src_mem = get_memory_rtx (src, len);
3630 set_mem_align (src_mem, src_align);
3631 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3632 MIN (dest_align, src_align), endp);
3633 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3634 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3643 # define HAVE_movstr 0
3644 # define CODE_FOR_movstr CODE_FOR_nothing
3647 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3648 we failed, the caller should emit a normal call, otherwise try to
3649 get the result in TARGET, if convenient. If ENDP is 0 return the
3650 destination pointer, if ENDP is 1 return the end pointer ala
3651 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3655 expand_movstr (tree dest, tree src, rtx target, int endp)
3657 struct expand_operand ops[3];
3664 dest_mem = get_memory_rtx (dest, NULL);
3665 src_mem = get_memory_rtx (src, NULL);
3668 target = force_reg (Pmode, XEXP (dest_mem, 0));
3669 dest_mem = replace_equiv_address (dest_mem, target);
3672 create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3673 create_fixed_operand (&ops[1], dest_mem);
3674 create_fixed_operand (&ops[2], src_mem);
3675 expand_insn (CODE_FOR_movstr, 3, ops);
3677 if (endp && target != const0_rtx)
3679 target = ops[0].value;
3680 /* movstr is supposed to set end to the address of the NUL
3681 terminator. If the caller requested a mempcpy-like return value,
3685 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), target), 1);
3686 emit_move_insn (target, force_operand (tem, NULL_RTX));
3692 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3693 NULL_RTX if we failed the caller should emit a normal call, otherwise
3694 try to get the result in TARGET, if convenient (and in mode MODE if that's
3698 expand_builtin_strcpy (tree exp, rtx target)
3700 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3702 tree dest = CALL_EXPR_ARG (exp, 0);
3703 tree src = CALL_EXPR_ARG (exp, 1);
3704 return expand_builtin_strcpy_args (dest, src, target);
3709 /* Helper function to do the actual work for expand_builtin_strcpy. The
3710 arguments to the builtin_strcpy call DEST and SRC are broken out
3711 so that this can also be called without constructing an actual CALL_EXPR.
3712 The other arguments and return value are the same as for
3713 expand_builtin_strcpy. */
3716 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3718 return expand_movstr (dest, src, target, /*endp=*/0);
3721 /* Expand a call EXP to the stpcpy builtin.
3722 Return NULL_RTX if we failed the caller should emit a normal call,
3723 otherwise try to get the result in TARGET, if convenient (and in
3724 mode MODE if that's convenient). */
3727 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3730 location_t loc = EXPR_LOCATION (exp);
3732 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3735 dst = CALL_EXPR_ARG (exp, 0);
3736 src = CALL_EXPR_ARG (exp, 1);
3738 /* If return value is ignored, transform stpcpy into strcpy. */
3739 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3741 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3742 tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3743 return expand_expr (result, target, mode, EXPAND_NORMAL);
3750 /* Ensure we get an actual string whose length can be evaluated at
3751 compile-time, not an expression containing a string. This is
3752 because the latter will potentially produce pessimized code
3753 when used to produce the return value. */
3754 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3755 return expand_movstr (dst, src, target, /*endp=*/2);
3757 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3758 ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3759 target, mode, /*endp=*/2);
3764 if (TREE_CODE (len) == INTEGER_CST)
3766 rtx len_rtx = expand_normal (len);
3768 if (CONST_INT_P (len_rtx))
3770 ret = expand_builtin_strcpy_args (dst, src, target);
3776 if (mode != VOIDmode)
3777 target = gen_reg_rtx (mode);
3779 target = gen_reg_rtx (GET_MODE (ret));
3781 if (GET_MODE (target) != GET_MODE (ret))
3782 ret = gen_lowpart (GET_MODE (target), ret);
3784 ret = plus_constant (ret, INTVAL (len_rtx));
3785 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3793 return expand_movstr (dst, src, target, /*endp=*/2);
3797 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3798 bytes from constant string DATA + OFFSET and return it as target
3802 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3803 enum machine_mode mode)
3805 const char *str = (const char *) data;
3807 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3810 return c_readstr (str + offset, mode);
3813 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3814 NULL_RTX if we failed the caller should emit a normal call. */
3817 expand_builtin_strncpy (tree exp, rtx target)
3819 location_t loc = EXPR_LOCATION (exp);
3821 if (validate_arglist (exp,
3822 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3824 tree dest = CALL_EXPR_ARG (exp, 0);
3825 tree src = CALL_EXPR_ARG (exp, 1);
3826 tree len = CALL_EXPR_ARG (exp, 2);
3827 tree slen = c_strlen (src, 1);
3829 /* We must be passed a constant len and src parameter. */
3830 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3833 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3835 /* We're required to pad with trailing zeros if the requested
3836 len is greater than strlen(s2)+1. In that case try to
3837 use store_by_pieces, if it fails, punt. */
3838 if (tree_int_cst_lt (slen, len))
3840 unsigned int dest_align
3841 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3842 const char *p = c_getstr (src);
3845 if (!p || dest_align == 0 || !host_integerp (len, 1)
3846 || !can_store_by_pieces (tree_low_cst (len, 1),
3847 builtin_strncpy_read_str,
3848 CONST_CAST (char *, p),
3852 dest_mem = get_memory_rtx (dest, len);
3853 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3854 builtin_strncpy_read_str,
3855 CONST_CAST (char *, p), dest_align, false, 0);
3856 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3857 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3864 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3865 bytes from constant string DATA + OFFSET and return it as target
3869 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3870 enum machine_mode mode)
3872 const char *c = (const char *) data;
3873 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3875 memset (p, *c, GET_MODE_SIZE (mode));
3877 return c_readstr (p, mode);
3880 /* Callback routine for store_by_pieces. Return the RTL of a register
3881 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3882 char value given in the RTL register data. For example, if mode is
3883 4 bytes wide, return the RTL for 0x01010101*data. */
3886 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3887 enum machine_mode mode)
3893 size = GET_MODE_SIZE (mode);
3897 p = XALLOCAVEC (char, size);
3898 memset (p, 1, size);
3899 coeff = c_readstr (p, mode);
3901 target = convert_to_mode (mode, (rtx) data, 1);
3902 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3903 return force_reg (mode, target);
3906 /* Expand expression EXP, which is a call to the memset builtin. Return
3907 NULL_RTX if we failed the caller should emit a normal call, otherwise
3908 try to get the result in TARGET, if convenient (and in mode MODE if that's
3912 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3914 if (!validate_arglist (exp,
3915 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3919 tree dest = CALL_EXPR_ARG (exp, 0);
3920 tree val = CALL_EXPR_ARG (exp, 1);
3921 tree len = CALL_EXPR_ARG (exp, 2);
3922 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3926 /* Helper function to do the actual work for expand_builtin_memset. The
3927 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3928 so that this can also be called without constructing an actual CALL_EXPR.
3929 The other arguments and return value are the same as for
3930 expand_builtin_memset. */
3933 expand_builtin_memset_args (tree dest, tree val, tree len,
3934 rtx target, enum machine_mode mode, tree orig_exp)
3937 enum built_in_function fcode;
3938 enum machine_mode val_mode;
3940 unsigned int dest_align;
3941 rtx dest_mem, dest_addr, len_rtx;
3942 HOST_WIDE_INT expected_size = -1;
3943 unsigned int expected_align = 0;
3945 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3947 /* If DEST is not a pointer type, don't do this operation in-line. */
3948 if (dest_align == 0)
3951 if (currently_expanding_gimple_stmt)
3952 stringop_block_profile (currently_expanding_gimple_stmt,
3953 &expected_align, &expected_size);
3955 if (expected_align < dest_align)
3956 expected_align = dest_align;
3958 /* If the LEN parameter is zero, return DEST. */
3959 if (integer_zerop (len))
3961 /* Evaluate and ignore VAL in case it has side-effects. */
3962 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3963 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3966 /* Stabilize the arguments in case we fail. */
3967 dest = builtin_save_expr (dest);
3968 val = builtin_save_expr (val);
3969 len = builtin_save_expr (len);
3971 len_rtx = expand_normal (len);
3972 dest_mem = get_memory_rtx (dest, len);
3973 val_mode = TYPE_MODE (unsigned_char_type_node);
3975 if (TREE_CODE (val) != INTEGER_CST)
3979 val_rtx = expand_normal (val);
3980 val_rtx = convert_to_mode (val_mode, val_rtx, 0);
3982 /* Assume that we can memset by pieces if we can store
3983 * the coefficients by pieces (in the required modes).
3984 * We can't pass builtin_memset_gen_str as that emits RTL. */
3986 if (host_integerp (len, 1)
3987 && can_store_by_pieces (tree_low_cst (len, 1),
3988 builtin_memset_read_str, &c, dest_align,
3991 val_rtx = force_reg (val_mode, val_rtx);
3992 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3993 builtin_memset_gen_str, val_rtx, dest_align,
3996 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3997 dest_align, expected_align,
4001 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4002 dest_mem = convert_memory_address (ptr_mode, dest_mem);
4006 if (target_char_cast (val, &c))
4011 if (host_integerp (len, 1)
4012 && can_store_by_pieces (tree_low_cst (len, 1),
4013 builtin_memset_read_str, &c, dest_align,
4015 store_by_pieces (dest_mem, tree_low_cst (len, 1),
4016 builtin_memset_read_str, &c, dest_align, true, 0);
4017 else if (!set_storage_via_setmem (dest_mem, len_rtx,
4018 gen_int_mode (c, val_mode),
4019 dest_align, expected_align,
4023 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4024 dest_mem = convert_memory_address (ptr_mode, dest_mem);
4028 set_mem_align (dest_mem, dest_align);
4029 dest_addr = clear_storage_hints (dest_mem, len_rtx,
4030 CALL_EXPR_TAILCALL (orig_exp)
4031 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
4032 expected_align, expected_size);
4036 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4037 dest_addr = convert_memory_address (ptr_mode, dest_addr);
4043 fndecl = get_callee_fndecl (orig_exp);
4044 fcode = DECL_FUNCTION_CODE (fndecl);
4045 if (fcode == BUILT_IN_MEMSET)
4046 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4048 else if (fcode == BUILT_IN_BZERO)
4049 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4053 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4054 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4055 return expand_call (fn, target, target == const0_rtx);
4058 /* Expand expression EXP, which is a call to the bzero builtin. Return
4059 NULL_RTX if we failed the caller should emit a normal call. */
4062 expand_builtin_bzero (tree exp)
4065 location_t loc = EXPR_LOCATION (exp);
4067 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4070 dest = CALL_EXPR_ARG (exp, 0);
4071 size = CALL_EXPR_ARG (exp, 1);
4073 /* New argument list transforming bzero(ptr x, int y) to
4074 memset(ptr x, int 0, size_t y). This is done this way
4075 so that if it isn't expanded inline, we fallback to
4076 calling bzero instead of memset. */
4078 return expand_builtin_memset_args (dest, integer_zero_node,
4079 fold_convert_loc (loc, sizetype, size),
4080 const0_rtx, VOIDmode, exp);
4083 /* Expand expression EXP, which is a call to the memcmp built-in function.
4084 Return NULL_RTX if we failed and the
4085 caller should emit a normal call, otherwise try to get the result in
4086 TARGET, if convenient (and in mode MODE, if that's convenient). */
4089 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4090 ATTRIBUTE_UNUSED enum machine_mode mode)
4092 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4094 if (!validate_arglist (exp,
4095 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4098 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4100 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4103 tree arg1 = CALL_EXPR_ARG (exp, 0);
4104 tree arg2 = CALL_EXPR_ARG (exp, 1);
4105 tree len = CALL_EXPR_ARG (exp, 2);
4107 unsigned int arg1_align
4108 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4109 unsigned int arg2_align
4110 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4111 enum machine_mode insn_mode;
4113 #ifdef HAVE_cmpmemsi
4115 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4118 #ifdef HAVE_cmpstrnsi
4120 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4125 /* If we don't have POINTER_TYPE, call the function. */
4126 if (arg1_align == 0 || arg2_align == 0)
4129 /* Make a place to write the result of the instruction. */
4132 && REG_P (result) && GET_MODE (result) == insn_mode
4133 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4134 result = gen_reg_rtx (insn_mode);
4136 arg1_rtx = get_memory_rtx (arg1, len);
4137 arg2_rtx = get_memory_rtx (arg2, len);
4138 arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4140 /* Set MEM_SIZE as appropriate. */
4141 if (CONST_INT_P (arg3_rtx))
4143 set_mem_size (arg1_rtx, arg3_rtx);
4144 set_mem_size (arg2_rtx, arg3_rtx);
4147 #ifdef HAVE_cmpmemsi
4149 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4150 GEN_INT (MIN (arg1_align, arg2_align)));
4153 #ifdef HAVE_cmpstrnsi
4155 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4156 GEN_INT (MIN (arg1_align, arg2_align)));
4164 emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4165 TYPE_MODE (integer_type_node), 3,
4166 XEXP (arg1_rtx, 0), Pmode,
4167 XEXP (arg2_rtx, 0), Pmode,
4168 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4169 TYPE_UNSIGNED (sizetype)),
4170 TYPE_MODE (sizetype));
4172 /* Return the value in the proper mode for this function. */
4173 mode = TYPE_MODE (TREE_TYPE (exp));
4174 if (GET_MODE (result) == mode)
4176 else if (target != 0)
4178 convert_move (target, result, 0);
4182 return convert_to_mode (mode, result, 0);
4189 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4190 if we failed the caller should emit a normal call, otherwise try to get
4191 the result in TARGET, if convenient. */
4194 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4196 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4199 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4200 if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4201 || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4203 rtx arg1_rtx, arg2_rtx;
4204 rtx result, insn = NULL_RTX;
4206 tree arg1 = CALL_EXPR_ARG (exp, 0);
4207 tree arg2 = CALL_EXPR_ARG (exp, 1);
4209 unsigned int arg1_align
4210 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4211 unsigned int arg2_align
4212 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4214 /* If we don't have POINTER_TYPE, call the function. */
4215 if (arg1_align == 0 || arg2_align == 0)
4218 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4219 arg1 = builtin_save_expr (arg1);
4220 arg2 = builtin_save_expr (arg2);
4222 arg1_rtx = get_memory_rtx (arg1, NULL);
4223 arg2_rtx = get_memory_rtx (arg2, NULL);
4225 #ifdef HAVE_cmpstrsi
4226 /* Try to call cmpstrsi. */
4229 enum machine_mode insn_mode
4230 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4232 /* Make a place to write the result of the instruction. */
4235 && REG_P (result) && GET_MODE (result) == insn_mode
4236 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4237 result = gen_reg_rtx (insn_mode);
4239 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4240 GEN_INT (MIN (arg1_align, arg2_align)));
4243 #ifdef HAVE_cmpstrnsi
4244 /* Try to determine at least one length and call cmpstrnsi. */
4245 if (!insn && HAVE_cmpstrnsi)
4250 enum machine_mode insn_mode
4251 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4252 tree len1 = c_strlen (arg1, 1);
4253 tree len2 = c_strlen (arg2, 1);
4256 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4258 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4260 /* If we don't have a constant length for the first, use the length
4261 of the second, if we know it. We don't require a constant for
4262 this case; some cost analysis could be done if both are available
4263 but neither is constant. For now, assume they're equally cheap,
4264 unless one has side effects. If both strings have constant lengths,
4271 else if (TREE_SIDE_EFFECTS (len1))
4273 else if (TREE_SIDE_EFFECTS (len2))
4275 else if (TREE_CODE (len1) != INTEGER_CST)
4277 else if (TREE_CODE (len2) != INTEGER_CST)
4279 else if (tree_int_cst_lt (len1, len2))
4284 /* If both arguments have side effects, we cannot optimize. */
4285 if (!len || TREE_SIDE_EFFECTS (len))
4288 arg3_rtx = expand_normal (len);
4290 /* Make a place to write the result of the instruction. */
4293 && REG_P (result) && GET_MODE (result) == insn_mode
4294 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4295 result = gen_reg_rtx (insn_mode);
4297 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4298 GEN_INT (MIN (arg1_align, arg2_align)));
4304 enum machine_mode mode;
4307 /* Return the value in the proper mode for this function. */
4308 mode = TYPE_MODE (TREE_TYPE (exp));
4309 if (GET_MODE (result) == mode)
4312 return convert_to_mode (mode, result, 0);
4313 convert_move (target, result, 0);
4317 /* Expand the library call ourselves using a stabilized argument
4318 list to avoid re-evaluating the function's arguments twice. */
4319 #ifdef HAVE_cmpstrnsi
4322 fndecl = get_callee_fndecl (exp);
4323 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4324 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4325 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4326 return expand_call (fn, target, target == const0_rtx);
4332 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4333 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4334 the result in TARGET, if convenient. */
4337 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4338 ATTRIBUTE_UNUSED enum machine_mode mode)
4340 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4342 if (!validate_arglist (exp,
4343 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4346 /* If c_strlen can determine an expression for one of the string
4347 lengths, and it doesn't have side effects, then emit cmpstrnsi
4348 using length MIN(strlen(string)+1, arg3). */
4349 #ifdef HAVE_cmpstrnsi
4352 tree len, len1, len2;
4353 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4356 tree arg1 = CALL_EXPR_ARG (exp, 0);
4357 tree arg2 = CALL_EXPR_ARG (exp, 1);
4358 tree arg3 = CALL_EXPR_ARG (exp, 2);
4360 unsigned int arg1_align
4361 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4362 unsigned int arg2_align
4363 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4364 enum machine_mode insn_mode
4365 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4367 len1 = c_strlen (arg1, 1);
4368 len2 = c_strlen (arg2, 1);
4371 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4373 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4375 /* If we don't have a constant length for the first, use the length
4376 of the second, if we know it. We don't require a constant for
4377 this case; some cost analysis could be done if both are available
4378 but neither is constant. For now, assume they're equally cheap,
4379 unless one has side effects. If both strings have constant lengths,
4386 else if (TREE_SIDE_EFFECTS (len1))
4388 else if (TREE_SIDE_EFFECTS (len2))
4390 else if (TREE_CODE (len1) != INTEGER_CST)
4392 else if (TREE_CODE (len2) != INTEGER_CST)
4394 else if (tree_int_cst_lt (len1, len2))
4399 /* If both arguments have side effects, we cannot optimize. */
4400 if (!len || TREE_SIDE_EFFECTS (len))
4403 /* The actual new length parameter is MIN(len,arg3). */
4404 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4405 fold_convert_loc (loc, TREE_TYPE (len), arg3));
4407 /* If we don't have POINTER_TYPE, call the function. */
4408 if (arg1_align == 0 || arg2_align == 0)
4411 /* Make a place to write the result of the instruction. */
4414 && REG_P (result) && GET_MODE (result) == insn_mode
4415 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4416 result = gen_reg_rtx (insn_mode);
4418 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4419 arg1 = builtin_save_expr (arg1);
4420 arg2 = builtin_save_expr (arg2);
4421 len = builtin_save_expr (len);
4423 arg1_rtx = get_memory_rtx (arg1, len);
4424 arg2_rtx = get_memory_rtx (arg2, len);
4425 arg3_rtx = expand_normal (len);
4426 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4427 GEN_INT (MIN (arg1_align, arg2_align)));
4432 /* Return the value in the proper mode for this function. */
4433 mode = TYPE_MODE (TREE_TYPE (exp));
4434 if (GET_MODE (result) == mode)
4437 return convert_to_mode (mode, result, 0);
4438 convert_move (target, result, 0);
4442 /* Expand the library call ourselves using a stabilized argument
4443 list to avoid re-evaluating the function's arguments twice. */
4444 fndecl = get_callee_fndecl (exp);
4445 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4447 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4448 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4449 return expand_call (fn, target, target == const0_rtx);
4455 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4456 if that's convenient. */
4459 expand_builtin_saveregs (void)
4463 /* Don't do __builtin_saveregs more than once in a function.
4464 Save the result of the first call and reuse it. */
4465 if (saveregs_value != 0)
4466 return saveregs_value;
4468 /* When this function is called, it means that registers must be
4469 saved on entry to this function. So we migrate the call to the
4470 first insn of this function. */
4474 /* Do whatever the machine needs done in this case. */
4475 val = targetm.calls.expand_builtin_saveregs ();
4480 saveregs_value = val;
4482 /* Put the insns after the NOTE that starts the function. If this
4483 is inside a start_sequence, make the outer-level insn chain current, so
4484 the code is placed at the start of the function. */
4485 push_topmost_sequence ();
4486 emit_insn_after (seq, entry_of_function ());
4487 pop_topmost_sequence ();
4492 /* Expand a call to __builtin_next_arg. */
4495 expand_builtin_next_arg (void)
4497 /* Checking arguments is already done in fold_builtin_next_arg
4498 that must be called before this function. */
4499 return expand_binop (ptr_mode, add_optab,
4500 crtl->args.internal_arg_pointer,
4501 crtl->args.arg_offset_rtx,
4502 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4505 /* Make it easier for the backends by protecting the valist argument
4506 from multiple evaluations. */
4509 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4511 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4513 /* The current way of determining the type of valist is completely
4514 bogus. We should have the information on the va builtin instead. */
4516 vatype = targetm.fn_abi_va_list (cfun->decl);
4518 if (TREE_CODE (vatype) == ARRAY_TYPE)
4520 if (TREE_SIDE_EFFECTS (valist))
4521 valist = save_expr (valist);
4523 /* For this case, the backends will be expecting a pointer to
4524 vatype, but it's possible we've actually been given an array
4525 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4527 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4529 tree p1 = build_pointer_type (TREE_TYPE (vatype));
4530 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4535 tree pt = build_pointer_type (vatype);
4539 if (! TREE_SIDE_EFFECTS (valist))
4542 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4543 TREE_SIDE_EFFECTS (valist) = 1;
4546 if (TREE_SIDE_EFFECTS (valist))
4547 valist = save_expr (valist);
4548 valist = fold_build2_loc (loc, MEM_REF,
4549 vatype, valist, build_int_cst (pt, 0));
4555 /* The "standard" definition of va_list is void*. */
4558 std_build_builtin_va_list (void)
4560 return ptr_type_node;
4563 /* The "standard" abi va_list is va_list_type_node. */
4566 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4568 return va_list_type_node;
4571 /* The "standard" type of va_list is va_list_type_node. */
4574 std_canonical_va_list_type (tree type)
4578 if (INDIRECT_REF_P (type))
4579 type = TREE_TYPE (type);
4580 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4581 type = TREE_TYPE (type);
4582 wtype = va_list_type_node;
4584 /* Treat structure va_list types. */
4585 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4586 htype = TREE_TYPE (htype);
4587 else if (TREE_CODE (wtype) == ARRAY_TYPE)
4589 /* If va_list is an array type, the argument may have decayed
4590 to a pointer type, e.g. by being passed to another function.
4591 In that case, unwrap both types so that we can compare the
4592 underlying records. */
4593 if (TREE_CODE (htype) == ARRAY_TYPE
4594 || POINTER_TYPE_P (htype))
4596 wtype = TREE_TYPE (wtype);
4597 htype = TREE_TYPE (htype);
4600 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4601 return va_list_type_node;
4606 /* The "standard" implementation of va_start: just assign `nextarg' to
4610 std_expand_builtin_va_start (tree valist, rtx nextarg)
4612 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4613 convert_move (va_r, nextarg, 0);
4616 /* Expand EXP, a call to __builtin_va_start. */
4619 expand_builtin_va_start (tree exp)
4623 location_t loc = EXPR_LOCATION (exp);
4625 if (call_expr_nargs (exp) < 2)
4627 error_at (loc, "too few arguments to function %<va_start%>");
4631 if (fold_builtin_next_arg (exp, true))
4634 nextarg = expand_builtin_next_arg ();
4635 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4637 if (targetm.expand_builtin_va_start)
4638 targetm.expand_builtin_va_start (valist, nextarg);
4640 std_expand_builtin_va_start (valist, nextarg);
4645 /* The "standard" implementation of va_arg: read the value from the
4646 current (padded) address and increment by the (padded) size. */
4649 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4652 tree addr, t, type_size, rounded_size, valist_tmp;
4653 unsigned HOST_WIDE_INT align, boundary;
4656 #ifdef ARGS_GROW_DOWNWARD
4657 /* All of the alignment and movement below is for args-grow-up machines.
4658 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4659 implement their own specialized gimplify_va_arg_expr routines. */
4663 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4665 type = build_pointer_type (type);
4667 align = PARM_BOUNDARY / BITS_PER_UNIT;
4668 boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
4670 /* When we align parameter on stack for caller, if the parameter
4671 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4672 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
4673 here with caller. */
4674 if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4675 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4677 boundary /= BITS_PER_UNIT;
4679 /* Hoist the valist value into a temporary for the moment. */
4680 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4682 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4683 requires greater alignment, we must perform dynamic alignment. */
4684 if (boundary > align
4685 && !integer_zerop (TYPE_SIZE (type)))
4687 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4688 fold_build2 (POINTER_PLUS_EXPR,
4690 valist_tmp, size_int (boundary - 1)));
4691 gimplify_and_add (t, pre_p);
4693 t = fold_convert (sizetype, valist_tmp);
4694 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4695 fold_convert (TREE_TYPE (valist),
4696 fold_build2 (BIT_AND_EXPR, sizetype, t,
4697 size_int (-boundary))));
4698 gimplify_and_add (t, pre_p);
4703 /* If the actual alignment is less than the alignment of the type,
4704 adjust the type accordingly so that we don't assume strict alignment
4705 when dereferencing the pointer. */
4706 boundary *= BITS_PER_UNIT;
4707 if (boundary < TYPE_ALIGN (type))
4709 type = build_variant_type_copy (type);
4710 TYPE_ALIGN (type) = boundary;
4713 /* Compute the rounded size of the type. */
4714 type_size = size_in_bytes (type);
4715 rounded_size = round_up (type_size, align);
4717 /* Reduce rounded_size so it's sharable with the postqueue. */
4718 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4722 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4724 /* Small args are padded downward. */
4725 t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4726 rounded_size, size_int (align));
4727 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4728 size_binop (MINUS_EXPR, rounded_size, type_size));
4729 addr = fold_build2 (POINTER_PLUS_EXPR,
4730 TREE_TYPE (addr), addr, t);
4733 /* Compute new value for AP. */
4734 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4735 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4736 gimplify_and_add (t, pre_p);
4738 addr = fold_convert (build_pointer_type (type), addr);
4741 addr = build_va_arg_indirect_ref (addr);
4743 return build_va_arg_indirect_ref (addr);
4746 /* Build an indirect-ref expression over the given TREE, which represents a
4747 piece of a va_arg() expansion. */
4749 build_va_arg_indirect_ref (tree addr)
4751 addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
4753 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4759 /* Return a dummy expression of type TYPE in order to keep going after an
4763 dummy_object (tree type)
4765 tree t = build_int_cst (build_pointer_type (type), 0);
4766 return build2 (MEM_REF, type, t, t);
4769 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4770 builtin function, but a very special sort of operator. */
4772 enum gimplify_status
4773 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4775 tree promoted_type, have_va_type;
4776 tree valist = TREE_OPERAND (*expr_p, 0);
4777 tree type = TREE_TYPE (*expr_p);
4779 location_t loc = EXPR_LOCATION (*expr_p);
4781 /* Verify that valist is of the proper type. */
4782 have_va_type = TREE_TYPE (valist);
4783 if (have_va_type == error_mark_node)
4785 have_va_type = targetm.canonical_va_list_type (have_va_type);
4787 if (have_va_type == NULL_TREE)
4789 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4793 /* Generate a diagnostic for requesting data of a type that cannot
4794 be passed through `...' due to type promotion at the call site. */
4795 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4798 static bool gave_help;
4801 /* Unfortunately, this is merely undefined, rather than a constraint
4802 violation, so we cannot make this an error. If this call is never
4803 executed, the program is still strictly conforming. */
4804 warned = warning_at (loc, 0,
4805 "%qT is promoted to %qT when passed through %<...%>",
4806 type, promoted_type);
4807 if (!gave_help && warned)
4810 inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4811 promoted_type, type);
4814 /* We can, however, treat "undefined" any way we please.
4815 Call abort to encourage the user to fix the program. */
4817 inform (loc, "if this code is reached, the program will abort");
4818 /* Before the abort, allow the evaluation of the va_list
4819 expression to exit or longjmp. */
4820 gimplify_and_add (valist, pre_p);
4821 t = build_call_expr_loc (loc,
4822 implicit_built_in_decls[BUILT_IN_TRAP], 0);
4823 gimplify_and_add (t, pre_p);
4825 /* This is dead code, but go ahead and finish so that the
4826 mode of the result comes out right. */
4827 *expr_p = dummy_object (type);
4832 /* Make it easier for the backends by protecting the valist argument
4833 from multiple evaluations. */
4834 if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4836 /* For this case, the backends will be expecting a pointer to
4837 TREE_TYPE (abi), but it's possible we've
4838 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4840 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4842 tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4843 valist = fold_convert_loc (loc, p1,
4844 build_fold_addr_expr_loc (loc, valist));
4847 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4850 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4852 if (!targetm.gimplify_va_arg_expr)
4853 /* FIXME: Once most targets are converted we should merely
4854 assert this is non-null. */
4857 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4862 /* Expand EXP, a call to __builtin_va_end. */
4865 expand_builtin_va_end (tree exp)
4867 tree valist = CALL_EXPR_ARG (exp, 0);
4869 /* Evaluate for side effects, if needed. I hate macros that don't
4871 if (TREE_SIDE_EFFECTS (valist))
4872 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4877 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4878 builtin rather than just as an assignment in stdarg.h because of the
4879 nastiness of array-type va_list types. */
4882 expand_builtin_va_copy (tree exp)
4885 location_t loc = EXPR_LOCATION (exp);
4887 dst = CALL_EXPR_ARG (exp, 0);
4888 src = CALL_EXPR_ARG (exp, 1);
4890 dst = stabilize_va_list_loc (loc, dst, 1);
4891 src = stabilize_va_list_loc (loc, src, 0);
4893 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4895 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4897 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4898 TREE_SIDE_EFFECTS (t) = 1;
4899 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4903 rtx dstb, srcb, size;
4905 /* Evaluate to pointers. */
4906 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4907 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4908 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4909 NULL_RTX, VOIDmode, EXPAND_NORMAL);
4911 dstb = convert_memory_address (Pmode, dstb);
4912 srcb = convert_memory_address (Pmode, srcb);
4914 /* "Dereference" to BLKmode memories. */
4915 dstb = gen_rtx_MEM (BLKmode, dstb);
4916 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4917 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4918 srcb = gen_rtx_MEM (BLKmode, srcb);
4919 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4920 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4923 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4929 /* Expand a call to one of the builtin functions __builtin_frame_address or
4930 __builtin_return_address. */
4933 expand_builtin_frame_address (tree fndecl, tree exp)
4935 /* The argument must be a nonnegative integer constant.
4936 It counts the number of frames to scan up the stack.
4937 The value is the return address saved in that frame. */
4938 if (call_expr_nargs (exp) == 0)
4939 /* Warning about missing arg was already issued. */
4941 else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4943 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4944 error ("invalid argument to %<__builtin_frame_address%>");
4946 error ("invalid argument to %<__builtin_return_address%>");
4952 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4953 tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4955 /* Some ports cannot access arbitrary stack frames. */
4958 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4959 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4961 warning (0, "unsupported argument to %<__builtin_return_address%>");
4965 /* For __builtin_frame_address, return what we've got. */
4966 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4970 && ! CONSTANT_P (tem))
4971 tem = copy_to_mode_reg (Pmode, tem);
4976 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4977 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4978 is the same as for allocate_dynamic_stack_space. */
4981 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4986 /* Emit normal call if marked not-inlineable. */
4987 if (CALL_CANNOT_INLINE_P (exp))
4990 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4993 /* Compute the argument. */
4994 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4996 /* Allocate the desired space. */
4997 result = allocate_dynamic_stack_space (op0, 0, BIGGEST_ALIGNMENT,
4999 result = convert_memory_address (ptr_mode, result);
5004 /* Expand a call to a bswap builtin with argument ARG0. MODE
5005 is the mode to expand with. */
5008 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
5010 enum machine_mode mode;
5014 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5017 arg = CALL_EXPR_ARG (exp, 0);
5018 mode = TYPE_MODE (TREE_TYPE (arg));
5019 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5021 target = expand_unop (mode, bswap_optab, op0, target, 1);
5023 gcc_assert (target);
5025 return convert_to_mode (mode, target, 0);
5028 /* Expand a call to a unary builtin in EXP.
5029 Return NULL_RTX if a normal call should be emitted rather than expanding the
5030 function in-line. If convenient, the result should be placed in TARGET.
5031 SUBTARGET may be used as the target for computing one of EXP's operands. */
5034 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
5035 rtx subtarget, optab op_optab)
5039 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5042 /* Compute the argument. */
5043 op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
5045 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
5046 == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
5047 VOIDmode, EXPAND_NORMAL);
5048 /* Compute op, into TARGET if possible.
5049 Set TARGET to wherever the result comes back. */
5050 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5051 op_optab, op0, target, 1);
5052 gcc_assert (target);
5054 return convert_to_mode (target_mode, target, 0);
5057 /* Expand a call to __builtin_expect. We just return our argument
5058 as the builtin_expect semantic should've been already executed by
5059 tree branch prediction pass. */
5062 expand_builtin_expect (tree exp, rtx target)
5066 if (call_expr_nargs (exp) < 2)
5068 arg = CALL_EXPR_ARG (exp, 0);
5070 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5071 /* When guessing was done, the hints should be already stripped away. */
5072 gcc_assert (!flag_guess_branch_prob
5073 || optimize == 0 || seen_error ());
5078 expand_builtin_trap (void)
5082 emit_insn (gen_trap ());
5085 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5089 /* Expand a call to __builtin_unreachable. We do nothing except emit
5090 a barrier saying that control flow will not pass here.
5092 It is the responsibility of the program being compiled to ensure
5093 that control flow does never reach __builtin_unreachable. */
5095 expand_builtin_unreachable (void)
5100 /* Expand EXP, a call to fabs, fabsf or fabsl.
5101 Return NULL_RTX if a normal call should be emitted rather than expanding
5102 the function inline. If convenient, the result should be placed
5103 in TARGET. SUBTARGET may be used as the target for computing
5107 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5109 enum machine_mode mode;
5113 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5116 arg = CALL_EXPR_ARG (exp, 0);
5117 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5118 mode = TYPE_MODE (TREE_TYPE (arg));
5119 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5120 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5123 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5124 Return NULL is a normal call should be emitted rather than expanding the
5125 function inline. If convenient, the result should be placed in TARGET.
5126 SUBTARGET may be used as the target for computing the operand. */
5129 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5134 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5137 arg = CALL_EXPR_ARG (exp, 0);
5138 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5140 arg = CALL_EXPR_ARG (exp, 1);
5141 op1 = expand_normal (arg);
5143 return expand_copysign (op0, op1, target);
5146 /* Create a new constant string literal and return a char* pointer to it.
5147 The STRING_CST value is the LEN characters at STR. */
5149 build_string_literal (int len, const char *str)
5151 tree t, elem, index, type;
5153 t = build_string (len, str);
5154 elem = build_type_variant (char_type_node, 1, 0);
5155 index = build_index_type (size_int (len - 1));
5156 type = build_array_type (elem, index);
5157 TREE_TYPE (t) = type;
5158 TREE_CONSTANT (t) = 1;
5159 TREE_READONLY (t) = 1;
5160 TREE_STATIC (t) = 1;
5162 type = build_pointer_type (elem);
5163 t = build1 (ADDR_EXPR, type,
5164 build4 (ARRAY_REF, elem,
5165 t, integer_zero_node, NULL_TREE, NULL_TREE));
5169 /* Expand a call to __builtin___clear_cache. */
5172 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5174 #ifndef HAVE_clear_cache
5175 #ifdef CLEAR_INSN_CACHE
5176 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5177 does something. Just do the default expansion to a call to
5181 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5182 does nothing. There is no need to call it. Do nothing. */
5184 #endif /* CLEAR_INSN_CACHE */
5186 /* We have a "clear_cache" insn, and it will handle everything. */
5188 rtx begin_rtx, end_rtx;
5190 /* We must not expand to a library call. If we did, any
5191 fallback library function in libgcc that might contain a call to
5192 __builtin___clear_cache() would recurse infinitely. */
5193 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5195 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5199 if (HAVE_clear_cache)
5201 struct expand_operand ops[2];
5203 begin = CALL_EXPR_ARG (exp, 0);
5204 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5206 end = CALL_EXPR_ARG (exp, 1);
5207 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5209 create_address_operand (&ops[0], begin_rtx);
5210 create_address_operand (&ops[1], end_rtx);
5211 if (maybe_expand_insn (CODE_FOR_clear_cache, 2, ops))
5215 #endif /* HAVE_clear_cache */
5218 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5221 round_trampoline_addr (rtx tramp)
5223 rtx temp, addend, mask;
5225 /* If we don't need too much alignment, we'll have been guaranteed
5226 proper alignment by get_trampoline_type. */
5227 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5230 /* Round address up to desired boundary. */
5231 temp = gen_reg_rtx (Pmode);
5232 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5233 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5235 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
5236 temp, 0, OPTAB_LIB_WIDEN);
5237 tramp = expand_simple_binop (Pmode, AND, temp, mask,
5238 temp, 0, OPTAB_LIB_WIDEN);
5244 expand_builtin_init_trampoline (tree exp)
5246 tree t_tramp, t_func, t_chain;
5247 rtx m_tramp, r_tramp, r_chain, tmp;
5249 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5250 POINTER_TYPE, VOID_TYPE))
5253 t_tramp = CALL_EXPR_ARG (exp, 0);
5254 t_func = CALL_EXPR_ARG (exp, 1);
5255 t_chain = CALL_EXPR_ARG (exp, 2);
5257 r_tramp = expand_normal (t_tramp);
5258 m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5259 MEM_NOTRAP_P (m_tramp) = 1;
5261 /* The TRAMP argument should be the address of a field within the
5262 local function's FRAME decl. Let's see if we can fill in the
5263 to fill in the MEM_ATTRs for this memory. */
5264 if (TREE_CODE (t_tramp) == ADDR_EXPR)
5265 set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5268 tmp = round_trampoline_addr (r_tramp);
5271 m_tramp = change_address (m_tramp, BLKmode, tmp);
5272 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5273 set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5276 /* The FUNC argument should be the address of the nested function.
5277 Extract the actual function decl to pass to the hook. */
5278 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5279 t_func = TREE_OPERAND (t_func, 0);
5280 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5282 r_chain = expand_normal (t_chain);
5284 /* Generate insns to initialize the trampoline. */
5285 targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5287 trampolines_created = 1;
5289 warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5290 "trampoline generated for nested function %qD", t_func);
5296 expand_builtin_adjust_trampoline (tree exp)
5300 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5303 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5304 tramp = round_trampoline_addr (tramp);
5305 if (targetm.calls.trampoline_adjust_address)
5306 tramp = targetm.calls.trampoline_adjust_address (tramp);
5311 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5312 function. The function first checks whether the back end provides
5313 an insn to implement signbit for the respective mode. If not, it
5314 checks whether the floating point format of the value is such that
5315 the sign bit can be extracted. If that is not the case, the
5316 function returns NULL_RTX to indicate that a normal call should be
5317 emitted rather than expanding the function in-line. EXP is the
5318 expression that is a call to the builtin function; if convenient,
5319 the result should be placed in TARGET. */
5321 expand_builtin_signbit (tree exp, rtx target)
5323 const struct real_format *fmt;
5324 enum machine_mode fmode, imode, rmode;
5327 enum insn_code icode;
5329 location_t loc = EXPR_LOCATION (exp);
5331 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5334 arg = CALL_EXPR_ARG (exp, 0);
5335 fmode = TYPE_MODE (TREE_TYPE (arg));
5336 rmode = TYPE_MODE (TREE_TYPE (exp));
5337 fmt = REAL_MODE_FORMAT (fmode);
5339 arg = builtin_save_expr (arg);
5341 /* Expand the argument yielding a RTX expression. */
5342 temp = expand_normal (arg);
5344 /* Check if the back end provides an insn that handles signbit for the
5346 icode = optab_handler (signbit_optab, fmode);
5347 if (icode != CODE_FOR_nothing)
5349 rtx last = get_last_insn ();
5350 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5351 if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5353 delete_insns_since (last);
5356 /* For floating point formats without a sign bit, implement signbit
5358 bitpos = fmt->signbit_ro;
5361 /* But we can't do this if the format supports signed zero. */
5362 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5365 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5366 build_real (TREE_TYPE (arg), dconst0));
5367 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5370 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5372 imode = int_mode_for_mode (fmode);
5373 if (imode == BLKmode)
5375 temp = gen_lowpart (imode, temp);
5380 /* Handle targets with different FP word orders. */
5381 if (FLOAT_WORDS_BIG_ENDIAN)
5382 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5384 word = bitpos / BITS_PER_WORD;
5385 temp = operand_subword_force (temp, word, fmode);
5386 bitpos = bitpos % BITS_PER_WORD;
5389 /* Force the intermediate word_mode (or narrower) result into a
5390 register. This avoids attempting to create paradoxical SUBREGs
5391 of floating point modes below. */
5392 temp = force_reg (imode, temp);
5394 /* If the bitpos is within the "result mode" lowpart, the operation
5395 can be implement with a single bitwise AND. Otherwise, we need
5396 a right shift and an AND. */
5398 if (bitpos < GET_MODE_BITSIZE (rmode))
5400 double_int mask = double_int_setbit (double_int_zero, bitpos);
5402 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5403 temp = gen_lowpart (rmode, temp);
5404 temp = expand_binop (rmode, and_optab, temp,
5405 immed_double_int_const (mask, rmode),
5406 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5410 /* Perform a logical right shift to place the signbit in the least
5411 significant bit, then truncate the result to the desired mode
5412 and mask just this bit. */
5413 temp = expand_shift (RSHIFT_EXPR, imode, temp,
5414 build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5415 temp = gen_lowpart (rmode, temp);
5416 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5417 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5423 /* Expand fork or exec calls. TARGET is the desired target of the
5424 call. EXP is the call. FN is the
5425 identificator of the actual function. IGNORE is nonzero if the
5426 value is to be ignored. */
5429 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5434 /* If we are not profiling, just call the function. */
5435 if (!profile_arc_flag)
5438 /* Otherwise call the wrapper. This should be equivalent for the rest of
5439 compiler, so the code does not diverge, and the wrapper may run the
5440 code necessary for keeping the profiling sane. */
5442 switch (DECL_FUNCTION_CODE (fn))
5445 id = get_identifier ("__gcov_fork");
5448 case BUILT_IN_EXECL:
5449 id = get_identifier ("__gcov_execl");
5452 case BUILT_IN_EXECV:
5453 id = get_identifier ("__gcov_execv");
5456 case BUILT_IN_EXECLP:
5457 id = get_identifier ("__gcov_execlp");
5460 case BUILT_IN_EXECLE:
5461 id = get_identifier ("__gcov_execle");
5464 case BUILT_IN_EXECVP:
5465 id = get_identifier ("__gcov_execvp");
5468 case BUILT_IN_EXECVE:
5469 id = get_identifier ("__gcov_execve");
5476 decl = build_decl (DECL_SOURCE_LOCATION (fn),
5477 FUNCTION_DECL, id, TREE_TYPE (fn));
5478 DECL_EXTERNAL (decl) = 1;
5479 TREE_PUBLIC (decl) = 1;
5480 DECL_ARTIFICIAL (decl) = 1;
5481 TREE_NOTHROW (decl) = 1;
5482 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5483 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5484 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5485 return expand_call (call, target, ignore);
5490 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5491 the pointer in these functions is void*, the tree optimizers may remove
5492 casts. The mode computed in expand_builtin isn't reliable either, due
5493 to __sync_bool_compare_and_swap.
5495 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5496 group of builtins. This gives us log2 of the mode size. */
5498 static inline enum machine_mode
5499 get_builtin_sync_mode (int fcode_diff)
5501 /* The size is not negotiable, so ask not to get BLKmode in return
5502 if the target indicates that a smaller size would be better. */
5503 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5506 /* Expand the memory expression LOC and return the appropriate memory operand
5507 for the builtin_sync operations. */
5510 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5514 addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5515 addr = convert_memory_address (Pmode, addr);
5517 /* Note that we explicitly do not want any alias information for this
5518 memory, so that we kill all other live memories. Otherwise we don't
5519 satisfy the full barrier semantics of the intrinsic. */
5520 mem = validize_mem (gen_rtx_MEM (mode, addr));
5522 /* The alignment needs to be at least according to that of the mode. */
5523 set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5524 get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5525 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5526 MEM_VOLATILE_P (mem) = 1;
5531 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5532 EXP is the CALL_EXPR. CODE is the rtx code
5533 that corresponds to the arithmetic or logical operation from the name;
5534 an exception here is that NOT actually means NAND. TARGET is an optional
5535 place for us to store the results; AFTER is true if this is the
5536 fetch_and_xxx form. IGNORE is true if we don't actually care about
5537 the result of the operation at all. */
5540 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5541 enum rtx_code code, bool after,
5542 rtx target, bool ignore)
5545 enum machine_mode old_mode;
5546 location_t loc = EXPR_LOCATION (exp);
5548 if (code == NOT && warn_sync_nand)
5550 tree fndecl = get_callee_fndecl (exp);
5551 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5553 static bool warned_f_a_n, warned_n_a_f;
5557 case BUILT_IN_FETCH_AND_NAND_1:
5558 case BUILT_IN_FETCH_AND_NAND_2:
5559 case BUILT_IN_FETCH_AND_NAND_4:
5560 case BUILT_IN_FETCH_AND_NAND_8:
5561 case BUILT_IN_FETCH_AND_NAND_16:
5566 fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5567 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5568 warned_f_a_n = true;
5571 case BUILT_IN_NAND_AND_FETCH_1:
5572 case BUILT_IN_NAND_AND_FETCH_2:
5573 case BUILT_IN_NAND_AND_FETCH_4:
5574 case BUILT_IN_NAND_AND_FETCH_8:
5575 case BUILT_IN_NAND_AND_FETCH_16:
5580 fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5581 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5582 warned_n_a_f = true;
5590 /* Expand the operands. */
5591 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5593 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5594 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5595 of CONST_INTs, where we know the old_mode only from the call argument. */
5596 old_mode = GET_MODE (val);
5597 if (old_mode == VOIDmode)
5598 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5599 val = convert_modes (mode, old_mode, val, 1);
5602 return expand_sync_operation (mem, val, code);
5604 return expand_sync_fetch_operation (mem, val, code, after, target);
5607 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5608 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5609 true if this is the boolean form. TARGET is a place for us to store the
5610 results; this is NOT optional if IS_BOOL is true. */
5613 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5614 bool is_bool, rtx target)
5616 rtx old_val, new_val, mem;
5617 enum machine_mode old_mode;
5619 /* Expand the operands. */
5620 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5623 old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5624 mode, EXPAND_NORMAL);
5625 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5626 of CONST_INTs, where we know the old_mode only from the call argument. */
5627 old_mode = GET_MODE (old_val);
5628 if (old_mode == VOIDmode)
5629 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5630 old_val = convert_modes (mode, old_mode, old_val, 1);
5632 new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5633 mode, EXPAND_NORMAL);
5634 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5635 of CONST_INTs, where we know the old_mode only from the call argument. */
5636 old_mode = GET_MODE (new_val);
5637 if (old_mode == VOIDmode)
5638 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5639 new_val = convert_modes (mode, old_mode, new_val, 1);
5642 return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5644 return expand_val_compare_and_swap (mem, old_val, new_val, target);
5647 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5648 general form is actually an atomic exchange, and some targets only
5649 support a reduced form with the second argument being a constant 1.
5650 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5654 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5658 enum machine_mode old_mode;
5660 /* Expand the operands. */
5661 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5662 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5663 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5664 of CONST_INTs, where we know the old_mode only from the call argument. */
5665 old_mode = GET_MODE (val);
5666 if (old_mode == VOIDmode)
5667 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5668 val = convert_modes (mode, old_mode, val, 1);
5670 return expand_sync_lock_test_and_set (mem, val, target);
5673 /* Expand the __sync_synchronize intrinsic. */
5676 expand_builtin_synchronize (void)
5679 VEC (tree, gc) *v_clobbers;
5681 #ifdef HAVE_memory_barrier
5682 if (HAVE_memory_barrier)
5684 emit_insn (gen_memory_barrier ());
5689 if (synchronize_libfunc != NULL_RTX)
5691 emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5695 /* If no explicit memory barrier instruction is available, create an
5696 empty asm stmt with a memory clobber. */
5697 v_clobbers = VEC_alloc (tree, gc, 1);
5698 VEC_quick_push (tree, v_clobbers,
5699 tree_cons (NULL, build_string (6, "memory"), NULL));
5700 x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5701 gimple_asm_set_volatile (x, true);
5702 expand_asm_stmt (x);
5705 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5708 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5710 struct expand_operand ops[2];
5711 enum insn_code icode;
5714 /* Expand the operands. */
5715 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5717 /* If there is an explicit operation in the md file, use it. */
5718 icode = direct_optab_handler (sync_lock_release_optab, mode);
5719 if (icode != CODE_FOR_nothing)
5721 create_fixed_operand (&ops[0], mem);
5722 create_input_operand (&ops[1], const0_rtx, mode);
5723 if (maybe_expand_insn (icode, 2, ops))
5727 /* Otherwise we can implement this operation by emitting a barrier
5728 followed by a store of zero. */
5729 expand_builtin_synchronize ();
5730 emit_move_insn (mem, const0_rtx);
5733 /* Expand an expression EXP that calls a built-in function,
5734 with result going to TARGET if that's convenient
5735 (and in mode MODE if that's convenient).
5736 SUBTARGET may be used as the target for computing one of EXP's operands.
5737 IGNORE is nonzero if the value is to be ignored. */
5740 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5743 tree fndecl = get_callee_fndecl (exp);
5744 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5745 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5748 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5749 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5751 /* When not optimizing, generate calls to library functions for a certain
5754 && !called_as_built_in (fndecl)
5755 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5756 && fcode != BUILT_IN_ALLOCA
5757 && fcode != BUILT_IN_FREE)
5758 return expand_call (exp, target, ignore);
5760 /* The built-in function expanders test for target == const0_rtx
5761 to determine whether the function's result will be ignored. */
5763 target = const0_rtx;
5765 /* If the result of a pure or const built-in function is ignored, and
5766 none of its arguments are volatile, we can avoid expanding the
5767 built-in call and just evaluate the arguments for side-effects. */
5768 if (target == const0_rtx
5769 && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5770 && !(flags & ECF_LOOPING_CONST_OR_PURE))
5772 bool volatilep = false;
5774 call_expr_arg_iterator iter;
5776 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5777 if (TREE_THIS_VOLATILE (arg))
5785 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5786 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5793 CASE_FLT_FN (BUILT_IN_FABS):
5794 target = expand_builtin_fabs (exp, target, subtarget);
5799 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5800 target = expand_builtin_copysign (exp, target, subtarget);
5805 /* Just do a normal library call if we were unable to fold
5807 CASE_FLT_FN (BUILT_IN_CABS):
5810 CASE_FLT_FN (BUILT_IN_EXP):
5811 CASE_FLT_FN (BUILT_IN_EXP10):
5812 CASE_FLT_FN (BUILT_IN_POW10):
5813 CASE_FLT_FN (BUILT_IN_EXP2):
5814 CASE_FLT_FN (BUILT_IN_EXPM1):
5815 CASE_FLT_FN (BUILT_IN_LOGB):
5816 CASE_FLT_FN (BUILT_IN_LOG):
5817 CASE_FLT_FN (BUILT_IN_LOG10):
5818 CASE_FLT_FN (BUILT_IN_LOG2):
5819 CASE_FLT_FN (BUILT_IN_LOG1P):
5820 CASE_FLT_FN (BUILT_IN_TAN):
5821 CASE_FLT_FN (BUILT_IN_ASIN):
5822 CASE_FLT_FN (BUILT_IN_ACOS):
5823 CASE_FLT_FN (BUILT_IN_ATAN):
5824 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5825 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5826 because of possible accuracy problems. */
5827 if (! flag_unsafe_math_optimizations)
5829 CASE_FLT_FN (BUILT_IN_SQRT):
5830 CASE_FLT_FN (BUILT_IN_FLOOR):
5831 CASE_FLT_FN (BUILT_IN_CEIL):
5832 CASE_FLT_FN (BUILT_IN_TRUNC):
5833 CASE_FLT_FN (BUILT_IN_ROUND):
5834 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5835 CASE_FLT_FN (BUILT_IN_RINT):
5836 target = expand_builtin_mathfn (exp, target, subtarget);
5841 CASE_FLT_FN (BUILT_IN_FMA):
5842 target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5847 CASE_FLT_FN (BUILT_IN_ILOGB):
5848 if (! flag_unsafe_math_optimizations)
5850 CASE_FLT_FN (BUILT_IN_ISINF):
5851 CASE_FLT_FN (BUILT_IN_FINITE):
5852 case BUILT_IN_ISFINITE:
5853 case BUILT_IN_ISNORMAL:
5854 target = expand_builtin_interclass_mathfn (exp, target);
5859 CASE_FLT_FN (BUILT_IN_LCEIL):
5860 CASE_FLT_FN (BUILT_IN_LLCEIL):
5861 CASE_FLT_FN (BUILT_IN_LFLOOR):
5862 CASE_FLT_FN (BUILT_IN_LLFLOOR):
5863 target = expand_builtin_int_roundingfn (exp, target);
5868 CASE_FLT_FN (BUILT_IN_LRINT):
5869 CASE_FLT_FN (BUILT_IN_LLRINT):
5870 CASE_FLT_FN (BUILT_IN_LROUND):
5871 CASE_FLT_FN (BUILT_IN_LLROUND):
5872 target = expand_builtin_int_roundingfn_2 (exp, target);
5877 CASE_FLT_FN (BUILT_IN_POW):
5878 target = expand_builtin_pow (exp, target, subtarget);
5883 CASE_FLT_FN (BUILT_IN_POWI):
5884 target = expand_builtin_powi (exp, target);
5889 CASE_FLT_FN (BUILT_IN_ATAN2):
5890 CASE_FLT_FN (BUILT_IN_LDEXP):
5891 CASE_FLT_FN (BUILT_IN_SCALB):
5892 CASE_FLT_FN (BUILT_IN_SCALBN):
5893 CASE_FLT_FN (BUILT_IN_SCALBLN):
5894 if (! flag_unsafe_math_optimizations)
5897 CASE_FLT_FN (BUILT_IN_FMOD):
5898 CASE_FLT_FN (BUILT_IN_REMAINDER):
5899 CASE_FLT_FN (BUILT_IN_DREM):
5900 target = expand_builtin_mathfn_2 (exp, target, subtarget);
5905 CASE_FLT_FN (BUILT_IN_CEXPI):
5906 target = expand_builtin_cexpi (exp, target);
5907 gcc_assert (target);
5910 CASE_FLT_FN (BUILT_IN_SIN):
5911 CASE_FLT_FN (BUILT_IN_COS):
5912 if (! flag_unsafe_math_optimizations)
5914 target = expand_builtin_mathfn_3 (exp, target, subtarget);
5919 CASE_FLT_FN (BUILT_IN_SINCOS):
5920 if (! flag_unsafe_math_optimizations)
5922 target = expand_builtin_sincos (exp);
5927 case BUILT_IN_APPLY_ARGS:
5928 return expand_builtin_apply_args ();
5930 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5931 FUNCTION with a copy of the parameters described by
5932 ARGUMENTS, and ARGSIZE. It returns a block of memory
5933 allocated on the stack into which is stored all the registers
5934 that might possibly be used for returning the result of a
5935 function. ARGUMENTS is the value returned by
5936 __builtin_apply_args. ARGSIZE is the number of bytes of
5937 arguments that must be copied. ??? How should this value be
5938 computed? We'll also need a safe worst case value for varargs
5940 case BUILT_IN_APPLY:
5941 if (!validate_arglist (exp, POINTER_TYPE,
5942 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5943 && !validate_arglist (exp, REFERENCE_TYPE,
5944 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5950 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5951 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5952 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5954 return expand_builtin_apply (ops[0], ops[1], ops[2]);
5957 /* __builtin_return (RESULT) causes the function to return the
5958 value described by RESULT. RESULT is address of the block of
5959 memory returned by __builtin_apply. */
5960 case BUILT_IN_RETURN:
5961 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5962 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5965 case BUILT_IN_SAVEREGS:
5966 return expand_builtin_saveregs ();
5968 case BUILT_IN_VA_ARG_PACK:
5969 /* All valid uses of __builtin_va_arg_pack () are removed during
5971 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5974 case BUILT_IN_VA_ARG_PACK_LEN:
5975 /* All valid uses of __builtin_va_arg_pack_len () are removed during
5977 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5980 /* Return the address of the first anonymous stack arg. */
5981 case BUILT_IN_NEXT_ARG:
5982 if (fold_builtin_next_arg (exp, false))
5984 return expand_builtin_next_arg ();
5986 case BUILT_IN_CLEAR_CACHE:
5987 target = expand_builtin___clear_cache (exp);
5992 case BUILT_IN_CLASSIFY_TYPE:
5993 return expand_builtin_classify_type (exp);
5995 case BUILT_IN_CONSTANT_P:
5998 case BUILT_IN_FRAME_ADDRESS:
5999 case BUILT_IN_RETURN_ADDRESS:
6000 return expand_builtin_frame_address (fndecl, exp);
6002 /* Returns the address of the area where the structure is returned.
6004 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6005 if (call_expr_nargs (exp) != 0
6006 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6007 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6010 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6012 case BUILT_IN_ALLOCA:
6013 /* If the allocation stems from the declaration of a variable-sized
6014 object, it cannot accumulate. */
6015 target = expand_builtin_alloca (exp, ALLOCA_FOR_VAR_P (exp));
6020 case BUILT_IN_STACK_SAVE:
6021 return expand_stack_save ();
6023 case BUILT_IN_STACK_RESTORE:
6024 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6027 case BUILT_IN_BSWAP32:
6028 case BUILT_IN_BSWAP64:
6029 target = expand_builtin_bswap (exp, target, subtarget);
6035 CASE_INT_FN (BUILT_IN_FFS):
6036 case BUILT_IN_FFSIMAX:
6037 target = expand_builtin_unop (target_mode, exp, target,
6038 subtarget, ffs_optab);
6043 CASE_INT_FN (BUILT_IN_CLZ):
6044 case BUILT_IN_CLZIMAX:
6045 target = expand_builtin_unop (target_mode, exp, target,
6046 subtarget, clz_optab);
6051 CASE_INT_FN (BUILT_IN_CTZ):
6052 case BUILT_IN_CTZIMAX:
6053 target = expand_builtin_unop (target_mode, exp, target,
6054 subtarget, ctz_optab);
6059 CASE_INT_FN (BUILT_IN_POPCOUNT):
6060 case BUILT_IN_POPCOUNTIMAX:
6061 target = expand_builtin_unop (target_mode, exp, target,
6062 subtarget, popcount_optab);
6067 CASE_INT_FN (BUILT_IN_PARITY):
6068 case BUILT_IN_PARITYIMAX:
6069 target = expand_builtin_unop (target_mode, exp, target,
6070 subtarget, parity_optab);
6075 case BUILT_IN_STRLEN:
6076 target = expand_builtin_strlen (exp, target, target_mode);
6081 case BUILT_IN_STRCPY:
6082 target = expand_builtin_strcpy (exp, target);
6087 case BUILT_IN_STRNCPY:
6088 target = expand_builtin_strncpy (exp, target);
6093 case BUILT_IN_STPCPY:
6094 target = expand_builtin_stpcpy (exp, target, mode);
6099 case BUILT_IN_MEMCPY:
6100 target = expand_builtin_memcpy (exp, target);
6105 case BUILT_IN_MEMPCPY:
6106 target = expand_builtin_mempcpy (exp, target, mode);
6111 case BUILT_IN_MEMSET:
6112 target = expand_builtin_memset (exp, target, mode);
6117 case BUILT_IN_BZERO:
6118 target = expand_builtin_bzero (exp);
6123 case BUILT_IN_STRCMP:
6124 target = expand_builtin_strcmp (exp, target);
6129 case BUILT_IN_STRNCMP:
6130 target = expand_builtin_strncmp (exp, target, mode);
6136 case BUILT_IN_MEMCMP:
6137 target = expand_builtin_memcmp (exp, target, mode);
6142 case BUILT_IN_SETJMP:
6143 /* This should have been lowered to the builtins below. */
6146 case BUILT_IN_SETJMP_SETUP:
6147 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6148 and the receiver label. */
6149 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6151 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6152 VOIDmode, EXPAND_NORMAL);
6153 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6154 rtx label_r = label_rtx (label);
6156 /* This is copied from the handling of non-local gotos. */
6157 expand_builtin_setjmp_setup (buf_addr, label_r);
6158 nonlocal_goto_handler_labels
6159 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6160 nonlocal_goto_handler_labels);
6161 /* ??? Do not let expand_label treat us as such since we would
6162 not want to be both on the list of non-local labels and on
6163 the list of forced labels. */
6164 FORCED_LABEL (label) = 0;
6169 case BUILT_IN_SETJMP_DISPATCHER:
6170 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6171 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6173 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6174 rtx label_r = label_rtx (label);
6176 /* Remove the dispatcher label from the list of non-local labels
6177 since the receiver labels have been added to it above. */
6178 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6183 case BUILT_IN_SETJMP_RECEIVER:
6184 /* __builtin_setjmp_receiver is passed the receiver label. */
6185 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6187 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6188 rtx label_r = label_rtx (label);
6190 expand_builtin_setjmp_receiver (label_r);
6195 /* __builtin_longjmp is passed a pointer to an array of five words.
6196 It's similar to the C library longjmp function but works with
6197 __builtin_setjmp above. */
6198 case BUILT_IN_LONGJMP:
6199 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6201 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6202 VOIDmode, EXPAND_NORMAL);
6203 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6205 if (value != const1_rtx)
6207 error ("%<__builtin_longjmp%> second argument must be 1");
6211 expand_builtin_longjmp (buf_addr, value);
6216 case BUILT_IN_NONLOCAL_GOTO:
6217 target = expand_builtin_nonlocal_goto (exp);
6222 /* This updates the setjmp buffer that is its argument with the value
6223 of the current stack pointer. */
6224 case BUILT_IN_UPDATE_SETJMP_BUF:
6225 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6228 = expand_normal (CALL_EXPR_ARG (exp, 0));
6230 expand_builtin_update_setjmp_buf (buf_addr);
6236 expand_builtin_trap ();
6239 case BUILT_IN_UNREACHABLE:
6240 expand_builtin_unreachable ();
6243 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6244 case BUILT_IN_SIGNBITD32:
6245 case BUILT_IN_SIGNBITD64:
6246 case BUILT_IN_SIGNBITD128:
6247 target = expand_builtin_signbit (exp, target);
6252 /* Various hooks for the DWARF 2 __throw routine. */
6253 case BUILT_IN_UNWIND_INIT:
6254 expand_builtin_unwind_init ();
6256 case BUILT_IN_DWARF_CFA:
6257 return virtual_cfa_rtx;
6258 #ifdef DWARF2_UNWIND_INFO
6259 case BUILT_IN_DWARF_SP_COLUMN:
6260 return expand_builtin_dwarf_sp_column ();
6261 case BUILT_IN_INIT_DWARF_REG_SIZES:
6262 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6265 case BUILT_IN_FROB_RETURN_ADDR:
6266 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6267 case BUILT_IN_EXTRACT_RETURN_ADDR:
6268 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6269 case BUILT_IN_EH_RETURN:
6270 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6271 CALL_EXPR_ARG (exp, 1));
6273 #ifdef EH_RETURN_DATA_REGNO
6274 case BUILT_IN_EH_RETURN_DATA_REGNO:
6275 return expand_builtin_eh_return_data_regno (exp);
6277 case BUILT_IN_EXTEND_POINTER:
6278 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6279 case BUILT_IN_EH_POINTER:
6280 return expand_builtin_eh_pointer (exp);
6281 case BUILT_IN_EH_FILTER:
6282 return expand_builtin_eh_filter (exp);
6283 case BUILT_IN_EH_COPY_VALUES:
6284 return expand_builtin_eh_copy_values (exp);
6286 case BUILT_IN_VA_START:
6287 return expand_builtin_va_start (exp);
6288 case BUILT_IN_VA_END:
6289 return expand_builtin_va_end (exp);
6290 case BUILT_IN_VA_COPY:
6291 return expand_builtin_va_copy (exp);
6292 case BUILT_IN_EXPECT:
6293 return expand_builtin_expect (exp, target);
6294 case BUILT_IN_PREFETCH:
6295 expand_builtin_prefetch (exp);
6298 case BUILT_IN_INIT_TRAMPOLINE:
6299 return expand_builtin_init_trampoline (exp);
6300 case BUILT_IN_ADJUST_TRAMPOLINE:
6301 return expand_builtin_adjust_trampoline (exp);
6304 case BUILT_IN_EXECL:
6305 case BUILT_IN_EXECV:
6306 case BUILT_IN_EXECLP:
6307 case BUILT_IN_EXECLE:
6308 case BUILT_IN_EXECVP:
6309 case BUILT_IN_EXECVE:
6310 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6315 case BUILT_IN_FETCH_AND_ADD_1:
6316 case BUILT_IN_FETCH_AND_ADD_2:
6317 case BUILT_IN_FETCH_AND_ADD_4:
6318 case BUILT_IN_FETCH_AND_ADD_8:
6319 case BUILT_IN_FETCH_AND_ADD_16:
6320 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6321 target = expand_builtin_sync_operation (mode, exp, PLUS,
6322 false, target, ignore);
6327 case BUILT_IN_FETCH_AND_SUB_1:
6328 case BUILT_IN_FETCH_AND_SUB_2:
6329 case BUILT_IN_FETCH_AND_SUB_4:
6330 case BUILT_IN_FETCH_AND_SUB_8:
6331 case BUILT_IN_FETCH_AND_SUB_16:
6332 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6333 target = expand_builtin_sync_operation (mode, exp, MINUS,
6334 false, target, ignore);
6339 case BUILT_IN_FETCH_AND_OR_1:
6340 case BUILT_IN_FETCH_AND_OR_2:
6341 case BUILT_IN_FETCH_AND_OR_4:
6342 case BUILT_IN_FETCH_AND_OR_8:
6343 case BUILT_IN_FETCH_AND_OR_16:
6344 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6345 target = expand_builtin_sync_operation (mode, exp, IOR,
6346 false, target, ignore);
6351 case BUILT_IN_FETCH_AND_AND_1:
6352 case BUILT_IN_FETCH_AND_AND_2:
6353 case BUILT_IN_FETCH_AND_AND_4:
6354 case BUILT_IN_FETCH_AND_AND_8:
6355 case BUILT_IN_FETCH_AND_AND_16:
6356 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6357 target = expand_builtin_sync_operation (mode, exp, AND,
6358 false, target, ignore);
6363 case BUILT_IN_FETCH_AND_XOR_1:
6364 case BUILT_IN_FETCH_AND_XOR_2:
6365 case BUILT_IN_FETCH_AND_XOR_4:
6366 case BUILT_IN_FETCH_AND_XOR_8:
6367 case BUILT_IN_FETCH_AND_XOR_16:
6368 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6369 target = expand_builtin_sync_operation (mode, exp, XOR,
6370 false, target, ignore);
6375 case BUILT_IN_FETCH_AND_NAND_1:
6376 case BUILT_IN_FETCH_AND_NAND_2:
6377 case BUILT_IN_FETCH_AND_NAND_4:
6378 case BUILT_IN_FETCH_AND_NAND_8:
6379 case BUILT_IN_FETCH_AND_NAND_16:
6380 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6381 target = expand_builtin_sync_operation (mode, exp, NOT,
6382 false, target, ignore);
6387 case BUILT_IN_ADD_AND_FETCH_1:
6388 case BUILT_IN_ADD_AND_FETCH_2:
6389 case BUILT_IN_ADD_AND_FETCH_4:
6390 case BUILT_IN_ADD_AND_FETCH_8:
6391 case BUILT_IN_ADD_AND_FETCH_16:
6392 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6393 target = expand_builtin_sync_operation (mode, exp, PLUS,
6394 true, target, ignore);
6399 case BUILT_IN_SUB_AND_FETCH_1:
6400 case BUILT_IN_SUB_AND_FETCH_2:
6401 case BUILT_IN_SUB_AND_FETCH_4:
6402 case BUILT_IN_SUB_AND_FETCH_8:
6403 case BUILT_IN_SUB_AND_FETCH_16:
6404 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6405 target = expand_builtin_sync_operation (mode, exp, MINUS,
6406 true, target, ignore);
6411 case BUILT_IN_OR_AND_FETCH_1:
6412 case BUILT_IN_OR_AND_FETCH_2:
6413 case BUILT_IN_OR_AND_FETCH_4:
6414 case BUILT_IN_OR_AND_FETCH_8:
6415 case BUILT_IN_OR_AND_FETCH_16:
6416 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6417 target = expand_builtin_sync_operation (mode, exp, IOR,
6418 true, target, ignore);
6423 case BUILT_IN_AND_AND_FETCH_1:
6424 case BUILT_IN_AND_AND_FETCH_2:
6425 case BUILT_IN_AND_AND_FETCH_4:
6426 case BUILT_IN_AND_AND_FETCH_8:
6427 case BUILT_IN_AND_AND_FETCH_16:
6428 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6429 target = expand_builtin_sync_operation (mode, exp, AND,
6430 true, target, ignore);
6435 case BUILT_IN_XOR_AND_FETCH_1:
6436 case BUILT_IN_XOR_AND_FETCH_2:
6437 case BUILT_IN_XOR_AND_FETCH_4:
6438 case BUILT_IN_XOR_AND_FETCH_8:
6439 case BUILT_IN_XOR_AND_FETCH_16:
6440 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6441 target = expand_builtin_sync_operation (mode, exp, XOR,
6442 true, target, ignore);
6447 case BUILT_IN_NAND_AND_FETCH_1:
6448 case BUILT_IN_NAND_AND_FETCH_2:
6449 case BUILT_IN_NAND_AND_FETCH_4:
6450 case BUILT_IN_NAND_AND_FETCH_8:
6451 case BUILT_IN_NAND_AND_FETCH_16:
6452 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6453 target = expand_builtin_sync_operation (mode, exp, NOT,
6454 true, target, ignore);
6459 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6460 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6461 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6462 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6463 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6464 if (mode == VOIDmode)
6465 mode = TYPE_MODE (boolean_type_node);
6466 if (!target || !register_operand (target, mode))
6467 target = gen_reg_rtx (mode);
6469 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6470 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6475 case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6476 case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6477 case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6478 case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6479 case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6480 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6481 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6486 case BUILT_IN_LOCK_TEST_AND_SET_1:
6487 case BUILT_IN_LOCK_TEST_AND_SET_2:
6488 case BUILT_IN_LOCK_TEST_AND_SET_4:
6489 case BUILT_IN_LOCK_TEST_AND_SET_8:
6490 case BUILT_IN_LOCK_TEST_AND_SET_16:
6491 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6492 target = expand_builtin_lock_test_and_set (mode, exp, target);
6497 case BUILT_IN_LOCK_RELEASE_1:
6498 case BUILT_IN_LOCK_RELEASE_2:
6499 case BUILT_IN_LOCK_RELEASE_4:
6500 case BUILT_IN_LOCK_RELEASE_8:
6501 case BUILT_IN_LOCK_RELEASE_16:
6502 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6503 expand_builtin_lock_release (mode, exp);
6506 case BUILT_IN_SYNCHRONIZE:
6507 expand_builtin_synchronize ();
6510 case BUILT_IN_OBJECT_SIZE:
6511 return expand_builtin_object_size (exp);
6513 case BUILT_IN_MEMCPY_CHK:
6514 case BUILT_IN_MEMPCPY_CHK:
6515 case BUILT_IN_MEMMOVE_CHK:
6516 case BUILT_IN_MEMSET_CHK:
6517 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6522 case BUILT_IN_STRCPY_CHK:
6523 case BUILT_IN_STPCPY_CHK:
6524 case BUILT_IN_STRNCPY_CHK:
6525 case BUILT_IN_STRCAT_CHK:
6526 case BUILT_IN_STRNCAT_CHK:
6527 case BUILT_IN_SNPRINTF_CHK:
6528 case BUILT_IN_VSNPRINTF_CHK:
6529 maybe_emit_chk_warning (exp, fcode);
6532 case BUILT_IN_SPRINTF_CHK:
6533 case BUILT_IN_VSPRINTF_CHK:
6534 maybe_emit_sprintf_chk_warning (exp, fcode);
6538 maybe_emit_free_warning (exp);
6541 default: /* just do library call, if unknown builtin */
6545 /* The switch statement above can drop through to cause the function
6546 to be called normally. */
6547 return expand_call (exp, target, ignore);
6550 /* Determine whether a tree node represents a call to a built-in
6551 function. If the tree T is a call to a built-in function with
6552 the right number of arguments of the appropriate types, return
6553 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6554 Otherwise the return value is END_BUILTINS. */
6556 enum built_in_function
6557 builtin_mathfn_code (const_tree t)
6559 const_tree fndecl, arg, parmlist;
6560 const_tree argtype, parmtype;
6561 const_call_expr_arg_iterator iter;
6563 if (TREE_CODE (t) != CALL_EXPR
6564 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6565 return END_BUILTINS;
6567 fndecl = get_callee_fndecl (t);
6568 if (fndecl == NULL_TREE
6569 || TREE_CODE (fndecl) != FUNCTION_DECL
6570 || ! DECL_BUILT_IN (fndecl)
6571 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6572 return END_BUILTINS;
6574 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6575 init_const_call_expr_arg_iterator (t, &iter);
6576 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6578 /* If a function doesn't take a variable number of arguments,
6579 the last element in the list will have type `void'. */
6580 parmtype = TREE_VALUE (parmlist);
6581 if (VOID_TYPE_P (parmtype))
6583 if (more_const_call_expr_args_p (&iter))
6584 return END_BUILTINS;
6585 return DECL_FUNCTION_CODE (fndecl);
6588 if (! more_const_call_expr_args_p (&iter))
6589 return END_BUILTINS;
6591 arg = next_const_call_expr_arg (&iter);
6592 argtype = TREE_TYPE (arg);
6594 if (SCALAR_FLOAT_TYPE_P (parmtype))
6596 if (! SCALAR_FLOAT_TYPE_P (argtype))
6597 return END_BUILTINS;
6599 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6601 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6602 return END_BUILTINS;
6604 else if (POINTER_TYPE_P (parmtype))
6606 if (! POINTER_TYPE_P (argtype))
6607 return END_BUILTINS;
6609 else if (INTEGRAL_TYPE_P (parmtype))
6611 if (! INTEGRAL_TYPE_P (argtype))
6612 return END_BUILTINS;
6615 return END_BUILTINS;
6618 /* Variable-length argument list. */
6619 return DECL_FUNCTION_CODE (fndecl);
6622 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6623 evaluate to a constant. */
6626 fold_builtin_constant_p (tree arg)
6628 /* We return 1 for a numeric type that's known to be a constant
6629 value at compile-time or for an aggregate type that's a
6630 literal constant. */
6633 /* If we know this is a constant, emit the constant of one. */
6634 if (CONSTANT_CLASS_P (arg)
6635 || (TREE_CODE (arg) == CONSTRUCTOR
6636 && TREE_CONSTANT (arg)))
6637 return integer_one_node;
6638 if (TREE_CODE (arg) == ADDR_EXPR)
6640 tree op = TREE_OPERAND (arg, 0);
6641 if (TREE_CODE (op) == STRING_CST
6642 || (TREE_CODE (op) == ARRAY_REF
6643 && integer_zerop (TREE_OPERAND (op, 1))
6644 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6645 return integer_one_node;
6648 /* If this expression has side effects, show we don't know it to be a
6649 constant. Likewise if it's a pointer or aggregate type since in
6650 those case we only want literals, since those are only optimized
6651 when generating RTL, not later.
6652 And finally, if we are compiling an initializer, not code, we
6653 need to return a definite result now; there's not going to be any
6654 more optimization done. */
6655 if (TREE_SIDE_EFFECTS (arg)
6656 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6657 || POINTER_TYPE_P (TREE_TYPE (arg))
6659 || folding_initializer)
6660 return integer_zero_node;
6665 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6666 return it as a truthvalue. */
6669 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6671 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6673 fn = built_in_decls[BUILT_IN_EXPECT];
6674 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6675 ret_type = TREE_TYPE (TREE_TYPE (fn));
6676 pred_type = TREE_VALUE (arg_types);
6677 expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6679 pred = fold_convert_loc (loc, pred_type, pred);
6680 expected = fold_convert_loc (loc, expected_type, expected);
6681 call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6683 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6684 build_int_cst (ret_type, 0));
6687 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6688 NULL_TREE if no simplification is possible. */
6691 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6694 enum tree_code code;
6696 /* If this is a builtin_expect within a builtin_expect keep the
6697 inner one. See through a comparison against a constant. It
6698 might have been added to create a thruthvalue. */
6700 if (COMPARISON_CLASS_P (inner)
6701 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6702 inner = TREE_OPERAND (inner, 0);
6704 if (TREE_CODE (inner) == CALL_EXPR
6705 && (fndecl = get_callee_fndecl (inner))
6706 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6707 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6710 /* Distribute the expected value over short-circuiting operators.
6711 See through the cast from truthvalue_type_node to long. */
6713 while (TREE_CODE (inner) == NOP_EXPR
6714 && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6715 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6716 inner = TREE_OPERAND (inner, 0);
6718 code = TREE_CODE (inner);
6719 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6721 tree op0 = TREE_OPERAND (inner, 0);
6722 tree op1 = TREE_OPERAND (inner, 1);
6724 op0 = build_builtin_expect_predicate (loc, op0, arg1);
6725 op1 = build_builtin_expect_predicate (loc, op1, arg1);
6726 inner = build2 (code, TREE_TYPE (inner), op0, op1);
6728 return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6731 /* If the argument isn't invariant then there's nothing else we can do. */
6732 if (!TREE_CONSTANT (arg0))
6735 /* If we expect that a comparison against the argument will fold to
6736 a constant return the constant. In practice, this means a true
6737 constant or the address of a non-weak symbol. */
6740 if (TREE_CODE (inner) == ADDR_EXPR)
6744 inner = TREE_OPERAND (inner, 0);
6746 while (TREE_CODE (inner) == COMPONENT_REF
6747 || TREE_CODE (inner) == ARRAY_REF);
6748 if ((TREE_CODE (inner) == VAR_DECL
6749 || TREE_CODE (inner) == FUNCTION_DECL)
6750 && DECL_WEAK (inner))
6754 /* Otherwise, ARG0 already has the proper type for the return value. */
6758 /* Fold a call to __builtin_classify_type with argument ARG. */
6761 fold_builtin_classify_type (tree arg)
6764 return build_int_cst (NULL_TREE, no_type_class);
6766 return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6769 /* Fold a call to __builtin_strlen with argument ARG. */
6772 fold_builtin_strlen (location_t loc, tree type, tree arg)
6774 if (!validate_arg (arg, POINTER_TYPE))
6778 tree len = c_strlen (arg, 0);
6781 return fold_convert_loc (loc, type, len);
6787 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6790 fold_builtin_inf (location_t loc, tree type, int warn)
6792 REAL_VALUE_TYPE real;
6794 /* __builtin_inff is intended to be usable to define INFINITY on all
6795 targets. If an infinity is not available, INFINITY expands "to a
6796 positive constant of type float that overflows at translation
6797 time", footnote "In this case, using INFINITY will violate the
6798 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6799 Thus we pedwarn to ensure this constraint violation is
6801 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6802 pedwarn (loc, 0, "target format does not support infinity");
6805 return build_real (type, real);
6808 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
6811 fold_builtin_nan (tree arg, tree type, int quiet)
6813 REAL_VALUE_TYPE real;
6816 if (!validate_arg (arg, POINTER_TYPE))
6818 str = c_getstr (arg);
6822 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6825 return build_real (type, real);
6828 /* Return true if the floating point expression T has an integer value.
6829 We also allow +Inf, -Inf and NaN to be considered integer values. */
6832 integer_valued_real_p (tree t)
6834 switch (TREE_CODE (t))
6841 return integer_valued_real_p (TREE_OPERAND (t, 0));
6846 return integer_valued_real_p (TREE_OPERAND (t, 1));
6853 return integer_valued_real_p (TREE_OPERAND (t, 0))
6854 && integer_valued_real_p (TREE_OPERAND (t, 1));
6857 return integer_valued_real_p (TREE_OPERAND (t, 1))
6858 && integer_valued_real_p (TREE_OPERAND (t, 2));
6861 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6865 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6866 if (TREE_CODE (type) == INTEGER_TYPE)
6868 if (TREE_CODE (type) == REAL_TYPE)
6869 return integer_valued_real_p (TREE_OPERAND (t, 0));
6874 switch (builtin_mathfn_code (t))
6876 CASE_FLT_FN (BUILT_IN_CEIL):
6877 CASE_FLT_FN (BUILT_IN_FLOOR):
6878 CASE_FLT_FN (BUILT_IN_NEARBYINT):
6879 CASE_FLT_FN (BUILT_IN_RINT):
6880 CASE_FLT_FN (BUILT_IN_ROUND):
6881 CASE_FLT_FN (BUILT_IN_TRUNC):
6884 CASE_FLT_FN (BUILT_IN_FMIN):
6885 CASE_FLT_FN (BUILT_IN_FMAX):
6886 return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6887 && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6900 /* FNDECL is assumed to be a builtin where truncation can be propagated
6901 across (for instance floor((double)f) == (double)floorf (f).
6902 Do the transformation for a call with argument ARG. */
6905 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6907 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6909 if (!validate_arg (arg, REAL_TYPE))
6912 /* Integer rounding functions are idempotent. */
6913 if (fcode == builtin_mathfn_code (arg))
6916 /* If argument is already integer valued, and we don't need to worry
6917 about setting errno, there's no need to perform rounding. */
6918 if (! flag_errno_math && integer_valued_real_p (arg))
6923 tree arg0 = strip_float_extensions (arg);
6924 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6925 tree newtype = TREE_TYPE (arg0);
6928 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6929 && (decl = mathfn_built_in (newtype, fcode)))
6930 return fold_convert_loc (loc, ftype,
6931 build_call_expr_loc (loc, decl, 1,
6932 fold_convert_loc (loc,
6939 /* FNDECL is assumed to be builtin which can narrow the FP type of
6940 the argument, for instance lround((double)f) -> lroundf (f).
6941 Do the transformation for a call with argument ARG. */
6944 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6946 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6948 if (!validate_arg (arg, REAL_TYPE))
6951 /* If argument is already integer valued, and we don't need to worry
6952 about setting errno, there's no need to perform rounding. */
6953 if (! flag_errno_math && integer_valued_real_p (arg))
6954 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6955 TREE_TYPE (TREE_TYPE (fndecl)), arg);
6959 tree ftype = TREE_TYPE (arg);
6960 tree arg0 = strip_float_extensions (arg);
6961 tree newtype = TREE_TYPE (arg0);
6964 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6965 && (decl = mathfn_built_in (newtype, fcode)))
6966 return build_call_expr_loc (loc, decl, 1,
6967 fold_convert_loc (loc, newtype, arg0));
6970 /* Canonicalize llround (x) to lround (x) on LP64 targets where
6971 sizeof (long long) == sizeof (long). */
6972 if (TYPE_PRECISION (long_long_integer_type_node)
6973 == TYPE_PRECISION (long_integer_type_node))
6975 tree newfn = NULL_TREE;
6978 CASE_FLT_FN (BUILT_IN_LLCEIL):
6979 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6982 CASE_FLT_FN (BUILT_IN_LLFLOOR):
6983 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6986 CASE_FLT_FN (BUILT_IN_LLROUND):
6987 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6990 CASE_FLT_FN (BUILT_IN_LLRINT):
6991 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7000 tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7001 return fold_convert_loc (loc,
7002 TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7009 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7010 return type. Return NULL_TREE if no simplification can be made. */
7013 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7017 if (!validate_arg (arg, COMPLEX_TYPE)
7018 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7021 /* Calculate the result when the argument is a constant. */
7022 if (TREE_CODE (arg) == COMPLEX_CST
7023 && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7027 if (TREE_CODE (arg) == COMPLEX_EXPR)
7029 tree real = TREE_OPERAND (arg, 0);
7030 tree imag = TREE_OPERAND (arg, 1);
7032 /* If either part is zero, cabs is fabs of the other. */
7033 if (real_zerop (real))
7034 return fold_build1_loc (loc, ABS_EXPR, type, imag);
7035 if (real_zerop (imag))
7036 return fold_build1_loc (loc, ABS_EXPR, type, real);
7038 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7039 if (flag_unsafe_math_optimizations
7040 && operand_equal_p (real, imag, OEP_PURE_SAME))
7042 const REAL_VALUE_TYPE sqrt2_trunc
7043 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7045 return fold_build2_loc (loc, MULT_EXPR, type,
7046 fold_build1_loc (loc, ABS_EXPR, type, real),
7047 build_real (type, sqrt2_trunc));
7051 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7052 if (TREE_CODE (arg) == NEGATE_EXPR
7053 || TREE_CODE (arg) == CONJ_EXPR)
7054 return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7056 /* Don't do this when optimizing for size. */
7057 if (flag_unsafe_math_optimizations
7058 && optimize && optimize_function_for_speed_p (cfun))
7060 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7062 if (sqrtfn != NULL_TREE)
7064 tree rpart, ipart, result;
7066 arg = builtin_save_expr (arg);
7068 rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7069 ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7071 rpart = builtin_save_expr (rpart);
7072 ipart = builtin_save_expr (ipart);
7074 result = fold_build2_loc (loc, PLUS_EXPR, type,
7075 fold_build2_loc (loc, MULT_EXPR, type,
7077 fold_build2_loc (loc, MULT_EXPR, type,
7080 return build_call_expr_loc (loc, sqrtfn, 1, result);
7087 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7088 complex tree type of the result. If NEG is true, the imaginary
7089 zero is negative. */
7092 build_complex_cproj (tree type, bool neg)
7094 REAL_VALUE_TYPE rinf, rzero = dconst0;
7098 return build_complex (type, build_real (TREE_TYPE (type), rinf),
7099 build_real (TREE_TYPE (type), rzero));
7102 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7103 return type. Return NULL_TREE if no simplification can be made. */
7106 fold_builtin_cproj (location_t loc, tree arg, tree type)
7108 if (!validate_arg (arg, COMPLEX_TYPE)
7109 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7112 /* If there are no infinities, return arg. */
7113 if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7114 return non_lvalue_loc (loc, arg);
7116 /* Calculate the result when the argument is a constant. */
7117 if (TREE_CODE (arg) == COMPLEX_CST)
7119 const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7120 const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7122 if (real_isinf (real) || real_isinf (imag))
7123 return build_complex_cproj (type, imag->sign);
7127 else if (TREE_CODE (arg) == COMPLEX_EXPR)
7129 tree real = TREE_OPERAND (arg, 0);
7130 tree imag = TREE_OPERAND (arg, 1);
7135 /* If the real part is inf and the imag part is known to be
7136 nonnegative, return (inf + 0i). Remember side-effects are
7137 possible in the imag part. */
7138 if (TREE_CODE (real) == REAL_CST
7139 && real_isinf (TREE_REAL_CST_PTR (real))
7140 && tree_expr_nonnegative_p (imag))
7141 return omit_one_operand_loc (loc, type,
7142 build_complex_cproj (type, false),
7145 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7146 Remember side-effects are possible in the real part. */
7147 if (TREE_CODE (imag) == REAL_CST
7148 && real_isinf (TREE_REAL_CST_PTR (imag)))
7150 omit_one_operand_loc (loc, type,
7151 build_complex_cproj (type, TREE_REAL_CST_PTR
7152 (imag)->sign), arg);
7158 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7159 Return NULL_TREE if no simplification can be made. */
7162 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7165 enum built_in_function fcode;
7168 if (!validate_arg (arg, REAL_TYPE))
7171 /* Calculate the result when the argument is a constant. */
7172 if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7175 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7176 fcode = builtin_mathfn_code (arg);
7177 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7179 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7180 arg = fold_build2_loc (loc, MULT_EXPR, type,
7181 CALL_EXPR_ARG (arg, 0),
7182 build_real (type, dconsthalf));
7183 return build_call_expr_loc (loc, expfn, 1, arg);
7186 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7187 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7189 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7193 tree arg0 = CALL_EXPR_ARG (arg, 0);
7195 /* The inner root was either sqrt or cbrt. */
7196 /* This was a conditional expression but it triggered a bug
7198 REAL_VALUE_TYPE dconstroot;
7199 if (BUILTIN_SQRT_P (fcode))
7200 dconstroot = dconsthalf;
7202 dconstroot = dconst_third ();
7204 /* Adjust for the outer root. */
7205 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7206 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7207 tree_root = build_real (type, dconstroot);
7208 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7212 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7213 if (flag_unsafe_math_optimizations
7214 && (fcode == BUILT_IN_POW
7215 || fcode == BUILT_IN_POWF
7216 || fcode == BUILT_IN_POWL))
7218 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7219 tree arg0 = CALL_EXPR_ARG (arg, 0);
7220 tree arg1 = CALL_EXPR_ARG (arg, 1);
7222 if (!tree_expr_nonnegative_p (arg0))
7223 arg0 = build1 (ABS_EXPR, type, arg0);
7224 narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7225 build_real (type, dconsthalf));
7226 return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7232 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7233 Return NULL_TREE if no simplification can be made. */
7236 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7238 const enum built_in_function fcode = builtin_mathfn_code (arg);
7241 if (!validate_arg (arg, REAL_TYPE))
7244 /* Calculate the result when the argument is a constant. */
7245 if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7248 if (flag_unsafe_math_optimizations)
7250 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7251 if (BUILTIN_EXPONENT_P (fcode))
7253 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7254 const REAL_VALUE_TYPE third_trunc =
7255 real_value_truncate (TYPE_MODE (type), dconst_third ());
7256 arg = fold_build2_loc (loc, MULT_EXPR, type,
7257 CALL_EXPR_ARG (arg, 0),
7258 build_real (type, third_trunc));
7259 return build_call_expr_loc (loc, expfn, 1, arg);
7262 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7263 if (BUILTIN_SQRT_P (fcode))
7265 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7269 tree arg0 = CALL_EXPR_ARG (arg, 0);
7271 REAL_VALUE_TYPE dconstroot = dconst_third ();
7273 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7274 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7275 tree_root = build_real (type, dconstroot);
7276 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7280 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7281 if (BUILTIN_CBRT_P (fcode))
7283 tree arg0 = CALL_EXPR_ARG (arg, 0);
7284 if (tree_expr_nonnegative_p (arg0))
7286 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7291 REAL_VALUE_TYPE dconstroot;
7293 real_arithmetic (&dconstroot, MULT_EXPR,
7294 dconst_third_ptr (), dconst_third_ptr ());
7295 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7296 tree_root = build_real (type, dconstroot);
7297 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7302 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7303 if (fcode == BUILT_IN_POW
7304 || fcode == BUILT_IN_POWF
7305 || fcode == BUILT_IN_POWL)
7307 tree arg00 = CALL_EXPR_ARG (arg, 0);
7308 tree arg01 = CALL_EXPR_ARG (arg, 1);
7309 if (tree_expr_nonnegative_p (arg00))
7311 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7312 const REAL_VALUE_TYPE dconstroot
7313 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7314 tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7315 build_real (type, dconstroot));
7316 return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7323 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7324 TYPE is the type of the return value. Return NULL_TREE if no
7325 simplification can be made. */
7328 fold_builtin_cos (location_t loc,
7329 tree arg, tree type, tree fndecl)
7333 if (!validate_arg (arg, REAL_TYPE))
7336 /* Calculate the result when the argument is a constant. */
7337 if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7340 /* Optimize cos(-x) into cos (x). */
7341 if ((narg = fold_strip_sign_ops (arg)))
7342 return build_call_expr_loc (loc, fndecl, 1, narg);
7347 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7348 Return NULL_TREE if no simplification can be made. */
7351 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7353 if (validate_arg (arg, REAL_TYPE))
7357 /* Calculate the result when the argument is a constant. */
7358 if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7361 /* Optimize cosh(-x) into cosh (x). */
7362 if ((narg = fold_strip_sign_ops (arg)))
7363 return build_call_expr_loc (loc, fndecl, 1, narg);
7369 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7370 argument ARG. TYPE is the type of the return value. Return
7371 NULL_TREE if no simplification can be made. */
7374 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7377 if (validate_arg (arg, COMPLEX_TYPE)
7378 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7382 /* Calculate the result when the argument is a constant. */
7383 if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7386 /* Optimize fn(-x) into fn(x). */
7387 if ((tmp = fold_strip_sign_ops (arg)))
7388 return build_call_expr_loc (loc, fndecl, 1, tmp);
7394 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7395 Return NULL_TREE if no simplification can be made. */
7398 fold_builtin_tan (tree arg, tree type)
7400 enum built_in_function fcode;
7403 if (!validate_arg (arg, REAL_TYPE))
7406 /* Calculate the result when the argument is a constant. */
7407 if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7410 /* Optimize tan(atan(x)) = x. */
7411 fcode = builtin_mathfn_code (arg);
7412 if (flag_unsafe_math_optimizations
7413 && (fcode == BUILT_IN_ATAN
7414 || fcode == BUILT_IN_ATANF
7415 || fcode == BUILT_IN_ATANL))
7416 return CALL_EXPR_ARG (arg, 0);
7421 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7422 NULL_TREE if no simplification can be made. */
7425 fold_builtin_sincos (location_t loc,
7426 tree arg0, tree arg1, tree arg2)
7431 if (!validate_arg (arg0, REAL_TYPE)
7432 || !validate_arg (arg1, POINTER_TYPE)
7433 || !validate_arg (arg2, POINTER_TYPE))
7436 type = TREE_TYPE (arg0);
7438 /* Calculate the result when the argument is a constant. */
7439 if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7442 /* Canonicalize sincos to cexpi. */
7443 if (!TARGET_C99_FUNCTIONS)
7445 fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7449 call = build_call_expr_loc (loc, fn, 1, arg0);
7450 call = builtin_save_expr (call);
7452 return build2 (COMPOUND_EXPR, void_type_node,
7453 build2 (MODIFY_EXPR, void_type_node,
7454 build_fold_indirect_ref_loc (loc, arg1),
7455 build1 (IMAGPART_EXPR, type, call)),
7456 build2 (MODIFY_EXPR, void_type_node,
7457 build_fold_indirect_ref_loc (loc, arg2),
7458 build1 (REALPART_EXPR, type, call)));
7461 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7462 NULL_TREE if no simplification can be made. */
7465 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7468 tree realp, imagp, ifn;
7471 if (!validate_arg (arg0, COMPLEX_TYPE)
7472 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7475 /* Calculate the result when the argument is a constant. */
7476 if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7479 rtype = TREE_TYPE (TREE_TYPE (arg0));
7481 /* In case we can figure out the real part of arg0 and it is constant zero
7483 if (!TARGET_C99_FUNCTIONS)
7485 ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7489 if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7490 && real_zerop (realp))
7492 tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7493 return build_call_expr_loc (loc, ifn, 1, narg);
7496 /* In case we can easily decompose real and imaginary parts split cexp
7497 to exp (r) * cexpi (i). */
7498 if (flag_unsafe_math_optimizations
7501 tree rfn, rcall, icall;
7503 rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7507 imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7511 icall = build_call_expr_loc (loc, ifn, 1, imagp);
7512 icall = builtin_save_expr (icall);
7513 rcall = build_call_expr_loc (loc, rfn, 1, realp);
7514 rcall = builtin_save_expr (rcall);
7515 return fold_build2_loc (loc, COMPLEX_EXPR, type,
7516 fold_build2_loc (loc, MULT_EXPR, rtype,
7518 fold_build1_loc (loc, REALPART_EXPR,
7520 fold_build2_loc (loc, MULT_EXPR, rtype,
7522 fold_build1_loc (loc, IMAGPART_EXPR,
7529 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7530 Return NULL_TREE if no simplification can be made. */
7533 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7535 if (!validate_arg (arg, REAL_TYPE))
7538 /* Optimize trunc of constant value. */
7539 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7541 REAL_VALUE_TYPE r, x;
7542 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7544 x = TREE_REAL_CST (arg);
7545 real_trunc (&r, TYPE_MODE (type), &x);
7546 return build_real (type, r);
7549 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7552 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7553 Return NULL_TREE if no simplification can be made. */
7556 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7558 if (!validate_arg (arg, REAL_TYPE))
7561 /* Optimize floor of constant value. */
7562 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7566 x = TREE_REAL_CST (arg);
7567 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7569 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7572 real_floor (&r, TYPE_MODE (type), &x);
7573 return build_real (type, r);
7577 /* Fold floor (x) where x is nonnegative to trunc (x). */
7578 if (tree_expr_nonnegative_p (arg))
7580 tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7582 return build_call_expr_loc (loc, truncfn, 1, arg);
7585 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7588 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7589 Return NULL_TREE if no simplification can be made. */
7592 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7594 if (!validate_arg (arg, REAL_TYPE))
7597 /* Optimize ceil of constant value. */
7598 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7602 x = TREE_REAL_CST (arg);
7603 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7605 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7608 real_ceil (&r, TYPE_MODE (type), &x);
7609 return build_real (type, r);
7613 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7616 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7617 Return NULL_TREE if no simplification can be made. */
7620 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7622 if (!validate_arg (arg, REAL_TYPE))
7625 /* Optimize round of constant value. */
7626 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7630 x = TREE_REAL_CST (arg);
7631 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7633 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7636 real_round (&r, TYPE_MODE (type), &x);
7637 return build_real (type, r);
7641 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7644 /* Fold function call to builtin lround, lroundf or lroundl (or the
7645 corresponding long long versions) and other rounding functions. ARG
7646 is the argument to the call. Return NULL_TREE if no simplification
7650 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7652 if (!validate_arg (arg, REAL_TYPE))
7655 /* Optimize lround of constant value. */
7656 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7658 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7660 if (real_isfinite (&x))
7662 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7663 tree ftype = TREE_TYPE (arg);
7667 switch (DECL_FUNCTION_CODE (fndecl))
7669 CASE_FLT_FN (BUILT_IN_LFLOOR):
7670 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7671 real_floor (&r, TYPE_MODE (ftype), &x);
7674 CASE_FLT_FN (BUILT_IN_LCEIL):
7675 CASE_FLT_FN (BUILT_IN_LLCEIL):
7676 real_ceil (&r, TYPE_MODE (ftype), &x);
7679 CASE_FLT_FN (BUILT_IN_LROUND):
7680 CASE_FLT_FN (BUILT_IN_LLROUND):
7681 real_round (&r, TYPE_MODE (ftype), &x);
7688 real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7689 if (double_int_fits_to_tree_p (itype, val))
7690 return double_int_to_tree (itype, val);
7694 switch (DECL_FUNCTION_CODE (fndecl))
7696 CASE_FLT_FN (BUILT_IN_LFLOOR):
7697 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7698 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
7699 if (tree_expr_nonnegative_p (arg))
7700 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7701 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7706 return fold_fixed_mathfn (loc, fndecl, arg);
7709 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7710 and their long and long long variants (i.e. ffsl and ffsll). ARG is
7711 the argument to the call. Return NULL_TREE if no simplification can
7715 fold_builtin_bitop (tree fndecl, tree arg)
7717 if (!validate_arg (arg, INTEGER_TYPE))
7720 /* Optimize for constant argument. */
7721 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7723 HOST_WIDE_INT hi, width, result;
7724 unsigned HOST_WIDE_INT lo;
7727 type = TREE_TYPE (arg);
7728 width = TYPE_PRECISION (type);
7729 lo = TREE_INT_CST_LOW (arg);
7731 /* Clear all the bits that are beyond the type's precision. */
7732 if (width > HOST_BITS_PER_WIDE_INT)
7734 hi = TREE_INT_CST_HIGH (arg);
7735 if (width < 2 * HOST_BITS_PER_WIDE_INT)
7736 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7741 if (width < HOST_BITS_PER_WIDE_INT)
7742 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7745 switch (DECL_FUNCTION_CODE (fndecl))
7747 CASE_INT_FN (BUILT_IN_FFS):
7749 result = ffs_hwi (lo);
7751 result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7756 CASE_INT_FN (BUILT_IN_CLZ):
7758 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7760 result = width - floor_log2 (lo) - 1;
7761 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7765 CASE_INT_FN (BUILT_IN_CTZ):
7767 result = ctz_hwi (lo);
7769 result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7770 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7774 CASE_INT_FN (BUILT_IN_POPCOUNT):
7777 result++, lo &= lo - 1;
7779 result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7782 CASE_INT_FN (BUILT_IN_PARITY):
7785 result++, lo &= lo - 1;
7787 result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7795 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7801 /* Fold function call to builtin_bswap and the long and long long
7802 variants. Return NULL_TREE if no simplification can be made. */
7804 fold_builtin_bswap (tree fndecl, tree arg)
7806 if (! validate_arg (arg, INTEGER_TYPE))
7809 /* Optimize constant value. */
7810 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7812 HOST_WIDE_INT hi, width, r_hi = 0;
7813 unsigned HOST_WIDE_INT lo, r_lo = 0;
7816 type = TREE_TYPE (arg);
7817 width = TYPE_PRECISION (type);
7818 lo = TREE_INT_CST_LOW (arg);
7819 hi = TREE_INT_CST_HIGH (arg);
7821 switch (DECL_FUNCTION_CODE (fndecl))
7823 case BUILT_IN_BSWAP32:
7824 case BUILT_IN_BSWAP64:
7828 for (s = 0; s < width; s += 8)
7830 int d = width - s - 8;
7831 unsigned HOST_WIDE_INT byte;
7833 if (s < HOST_BITS_PER_WIDE_INT)
7834 byte = (lo >> s) & 0xff;
7836 byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7838 if (d < HOST_BITS_PER_WIDE_INT)
7841 r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7851 if (width < HOST_BITS_PER_WIDE_INT)
7852 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7854 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7860 /* A subroutine of fold_builtin to fold the various logarithmic
7861 functions. Return NULL_TREE if no simplification can me made.
7862 FUNC is the corresponding MPFR logarithm function. */
7865 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7866 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7868 if (validate_arg (arg, REAL_TYPE))
7870 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7872 const enum built_in_function fcode = builtin_mathfn_code (arg);
7874 /* Calculate the result when the argument is a constant. */
7875 if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7878 /* Special case, optimize logN(expN(x)) = x. */
7879 if (flag_unsafe_math_optimizations
7880 && ((func == mpfr_log
7881 && (fcode == BUILT_IN_EXP
7882 || fcode == BUILT_IN_EXPF
7883 || fcode == BUILT_IN_EXPL))
7884 || (func == mpfr_log2
7885 && (fcode == BUILT_IN_EXP2
7886 || fcode == BUILT_IN_EXP2F
7887 || fcode == BUILT_IN_EXP2L))
7888 || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7889 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7891 /* Optimize logN(func()) for various exponential functions. We
7892 want to determine the value "x" and the power "exponent" in
7893 order to transform logN(x**exponent) into exponent*logN(x). */
7894 if (flag_unsafe_math_optimizations)
7896 tree exponent = 0, x = 0;
7900 CASE_FLT_FN (BUILT_IN_EXP):
7901 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7902 x = build_real (type, real_value_truncate (TYPE_MODE (type),
7904 exponent = CALL_EXPR_ARG (arg, 0);
7906 CASE_FLT_FN (BUILT_IN_EXP2):
7907 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7908 x = build_real (type, dconst2);
7909 exponent = CALL_EXPR_ARG (arg, 0);
7911 CASE_FLT_FN (BUILT_IN_EXP10):
7912 CASE_FLT_FN (BUILT_IN_POW10):
7913 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7915 REAL_VALUE_TYPE dconst10;
7916 real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7917 x = build_real (type, dconst10);
7919 exponent = CALL_EXPR_ARG (arg, 0);
7921 CASE_FLT_FN (BUILT_IN_SQRT):
7922 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7923 x = CALL_EXPR_ARG (arg, 0);
7924 exponent = build_real (type, dconsthalf);
7926 CASE_FLT_FN (BUILT_IN_CBRT):
7927 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7928 x = CALL_EXPR_ARG (arg, 0);
7929 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7932 CASE_FLT_FN (BUILT_IN_POW):
7933 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7934 x = CALL_EXPR_ARG (arg, 0);
7935 exponent = CALL_EXPR_ARG (arg, 1);
7941 /* Now perform the optimization. */
7944 tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7945 return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7953 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
7954 NULL_TREE if no simplification can be made. */
7957 fold_builtin_hypot (location_t loc, tree fndecl,
7958 tree arg0, tree arg1, tree type)
7960 tree res, narg0, narg1;
7962 if (!validate_arg (arg0, REAL_TYPE)
7963 || !validate_arg (arg1, REAL_TYPE))
7966 /* Calculate the result when the argument is a constant. */
7967 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7970 /* If either argument to hypot has a negate or abs, strip that off.
7971 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
7972 narg0 = fold_strip_sign_ops (arg0);
7973 narg1 = fold_strip_sign_ops (arg1);
7976 return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7977 narg1 ? narg1 : arg1);
7980 /* If either argument is zero, hypot is fabs of the other. */
7981 if (real_zerop (arg0))
7982 return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7983 else if (real_zerop (arg1))
7984 return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7986 /* hypot(x,x) -> fabs(x)*sqrt(2). */
7987 if (flag_unsafe_math_optimizations
7988 && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7990 const REAL_VALUE_TYPE sqrt2_trunc
7991 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7992 return fold_build2_loc (loc, MULT_EXPR, type,
7993 fold_build1_loc (loc, ABS_EXPR, type, arg0),
7994 build_real (type, sqrt2_trunc));
8001 /* Fold a builtin function call to pow, powf, or powl. Return
8002 NULL_TREE if no simplification can be made. */
8004 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8008 if (!validate_arg (arg0, REAL_TYPE)
8009 || !validate_arg (arg1, REAL_TYPE))
8012 /* Calculate the result when the argument is a constant. */
8013 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8016 /* Optimize pow(1.0,y) = 1.0. */
8017 if (real_onep (arg0))
8018 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8020 if (TREE_CODE (arg1) == REAL_CST
8021 && !TREE_OVERFLOW (arg1))
8023 REAL_VALUE_TYPE cint;
8027 c = TREE_REAL_CST (arg1);
8029 /* Optimize pow(x,0.0) = 1.0. */
8030 if (REAL_VALUES_EQUAL (c, dconst0))
8031 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8034 /* Optimize pow(x,1.0) = x. */
8035 if (REAL_VALUES_EQUAL (c, dconst1))
8038 /* Optimize pow(x,-1.0) = 1.0/x. */
8039 if (REAL_VALUES_EQUAL (c, dconstm1))
8040 return fold_build2_loc (loc, RDIV_EXPR, type,
8041 build_real (type, dconst1), arg0);
8043 /* Optimize pow(x,0.5) = sqrt(x). */
8044 if (flag_unsafe_math_optimizations
8045 && REAL_VALUES_EQUAL (c, dconsthalf))
8047 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8049 if (sqrtfn != NULL_TREE)
8050 return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8053 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8054 if (flag_unsafe_math_optimizations)
8056 const REAL_VALUE_TYPE dconstroot
8057 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8059 if (REAL_VALUES_EQUAL (c, dconstroot))
8061 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8062 if (cbrtfn != NULL_TREE)
8063 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8067 /* Check for an integer exponent. */
8068 n = real_to_integer (&c);
8069 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8070 if (real_identical (&c, &cint))
8072 /* Attempt to evaluate pow at compile-time, unless this should
8073 raise an exception. */
8074 if (TREE_CODE (arg0) == REAL_CST
8075 && !TREE_OVERFLOW (arg0)
8077 || (!flag_trapping_math && !flag_errno_math)
8078 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8083 x = TREE_REAL_CST (arg0);
8084 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8085 if (flag_unsafe_math_optimizations || !inexact)
8086 return build_real (type, x);
8089 /* Strip sign ops from even integer powers. */
8090 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8092 tree narg0 = fold_strip_sign_ops (arg0);
8094 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8099 if (flag_unsafe_math_optimizations)
8101 const enum built_in_function fcode = builtin_mathfn_code (arg0);
8103 /* Optimize pow(expN(x),y) = expN(x*y). */
8104 if (BUILTIN_EXPONENT_P (fcode))
8106 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8107 tree arg = CALL_EXPR_ARG (arg0, 0);
8108 arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8109 return build_call_expr_loc (loc, expfn, 1, arg);
8112 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8113 if (BUILTIN_SQRT_P (fcode))
8115 tree narg0 = CALL_EXPR_ARG (arg0, 0);
8116 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8117 build_real (type, dconsthalf));
8118 return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8121 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8122 if (BUILTIN_CBRT_P (fcode))
8124 tree arg = CALL_EXPR_ARG (arg0, 0);
8125 if (tree_expr_nonnegative_p (arg))
8127 const REAL_VALUE_TYPE dconstroot
8128 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8129 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8130 build_real (type, dconstroot));
8131 return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8135 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8136 if (fcode == BUILT_IN_POW
8137 || fcode == BUILT_IN_POWF
8138 || fcode == BUILT_IN_POWL)
8140 tree arg00 = CALL_EXPR_ARG (arg0, 0);
8141 if (tree_expr_nonnegative_p (arg00))
8143 tree arg01 = CALL_EXPR_ARG (arg0, 1);
8144 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8145 return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8153 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8154 Return NULL_TREE if no simplification can be made. */
8156 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8157 tree arg0, tree arg1, tree type)
8159 if (!validate_arg (arg0, REAL_TYPE)
8160 || !validate_arg (arg1, INTEGER_TYPE))
8163 /* Optimize pow(1.0,y) = 1.0. */
8164 if (real_onep (arg0))
8165 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8167 if (host_integerp (arg1, 0))
8169 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8171 /* Evaluate powi at compile-time. */
8172 if (TREE_CODE (arg0) == REAL_CST
8173 && !TREE_OVERFLOW (arg0))
8176 x = TREE_REAL_CST (arg0);
8177 real_powi (&x, TYPE_MODE (type), &x, c);
8178 return build_real (type, x);
8181 /* Optimize pow(x,0) = 1.0. */
8183 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8186 /* Optimize pow(x,1) = x. */
8190 /* Optimize pow(x,-1) = 1.0/x. */
8192 return fold_build2_loc (loc, RDIV_EXPR, type,
8193 build_real (type, dconst1), arg0);
8199 /* A subroutine of fold_builtin to fold the various exponent
8200 functions. Return NULL_TREE if no simplification can be made.
8201 FUNC is the corresponding MPFR exponent function. */
8204 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8205 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8207 if (validate_arg (arg, REAL_TYPE))
8209 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8212 /* Calculate the result when the argument is a constant. */
8213 if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8216 /* Optimize expN(logN(x)) = x. */
8217 if (flag_unsafe_math_optimizations)
8219 const enum built_in_function fcode = builtin_mathfn_code (arg);
8221 if ((func == mpfr_exp
8222 && (fcode == BUILT_IN_LOG
8223 || fcode == BUILT_IN_LOGF
8224 || fcode == BUILT_IN_LOGL))
8225 || (func == mpfr_exp2
8226 && (fcode == BUILT_IN_LOG2
8227 || fcode == BUILT_IN_LOG2F
8228 || fcode == BUILT_IN_LOG2L))
8229 || (func == mpfr_exp10
8230 && (fcode == BUILT_IN_LOG10
8231 || fcode == BUILT_IN_LOG10F
8232 || fcode == BUILT_IN_LOG10L)))
8233 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8240 /* Return true if VAR is a VAR_DECL or a component thereof. */
8243 var_decl_component_p (tree var)
8246 while (handled_component_p (inner))
8247 inner = TREE_OPERAND (inner, 0);
8248 return SSA_VAR_P (inner);
8251 /* Fold function call to builtin memset. Return
8252 NULL_TREE if no simplification can be made. */
8255 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8256 tree type, bool ignore)
8258 tree var, ret, etype;
8259 unsigned HOST_WIDE_INT length, cval;
8261 if (! validate_arg (dest, POINTER_TYPE)
8262 || ! validate_arg (c, INTEGER_TYPE)
8263 || ! validate_arg (len, INTEGER_TYPE))
8266 if (! host_integerp (len, 1))
8269 /* If the LEN parameter is zero, return DEST. */
8270 if (integer_zerop (len))
8271 return omit_one_operand_loc (loc, type, dest, c);
8273 if (TREE_CODE (c) != INTEGER_CST || TREE_SIDE_EFFECTS (dest))
8278 if (TREE_CODE (var) != ADDR_EXPR)
8281 var = TREE_OPERAND (var, 0);
8282 if (TREE_THIS_VOLATILE (var))
8285 etype = TREE_TYPE (var);
8286 if (TREE_CODE (etype) == ARRAY_TYPE)
8287 etype = TREE_TYPE (etype);
8289 if (!INTEGRAL_TYPE_P (etype)
8290 && !POINTER_TYPE_P (etype))
8293 if (! var_decl_component_p (var))
8296 length = tree_low_cst (len, 1);
8297 if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8298 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8302 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8305 if (integer_zerop (c))
8309 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8312 cval = TREE_INT_CST_LOW (c);
8316 cval |= (cval << 31) << 1;
8319 ret = build_int_cst_type (etype, cval);
8320 var = build_fold_indirect_ref_loc (loc,
8321 fold_convert_loc (loc,
8322 build_pointer_type (etype),
8324 ret = build2 (MODIFY_EXPR, etype, var, ret);
8328 return omit_one_operand_loc (loc, type, dest, ret);
8331 /* Fold function call to builtin memset. Return
8332 NULL_TREE if no simplification can be made. */
8335 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8337 if (! validate_arg (dest, POINTER_TYPE)
8338 || ! validate_arg (size, INTEGER_TYPE))
8344 /* New argument list transforming bzero(ptr x, int y) to
8345 memset(ptr x, int 0, size_t y). This is done this way
8346 so that if it isn't expanded inline, we fallback to
8347 calling bzero instead of memset. */
8349 return fold_builtin_memset (loc, dest, integer_zero_node,
8350 fold_convert_loc (loc, sizetype, size),
8351 void_type_node, ignore);
8354 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8355 NULL_TREE if no simplification can be made.
8356 If ENDP is 0, return DEST (like memcpy).
8357 If ENDP is 1, return DEST+LEN (like mempcpy).
8358 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8359 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8363 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8364 tree len, tree type, bool ignore, int endp)
8366 tree destvar, srcvar, expr;
8368 if (! validate_arg (dest, POINTER_TYPE)
8369 || ! validate_arg (src, POINTER_TYPE)
8370 || ! validate_arg (len, INTEGER_TYPE))
8373 /* If the LEN parameter is zero, return DEST. */
8374 if (integer_zerop (len))
8375 return omit_one_operand_loc (loc, type, dest, src);
8377 /* If SRC and DEST are the same (and not volatile), return
8378 DEST{,+LEN,+LEN-1}. */
8379 if (operand_equal_p (src, dest, 0))
8383 tree srctype, desttype;
8384 unsigned int src_align, dest_align;
8389 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8390 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8392 /* Both DEST and SRC must be pointer types.
8393 ??? This is what old code did. Is the testing for pointer types
8396 If either SRC is readonly or length is 1, we can use memcpy. */
8397 if (!dest_align || !src_align)
8399 if (readonly_data_expr (src)
8400 || (host_integerp (len, 1)
8401 && (MIN (src_align, dest_align) / BITS_PER_UNIT
8402 >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8404 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8407 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8410 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8411 if (TREE_CODE (src) == ADDR_EXPR
8412 && TREE_CODE (dest) == ADDR_EXPR)
8414 tree src_base, dest_base, fn;
8415 HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8416 HOST_WIDE_INT size = -1;
8417 HOST_WIDE_INT maxsize = -1;
8419 srcvar = TREE_OPERAND (src, 0);
8420 src_base = get_ref_base_and_extent (srcvar, &src_offset,
8422 destvar = TREE_OPERAND (dest, 0);
8423 dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8425 if (host_integerp (len, 1))
8426 maxsize = tree_low_cst (len, 1);
8429 src_offset /= BITS_PER_UNIT;
8430 dest_offset /= BITS_PER_UNIT;
8431 if (SSA_VAR_P (src_base)
8432 && SSA_VAR_P (dest_base))
8434 if (operand_equal_p (src_base, dest_base, 0)
8435 && ranges_overlap_p (src_offset, maxsize,
8436 dest_offset, maxsize))
8439 else if (TREE_CODE (src_base) == MEM_REF
8440 && TREE_CODE (dest_base) == MEM_REF)
8443 if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8444 TREE_OPERAND (dest_base, 0), 0))
8446 off = double_int_add (mem_ref_offset (src_base),
8447 shwi_to_double_int (src_offset));
8448 if (!double_int_fits_in_shwi_p (off))
8450 src_offset = off.low;
8451 off = double_int_add (mem_ref_offset (dest_base),
8452 shwi_to_double_int (dest_offset));
8453 if (!double_int_fits_in_shwi_p (off))
8455 dest_offset = off.low;
8456 if (ranges_overlap_p (src_offset, maxsize,
8457 dest_offset, maxsize))
8463 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8466 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8469 /* If the destination and source do not alias optimize into
8471 if ((is_gimple_min_invariant (dest)
8472 || TREE_CODE (dest) == SSA_NAME)
8473 && (is_gimple_min_invariant (src)
8474 || TREE_CODE (src) == SSA_NAME))
8477 ao_ref_init_from_ptr_and_size (&destr, dest, len);
8478 ao_ref_init_from_ptr_and_size (&srcr, src, len);
8479 if (!refs_may_alias_p_1 (&destr, &srcr, false))
8482 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8485 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8492 if (!host_integerp (len, 0))
8495 This logic lose for arguments like (type *)malloc (sizeof (type)),
8496 since we strip the casts of up to VOID return value from malloc.
8497 Perhaps we ought to inherit type from non-VOID argument here? */
8500 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8501 if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8503 tree tem = TREE_OPERAND (src, 0);
8505 if (tem != TREE_OPERAND (src, 0))
8506 src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8508 if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8510 tree tem = TREE_OPERAND (dest, 0);
8512 if (tem != TREE_OPERAND (dest, 0))
8513 dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8515 srctype = TREE_TYPE (TREE_TYPE (src));
8517 && TREE_CODE (srctype) == ARRAY_TYPE
8518 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8520 srctype = TREE_TYPE (srctype);
8522 src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8524 desttype = TREE_TYPE (TREE_TYPE (dest));
8526 && TREE_CODE (desttype) == ARRAY_TYPE
8527 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8529 desttype = TREE_TYPE (desttype);
8531 dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8533 if (!srctype || !desttype
8534 || TREE_ADDRESSABLE (srctype)
8535 || TREE_ADDRESSABLE (desttype)
8536 || !TYPE_SIZE_UNIT (srctype)
8537 || !TYPE_SIZE_UNIT (desttype)
8538 || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8539 || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8542 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8543 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8544 if (dest_align < TYPE_ALIGN (desttype)
8545 || src_align < TYPE_ALIGN (srctype))
8549 dest = builtin_save_expr (dest);
8551 /* Build accesses at offset zero with a ref-all character type. */
8552 off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8553 ptr_mode, true), 0);
8556 STRIP_NOPS (destvar);
8557 if (TREE_CODE (destvar) == ADDR_EXPR
8558 && var_decl_component_p (TREE_OPERAND (destvar, 0))
8559 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8560 destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8562 destvar = NULL_TREE;
8565 STRIP_NOPS (srcvar);
8566 if (TREE_CODE (srcvar) == ADDR_EXPR
8567 && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8568 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8571 || src_align >= TYPE_ALIGN (desttype))
8572 srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8574 else if (!STRICT_ALIGNMENT)
8576 srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8578 srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8586 if (srcvar == NULL_TREE && destvar == NULL_TREE)
8589 if (srcvar == NULL_TREE)
8592 if (src_align >= TYPE_ALIGN (desttype))
8593 srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8596 if (STRICT_ALIGNMENT)
8598 srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8600 srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8603 else if (destvar == NULL_TREE)
8606 if (dest_align >= TYPE_ALIGN (srctype))
8607 destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8610 if (STRICT_ALIGNMENT)
8612 desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8614 destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8618 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8624 if (endp == 0 || endp == 3)
8625 return omit_one_operand_loc (loc, type, dest, expr);
8631 len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8634 len = fold_convert_loc (loc, sizetype, len);
8635 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8636 dest = fold_convert_loc (loc, type, dest);
8638 dest = omit_one_operand_loc (loc, type, dest, expr);
8642 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8643 If LEN is not NULL, it represents the length of the string to be
8644 copied. Return NULL_TREE if no simplification can be made. */
8647 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8651 if (!validate_arg (dest, POINTER_TYPE)
8652 || !validate_arg (src, POINTER_TYPE))
8655 /* If SRC and DEST are the same (and not volatile), return DEST. */
8656 if (operand_equal_p (src, dest, 0))
8657 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8659 if (optimize_function_for_size_p (cfun))
8662 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8668 len = c_strlen (src, 1);
8669 if (! len || TREE_SIDE_EFFECTS (len))
8673 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8674 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8675 build_call_expr_loc (loc, fn, 3, dest, src, len));
8678 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8679 Return NULL_TREE if no simplification can be made. */
8682 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8684 tree fn, len, lenp1, call, type;
8686 if (!validate_arg (dest, POINTER_TYPE)
8687 || !validate_arg (src, POINTER_TYPE))
8690 len = c_strlen (src, 1);
8692 || TREE_CODE (len) != INTEGER_CST)
8695 if (optimize_function_for_size_p (cfun)
8696 /* If length is zero it's small enough. */
8697 && !integer_zerop (len))
8700 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8704 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8705 /* We use dest twice in building our expression. Save it from
8706 multiple expansions. */
8707 dest = builtin_save_expr (dest);
8708 call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8710 type = TREE_TYPE (TREE_TYPE (fndecl));
8711 len = fold_convert_loc (loc, sizetype, len);
8712 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8713 dest = fold_convert_loc (loc, type, dest);
8714 dest = omit_one_operand_loc (loc, type, dest, call);
8718 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8719 If SLEN is not NULL, it represents the length of the source string.
8720 Return NULL_TREE if no simplification can be made. */
8723 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8724 tree src, tree len, tree slen)
8728 if (!validate_arg (dest, POINTER_TYPE)
8729 || !validate_arg (src, POINTER_TYPE)
8730 || !validate_arg (len, INTEGER_TYPE))
8733 /* If the LEN parameter is zero, return DEST. */
8734 if (integer_zerop (len))
8735 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8737 /* We can't compare slen with len as constants below if len is not a
8739 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8743 slen = c_strlen (src, 1);
8745 /* Now, we must be passed a constant src ptr parameter. */
8746 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8749 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8751 /* We do not support simplification of this case, though we do
8752 support it when expanding trees into RTL. */
8753 /* FIXME: generate a call to __builtin_memset. */
8754 if (tree_int_cst_lt (slen, len))
8757 /* OK transform into builtin memcpy. */
8758 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8761 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8762 build_call_expr_loc (loc, fn, 3, dest, src, len));
8765 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8766 arguments to the call, and TYPE is its return type.
8767 Return NULL_TREE if no simplification can be made. */
8770 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8772 if (!validate_arg (arg1, POINTER_TYPE)
8773 || !validate_arg (arg2, INTEGER_TYPE)
8774 || !validate_arg (len, INTEGER_TYPE))
8780 if (TREE_CODE (arg2) != INTEGER_CST
8781 || !host_integerp (len, 1))
8784 p1 = c_getstr (arg1);
8785 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8791 if (target_char_cast (arg2, &c))
8794 r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8797 return build_int_cst (TREE_TYPE (arg1), 0);
8799 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8801 return fold_convert_loc (loc, type, tem);
8807 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8808 Return NULL_TREE if no simplification can be made. */
8811 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8813 const char *p1, *p2;
8815 if (!validate_arg (arg1, POINTER_TYPE)
8816 || !validate_arg (arg2, POINTER_TYPE)
8817 || !validate_arg (len, INTEGER_TYPE))
8820 /* If the LEN parameter is zero, return zero. */
8821 if (integer_zerop (len))
8822 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8825 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8826 if (operand_equal_p (arg1, arg2, 0))
8827 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8829 p1 = c_getstr (arg1);
8830 p2 = c_getstr (arg2);
8832 /* If all arguments are constant, and the value of len is not greater
8833 than the lengths of arg1 and arg2, evaluate at compile-time. */
8834 if (host_integerp (len, 1) && p1 && p2
8835 && compare_tree_int (len, strlen (p1) + 1) <= 0
8836 && compare_tree_int (len, strlen (p2) + 1) <= 0)
8838 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8841 return integer_one_node;
8843 return integer_minus_one_node;
8845 return integer_zero_node;
8848 /* If len parameter is one, return an expression corresponding to
8849 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8850 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8852 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8853 tree cst_uchar_ptr_node
8854 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8857 = fold_convert_loc (loc, integer_type_node,
8858 build1 (INDIRECT_REF, cst_uchar_node,
8859 fold_convert_loc (loc,
8863 = fold_convert_loc (loc, integer_type_node,
8864 build1 (INDIRECT_REF, cst_uchar_node,
8865 fold_convert_loc (loc,
8868 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8874 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8875 Return NULL_TREE if no simplification can be made. */
8878 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8880 const char *p1, *p2;
8882 if (!validate_arg (arg1, POINTER_TYPE)
8883 || !validate_arg (arg2, POINTER_TYPE))
8886 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8887 if (operand_equal_p (arg1, arg2, 0))
8888 return integer_zero_node;
8890 p1 = c_getstr (arg1);
8891 p2 = c_getstr (arg2);
8895 const int i = strcmp (p1, p2);
8897 return integer_minus_one_node;
8899 return integer_one_node;
8901 return integer_zero_node;
8904 /* If the second arg is "", return *(const unsigned char*)arg1. */
8905 if (p2 && *p2 == '\0')
8907 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8908 tree cst_uchar_ptr_node
8909 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8911 return fold_convert_loc (loc, integer_type_node,
8912 build1 (INDIRECT_REF, cst_uchar_node,
8913 fold_convert_loc (loc,
8918 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8919 if (p1 && *p1 == '\0')
8921 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8922 tree cst_uchar_ptr_node
8923 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8926 = fold_convert_loc (loc, integer_type_node,
8927 build1 (INDIRECT_REF, cst_uchar_node,
8928 fold_convert_loc (loc,
8931 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8937 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8938 Return NULL_TREE if no simplification can be made. */
8941 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8943 const char *p1, *p2;
8945 if (!validate_arg (arg1, POINTER_TYPE)
8946 || !validate_arg (arg2, POINTER_TYPE)
8947 || !validate_arg (len, INTEGER_TYPE))
8950 /* If the LEN parameter is zero, return zero. */
8951 if (integer_zerop (len))
8952 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8955 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8956 if (operand_equal_p (arg1, arg2, 0))
8957 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8959 p1 = c_getstr (arg1);
8960 p2 = c_getstr (arg2);
8962 if (host_integerp (len, 1) && p1 && p2)
8964 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8966 return integer_one_node;
8968 return integer_minus_one_node;
8970 return integer_zero_node;
8973 /* If the second arg is "", and the length is greater than zero,
8974 return *(const unsigned char*)arg1. */
8975 if (p2 && *p2 == '\0'
8976 && TREE_CODE (len) == INTEGER_CST
8977 && tree_int_cst_sgn (len) == 1)
8979 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8980 tree cst_uchar_ptr_node
8981 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8983 return fold_convert_loc (loc, integer_type_node,
8984 build1 (INDIRECT_REF, cst_uchar_node,
8985 fold_convert_loc (loc,
8990 /* If the first arg is "", and the length is greater than zero,
8991 return -*(const unsigned char*)arg2. */
8992 if (p1 && *p1 == '\0'
8993 && TREE_CODE (len) == INTEGER_CST
8994 && tree_int_cst_sgn (len) == 1)
8996 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8997 tree cst_uchar_ptr_node
8998 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9000 tree temp = fold_convert_loc (loc, integer_type_node,
9001 build1 (INDIRECT_REF, cst_uchar_node,
9002 fold_convert_loc (loc,
9005 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9008 /* If len parameter is one, return an expression corresponding to
9009 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9010 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9012 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9013 tree cst_uchar_ptr_node
9014 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9016 tree ind1 = fold_convert_loc (loc, integer_type_node,
9017 build1 (INDIRECT_REF, cst_uchar_node,
9018 fold_convert_loc (loc,
9021 tree ind2 = fold_convert_loc (loc, integer_type_node,
9022 build1 (INDIRECT_REF, cst_uchar_node,
9023 fold_convert_loc (loc,
9026 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9032 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9033 ARG. Return NULL_TREE if no simplification can be made. */
9036 fold_builtin_signbit (location_t loc, tree arg, tree type)
9038 if (!validate_arg (arg, REAL_TYPE))
9041 /* If ARG is a compile-time constant, determine the result. */
9042 if (TREE_CODE (arg) == REAL_CST
9043 && !TREE_OVERFLOW (arg))
9047 c = TREE_REAL_CST (arg);
9048 return (REAL_VALUE_NEGATIVE (c)
9049 ? build_one_cst (type)
9050 : build_zero_cst (type));
9053 /* If ARG is non-negative, the result is always zero. */
9054 if (tree_expr_nonnegative_p (arg))
9055 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9057 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9058 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9059 return fold_build2_loc (loc, LT_EXPR, type, arg,
9060 build_real (TREE_TYPE (arg), dconst0));
9065 /* Fold function call to builtin copysign, copysignf or copysignl with
9066 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9070 fold_builtin_copysign (location_t loc, tree fndecl,
9071 tree arg1, tree arg2, tree type)
9075 if (!validate_arg (arg1, REAL_TYPE)
9076 || !validate_arg (arg2, REAL_TYPE))
9079 /* copysign(X,X) is X. */
9080 if (operand_equal_p (arg1, arg2, 0))
9081 return fold_convert_loc (loc, type, arg1);
9083 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9084 if (TREE_CODE (arg1) == REAL_CST
9085 && TREE_CODE (arg2) == REAL_CST
9086 && !TREE_OVERFLOW (arg1)
9087 && !TREE_OVERFLOW (arg2))
9089 REAL_VALUE_TYPE c1, c2;
9091 c1 = TREE_REAL_CST (arg1);
9092 c2 = TREE_REAL_CST (arg2);
9093 /* c1.sign := c2.sign. */
9094 real_copysign (&c1, &c2);
9095 return build_real (type, c1);
9098 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9099 Remember to evaluate Y for side-effects. */
9100 if (tree_expr_nonnegative_p (arg2))
9101 return omit_one_operand_loc (loc, type,
9102 fold_build1_loc (loc, ABS_EXPR, type, arg1),
9105 /* Strip sign changing operations for the first argument. */
9106 tem = fold_strip_sign_ops (arg1);
9108 return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9113 /* Fold a call to builtin isascii with argument ARG. */
9116 fold_builtin_isascii (location_t loc, tree arg)
9118 if (!validate_arg (arg, INTEGER_TYPE))
9122 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9123 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9124 build_int_cst (NULL_TREE,
9125 ~ (unsigned HOST_WIDE_INT) 0x7f));
9126 return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9127 arg, integer_zero_node);
9131 /* Fold a call to builtin toascii with argument ARG. */
9134 fold_builtin_toascii (location_t loc, tree arg)
9136 if (!validate_arg (arg, INTEGER_TYPE))
9139 /* Transform toascii(c) -> (c & 0x7f). */
9140 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9141 build_int_cst (NULL_TREE, 0x7f));
9144 /* Fold a call to builtin isdigit with argument ARG. */
9147 fold_builtin_isdigit (location_t loc, tree arg)
9149 if (!validate_arg (arg, INTEGER_TYPE))
9153 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9154 /* According to the C standard, isdigit is unaffected by locale.
9155 However, it definitely is affected by the target character set. */
9156 unsigned HOST_WIDE_INT target_digit0
9157 = lang_hooks.to_target_charset ('0');
9159 if (target_digit0 == 0)
9162 arg = fold_convert_loc (loc, unsigned_type_node, arg);
9163 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9164 build_int_cst (unsigned_type_node, target_digit0));
9165 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9166 build_int_cst (unsigned_type_node, 9));
9170 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9173 fold_builtin_fabs (location_t loc, tree arg, tree type)
9175 if (!validate_arg (arg, REAL_TYPE))
9178 arg = fold_convert_loc (loc, type, arg);
9179 if (TREE_CODE (arg) == REAL_CST)
9180 return fold_abs_const (arg, type);
9181 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9184 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9187 fold_builtin_abs (location_t loc, tree arg, tree type)
9189 if (!validate_arg (arg, INTEGER_TYPE))
9192 arg = fold_convert_loc (loc, type, arg);
9193 if (TREE_CODE (arg) == INTEGER_CST)
9194 return fold_abs_const (arg, type);
9195 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9198 /* Fold a fma operation with arguments ARG[012]. */
9201 fold_fma (location_t loc ATTRIBUTE_UNUSED,
9202 tree type, tree arg0, tree arg1, tree arg2)
9204 if (TREE_CODE (arg0) == REAL_CST
9205 && TREE_CODE (arg1) == REAL_CST
9206 && TREE_CODE (arg2) == REAL_CST)
9207 return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
9212 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
9215 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
9217 if (validate_arg (arg0, REAL_TYPE)
9218 && validate_arg(arg1, REAL_TYPE)
9219 && validate_arg(arg2, REAL_TYPE))
9221 tree tem = fold_fma (loc, type, arg0, arg1, arg2);
9225 /* ??? Only expand to FMA_EXPR if it's directly supported. */
9226 if (optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
9227 return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
9232 /* Fold a call to builtin fmin or fmax. */
9235 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9236 tree type, bool max)
9238 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9240 /* Calculate the result when the argument is a constant. */
9241 tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9246 /* If either argument is NaN, return the other one. Avoid the
9247 transformation if we get (and honor) a signalling NaN. Using
9248 omit_one_operand() ensures we create a non-lvalue. */
9249 if (TREE_CODE (arg0) == REAL_CST
9250 && real_isnan (&TREE_REAL_CST (arg0))
9251 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9252 || ! TREE_REAL_CST (arg0).signalling))
9253 return omit_one_operand_loc (loc, type, arg1, arg0);
9254 if (TREE_CODE (arg1) == REAL_CST
9255 && real_isnan (&TREE_REAL_CST (arg1))
9256 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9257 || ! TREE_REAL_CST (arg1).signalling))
9258 return omit_one_operand_loc (loc, type, arg0, arg1);
9260 /* Transform fmin/fmax(x,x) -> x. */
9261 if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9262 return omit_one_operand_loc (loc, type, arg0, arg1);
9264 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9265 functions to return the numeric arg if the other one is NaN.
9266 These tree codes don't honor that, so only transform if
9267 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9268 handled, so we don't have to worry about it either. */
9269 if (flag_finite_math_only)
9270 return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9271 fold_convert_loc (loc, type, arg0),
9272 fold_convert_loc (loc, type, arg1));
9277 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9280 fold_builtin_carg (location_t loc, tree arg, tree type)
9282 if (validate_arg (arg, COMPLEX_TYPE)
9283 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9285 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9289 tree new_arg = builtin_save_expr (arg);
9290 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9291 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9292 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9299 /* Fold a call to builtin logb/ilogb. */
9302 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9304 if (! validate_arg (arg, REAL_TYPE))
9309 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9311 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9317 /* If arg is Inf or NaN and we're logb, return it. */
9318 if (TREE_CODE (rettype) == REAL_TYPE)
9319 return fold_convert_loc (loc, rettype, arg);
9320 /* Fall through... */
9322 /* Zero may set errno and/or raise an exception for logb, also
9323 for ilogb we don't know FP_ILOGB0. */
9326 /* For normal numbers, proceed iff radix == 2. In GCC,
9327 normalized significands are in the range [0.5, 1.0). We
9328 want the exponent as if they were [1.0, 2.0) so get the
9329 exponent and subtract 1. */
9330 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9331 return fold_convert_loc (loc, rettype,
9332 build_int_cst (NULL_TREE,
9333 REAL_EXP (value)-1));
9341 /* Fold a call to builtin significand, if radix == 2. */
9344 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9346 if (! validate_arg (arg, REAL_TYPE))
9351 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9353 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9360 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9361 return fold_convert_loc (loc, rettype, arg);
9363 /* For normal numbers, proceed iff radix == 2. */
9364 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9366 REAL_VALUE_TYPE result = *value;
9367 /* In GCC, normalized significands are in the range [0.5,
9368 1.0). We want them to be [1.0, 2.0) so set the
9370 SET_REAL_EXP (&result, 1);
9371 return build_real (rettype, result);
9380 /* Fold a call to builtin frexp, we can assume the base is 2. */
9383 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9385 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9390 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9393 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9395 /* Proceed if a valid pointer type was passed in. */
9396 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9398 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9404 /* For +-0, return (*exp = 0, +-0). */
9405 exp = integer_zero_node;
9410 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9411 return omit_one_operand_loc (loc, rettype, arg0, arg1);
9414 /* Since the frexp function always expects base 2, and in
9415 GCC normalized significands are already in the range
9416 [0.5, 1.0), we have exactly what frexp wants. */
9417 REAL_VALUE_TYPE frac_rvt = *value;
9418 SET_REAL_EXP (&frac_rvt, 0);
9419 frac = build_real (rettype, frac_rvt);
9420 exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9427 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9428 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9429 TREE_SIDE_EFFECTS (arg1) = 1;
9430 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9436 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9437 then we can assume the base is two. If it's false, then we have to
9438 check the mode of the TYPE parameter in certain cases. */
9441 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9442 tree type, bool ldexp)
9444 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9449 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9450 if (real_zerop (arg0) || integer_zerop (arg1)
9451 || (TREE_CODE (arg0) == REAL_CST
9452 && !real_isfinite (&TREE_REAL_CST (arg0))))
9453 return omit_one_operand_loc (loc, type, arg0, arg1);
9455 /* If both arguments are constant, then try to evaluate it. */
9456 if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9457 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9458 && host_integerp (arg1, 0))
9460 /* Bound the maximum adjustment to twice the range of the
9461 mode's valid exponents. Use abs to ensure the range is
9462 positive as a sanity check. */
9463 const long max_exp_adj = 2 *
9464 labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9465 - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9467 /* Get the user-requested adjustment. */
9468 const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9470 /* The requested adjustment must be inside this range. This
9471 is a preliminary cap to avoid things like overflow, we
9472 may still fail to compute the result for other reasons. */
9473 if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9475 REAL_VALUE_TYPE initial_result;
9477 real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9479 /* Ensure we didn't overflow. */
9480 if (! real_isinf (&initial_result))
9482 const REAL_VALUE_TYPE trunc_result
9483 = real_value_truncate (TYPE_MODE (type), initial_result);
9485 /* Only proceed if the target mode can hold the
9487 if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9488 return build_real (type, trunc_result);
9497 /* Fold a call to builtin modf. */
9500 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9502 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9507 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9510 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9512 /* Proceed if a valid pointer type was passed in. */
9513 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9515 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9516 REAL_VALUE_TYPE trunc, frac;
9522 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9523 trunc = frac = *value;
9526 /* For +-Inf, return (*arg1 = arg0, +-0). */
9528 frac.sign = value->sign;
9532 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9533 real_trunc (&trunc, VOIDmode, value);
9534 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9535 /* If the original number was negative and already
9536 integral, then the fractional part is -0.0. */
9537 if (value->sign && frac.cl == rvc_zero)
9538 frac.sign = value->sign;
9542 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9543 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9544 build_real (rettype, trunc));
9545 TREE_SIDE_EFFECTS (arg1) = 1;
9546 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9547 build_real (rettype, frac));
9553 /* Given a location LOC, an interclass builtin function decl FNDECL
9554 and its single argument ARG, return an folded expression computing
9555 the same, or NULL_TREE if we either couldn't or didn't want to fold
9556 (the latter happen if there's an RTL instruction available). */
9559 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9561 enum machine_mode mode;
9563 if (!validate_arg (arg, REAL_TYPE))
9566 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9569 mode = TYPE_MODE (TREE_TYPE (arg));
9571 /* If there is no optab, try generic code. */
9572 switch (DECL_FUNCTION_CODE (fndecl))
9576 CASE_FLT_FN (BUILT_IN_ISINF):
9578 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9579 tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9580 tree const type = TREE_TYPE (arg);
9584 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9585 real_from_string (&r, buf);
9586 result = build_call_expr (isgr_fn, 2,
9587 fold_build1_loc (loc, ABS_EXPR, type, arg),
9588 build_real (type, r));
9591 CASE_FLT_FN (BUILT_IN_FINITE):
9592 case BUILT_IN_ISFINITE:
9594 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9595 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9596 tree const type = TREE_TYPE (arg);
9600 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9601 real_from_string (&r, buf);
9602 result = build_call_expr (isle_fn, 2,
9603 fold_build1_loc (loc, ABS_EXPR, type, arg),
9604 build_real (type, r));
9605 /*result = fold_build2_loc (loc, UNGT_EXPR,
9606 TREE_TYPE (TREE_TYPE (fndecl)),
9607 fold_build1_loc (loc, ABS_EXPR, type, arg),
9608 build_real (type, r));
9609 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9610 TREE_TYPE (TREE_TYPE (fndecl)),
9614 case BUILT_IN_ISNORMAL:
9616 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9617 islessequal(fabs(x),DBL_MAX). */
9618 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9619 tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9620 tree const type = TREE_TYPE (arg);
9621 REAL_VALUE_TYPE rmax, rmin;
9624 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9625 real_from_string (&rmax, buf);
9626 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9627 real_from_string (&rmin, buf);
9628 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9629 result = build_call_expr (isle_fn, 2, arg,
9630 build_real (type, rmax));
9631 result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9632 build_call_expr (isge_fn, 2, arg,
9633 build_real (type, rmin)));
9643 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9644 ARG is the argument for the call. */
9647 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9649 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9652 if (!validate_arg (arg, REAL_TYPE))
9655 switch (builtin_index)
9657 case BUILT_IN_ISINF:
9658 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9659 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9661 if (TREE_CODE (arg) == REAL_CST)
9663 r = TREE_REAL_CST (arg);
9664 if (real_isinf (&r))
9665 return real_compare (GT_EXPR, &r, &dconst0)
9666 ? integer_one_node : integer_minus_one_node;
9668 return integer_zero_node;
9673 case BUILT_IN_ISINF_SIGN:
9675 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9676 /* In a boolean context, GCC will fold the inner COND_EXPR to
9677 1. So e.g. "if (isinf_sign(x))" would be folded to just
9678 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9679 tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9680 tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9681 tree tmp = NULL_TREE;
9683 arg = builtin_save_expr (arg);
9685 if (signbit_fn && isinf_fn)
9687 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9688 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9690 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9691 signbit_call, integer_zero_node);
9692 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9693 isinf_call, integer_zero_node);
9695 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9696 integer_minus_one_node, integer_one_node);
9697 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9705 case BUILT_IN_ISFINITE:
9706 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9707 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9708 return omit_one_operand_loc (loc, type, integer_one_node, arg);
9710 if (TREE_CODE (arg) == REAL_CST)
9712 r = TREE_REAL_CST (arg);
9713 return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9718 case BUILT_IN_ISNAN:
9719 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9720 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9722 if (TREE_CODE (arg) == REAL_CST)
9724 r = TREE_REAL_CST (arg);
9725 return real_isnan (&r) ? integer_one_node : integer_zero_node;
9728 arg = builtin_save_expr (arg);
9729 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9736 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9737 This builtin will generate code to return the appropriate floating
9738 point classification depending on the value of the floating point
9739 number passed in. The possible return values must be supplied as
9740 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9741 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9742 one floating point argument which is "type generic". */
9745 fold_builtin_fpclassify (location_t loc, tree exp)
9747 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9748 arg, type, res, tmp;
9749 enum machine_mode mode;
9753 /* Verify the required arguments in the original call. */
9754 if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9755 INTEGER_TYPE, INTEGER_TYPE,
9756 INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9759 fp_nan = CALL_EXPR_ARG (exp, 0);
9760 fp_infinite = CALL_EXPR_ARG (exp, 1);
9761 fp_normal = CALL_EXPR_ARG (exp, 2);
9762 fp_subnormal = CALL_EXPR_ARG (exp, 3);
9763 fp_zero = CALL_EXPR_ARG (exp, 4);
9764 arg = CALL_EXPR_ARG (exp, 5);
9765 type = TREE_TYPE (arg);
9766 mode = TYPE_MODE (type);
9767 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9771 (fabs(x) == Inf ? FP_INFINITE :
9772 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9773 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9775 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9776 build_real (type, dconst0));
9777 res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9778 tmp, fp_zero, fp_subnormal);
9780 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9781 real_from_string (&r, buf);
9782 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9783 arg, build_real (type, r));
9784 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9786 if (HONOR_INFINITIES (mode))
9789 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9790 build_real (type, r));
9791 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9795 if (HONOR_NANS (mode))
9797 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9798 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9804 /* Fold a call to an unordered comparison function such as
9805 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9806 being called and ARG0 and ARG1 are the arguments for the call.
9807 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9808 the opposite of the desired result. UNORDERED_CODE is used
9809 for modes that can hold NaNs and ORDERED_CODE is used for
9813 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9814 enum tree_code unordered_code,
9815 enum tree_code ordered_code)
9817 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9818 enum tree_code code;
9820 enum tree_code code0, code1;
9821 tree cmp_type = NULL_TREE;
9823 type0 = TREE_TYPE (arg0);
9824 type1 = TREE_TYPE (arg1);
9826 code0 = TREE_CODE (type0);
9827 code1 = TREE_CODE (type1);
9829 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9830 /* Choose the wider of two real types. */
9831 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9833 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9835 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9838 arg0 = fold_convert_loc (loc, cmp_type, arg0);
9839 arg1 = fold_convert_loc (loc, cmp_type, arg1);
9841 if (unordered_code == UNORDERED_EXPR)
9843 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9844 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9845 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9848 code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9850 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9851 fold_build2_loc (loc, code, type, arg0, arg1));
9854 /* Fold a call to built-in function FNDECL with 0 arguments.
9855 IGNORE is true if the result of the function call is ignored. This
9856 function returns NULL_TREE if no simplification was possible. */
9859 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9861 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9862 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9865 CASE_FLT_FN (BUILT_IN_INF):
9866 case BUILT_IN_INFD32:
9867 case BUILT_IN_INFD64:
9868 case BUILT_IN_INFD128:
9869 return fold_builtin_inf (loc, type, true);
9871 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9872 return fold_builtin_inf (loc, type, false);
9874 case BUILT_IN_CLASSIFY_TYPE:
9875 return fold_builtin_classify_type (NULL_TREE);
9883 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9884 IGNORE is true if the result of the function call is ignored. This
9885 function returns NULL_TREE if no simplification was possible. */
9888 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9890 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9891 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9894 case BUILT_IN_CONSTANT_P:
9896 tree val = fold_builtin_constant_p (arg0);
9898 /* Gimplification will pull the CALL_EXPR for the builtin out of
9899 an if condition. When not optimizing, we'll not CSE it back.
9900 To avoid link error types of regressions, return false now. */
9901 if (!val && !optimize)
9902 val = integer_zero_node;
9907 case BUILT_IN_CLASSIFY_TYPE:
9908 return fold_builtin_classify_type (arg0);
9910 case BUILT_IN_STRLEN:
9911 return fold_builtin_strlen (loc, type, arg0);
9913 CASE_FLT_FN (BUILT_IN_FABS):
9914 return fold_builtin_fabs (loc, arg0, type);
9918 case BUILT_IN_LLABS:
9919 case BUILT_IN_IMAXABS:
9920 return fold_builtin_abs (loc, arg0, type);
9922 CASE_FLT_FN (BUILT_IN_CONJ):
9923 if (validate_arg (arg0, COMPLEX_TYPE)
9924 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9925 return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9928 CASE_FLT_FN (BUILT_IN_CREAL):
9929 if (validate_arg (arg0, COMPLEX_TYPE)
9930 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9931 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9934 CASE_FLT_FN (BUILT_IN_CIMAG):
9935 if (validate_arg (arg0, COMPLEX_TYPE)
9936 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9937 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9940 CASE_FLT_FN (BUILT_IN_CCOS):
9941 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9943 CASE_FLT_FN (BUILT_IN_CCOSH):
9944 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9946 CASE_FLT_FN (BUILT_IN_CPROJ):
9947 return fold_builtin_cproj(loc, arg0, type);
9949 CASE_FLT_FN (BUILT_IN_CSIN):
9950 if (validate_arg (arg0, COMPLEX_TYPE)
9951 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9952 return do_mpc_arg1 (arg0, type, mpc_sin);
9955 CASE_FLT_FN (BUILT_IN_CSINH):
9956 if (validate_arg (arg0, COMPLEX_TYPE)
9957 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9958 return do_mpc_arg1 (arg0, type, mpc_sinh);
9961 CASE_FLT_FN (BUILT_IN_CTAN):
9962 if (validate_arg (arg0, COMPLEX_TYPE)
9963 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9964 return do_mpc_arg1 (arg0, type, mpc_tan);
9967 CASE_FLT_FN (BUILT_IN_CTANH):
9968 if (validate_arg (arg0, COMPLEX_TYPE)
9969 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9970 return do_mpc_arg1 (arg0, type, mpc_tanh);
9973 CASE_FLT_FN (BUILT_IN_CLOG):
9974 if (validate_arg (arg0, COMPLEX_TYPE)
9975 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9976 return do_mpc_arg1 (arg0, type, mpc_log);
9979 CASE_FLT_FN (BUILT_IN_CSQRT):
9980 if (validate_arg (arg0, COMPLEX_TYPE)
9981 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9982 return do_mpc_arg1 (arg0, type, mpc_sqrt);
9985 CASE_FLT_FN (BUILT_IN_CASIN):
9986 if (validate_arg (arg0, COMPLEX_TYPE)
9987 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9988 return do_mpc_arg1 (arg0, type, mpc_asin);
9991 CASE_FLT_FN (BUILT_IN_CACOS):
9992 if (validate_arg (arg0, COMPLEX_TYPE)
9993 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9994 return do_mpc_arg1 (arg0, type, mpc_acos);
9997 CASE_FLT_FN (BUILT_IN_CATAN):
9998 if (validate_arg (arg0, COMPLEX_TYPE)
9999 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10000 return do_mpc_arg1 (arg0, type, mpc_atan);
10003 CASE_FLT_FN (BUILT_IN_CASINH):
10004 if (validate_arg (arg0, COMPLEX_TYPE)
10005 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10006 return do_mpc_arg1 (arg0, type, mpc_asinh);
10009 CASE_FLT_FN (BUILT_IN_CACOSH):
10010 if (validate_arg (arg0, COMPLEX_TYPE)
10011 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10012 return do_mpc_arg1 (arg0, type, mpc_acosh);
10015 CASE_FLT_FN (BUILT_IN_CATANH):
10016 if (validate_arg (arg0, COMPLEX_TYPE)
10017 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10018 return do_mpc_arg1 (arg0, type, mpc_atanh);
10021 CASE_FLT_FN (BUILT_IN_CABS):
10022 return fold_builtin_cabs (loc, arg0, type, fndecl);
10024 CASE_FLT_FN (BUILT_IN_CARG):
10025 return fold_builtin_carg (loc, arg0, type);
10027 CASE_FLT_FN (BUILT_IN_SQRT):
10028 return fold_builtin_sqrt (loc, arg0, type);
10030 CASE_FLT_FN (BUILT_IN_CBRT):
10031 return fold_builtin_cbrt (loc, arg0, type);
10033 CASE_FLT_FN (BUILT_IN_ASIN):
10034 if (validate_arg (arg0, REAL_TYPE))
10035 return do_mpfr_arg1 (arg0, type, mpfr_asin,
10036 &dconstm1, &dconst1, true);
10039 CASE_FLT_FN (BUILT_IN_ACOS):
10040 if (validate_arg (arg0, REAL_TYPE))
10041 return do_mpfr_arg1 (arg0, type, mpfr_acos,
10042 &dconstm1, &dconst1, true);
10045 CASE_FLT_FN (BUILT_IN_ATAN):
10046 if (validate_arg (arg0, REAL_TYPE))
10047 return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10050 CASE_FLT_FN (BUILT_IN_ASINH):
10051 if (validate_arg (arg0, REAL_TYPE))
10052 return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10055 CASE_FLT_FN (BUILT_IN_ACOSH):
10056 if (validate_arg (arg0, REAL_TYPE))
10057 return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10058 &dconst1, NULL, true);
10061 CASE_FLT_FN (BUILT_IN_ATANH):
10062 if (validate_arg (arg0, REAL_TYPE))
10063 return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10064 &dconstm1, &dconst1, false);
10067 CASE_FLT_FN (BUILT_IN_SIN):
10068 if (validate_arg (arg0, REAL_TYPE))
10069 return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10072 CASE_FLT_FN (BUILT_IN_COS):
10073 return fold_builtin_cos (loc, arg0, type, fndecl);
10075 CASE_FLT_FN (BUILT_IN_TAN):
10076 return fold_builtin_tan (arg0, type);
10078 CASE_FLT_FN (BUILT_IN_CEXP):
10079 return fold_builtin_cexp (loc, arg0, type);
10081 CASE_FLT_FN (BUILT_IN_CEXPI):
10082 if (validate_arg (arg0, REAL_TYPE))
10083 return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10086 CASE_FLT_FN (BUILT_IN_SINH):
10087 if (validate_arg (arg0, REAL_TYPE))
10088 return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10091 CASE_FLT_FN (BUILT_IN_COSH):
10092 return fold_builtin_cosh (loc, arg0, type, fndecl);
10094 CASE_FLT_FN (BUILT_IN_TANH):
10095 if (validate_arg (arg0, REAL_TYPE))
10096 return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10099 CASE_FLT_FN (BUILT_IN_ERF):
10100 if (validate_arg (arg0, REAL_TYPE))
10101 return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10104 CASE_FLT_FN (BUILT_IN_ERFC):
10105 if (validate_arg (arg0, REAL_TYPE))
10106 return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10109 CASE_FLT_FN (BUILT_IN_TGAMMA):
10110 if (validate_arg (arg0, REAL_TYPE))
10111 return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10114 CASE_FLT_FN (BUILT_IN_EXP):
10115 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10117 CASE_FLT_FN (BUILT_IN_EXP2):
10118 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10120 CASE_FLT_FN (BUILT_IN_EXP10):
10121 CASE_FLT_FN (BUILT_IN_POW10):
10122 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10124 CASE_FLT_FN (BUILT_IN_EXPM1):
10125 if (validate_arg (arg0, REAL_TYPE))
10126 return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10129 CASE_FLT_FN (BUILT_IN_LOG):
10130 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10132 CASE_FLT_FN (BUILT_IN_LOG2):
10133 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10135 CASE_FLT_FN (BUILT_IN_LOG10):
10136 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10138 CASE_FLT_FN (BUILT_IN_LOG1P):
10139 if (validate_arg (arg0, REAL_TYPE))
10140 return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10141 &dconstm1, NULL, false);
10144 CASE_FLT_FN (BUILT_IN_J0):
10145 if (validate_arg (arg0, REAL_TYPE))
10146 return do_mpfr_arg1 (arg0, type, mpfr_j0,
10150 CASE_FLT_FN (BUILT_IN_J1):
10151 if (validate_arg (arg0, REAL_TYPE))
10152 return do_mpfr_arg1 (arg0, type, mpfr_j1,
10156 CASE_FLT_FN (BUILT_IN_Y0):
10157 if (validate_arg (arg0, REAL_TYPE))
10158 return do_mpfr_arg1 (arg0, type, mpfr_y0,
10159 &dconst0, NULL, false);
10162 CASE_FLT_FN (BUILT_IN_Y1):
10163 if (validate_arg (arg0, REAL_TYPE))
10164 return do_mpfr_arg1 (arg0, type, mpfr_y1,
10165 &dconst0, NULL, false);
10168 CASE_FLT_FN (BUILT_IN_NAN):
10169 case BUILT_IN_NAND32:
10170 case BUILT_IN_NAND64:
10171 case BUILT_IN_NAND128:
10172 return fold_builtin_nan (arg0, type, true);
10174 CASE_FLT_FN (BUILT_IN_NANS):
10175 return fold_builtin_nan (arg0, type, false);
10177 CASE_FLT_FN (BUILT_IN_FLOOR):
10178 return fold_builtin_floor (loc, fndecl, arg0);
10180 CASE_FLT_FN (BUILT_IN_CEIL):
10181 return fold_builtin_ceil (loc, fndecl, arg0);
10183 CASE_FLT_FN (BUILT_IN_TRUNC):
10184 return fold_builtin_trunc (loc, fndecl, arg0);
10186 CASE_FLT_FN (BUILT_IN_ROUND):
10187 return fold_builtin_round (loc, fndecl, arg0);
10189 CASE_FLT_FN (BUILT_IN_NEARBYINT):
10190 CASE_FLT_FN (BUILT_IN_RINT):
10191 return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10193 CASE_FLT_FN (BUILT_IN_LCEIL):
10194 CASE_FLT_FN (BUILT_IN_LLCEIL):
10195 CASE_FLT_FN (BUILT_IN_LFLOOR):
10196 CASE_FLT_FN (BUILT_IN_LLFLOOR):
10197 CASE_FLT_FN (BUILT_IN_LROUND):
10198 CASE_FLT_FN (BUILT_IN_LLROUND):
10199 return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10201 CASE_FLT_FN (BUILT_IN_LRINT):
10202 CASE_FLT_FN (BUILT_IN_LLRINT):
10203 return fold_fixed_mathfn (loc, fndecl, arg0);
10205 case BUILT_IN_BSWAP32:
10206 case BUILT_IN_BSWAP64:
10207 return fold_builtin_bswap (fndecl, arg0);
10209 CASE_INT_FN (BUILT_IN_FFS):
10210 CASE_INT_FN (BUILT_IN_CLZ):
10211 CASE_INT_FN (BUILT_IN_CTZ):
10212 CASE_INT_FN (BUILT_IN_POPCOUNT):
10213 CASE_INT_FN (BUILT_IN_PARITY):
10214 return fold_builtin_bitop (fndecl, arg0);
10216 CASE_FLT_FN (BUILT_IN_SIGNBIT):
10217 return fold_builtin_signbit (loc, arg0, type);
10219 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10220 return fold_builtin_significand (loc, arg0, type);
10222 CASE_FLT_FN (BUILT_IN_ILOGB):
10223 CASE_FLT_FN (BUILT_IN_LOGB):
10224 return fold_builtin_logb (loc, arg0, type);
10226 case BUILT_IN_ISASCII:
10227 return fold_builtin_isascii (loc, arg0);
10229 case BUILT_IN_TOASCII:
10230 return fold_builtin_toascii (loc, arg0);
10232 case BUILT_IN_ISDIGIT:
10233 return fold_builtin_isdigit (loc, arg0);
10235 CASE_FLT_FN (BUILT_IN_FINITE):
10236 case BUILT_IN_FINITED32:
10237 case BUILT_IN_FINITED64:
10238 case BUILT_IN_FINITED128:
10239 case BUILT_IN_ISFINITE:
10241 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10244 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10247 CASE_FLT_FN (BUILT_IN_ISINF):
10248 case BUILT_IN_ISINFD32:
10249 case BUILT_IN_ISINFD64:
10250 case BUILT_IN_ISINFD128:
10252 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10255 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10258 case BUILT_IN_ISNORMAL:
10259 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10261 case BUILT_IN_ISINF_SIGN:
10262 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10264 CASE_FLT_FN (BUILT_IN_ISNAN):
10265 case BUILT_IN_ISNAND32:
10266 case BUILT_IN_ISNAND64:
10267 case BUILT_IN_ISNAND128:
10268 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10270 case BUILT_IN_PRINTF:
10271 case BUILT_IN_PRINTF_UNLOCKED:
10272 case BUILT_IN_VPRINTF:
10273 return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10275 case BUILT_IN_FREE:
10276 if (integer_zerop (arg0))
10277 return build_empty_stmt (loc);
10288 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10289 IGNORE is true if the result of the function call is ignored. This
10290 function returns NULL_TREE if no simplification was possible. */
10293 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10295 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10296 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10300 CASE_FLT_FN (BUILT_IN_JN):
10301 if (validate_arg (arg0, INTEGER_TYPE)
10302 && validate_arg (arg1, REAL_TYPE))
10303 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10306 CASE_FLT_FN (BUILT_IN_YN):
10307 if (validate_arg (arg0, INTEGER_TYPE)
10308 && validate_arg (arg1, REAL_TYPE))
10309 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10313 CASE_FLT_FN (BUILT_IN_DREM):
10314 CASE_FLT_FN (BUILT_IN_REMAINDER):
10315 if (validate_arg (arg0, REAL_TYPE)
10316 && validate_arg(arg1, REAL_TYPE))
10317 return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10320 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10321 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10322 if (validate_arg (arg0, REAL_TYPE)
10323 && validate_arg(arg1, POINTER_TYPE))
10324 return do_mpfr_lgamma_r (arg0, arg1, type);
10327 CASE_FLT_FN (BUILT_IN_ATAN2):
10328 if (validate_arg (arg0, REAL_TYPE)
10329 && validate_arg(arg1, REAL_TYPE))
10330 return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10333 CASE_FLT_FN (BUILT_IN_FDIM):
10334 if (validate_arg (arg0, REAL_TYPE)
10335 && validate_arg(arg1, REAL_TYPE))
10336 return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10339 CASE_FLT_FN (BUILT_IN_HYPOT):
10340 return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10342 CASE_FLT_FN (BUILT_IN_CPOW):
10343 if (validate_arg (arg0, COMPLEX_TYPE)
10344 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10345 && validate_arg (arg1, COMPLEX_TYPE)
10346 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10347 return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10350 CASE_FLT_FN (BUILT_IN_LDEXP):
10351 return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10352 CASE_FLT_FN (BUILT_IN_SCALBN):
10353 CASE_FLT_FN (BUILT_IN_SCALBLN):
10354 return fold_builtin_load_exponent (loc, arg0, arg1,
10355 type, /*ldexp=*/false);
10357 CASE_FLT_FN (BUILT_IN_FREXP):
10358 return fold_builtin_frexp (loc, arg0, arg1, type);
10360 CASE_FLT_FN (BUILT_IN_MODF):
10361 return fold_builtin_modf (loc, arg0, arg1, type);
10363 case BUILT_IN_BZERO:
10364 return fold_builtin_bzero (loc, arg0, arg1, ignore);
10366 case BUILT_IN_FPUTS:
10367 return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10369 case BUILT_IN_FPUTS_UNLOCKED:
10370 return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10372 case BUILT_IN_STRSTR:
10373 return fold_builtin_strstr (loc, arg0, arg1, type);
10375 case BUILT_IN_STRCAT:
10376 return fold_builtin_strcat (loc, arg0, arg1);
10378 case BUILT_IN_STRSPN:
10379 return fold_builtin_strspn (loc, arg0, arg1);
10381 case BUILT_IN_STRCSPN:
10382 return fold_builtin_strcspn (loc, arg0, arg1);
10384 case BUILT_IN_STRCHR:
10385 case BUILT_IN_INDEX:
10386 return fold_builtin_strchr (loc, arg0, arg1, type);
10388 case BUILT_IN_STRRCHR:
10389 case BUILT_IN_RINDEX:
10390 return fold_builtin_strrchr (loc, arg0, arg1, type);
10392 case BUILT_IN_STRCPY:
10393 return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10395 case BUILT_IN_STPCPY:
10398 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10402 return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10405 return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10408 case BUILT_IN_STRCMP:
10409 return fold_builtin_strcmp (loc, arg0, arg1);
10411 case BUILT_IN_STRPBRK:
10412 return fold_builtin_strpbrk (loc, arg0, arg1, type);
10414 case BUILT_IN_EXPECT:
10415 return fold_builtin_expect (loc, arg0, arg1);
10417 CASE_FLT_FN (BUILT_IN_POW):
10418 return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10420 CASE_FLT_FN (BUILT_IN_POWI):
10421 return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10423 CASE_FLT_FN (BUILT_IN_COPYSIGN):
10424 return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10426 CASE_FLT_FN (BUILT_IN_FMIN):
10427 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10429 CASE_FLT_FN (BUILT_IN_FMAX):
10430 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10432 case BUILT_IN_ISGREATER:
10433 return fold_builtin_unordered_cmp (loc, fndecl,
10434 arg0, arg1, UNLE_EXPR, LE_EXPR);
10435 case BUILT_IN_ISGREATEREQUAL:
10436 return fold_builtin_unordered_cmp (loc, fndecl,
10437 arg0, arg1, UNLT_EXPR, LT_EXPR);
10438 case BUILT_IN_ISLESS:
10439 return fold_builtin_unordered_cmp (loc, fndecl,
10440 arg0, arg1, UNGE_EXPR, GE_EXPR);
10441 case BUILT_IN_ISLESSEQUAL:
10442 return fold_builtin_unordered_cmp (loc, fndecl,
10443 arg0, arg1, UNGT_EXPR, GT_EXPR);
10444 case BUILT_IN_ISLESSGREATER:
10445 return fold_builtin_unordered_cmp (loc, fndecl,
10446 arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10447 case BUILT_IN_ISUNORDERED:
10448 return fold_builtin_unordered_cmp (loc, fndecl,
10449 arg0, arg1, UNORDERED_EXPR,
10452 /* We do the folding for va_start in the expander. */
10453 case BUILT_IN_VA_START:
10456 case BUILT_IN_SPRINTF:
10457 return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10459 case BUILT_IN_OBJECT_SIZE:
10460 return fold_builtin_object_size (arg0, arg1);
10462 case BUILT_IN_PRINTF:
10463 case BUILT_IN_PRINTF_UNLOCKED:
10464 case BUILT_IN_VPRINTF:
10465 return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10467 case BUILT_IN_PRINTF_CHK:
10468 case BUILT_IN_VPRINTF_CHK:
10469 if (!validate_arg (arg0, INTEGER_TYPE)
10470 || TREE_SIDE_EFFECTS (arg0))
10473 return fold_builtin_printf (loc, fndecl,
10474 arg1, NULL_TREE, ignore, fcode);
10477 case BUILT_IN_FPRINTF:
10478 case BUILT_IN_FPRINTF_UNLOCKED:
10479 case BUILT_IN_VFPRINTF:
10480 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10489 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10490 and ARG2. IGNORE is true if the result of the function call is ignored.
10491 This function returns NULL_TREE if no simplification was possible. */
10494 fold_builtin_3 (location_t loc, tree fndecl,
10495 tree arg0, tree arg1, tree arg2, bool ignore)
10497 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10498 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10502 CASE_FLT_FN (BUILT_IN_SINCOS):
10503 return fold_builtin_sincos (loc, arg0, arg1, arg2);
10505 CASE_FLT_FN (BUILT_IN_FMA):
10506 return fold_builtin_fma (loc, arg0, arg1, arg2, type);
10509 CASE_FLT_FN (BUILT_IN_REMQUO):
10510 if (validate_arg (arg0, REAL_TYPE)
10511 && validate_arg(arg1, REAL_TYPE)
10512 && validate_arg(arg2, POINTER_TYPE))
10513 return do_mpfr_remquo (arg0, arg1, arg2);
10516 case BUILT_IN_MEMSET:
10517 return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10519 case BUILT_IN_BCOPY:
10520 return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10521 void_type_node, true, /*endp=*/3);
10523 case BUILT_IN_MEMCPY:
10524 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10525 type, ignore, /*endp=*/0);
10527 case BUILT_IN_MEMPCPY:
10528 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10529 type, ignore, /*endp=*/1);
10531 case BUILT_IN_MEMMOVE:
10532 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10533 type, ignore, /*endp=*/3);
10535 case BUILT_IN_STRNCAT:
10536 return fold_builtin_strncat (loc, arg0, arg1, arg2);
10538 case BUILT_IN_STRNCPY:
10539 return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10541 case BUILT_IN_STRNCMP:
10542 return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10544 case BUILT_IN_MEMCHR:
10545 return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10547 case BUILT_IN_BCMP:
10548 case BUILT_IN_MEMCMP:
10549 return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10551 case BUILT_IN_SPRINTF:
10552 return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10554 case BUILT_IN_SNPRINTF:
10555 return fold_builtin_snprintf (loc, arg0, arg1, arg2, NULL_TREE, ignore);
10557 case BUILT_IN_STRCPY_CHK:
10558 case BUILT_IN_STPCPY_CHK:
10559 return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10562 case BUILT_IN_STRCAT_CHK:
10563 return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10565 case BUILT_IN_PRINTF_CHK:
10566 case BUILT_IN_VPRINTF_CHK:
10567 if (!validate_arg (arg0, INTEGER_TYPE)
10568 || TREE_SIDE_EFFECTS (arg0))
10571 return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10574 case BUILT_IN_FPRINTF:
10575 case BUILT_IN_FPRINTF_UNLOCKED:
10576 case BUILT_IN_VFPRINTF:
10577 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10580 case BUILT_IN_FPRINTF_CHK:
10581 case BUILT_IN_VFPRINTF_CHK:
10582 if (!validate_arg (arg1, INTEGER_TYPE)
10583 || TREE_SIDE_EFFECTS (arg1))
10586 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10595 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10596 ARG2, and ARG3. IGNORE is true if the result of the function call is
10597 ignored. This function returns NULL_TREE if no simplification was
10601 fold_builtin_4 (location_t loc, tree fndecl,
10602 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10604 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10608 case BUILT_IN_MEMCPY_CHK:
10609 case BUILT_IN_MEMPCPY_CHK:
10610 case BUILT_IN_MEMMOVE_CHK:
10611 case BUILT_IN_MEMSET_CHK:
10612 return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10614 DECL_FUNCTION_CODE (fndecl));
10616 case BUILT_IN_STRNCPY_CHK:
10617 return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10619 case BUILT_IN_STRNCAT_CHK:
10620 return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10622 case BUILT_IN_SNPRINTF:
10623 return fold_builtin_snprintf (loc, arg0, arg1, arg2, arg3, ignore);
10625 case BUILT_IN_FPRINTF_CHK:
10626 case BUILT_IN_VFPRINTF_CHK:
10627 if (!validate_arg (arg1, INTEGER_TYPE)
10628 || TREE_SIDE_EFFECTS (arg1))
10631 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10641 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10642 arguments, where NARGS <= 4. IGNORE is true if the result of the
10643 function call is ignored. This function returns NULL_TREE if no
10644 simplification was possible. Note that this only folds builtins with
10645 fixed argument patterns. Foldings that do varargs-to-varargs
10646 transformations, or that match calls with more than 4 arguments,
10647 need to be handled with fold_builtin_varargs instead. */
10649 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10652 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10654 tree ret = NULL_TREE;
10659 ret = fold_builtin_0 (loc, fndecl, ignore);
10662 ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10665 ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10668 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10671 ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10679 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10680 SET_EXPR_LOCATION (ret, loc);
10681 TREE_NO_WARNING (ret) = 1;
10687 /* Builtins with folding operations that operate on "..." arguments
10688 need special handling; we need to store the arguments in a convenient
10689 data structure before attempting any folding. Fortunately there are
10690 only a few builtins that fall into this category. FNDECL is the
10691 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10692 result of the function call is ignored. */
10695 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10696 bool ignore ATTRIBUTE_UNUSED)
10698 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10699 tree ret = NULL_TREE;
10703 case BUILT_IN_SPRINTF_CHK:
10704 case BUILT_IN_VSPRINTF_CHK:
10705 ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10708 case BUILT_IN_SNPRINTF_CHK:
10709 case BUILT_IN_VSNPRINTF_CHK:
10710 ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10713 case BUILT_IN_FPCLASSIFY:
10714 ret = fold_builtin_fpclassify (loc, exp);
10722 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10723 SET_EXPR_LOCATION (ret, loc);
10724 TREE_NO_WARNING (ret) = 1;
10730 /* Return true if FNDECL shouldn't be folded right now.
10731 If a built-in function has an inline attribute always_inline
10732 wrapper, defer folding it after always_inline functions have
10733 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10734 might not be performed. */
10737 avoid_folding_inline_builtin (tree fndecl)
10739 return (DECL_DECLARED_INLINE_P (fndecl)
10740 && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10742 && !cfun->always_inline_functions_inlined
10743 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10746 /* A wrapper function for builtin folding that prevents warnings for
10747 "statement without effect" and the like, caused by removing the
10748 call node earlier than the warning is generated. */
10751 fold_call_expr (location_t loc, tree exp, bool ignore)
10753 tree ret = NULL_TREE;
10754 tree fndecl = get_callee_fndecl (exp);
10756 && TREE_CODE (fndecl) == FUNCTION_DECL
10757 && DECL_BUILT_IN (fndecl)
10758 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10759 yet. Defer folding until we see all the arguments
10760 (after inlining). */
10761 && !CALL_EXPR_VA_ARG_PACK (exp))
10763 int nargs = call_expr_nargs (exp);
10765 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10766 instead last argument is __builtin_va_arg_pack (). Defer folding
10767 even in that case, until arguments are finalized. */
10768 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10770 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10772 && TREE_CODE (fndecl2) == FUNCTION_DECL
10773 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10774 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10778 if (avoid_folding_inline_builtin (fndecl))
10781 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10782 return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10783 CALL_EXPR_ARGP (exp), ignore);
10786 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10788 tree *args = CALL_EXPR_ARGP (exp);
10789 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10792 ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10800 /* Conveniently construct a function call expression. FNDECL names the
10801 function to be called and N arguments are passed in the array
10805 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10807 tree fntype = TREE_TYPE (fndecl);
10808 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10810 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10813 /* Conveniently construct a function call expression. FNDECL names the
10814 function to be called and the arguments are passed in the vector
10818 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10820 return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10821 VEC_address (tree, vec));
10825 /* Conveniently construct a function call expression. FNDECL names the
10826 function to be called, N is the number of arguments, and the "..."
10827 parameters are the argument expressions. */
10830 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10833 tree *argarray = XALLOCAVEC (tree, n);
10837 for (i = 0; i < n; i++)
10838 argarray[i] = va_arg (ap, tree);
10840 return build_call_expr_loc_array (loc, fndecl, n, argarray);
10843 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10844 varargs macros aren't supported by all bootstrap compilers. */
10847 build_call_expr (tree fndecl, int n, ...)
10850 tree *argarray = XALLOCAVEC (tree, n);
10854 for (i = 0; i < n; i++)
10855 argarray[i] = va_arg (ap, tree);
10857 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10860 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10861 N arguments are passed in the array ARGARRAY. */
10864 fold_builtin_call_array (location_t loc, tree type,
10869 tree ret = NULL_TREE;
10872 if (TREE_CODE (fn) == ADDR_EXPR)
10874 tree fndecl = TREE_OPERAND (fn, 0);
10875 if (TREE_CODE (fndecl) == FUNCTION_DECL
10876 && DECL_BUILT_IN (fndecl))
10878 /* If last argument is __builtin_va_arg_pack (), arguments to this
10879 function are not finalized yet. Defer folding until they are. */
10880 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10882 tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10884 && TREE_CODE (fndecl2) == FUNCTION_DECL
10885 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10886 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10887 return build_call_array_loc (loc, type, fn, n, argarray);
10889 if (avoid_folding_inline_builtin (fndecl))
10890 return build_call_array_loc (loc, type, fn, n, argarray);
10891 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10893 ret = targetm.fold_builtin (fndecl, n, argarray, false);
10897 return build_call_array_loc (loc, type, fn, n, argarray);
10899 else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10901 /* First try the transformations that don't require consing up
10903 ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10908 /* If we got this far, we need to build an exp. */
10909 exp = build_call_array_loc (loc, type, fn, n, argarray);
10910 ret = fold_builtin_varargs (loc, fndecl, exp, false);
10911 return ret ? ret : exp;
10915 return build_call_array_loc (loc, type, fn, n, argarray);
10918 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10919 list ARGS along with N new arguments in NEWARGS. SKIP is the number
10920 of arguments in ARGS to be omitted. OLDNARGS is the number of
10921 elements in ARGS. */
10924 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
10925 int skip, tree fndecl, int n, va_list newargs)
10927 int nargs = oldnargs - skip + n;
10934 buffer = XALLOCAVEC (tree, nargs);
10935 for (i = 0; i < n; i++)
10936 buffer[i] = va_arg (newargs, tree);
10937 for (j = skip; j < oldnargs; j++, i++)
10938 buffer[i] = args[j];
10941 buffer = args + skip;
10943 return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
10946 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10947 list ARGS along with N new arguments specified as the "..."
10948 parameters. SKIP is the number of arguments in ARGS to be omitted.
10949 OLDNARGS is the number of elements in ARGS. */
10952 rewrite_call_expr_array (location_t loc, int oldnargs, tree *args,
10953 int skip, tree fndecl, int n, ...)
10959 t = rewrite_call_expr_valist (loc, oldnargs, args, skip, fndecl, n, ap);
10965 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10966 along with N new arguments specified as the "..." parameters. SKIP
10967 is the number of arguments in EXP to be omitted. This function is used
10968 to do varargs-to-varargs transformations. */
10971 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10977 t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
10978 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
10984 /* Validate a single argument ARG against a tree code CODE representing
10988 validate_arg (const_tree arg, enum tree_code code)
10992 else if (code == POINTER_TYPE)
10993 return POINTER_TYPE_P (TREE_TYPE (arg));
10994 else if (code == INTEGER_TYPE)
10995 return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10996 return code == TREE_CODE (TREE_TYPE (arg));
10999 /* This function validates the types of a function call argument list
11000 against a specified list of tree_codes. If the last specifier is a 0,
11001 that represents an ellipses, otherwise the last specifier must be a
11004 This is the GIMPLE version of validate_arglist. Eventually we want to
11005 completely convert builtins.c to work from GIMPLEs and the tree based
11006 validate_arglist will then be removed. */
11009 validate_gimple_arglist (const_gimple call, ...)
11011 enum tree_code code;
11017 va_start (ap, call);
11022 code = (enum tree_code) va_arg (ap, int);
11026 /* This signifies an ellipses, any further arguments are all ok. */
11030 /* This signifies an endlink, if no arguments remain, return
11031 true, otherwise return false. */
11032 res = (i == gimple_call_num_args (call));
11035 /* If no parameters remain or the parameter's code does not
11036 match the specified code, return false. Otherwise continue
11037 checking any remaining arguments. */
11038 arg = gimple_call_arg (call, i++);
11039 if (!validate_arg (arg, code))
11046 /* We need gotos here since we can only have one VA_CLOSE in a
11054 /* This function validates the types of a function call argument list
11055 against a specified list of tree_codes. If the last specifier is a 0,
11056 that represents an ellipses, otherwise the last specifier must be a
11060 validate_arglist (const_tree callexpr, ...)
11062 enum tree_code code;
11065 const_call_expr_arg_iterator iter;
11068 va_start (ap, callexpr);
11069 init_const_call_expr_arg_iterator (callexpr, &iter);
11073 code = (enum tree_code) va_arg (ap, int);
11077 /* This signifies an ellipses, any further arguments are all ok. */
11081 /* This signifies an endlink, if no arguments remain, return
11082 true, otherwise return false. */
11083 res = !more_const_call_expr_args_p (&iter);
11086 /* If no parameters remain or the parameter's code does not
11087 match the specified code, return false. Otherwise continue
11088 checking any remaining arguments. */
11089 arg = next_const_call_expr_arg (&iter);
11090 if (!validate_arg (arg, code))
11097 /* We need gotos here since we can only have one VA_CLOSE in a
11105 /* Default target-specific builtin expander that does nothing. */
11108 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11109 rtx target ATTRIBUTE_UNUSED,
11110 rtx subtarget ATTRIBUTE_UNUSED,
11111 enum machine_mode mode ATTRIBUTE_UNUSED,
11112 int ignore ATTRIBUTE_UNUSED)
11117 /* Returns true is EXP represents data that would potentially reside
11118 in a readonly section. */
11121 readonly_data_expr (tree exp)
11125 if (TREE_CODE (exp) != ADDR_EXPR)
11128 exp = get_base_address (TREE_OPERAND (exp, 0));
11132 /* Make sure we call decl_readonly_section only for trees it
11133 can handle (since it returns true for everything it doesn't
11135 if (TREE_CODE (exp) == STRING_CST
11136 || TREE_CODE (exp) == CONSTRUCTOR
11137 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11138 return decl_readonly_section (exp, 0);
11143 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11144 to the call, and TYPE is its return type.
11146 Return NULL_TREE if no simplification was possible, otherwise return the
11147 simplified form of the call as a tree.
11149 The simplified form may be a constant or other expression which
11150 computes the same value, but in a more efficient manner (including
11151 calls to other builtin functions).
11153 The call may contain arguments which need to be evaluated, but
11154 which are not useful to determine the result of the call. In
11155 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11156 COMPOUND_EXPR will be an argument which must be evaluated.
11157 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11158 COMPOUND_EXPR in the chain will contain the tree for the simplified
11159 form of the builtin function call. */
11162 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11164 if (!validate_arg (s1, POINTER_TYPE)
11165 || !validate_arg (s2, POINTER_TYPE))
11170 const char *p1, *p2;
11172 p2 = c_getstr (s2);
11176 p1 = c_getstr (s1);
11179 const char *r = strstr (p1, p2);
11183 return build_int_cst (TREE_TYPE (s1), 0);
11185 /* Return an offset into the constant string argument. */
11186 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11187 s1, size_int (r - p1));
11188 return fold_convert_loc (loc, type, tem);
11191 /* The argument is const char *, and the result is char *, so we need
11192 a type conversion here to avoid a warning. */
11194 return fold_convert_loc (loc, type, s1);
11199 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11203 /* New argument list transforming strstr(s1, s2) to
11204 strchr(s1, s2[0]). */
11205 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11209 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11210 the call, and TYPE is its return type.
11212 Return NULL_TREE if no simplification was possible, otherwise return the
11213 simplified form of the call as a tree.
11215 The simplified form may be a constant or other expression which
11216 computes the same value, but in a more efficient manner (including
11217 calls to other builtin functions).
11219 The call may contain arguments which need to be evaluated, but
11220 which are not useful to determine the result of the call. In
11221 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11222 COMPOUND_EXPR will be an argument which must be evaluated.
11223 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11224 COMPOUND_EXPR in the chain will contain the tree for the simplified
11225 form of the builtin function call. */
11228 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11230 if (!validate_arg (s1, POINTER_TYPE)
11231 || !validate_arg (s2, INTEGER_TYPE))
11237 if (TREE_CODE (s2) != INTEGER_CST)
11240 p1 = c_getstr (s1);
11247 if (target_char_cast (s2, &c))
11250 r = strchr (p1, c);
11253 return build_int_cst (TREE_TYPE (s1), 0);
11255 /* Return an offset into the constant string argument. */
11256 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11257 s1, size_int (r - p1));
11258 return fold_convert_loc (loc, type, tem);
11264 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11265 the call, and TYPE is its return type.
11267 Return NULL_TREE if no simplification was possible, otherwise return the
11268 simplified form of the call as a tree.
11270 The simplified form may be a constant or other expression which
11271 computes the same value, but in a more efficient manner (including
11272 calls to other builtin functions).
11274 The call may contain arguments which need to be evaluated, but
11275 which are not useful to determine the result of the call. In
11276 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11277 COMPOUND_EXPR will be an argument which must be evaluated.
11278 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11279 COMPOUND_EXPR in the chain will contain the tree for the simplified
11280 form of the builtin function call. */
11283 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11285 if (!validate_arg (s1, POINTER_TYPE)
11286 || !validate_arg (s2, INTEGER_TYPE))
11293 if (TREE_CODE (s2) != INTEGER_CST)
11296 p1 = c_getstr (s1);
11303 if (target_char_cast (s2, &c))
11306 r = strrchr (p1, c);
11309 return build_int_cst (TREE_TYPE (s1), 0);
11311 /* Return an offset into the constant string argument. */
11312 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11313 s1, size_int (r - p1));
11314 return fold_convert_loc (loc, type, tem);
11317 if (! integer_zerop (s2))
11320 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11324 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11325 return build_call_expr_loc (loc, fn, 2, s1, s2);
11329 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11330 to the call, and TYPE is its return type.
11332 Return NULL_TREE if no simplification was possible, otherwise return the
11333 simplified form of the call as a tree.
11335 The simplified form may be a constant or other expression which
11336 computes the same value, but in a more efficient manner (including
11337 calls to other builtin functions).
11339 The call may contain arguments which need to be evaluated, but
11340 which are not useful to determine the result of the call. In
11341 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11342 COMPOUND_EXPR will be an argument which must be evaluated.
11343 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11344 COMPOUND_EXPR in the chain will contain the tree for the simplified
11345 form of the builtin function call. */
11348 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11350 if (!validate_arg (s1, POINTER_TYPE)
11351 || !validate_arg (s2, POINTER_TYPE))
11356 const char *p1, *p2;
11358 p2 = c_getstr (s2);
11362 p1 = c_getstr (s1);
11365 const char *r = strpbrk (p1, p2);
11369 return build_int_cst (TREE_TYPE (s1), 0);
11371 /* Return an offset into the constant string argument. */
11372 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11373 s1, size_int (r - p1));
11374 return fold_convert_loc (loc, type, tem);
11378 /* strpbrk(x, "") == NULL.
11379 Evaluate and ignore s1 in case it had side-effects. */
11380 return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11383 return NULL_TREE; /* Really call strpbrk. */
11385 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11389 /* New argument list transforming strpbrk(s1, s2) to
11390 strchr(s1, s2[0]). */
11391 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11395 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11398 Return NULL_TREE if no simplification was possible, otherwise return the
11399 simplified form of the call as a tree.
11401 The simplified form may be a constant or other expression which
11402 computes the same value, but in a more efficient manner (including
11403 calls to other builtin functions).
11405 The call may contain arguments which need to be evaluated, but
11406 which are not useful to determine the result of the call. In
11407 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11408 COMPOUND_EXPR will be an argument which must be evaluated.
11409 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11410 COMPOUND_EXPR in the chain will contain the tree for the simplified
11411 form of the builtin function call. */
11414 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11416 if (!validate_arg (dst, POINTER_TYPE)
11417 || !validate_arg (src, POINTER_TYPE))
11421 const char *p = c_getstr (src);
11423 /* If the string length is zero, return the dst parameter. */
11424 if (p && *p == '\0')
11427 if (optimize_insn_for_speed_p ())
11429 /* See if we can store by pieces into (dst + strlen(dst)). */
11431 tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11432 tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11434 if (!strlen_fn || !strcpy_fn)
11437 /* If we don't have a movstr we don't want to emit an strcpy
11438 call. We have to do that if the length of the source string
11439 isn't computable (in that case we can use memcpy probably
11440 later expanding to a sequence of mov instructions). If we
11441 have movstr instructions we can emit strcpy calls. */
11444 tree len = c_strlen (src, 1);
11445 if (! len || TREE_SIDE_EFFECTS (len))
11449 /* Stabilize the argument list. */
11450 dst = builtin_save_expr (dst);
11452 /* Create strlen (dst). */
11453 newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11454 /* Create (dst p+ strlen (dst)). */
11456 newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11457 TREE_TYPE (dst), dst, newdst);
11458 newdst = builtin_save_expr (newdst);
11460 call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11461 return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11467 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11468 arguments to the call.
11470 Return NULL_TREE if no simplification was possible, otherwise return the
11471 simplified form of the call as a tree.
11473 The simplified form may be a constant or other expression which
11474 computes the same value, but in a more efficient manner (including
11475 calls to other builtin functions).
11477 The call may contain arguments which need to be evaluated, but
11478 which are not useful to determine the result of the call. In
11479 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11480 COMPOUND_EXPR will be an argument which must be evaluated.
11481 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11482 COMPOUND_EXPR in the chain will contain the tree for the simplified
11483 form of the builtin function call. */
11486 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11488 if (!validate_arg (dst, POINTER_TYPE)
11489 || !validate_arg (src, POINTER_TYPE)
11490 || !validate_arg (len, INTEGER_TYPE))
11494 const char *p = c_getstr (src);
11496 /* If the requested length is zero, or the src parameter string
11497 length is zero, return the dst parameter. */
11498 if (integer_zerop (len) || (p && *p == '\0'))
11499 return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11501 /* If the requested len is greater than or equal to the string
11502 length, call strcat. */
11503 if (TREE_CODE (len) == INTEGER_CST && p
11504 && compare_tree_int (len, strlen (p)) >= 0)
11506 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11508 /* If the replacement _DECL isn't initialized, don't do the
11513 return build_call_expr_loc (loc, fn, 2, dst, src);
11519 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11522 Return NULL_TREE if no simplification was possible, otherwise return the
11523 simplified form of the call as a tree.
11525 The simplified form may be a constant or other expression which
11526 computes the same value, but in a more efficient manner (including
11527 calls to other builtin functions).
11529 The call may contain arguments which need to be evaluated, but
11530 which are not useful to determine the result of the call. In
11531 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11532 COMPOUND_EXPR will be an argument which must be evaluated.
11533 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11534 COMPOUND_EXPR in the chain will contain the tree for the simplified
11535 form of the builtin function call. */
11538 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11540 if (!validate_arg (s1, POINTER_TYPE)
11541 || !validate_arg (s2, POINTER_TYPE))
11545 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11547 /* If both arguments are constants, evaluate at compile-time. */
11550 const size_t r = strspn (p1, p2);
11551 return size_int (r);
11554 /* If either argument is "", return NULL_TREE. */
11555 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11556 /* Evaluate and ignore both arguments in case either one has
11558 return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11564 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11567 Return NULL_TREE if no simplification was possible, otherwise return the
11568 simplified form of the call as a tree.
11570 The simplified form may be a constant or other expression which
11571 computes the same value, but in a more efficient manner (including
11572 calls to other builtin functions).
11574 The call may contain arguments which need to be evaluated, but
11575 which are not useful to determine the result of the call. In
11576 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11577 COMPOUND_EXPR will be an argument which must be evaluated.
11578 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11579 COMPOUND_EXPR in the chain will contain the tree for the simplified
11580 form of the builtin function call. */
11583 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11585 if (!validate_arg (s1, POINTER_TYPE)
11586 || !validate_arg (s2, POINTER_TYPE))
11590 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11592 /* If both arguments are constants, evaluate at compile-time. */
11595 const size_t r = strcspn (p1, p2);
11596 return size_int (r);
11599 /* If the first argument is "", return NULL_TREE. */
11600 if (p1 && *p1 == '\0')
11602 /* Evaluate and ignore argument s2 in case it has
11604 return omit_one_operand_loc (loc, size_type_node,
11605 size_zero_node, s2);
11608 /* If the second argument is "", return __builtin_strlen(s1). */
11609 if (p2 && *p2 == '\0')
11611 tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11613 /* If the replacement _DECL isn't initialized, don't do the
11618 return build_call_expr_loc (loc, fn, 1, s1);
11624 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
11625 to the call. IGNORE is true if the value returned
11626 by the builtin will be ignored. UNLOCKED is true is true if this
11627 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
11628 the known length of the string. Return NULL_TREE if no simplification
11632 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11633 bool ignore, bool unlocked, tree len)
11635 /* If we're using an unlocked function, assume the other unlocked
11636 functions exist explicitly. */
11637 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11638 : implicit_built_in_decls[BUILT_IN_FPUTC];
11639 tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11640 : implicit_built_in_decls[BUILT_IN_FWRITE];
11642 /* If the return value is used, don't do the transformation. */
11646 /* Verify the arguments in the original call. */
11647 if (!validate_arg (arg0, POINTER_TYPE)
11648 || !validate_arg (arg1, POINTER_TYPE))
11652 len = c_strlen (arg0, 0);
11654 /* Get the length of the string passed to fputs. If the length
11655 can't be determined, punt. */
11657 || TREE_CODE (len) != INTEGER_CST)
11660 switch (compare_tree_int (len, 1))
11662 case -1: /* length is 0, delete the call entirely . */
11663 return omit_one_operand_loc (loc, integer_type_node,
11664 integer_zero_node, arg1);;
11666 case 0: /* length is 1, call fputc. */
11668 const char *p = c_getstr (arg0);
11673 return build_call_expr_loc (loc, fn_fputc, 2,
11674 build_int_cst (NULL_TREE, p[0]), arg1);
11680 case 1: /* length is greater than 1, call fwrite. */
11682 /* If optimizing for size keep fputs. */
11683 if (optimize_function_for_size_p (cfun))
11685 /* New argument list transforming fputs(string, stream) to
11686 fwrite(string, 1, len, stream). */
11688 return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11689 size_one_node, len, arg1);
11694 gcc_unreachable ();
11699 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11700 produced. False otherwise. This is done so that we don't output the error
11701 or warning twice or three times. */
11704 fold_builtin_next_arg (tree exp, bool va_start_p)
11706 tree fntype = TREE_TYPE (current_function_decl);
11707 int nargs = call_expr_nargs (exp);
11710 if (!stdarg_p (fntype))
11712 error ("%<va_start%> used in function with fixed args");
11718 if (va_start_p && (nargs != 2))
11720 error ("wrong number of arguments to function %<va_start%>");
11723 arg = CALL_EXPR_ARG (exp, 1);
11725 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11726 when we checked the arguments and if needed issued a warning. */
11731 /* Evidently an out of date version of <stdarg.h>; can't validate
11732 va_start's second argument, but can still work as intended. */
11733 warning (0, "%<__builtin_next_arg%> called without an argument");
11736 else if (nargs > 1)
11738 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11741 arg = CALL_EXPR_ARG (exp, 0);
11744 if (TREE_CODE (arg) == SSA_NAME)
11745 arg = SSA_NAME_VAR (arg);
11747 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11748 or __builtin_next_arg (0) the first time we see it, after checking
11749 the arguments and if needed issuing a warning. */
11750 if (!integer_zerop (arg))
11752 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11754 /* Strip off all nops for the sake of the comparison. This
11755 is not quite the same as STRIP_NOPS. It does more.
11756 We must also strip off INDIRECT_EXPR for C++ reference
11758 while (CONVERT_EXPR_P (arg)
11759 || TREE_CODE (arg) == INDIRECT_REF)
11760 arg = TREE_OPERAND (arg, 0);
11761 if (arg != last_parm)
11763 /* FIXME: Sometimes with the tree optimizers we can get the
11764 not the last argument even though the user used the last
11765 argument. We just warn and set the arg to be the last
11766 argument so that we will get wrong-code because of
11768 warning (0, "second parameter of %<va_start%> not last named argument");
11771 /* Undefined by C99 7.15.1.4p4 (va_start):
11772 "If the parameter parmN is declared with the register storage
11773 class, with a function or array type, or with a type that is
11774 not compatible with the type that results after application of
11775 the default argument promotions, the behavior is undefined."
11777 else if (DECL_REGISTER (arg))
11778 warning (0, "undefined behaviour when second parameter of "
11779 "%<va_start%> is declared with %<register%> storage");
11781 /* We want to verify the second parameter just once before the tree
11782 optimizers are run and then avoid keeping it in the tree,
11783 as otherwise we could warn even for correct code like:
11784 void foo (int i, ...)
11785 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11787 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11789 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11795 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11796 ORIG may be null if this is a 2-argument call. We don't attempt to
11797 simplify calls with more than 3 arguments.
11799 Return NULL_TREE if no simplification was possible, otherwise return the
11800 simplified form of the call as a tree. If IGNORED is true, it means that
11801 the caller does not use the returned value of the function. */
11804 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11805 tree orig, int ignored)
11808 const char *fmt_str = NULL;
11810 /* Verify the required arguments in the original call. We deal with two
11811 types of sprintf() calls: 'sprintf (str, fmt)' and
11812 'sprintf (dest, "%s", orig)'. */
11813 if (!validate_arg (dest, POINTER_TYPE)
11814 || !validate_arg (fmt, POINTER_TYPE))
11816 if (orig && !validate_arg (orig, POINTER_TYPE))
11819 /* Check whether the format is a literal string constant. */
11820 fmt_str = c_getstr (fmt);
11821 if (fmt_str == NULL)
11825 retval = NULL_TREE;
11827 if (!init_target_chars ())
11830 /* If the format doesn't contain % args or %%, use strcpy. */
11831 if (strchr (fmt_str, target_percent) == NULL)
11833 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11838 /* Don't optimize sprintf (buf, "abc", ptr++). */
11842 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11843 'format' is known to contain no % formats. */
11844 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11846 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11849 /* If the format is "%s", use strcpy if the result isn't used. */
11850 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11853 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11858 /* Don't crash on sprintf (str1, "%s"). */
11862 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
11865 retval = c_strlen (orig, 1);
11866 if (!retval || TREE_CODE (retval) != INTEGER_CST)
11869 call = build_call_expr_loc (loc, fn, 2, dest, orig);
11872 if (call && retval)
11874 retval = fold_convert_loc
11875 (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11877 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11883 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
11884 FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
11885 attempt to simplify calls with more than 4 arguments.
11887 Return NULL_TREE if no simplification was possible, otherwise return the
11888 simplified form of the call as a tree. If IGNORED is true, it means that
11889 the caller does not use the returned value of the function. */
11892 fold_builtin_snprintf (location_t loc, tree dest, tree destsize, tree fmt,
11893 tree orig, int ignored)
11896 const char *fmt_str = NULL;
11897 unsigned HOST_WIDE_INT destlen;
11899 /* Verify the required arguments in the original call. We deal with two
11900 types of snprintf() calls: 'snprintf (str, cst, fmt)' and
11901 'snprintf (dest, cst, "%s", orig)'. */
11902 if (!validate_arg (dest, POINTER_TYPE)
11903 || !validate_arg (destsize, INTEGER_TYPE)
11904 || !validate_arg (fmt, POINTER_TYPE))
11906 if (orig && !validate_arg (orig, POINTER_TYPE))
11909 if (!host_integerp (destsize, 1))
11912 /* Check whether the format is a literal string constant. */
11913 fmt_str = c_getstr (fmt);
11914 if (fmt_str == NULL)
11918 retval = NULL_TREE;
11920 if (!init_target_chars ())
11923 destlen = tree_low_cst (destsize, 1);
11925 /* If the format doesn't contain % args or %%, use strcpy. */
11926 if (strchr (fmt_str, target_percent) == NULL)
11928 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11929 size_t len = strlen (fmt_str);
11931 /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
11935 /* We could expand this as
11936 memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
11938 memcpy (str, fmt_with_nul_at_cstm1, cst);
11939 but in the former case that might increase code size
11940 and in the latter case grow .rodata section too much.
11941 So punt for now. */
11942 if (len >= destlen)
11948 /* Convert snprintf (str, cst, fmt) into strcpy (str, fmt) when
11949 'format' is known to contain no % formats and
11950 strlen (fmt) < cst. */
11951 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11954 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11957 /* If the format is "%s", use strcpy if the result isn't used. */
11958 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11960 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11961 unsigned HOST_WIDE_INT origlen;
11963 /* Don't crash on snprintf (str1, cst, "%s"). */
11967 retval = c_strlen (orig, 1);
11968 if (!retval || !host_integerp (retval, 1))
11971 origlen = tree_low_cst (retval, 1);
11972 /* We could expand this as
11973 memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
11975 memcpy (str1, str2_with_nul_at_cstm1, cst);
11976 but in the former case that might increase code size
11977 and in the latter case grow .rodata section too much.
11978 So punt for now. */
11979 if (origlen >= destlen)
11982 /* Convert snprintf (str1, cst, "%s", str2) into
11983 strcpy (str1, str2) if strlen (str2) < cst. */
11987 call = build_call_expr_loc (loc, fn, 2, dest, orig);
11990 retval = NULL_TREE;
11993 if (call && retval)
11995 tree fn = built_in_decls[BUILT_IN_SNPRINTF];
11996 retval = fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fn)), retval);
11997 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12003 /* Expand a call EXP to __builtin_object_size. */
12006 expand_builtin_object_size (tree exp)
12009 int object_size_type;
12010 tree fndecl = get_callee_fndecl (exp);
12012 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
12014 error ("%Kfirst argument of %D must be a pointer, second integer constant",
12016 expand_builtin_trap ();
12020 ost = CALL_EXPR_ARG (exp, 1);
12023 if (TREE_CODE (ost) != INTEGER_CST
12024 || tree_int_cst_sgn (ost) < 0
12025 || compare_tree_int (ost, 3) > 0)
12027 error ("%Klast argument of %D is not integer constant between 0 and 3",
12029 expand_builtin_trap ();
12033 object_size_type = tree_low_cst (ost, 0);
12035 return object_size_type < 2 ? constm1_rtx : const0_rtx;
12038 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12039 FCODE is the BUILT_IN_* to use.
12040 Return NULL_RTX if we failed; the caller should emit a normal call,
12041 otherwise try to get the result in TARGET, if convenient (and in
12042 mode MODE if that's convenient). */
12045 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
12046 enum built_in_function fcode)
12048 tree dest, src, len, size;
12050 if (!validate_arglist (exp,
12052 fcode == BUILT_IN_MEMSET_CHK
12053 ? INTEGER_TYPE : POINTER_TYPE,
12054 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
12057 dest = CALL_EXPR_ARG (exp, 0);
12058 src = CALL_EXPR_ARG (exp, 1);
12059 len = CALL_EXPR_ARG (exp, 2);
12060 size = CALL_EXPR_ARG (exp, 3);
12062 if (! host_integerp (size, 1))
12065 if (host_integerp (len, 1) || integer_all_onesp (size))
12069 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
12071 warning_at (tree_nonartificial_location (exp),
12072 0, "%Kcall to %D will always overflow destination buffer",
12073 exp, get_callee_fndecl (exp));
12078 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12079 mem{cpy,pcpy,move,set} is available. */
12082 case BUILT_IN_MEMCPY_CHK:
12083 fn = built_in_decls[BUILT_IN_MEMCPY];
12085 case BUILT_IN_MEMPCPY_CHK:
12086 fn = built_in_decls[BUILT_IN_MEMPCPY];
12088 case BUILT_IN_MEMMOVE_CHK:
12089 fn = built_in_decls[BUILT_IN_MEMMOVE];
12091 case BUILT_IN_MEMSET_CHK:
12092 fn = built_in_decls[BUILT_IN_MEMSET];
12101 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
12102 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12103 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12104 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12106 else if (fcode == BUILT_IN_MEMSET_CHK)
12110 unsigned int dest_align
12111 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
12113 /* If DEST is not a pointer type, call the normal function. */
12114 if (dest_align == 0)
12117 /* If SRC and DEST are the same (and not volatile), do nothing. */
12118 if (operand_equal_p (src, dest, 0))
12122 if (fcode != BUILT_IN_MEMPCPY_CHK)
12124 /* Evaluate and ignore LEN in case it has side-effects. */
12125 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12126 return expand_expr (dest, target, mode, EXPAND_NORMAL);
12129 expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12130 return expand_expr (expr, target, mode, EXPAND_NORMAL);
12133 /* __memmove_chk special case. */
12134 if (fcode == BUILT_IN_MEMMOVE_CHK)
12136 unsigned int src_align
12137 = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
12139 if (src_align == 0)
12142 /* If src is categorized for a readonly section we can use
12143 normal __memcpy_chk. */
12144 if (readonly_data_expr (src))
12146 tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12149 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
12150 dest, src, len, size);
12151 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12152 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12153 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12160 /* Emit warning if a buffer overflow is detected at compile time. */
12163 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12167 location_t loc = tree_nonartificial_location (exp);
12171 case BUILT_IN_STRCPY_CHK:
12172 case BUILT_IN_STPCPY_CHK:
12173 /* For __strcat_chk the warning will be emitted only if overflowing
12174 by at least strlen (dest) + 1 bytes. */
12175 case BUILT_IN_STRCAT_CHK:
12176 len = CALL_EXPR_ARG (exp, 1);
12177 size = CALL_EXPR_ARG (exp, 2);
12180 case BUILT_IN_STRNCAT_CHK:
12181 case BUILT_IN_STRNCPY_CHK:
12182 len = CALL_EXPR_ARG (exp, 2);
12183 size = CALL_EXPR_ARG (exp, 3);
12185 case BUILT_IN_SNPRINTF_CHK:
12186 case BUILT_IN_VSNPRINTF_CHK:
12187 len = CALL_EXPR_ARG (exp, 1);
12188 size = CALL_EXPR_ARG (exp, 3);
12191 gcc_unreachable ();
12197 if (! host_integerp (size, 1) || integer_all_onesp (size))
12202 len = c_strlen (len, 1);
12203 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12206 else if (fcode == BUILT_IN_STRNCAT_CHK)
12208 tree src = CALL_EXPR_ARG (exp, 1);
12209 if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12211 src = c_strlen (src, 1);
12212 if (! src || ! host_integerp (src, 1))
12214 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12215 exp, get_callee_fndecl (exp));
12218 else if (tree_int_cst_lt (src, size))
12221 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12224 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12225 exp, get_callee_fndecl (exp));
12228 /* Emit warning if a buffer overflow is detected at compile time
12229 in __sprintf_chk/__vsprintf_chk calls. */
12232 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12234 tree size, len, fmt;
12235 const char *fmt_str;
12236 int nargs = call_expr_nargs (exp);
12238 /* Verify the required arguments in the original call. */
12242 size = CALL_EXPR_ARG (exp, 2);
12243 fmt = CALL_EXPR_ARG (exp, 3);
12245 if (! host_integerp (size, 1) || integer_all_onesp (size))
12248 /* Check whether the format is a literal string constant. */
12249 fmt_str = c_getstr (fmt);
12250 if (fmt_str == NULL)
12253 if (!init_target_chars ())
12256 /* If the format doesn't contain % args or %%, we know its size. */
12257 if (strchr (fmt_str, target_percent) == 0)
12258 len = build_int_cstu (size_type_node, strlen (fmt_str));
12259 /* If the format is "%s" and first ... argument is a string literal,
12261 else if (fcode == BUILT_IN_SPRINTF_CHK
12262 && strcmp (fmt_str, target_percent_s) == 0)
12268 arg = CALL_EXPR_ARG (exp, 4);
12269 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12272 len = c_strlen (arg, 1);
12273 if (!len || ! host_integerp (len, 1))
12279 if (! tree_int_cst_lt (len, size))
12280 warning_at (tree_nonartificial_location (exp),
12281 0, "%Kcall to %D will always overflow destination buffer",
12282 exp, get_callee_fndecl (exp));
12285 /* Emit warning if a free is called with address of a variable. */
12288 maybe_emit_free_warning (tree exp)
12290 tree arg = CALL_EXPR_ARG (exp, 0);
12293 if (TREE_CODE (arg) != ADDR_EXPR)
12296 arg = get_base_address (TREE_OPERAND (arg, 0));
12297 if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12300 if (SSA_VAR_P (arg))
12301 warning_at (tree_nonartificial_location (exp),
12302 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12304 warning_at (tree_nonartificial_location (exp),
12305 0, "%Kattempt to free a non-heap object", exp);
12308 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12312 fold_builtin_object_size (tree ptr, tree ost)
12314 unsigned HOST_WIDE_INT bytes;
12315 int object_size_type;
12317 if (!validate_arg (ptr, POINTER_TYPE)
12318 || !validate_arg (ost, INTEGER_TYPE))
12323 if (TREE_CODE (ost) != INTEGER_CST
12324 || tree_int_cst_sgn (ost) < 0
12325 || compare_tree_int (ost, 3) > 0)
12328 object_size_type = tree_low_cst (ost, 0);
12330 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12331 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12332 and (size_t) 0 for types 2 and 3. */
12333 if (TREE_SIDE_EFFECTS (ptr))
12334 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12336 if (TREE_CODE (ptr) == ADDR_EXPR)
12338 bytes = compute_builtin_object_size (ptr, object_size_type);
12339 if (double_int_fits_to_tree_p (size_type_node,
12340 uhwi_to_double_int (bytes)))
12341 return build_int_cstu (size_type_node, bytes);
12343 else if (TREE_CODE (ptr) == SSA_NAME)
12345 /* If object size is not known yet, delay folding until
12346 later. Maybe subsequent passes will help determining
12348 bytes = compute_builtin_object_size (ptr, object_size_type);
12349 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12350 && double_int_fits_to_tree_p (size_type_node,
12351 uhwi_to_double_int (bytes)))
12352 return build_int_cstu (size_type_node, bytes);
12358 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12359 DEST, SRC, LEN, and SIZE are the arguments to the call.
12360 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12361 code of the builtin. If MAXLEN is not NULL, it is maximum length
12362 passed as third argument. */
12365 fold_builtin_memory_chk (location_t loc, tree fndecl,
12366 tree dest, tree src, tree len, tree size,
12367 tree maxlen, bool ignore,
12368 enum built_in_function fcode)
12372 if (!validate_arg (dest, POINTER_TYPE)
12373 || !validate_arg (src,
12374 (fcode == BUILT_IN_MEMSET_CHK
12375 ? INTEGER_TYPE : POINTER_TYPE))
12376 || !validate_arg (len, INTEGER_TYPE)
12377 || !validate_arg (size, INTEGER_TYPE))
12380 /* If SRC and DEST are the same (and not volatile), return DEST
12381 (resp. DEST+LEN for __mempcpy_chk). */
12382 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12384 if (fcode != BUILT_IN_MEMPCPY_CHK)
12385 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12389 tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12391 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12395 if (! host_integerp (size, 1))
12398 if (! integer_all_onesp (size))
12400 if (! host_integerp (len, 1))
12402 /* If LEN is not constant, try MAXLEN too.
12403 For MAXLEN only allow optimizing into non-_ocs function
12404 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12405 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12407 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12409 /* (void) __mempcpy_chk () can be optimized into
12410 (void) __memcpy_chk (). */
12411 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12415 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12423 if (tree_int_cst_lt (size, maxlen))
12428 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12429 mem{cpy,pcpy,move,set} is available. */
12432 case BUILT_IN_MEMCPY_CHK:
12433 fn = built_in_decls[BUILT_IN_MEMCPY];
12435 case BUILT_IN_MEMPCPY_CHK:
12436 fn = built_in_decls[BUILT_IN_MEMPCPY];
12438 case BUILT_IN_MEMMOVE_CHK:
12439 fn = built_in_decls[BUILT_IN_MEMMOVE];
12441 case BUILT_IN_MEMSET_CHK:
12442 fn = built_in_decls[BUILT_IN_MEMSET];
12451 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12454 /* Fold a call to the __st[rp]cpy_chk builtin.
12455 DEST, SRC, and SIZE are the arguments to the call.
12456 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12457 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12458 strings passed as second argument. */
12461 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12462 tree src, tree size,
12463 tree maxlen, bool ignore,
12464 enum built_in_function fcode)
12468 if (!validate_arg (dest, POINTER_TYPE)
12469 || !validate_arg (src, POINTER_TYPE)
12470 || !validate_arg (size, INTEGER_TYPE))
12473 /* If SRC and DEST are the same (and not volatile), return DEST. */
12474 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12475 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12477 if (! host_integerp (size, 1))
12480 if (! integer_all_onesp (size))
12482 len = c_strlen (src, 1);
12483 if (! len || ! host_integerp (len, 1))
12485 /* If LEN is not constant, try MAXLEN too.
12486 For MAXLEN only allow optimizing into non-_ocs function
12487 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12488 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12490 if (fcode == BUILT_IN_STPCPY_CHK)
12495 /* If return value of __stpcpy_chk is ignored,
12496 optimize into __strcpy_chk. */
12497 fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12501 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12504 if (! len || TREE_SIDE_EFFECTS (len))
12507 /* If c_strlen returned something, but not a constant,
12508 transform __strcpy_chk into __memcpy_chk. */
12509 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12513 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12514 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12515 build_call_expr_loc (loc, fn, 4,
12516 dest, src, len, size));
12522 if (! tree_int_cst_lt (maxlen, size))
12526 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12527 fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12528 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12532 return build_call_expr_loc (loc, fn, 2, dest, src);
12535 /* Fold a call to the __strncpy_chk builtin. DEST, SRC, LEN, and SIZE
12536 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12537 length passed as third argument. */
12540 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12541 tree len, tree size, tree maxlen)
12545 if (!validate_arg (dest, POINTER_TYPE)
12546 || !validate_arg (src, POINTER_TYPE)
12547 || !validate_arg (len, INTEGER_TYPE)
12548 || !validate_arg (size, INTEGER_TYPE))
12551 if (! host_integerp (size, 1))
12554 if (! integer_all_onesp (size))
12556 if (! host_integerp (len, 1))
12558 /* If LEN is not constant, try MAXLEN too.
12559 For MAXLEN only allow optimizing into non-_ocs function
12560 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12561 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12567 if (tree_int_cst_lt (size, maxlen))
12571 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
12572 fn = built_in_decls[BUILT_IN_STRNCPY];
12576 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12579 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12580 are the arguments to the call. */
12583 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12584 tree src, tree size)
12589 if (!validate_arg (dest, POINTER_TYPE)
12590 || !validate_arg (src, POINTER_TYPE)
12591 || !validate_arg (size, INTEGER_TYPE))
12594 p = c_getstr (src);
12595 /* If the SRC parameter is "", return DEST. */
12596 if (p && *p == '\0')
12597 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12599 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12602 /* If __builtin_strcat_chk is used, assume strcat is available. */
12603 fn = built_in_decls[BUILT_IN_STRCAT];
12607 return build_call_expr_loc (loc, fn, 2, dest, src);
12610 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12614 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12615 tree dest, tree src, tree len, tree size)
12620 if (!validate_arg (dest, POINTER_TYPE)
12621 || !validate_arg (src, POINTER_TYPE)
12622 || !validate_arg (size, INTEGER_TYPE)
12623 || !validate_arg (size, INTEGER_TYPE))
12626 p = c_getstr (src);
12627 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
12628 if (p && *p == '\0')
12629 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12630 else if (integer_zerop (len))
12631 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12633 if (! host_integerp (size, 1))
12636 if (! integer_all_onesp (size))
12638 tree src_len = c_strlen (src, 1);
12640 && host_integerp (src_len, 1)
12641 && host_integerp (len, 1)
12642 && ! tree_int_cst_lt (len, src_len))
12644 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
12645 fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12649 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12654 /* If __builtin_strncat_chk is used, assume strncat is available. */
12655 fn = built_in_decls[BUILT_IN_STRNCAT];
12659 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12662 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
12663 Return NULL_TREE if a normal call should be emitted rather than
12664 expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
12665 or BUILT_IN_VSPRINTF_CHK. */
12668 fold_builtin_sprintf_chk_1 (location_t loc, int nargs, tree *args,
12669 enum built_in_function fcode)
12671 tree dest, size, len, fn, fmt, flag;
12672 const char *fmt_str;
12674 /* Verify the required arguments in the original call. */
12678 if (!validate_arg (dest, POINTER_TYPE))
12681 if (!validate_arg (flag, INTEGER_TYPE))
12684 if (!validate_arg (size, INTEGER_TYPE))
12687 if (!validate_arg (fmt, POINTER_TYPE))
12690 if (! host_integerp (size, 1))
12695 if (!init_target_chars ())
12698 /* Check whether the format is a literal string constant. */
12699 fmt_str = c_getstr (fmt);
12700 if (fmt_str != NULL)
12702 /* If the format doesn't contain % args or %%, we know the size. */
12703 if (strchr (fmt_str, target_percent) == 0)
12705 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12706 len = build_int_cstu (size_type_node, strlen (fmt_str));
12708 /* If the format is "%s" and first ... argument is a string literal,
12709 we know the size too. */
12710 else if (fcode == BUILT_IN_SPRINTF_CHK
12711 && strcmp (fmt_str, target_percent_s) == 0)
12718 if (validate_arg (arg, POINTER_TYPE))
12720 len = c_strlen (arg, 1);
12721 if (! len || ! host_integerp (len, 1))
12728 if (! integer_all_onesp (size))
12730 if (! len || ! tree_int_cst_lt (len, size))
12734 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12735 or if format doesn't contain % chars or is "%s". */
12736 if (! integer_zerop (flag))
12738 if (fmt_str == NULL)
12740 if (strchr (fmt_str, target_percent) != NULL
12741 && strcmp (fmt_str, target_percent_s))
12745 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
12746 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12747 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12751 return rewrite_call_expr_array (loc, nargs, args, 4, fn, 2, dest, fmt);
12754 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
12755 a normal call should be emitted rather than expanding the function
12756 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
12759 fold_builtin_sprintf_chk (location_t loc, tree exp,
12760 enum built_in_function fcode)
12762 return fold_builtin_sprintf_chk_1 (loc, call_expr_nargs (exp),
12763 CALL_EXPR_ARGP (exp), fcode);
12766 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
12767 NULL_TREE if a normal call should be emitted rather than expanding
12768 the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
12769 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
12770 passed as second argument. */
12773 fold_builtin_snprintf_chk_1 (location_t loc, int nargs, tree *args,
12774 tree maxlen, enum built_in_function fcode)
12776 tree dest, size, len, fn, fmt, flag;
12777 const char *fmt_str;
12779 /* Verify the required arguments in the original call. */
12783 if (!validate_arg (dest, POINTER_TYPE))
12786 if (!validate_arg (len, INTEGER_TYPE))
12789 if (!validate_arg (flag, INTEGER_TYPE))
12792 if (!validate_arg (size, INTEGER_TYPE))
12795 if (!validate_arg (fmt, POINTER_TYPE))
12798 if (! host_integerp (size, 1))
12801 if (! integer_all_onesp (size))
12803 if (! host_integerp (len, 1))
12805 /* If LEN is not constant, try MAXLEN too.
12806 For MAXLEN only allow optimizing into non-_ocs function
12807 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12808 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12814 if (tree_int_cst_lt (size, maxlen))
12818 if (!init_target_chars ())
12821 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12822 or if format doesn't contain % chars or is "%s". */
12823 if (! integer_zerop (flag))
12825 fmt_str = c_getstr (fmt);
12826 if (fmt_str == NULL)
12828 if (strchr (fmt_str, target_percent) != NULL
12829 && strcmp (fmt_str, target_percent_s))
12833 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12835 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12836 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12840 return rewrite_call_expr_array (loc, nargs, args, 5, fn, 3, dest, len, fmt);
12843 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
12844 a normal call should be emitted rather than expanding the function
12845 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
12846 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
12847 passed as second argument. */
12850 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12851 enum built_in_function fcode)
12853 return fold_builtin_snprintf_chk_1 (loc, call_expr_nargs (exp),
12854 CALL_EXPR_ARGP (exp), maxlen, fcode);
12857 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12858 FMT and ARG are the arguments to the call; we don't fold cases with
12859 more than 2 arguments, and ARG may be null if this is a 1-argument case.
12861 Return NULL_TREE if no simplification was possible, otherwise return the
12862 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12863 code of the function to be simplified. */
12866 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12867 tree arg, bool ignore,
12868 enum built_in_function fcode)
12870 tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12871 const char *fmt_str = NULL;
12873 /* If the return value is used, don't do the transformation. */
12877 /* Verify the required arguments in the original call. */
12878 if (!validate_arg (fmt, POINTER_TYPE))
12881 /* Check whether the format is a literal string constant. */
12882 fmt_str = c_getstr (fmt);
12883 if (fmt_str == NULL)
12886 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12888 /* If we're using an unlocked function, assume the other
12889 unlocked functions exist explicitly. */
12890 fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12891 fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12895 fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12896 fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12899 if (!init_target_chars ())
12902 if (strcmp (fmt_str, target_percent_s) == 0
12903 || strchr (fmt_str, target_percent) == NULL)
12907 if (strcmp (fmt_str, target_percent_s) == 0)
12909 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12912 if (!arg || !validate_arg (arg, POINTER_TYPE))
12915 str = c_getstr (arg);
12921 /* The format specifier doesn't contain any '%' characters. */
12922 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12928 /* If the string was "", printf does nothing. */
12929 if (str[0] == '\0')
12930 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12932 /* If the string has length of 1, call putchar. */
12933 if (str[1] == '\0')
12935 /* Given printf("c"), (where c is any one character,)
12936 convert "c"[0] to an int and pass that to the replacement
12938 newarg = build_int_cst (NULL_TREE, str[0]);
12940 call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12944 /* If the string was "string\n", call puts("string"). */
12945 size_t len = strlen (str);
12946 if ((unsigned char)str[len - 1] == target_newline
12947 && (size_t) (int) len == len
12951 tree offset_node, string_cst;
12953 /* Create a NUL-terminated string that's one char shorter
12954 than the original, stripping off the trailing '\n'. */
12955 newarg = build_string_literal (len, str);
12956 string_cst = string_constant (newarg, &offset_node);
12957 gcc_checking_assert (string_cst
12958 && (TREE_STRING_LENGTH (string_cst)
12960 && integer_zerop (offset_node)
12962 TREE_STRING_POINTER (string_cst)[len - 1]
12963 == target_newline);
12964 /* build_string_literal creates a new STRING_CST,
12965 modify it in place to avoid double copying. */
12966 newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst));
12967 newstr[len - 1] = '\0';
12969 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12972 /* We'd like to arrange to call fputs(string,stdout) here,
12973 but we need stdout and don't have a way to get it yet. */
12978 /* The other optimizations can be done only on the non-va_list variants. */
12979 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12982 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
12983 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12985 if (!arg || !validate_arg (arg, POINTER_TYPE))
12988 call = build_call_expr_loc (loc, fn_puts, 1, arg);
12991 /* If the format specifier was "%c", call __builtin_putchar(arg). */
12992 else if (strcmp (fmt_str, target_percent_c) == 0)
12994 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12997 call = build_call_expr_loc (loc, fn_putchar, 1, arg);
13003 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13006 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13007 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
13008 more than 3 arguments, and ARG may be null in the 2-argument case.
13010 Return NULL_TREE if no simplification was possible, otherwise return the
13011 simplified form of the call as a tree. FCODE is the BUILT_IN_*
13012 code of the function to be simplified. */
13015 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
13016 tree fmt, tree arg, bool ignore,
13017 enum built_in_function fcode)
13019 tree fn_fputc, fn_fputs, call = NULL_TREE;
13020 const char *fmt_str = NULL;
13022 /* If the return value is used, don't do the transformation. */
13026 /* Verify the required arguments in the original call. */
13027 if (!validate_arg (fp, POINTER_TYPE))
13029 if (!validate_arg (fmt, POINTER_TYPE))
13032 /* Check whether the format is a literal string constant. */
13033 fmt_str = c_getstr (fmt);
13034 if (fmt_str == NULL)
13037 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
13039 /* If we're using an unlocked function, assume the other
13040 unlocked functions exist explicitly. */
13041 fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
13042 fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
13046 fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
13047 fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
13050 if (!init_target_chars ())
13053 /* If the format doesn't contain % args or %%, use strcpy. */
13054 if (strchr (fmt_str, target_percent) == NULL)
13056 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
13060 /* If the format specifier was "", fprintf does nothing. */
13061 if (fmt_str[0] == '\0')
13063 /* If FP has side-effects, just wait until gimplification is
13065 if (TREE_SIDE_EFFECTS (fp))
13068 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13071 /* When "string" doesn't contain %, replace all cases of
13072 fprintf (fp, string) with fputs (string, fp). The fputs
13073 builtin will take care of special cases like length == 1. */
13075 call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
13078 /* The other optimizations can be done only on the non-va_list variants. */
13079 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
13082 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
13083 else if (strcmp (fmt_str, target_percent_s) == 0)
13085 if (!arg || !validate_arg (arg, POINTER_TYPE))
13088 call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
13091 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
13092 else if (strcmp (fmt_str, target_percent_c) == 0)
13094 if (!arg || !validate_arg (arg, INTEGER_TYPE))
13097 call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
13102 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13105 /* Initialize format string characters in the target charset. */
13108 init_target_chars (void)
13113 target_newline = lang_hooks.to_target_charset ('\n');
13114 target_percent = lang_hooks.to_target_charset ('%');
13115 target_c = lang_hooks.to_target_charset ('c');
13116 target_s = lang_hooks.to_target_charset ('s');
13117 if (target_newline == 0 || target_percent == 0 || target_c == 0
13121 target_percent_c[0] = target_percent;
13122 target_percent_c[1] = target_c;
13123 target_percent_c[2] = '\0';
13125 target_percent_s[0] = target_percent;
13126 target_percent_s[1] = target_s;
13127 target_percent_s[2] = '\0';
13129 target_percent_s_newline[0] = target_percent;
13130 target_percent_s_newline[1] = target_s;
13131 target_percent_s_newline[2] = target_newline;
13132 target_percent_s_newline[3] = '\0';
13139 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
13140 and no overflow/underflow occurred. INEXACT is true if M was not
13141 exactly calculated. TYPE is the tree type for the result. This
13142 function assumes that you cleared the MPFR flags and then
13143 calculated M to see if anything subsequently set a flag prior to
13144 entering this function. Return NULL_TREE if any checks fail. */
13147 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13149 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13150 overflow/underflow occurred. If -frounding-math, proceed iff the
13151 result of calling FUNC was exact. */
13152 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13153 && (!flag_rounding_math || !inexact))
13155 REAL_VALUE_TYPE rr;
13157 real_from_mpfr (&rr, m, type, GMP_RNDN);
13158 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13159 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13160 but the mpft_t is not, then we underflowed in the
13162 if (real_isfinite (&rr)
13163 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13165 REAL_VALUE_TYPE rmode;
13167 real_convert (&rmode, TYPE_MODE (type), &rr);
13168 /* Proceed iff the specified mode can hold the value. */
13169 if (real_identical (&rmode, &rr))
13170 return build_real (type, rmode);
13176 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
13177 number and no overflow/underflow occurred. INEXACT is true if M
13178 was not exactly calculated. TYPE is the tree type for the result.
13179 This function assumes that you cleared the MPFR flags and then
13180 calculated M to see if anything subsequently set a flag prior to
13181 entering this function. Return NULL_TREE if any checks fail, if
13182 FORCE_CONVERT is true, then bypass the checks. */
13185 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13187 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13188 overflow/underflow occurred. If -frounding-math, proceed iff the
13189 result of calling FUNC was exact. */
13191 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13192 && !mpfr_overflow_p () && !mpfr_underflow_p ()
13193 && (!flag_rounding_math || !inexact)))
13195 REAL_VALUE_TYPE re, im;
13197 real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
13198 real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
13199 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13200 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13201 but the mpft_t is not, then we underflowed in the
13204 || (real_isfinite (&re) && real_isfinite (&im)
13205 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13206 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13208 REAL_VALUE_TYPE re_mode, im_mode;
13210 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13211 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13212 /* Proceed iff the specified mode can hold the value. */
13214 || (real_identical (&re_mode, &re)
13215 && real_identical (&im_mode, &im)))
13216 return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13217 build_real (TREE_TYPE (type), im_mode));
13223 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13224 FUNC on it and return the resulting value as a tree with type TYPE.
13225 If MIN and/or MAX are not NULL, then the supplied ARG must be
13226 within those bounds. If INCLUSIVE is true, then MIN/MAX are
13227 acceptable values, otherwise they are not. The mpfr precision is
13228 set to the precision of TYPE. We assume that function FUNC returns
13229 zero if the result could be calculated exactly within the requested
13233 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13234 const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13237 tree result = NULL_TREE;
13241 /* To proceed, MPFR must exactly represent the target floating point
13242 format, which only happens when the target base equals two. */
13243 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13244 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13246 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13248 if (real_isfinite (ra)
13249 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13250 && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13252 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13253 const int prec = fmt->p;
13254 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13258 mpfr_init2 (m, prec);
13259 mpfr_from_real (m, ra, GMP_RNDN);
13260 mpfr_clear_flags ();
13261 inexact = func (m, m, rnd);
13262 result = do_mpfr_ckconv (m, type, inexact);
13270 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13271 FUNC on it and return the resulting value as a tree with type TYPE.
13272 The mpfr precision is set to the precision of TYPE. We assume that
13273 function FUNC returns zero if the result could be calculated
13274 exactly within the requested precision. */
13277 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13278 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13280 tree result = NULL_TREE;
13285 /* To proceed, MPFR must exactly represent the target floating point
13286 format, which only happens when the target base equals two. */
13287 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13288 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13289 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13291 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13292 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13294 if (real_isfinite (ra1) && real_isfinite (ra2))
13296 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13297 const int prec = fmt->p;
13298 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13302 mpfr_inits2 (prec, m1, m2, NULL);
13303 mpfr_from_real (m1, ra1, GMP_RNDN);
13304 mpfr_from_real (m2, ra2, GMP_RNDN);
13305 mpfr_clear_flags ();
13306 inexact = func (m1, m1, m2, rnd);
13307 result = do_mpfr_ckconv (m1, type, inexact);
13308 mpfr_clears (m1, m2, NULL);
13315 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13316 FUNC on it and return the resulting value as a tree with type TYPE.
13317 The mpfr precision is set to the precision of TYPE. We assume that
13318 function FUNC returns zero if the result could be calculated
13319 exactly within the requested precision. */
13322 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13323 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13325 tree result = NULL_TREE;
13331 /* To proceed, MPFR must exactly represent the target floating point
13332 format, which only happens when the target base equals two. */
13333 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13334 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13335 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13336 && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13338 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13339 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13340 const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13342 if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13344 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13345 const int prec = fmt->p;
13346 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13350 mpfr_inits2 (prec, m1, m2, m3, NULL);
13351 mpfr_from_real (m1, ra1, GMP_RNDN);
13352 mpfr_from_real (m2, ra2, GMP_RNDN);
13353 mpfr_from_real (m3, ra3, GMP_RNDN);
13354 mpfr_clear_flags ();
13355 inexact = func (m1, m1, m2, m3, rnd);
13356 result = do_mpfr_ckconv (m1, type, inexact);
13357 mpfr_clears (m1, m2, m3, NULL);
13364 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13365 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13366 If ARG_SINP and ARG_COSP are NULL then the result is returned
13367 as a complex value.
13368 The type is taken from the type of ARG and is used for setting the
13369 precision of the calculation and results. */
13372 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13374 tree const type = TREE_TYPE (arg);
13375 tree result = NULL_TREE;
13379 /* To proceed, MPFR must exactly represent the target floating point
13380 format, which only happens when the target base equals two. */
13381 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13382 && TREE_CODE (arg) == REAL_CST
13383 && !TREE_OVERFLOW (arg))
13385 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13387 if (real_isfinite (ra))
13389 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13390 const int prec = fmt->p;
13391 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13392 tree result_s, result_c;
13396 mpfr_inits2 (prec, m, ms, mc, NULL);
13397 mpfr_from_real (m, ra, GMP_RNDN);
13398 mpfr_clear_flags ();
13399 inexact = mpfr_sin_cos (ms, mc, m, rnd);
13400 result_s = do_mpfr_ckconv (ms, type, inexact);
13401 result_c = do_mpfr_ckconv (mc, type, inexact);
13402 mpfr_clears (m, ms, mc, NULL);
13403 if (result_s && result_c)
13405 /* If we are to return in a complex value do so. */
13406 if (!arg_sinp && !arg_cosp)
13407 return build_complex (build_complex_type (type),
13408 result_c, result_s);
13410 /* Dereference the sin/cos pointer arguments. */
13411 arg_sinp = build_fold_indirect_ref (arg_sinp);
13412 arg_cosp = build_fold_indirect_ref (arg_cosp);
13413 /* Proceed if valid pointer type were passed in. */
13414 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13415 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13417 /* Set the values. */
13418 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13420 TREE_SIDE_EFFECTS (result_s) = 1;
13421 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13423 TREE_SIDE_EFFECTS (result_c) = 1;
13424 /* Combine the assignments into a compound expr. */
13425 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13426 result_s, result_c));
13434 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13435 two-argument mpfr order N Bessel function FUNC on them and return
13436 the resulting value as a tree with type TYPE. The mpfr precision
13437 is set to the precision of TYPE. We assume that function FUNC
13438 returns zero if the result could be calculated exactly within the
13439 requested precision. */
13441 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13442 int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13443 const REAL_VALUE_TYPE *min, bool inclusive)
13445 tree result = NULL_TREE;
13450 /* To proceed, MPFR must exactly represent the target floating point
13451 format, which only happens when the target base equals two. */
13452 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13453 && host_integerp (arg1, 0)
13454 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13456 const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13457 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13460 && real_isfinite (ra)
13461 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13463 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13464 const int prec = fmt->p;
13465 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13469 mpfr_init2 (m, prec);
13470 mpfr_from_real (m, ra, GMP_RNDN);
13471 mpfr_clear_flags ();
13472 inexact = func (m, n, m, rnd);
13473 result = do_mpfr_ckconv (m, type, inexact);
13481 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13482 the pointer *(ARG_QUO) and return the result. The type is taken
13483 from the type of ARG0 and is used for setting the precision of the
13484 calculation and results. */
13487 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13489 tree const type = TREE_TYPE (arg0);
13490 tree result = NULL_TREE;
13495 /* To proceed, MPFR must exactly represent the target floating point
13496 format, which only happens when the target base equals two. */
13497 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13498 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13499 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13501 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13502 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13504 if (real_isfinite (ra0) && real_isfinite (ra1))
13506 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13507 const int prec = fmt->p;
13508 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13513 mpfr_inits2 (prec, m0, m1, NULL);
13514 mpfr_from_real (m0, ra0, GMP_RNDN);
13515 mpfr_from_real (m1, ra1, GMP_RNDN);
13516 mpfr_clear_flags ();
13517 mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13518 /* Remquo is independent of the rounding mode, so pass
13519 inexact=0 to do_mpfr_ckconv(). */
13520 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13521 mpfr_clears (m0, m1, NULL);
13524 /* MPFR calculates quo in the host's long so it may
13525 return more bits in quo than the target int can hold
13526 if sizeof(host long) > sizeof(target int). This can
13527 happen even for native compilers in LP64 mode. In
13528 these cases, modulo the quo value with the largest
13529 number that the target int can hold while leaving one
13530 bit for the sign. */
13531 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13532 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13534 /* Dereference the quo pointer argument. */
13535 arg_quo = build_fold_indirect_ref (arg_quo);
13536 /* Proceed iff a valid pointer type was passed in. */
13537 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13539 /* Set the value. */
13540 tree result_quo = fold_build2 (MODIFY_EXPR,
13541 TREE_TYPE (arg_quo), arg_quo,
13542 build_int_cst (NULL, integer_quo));
13543 TREE_SIDE_EFFECTS (result_quo) = 1;
13544 /* Combine the quo assignment with the rem. */
13545 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13546 result_quo, result_rem));
13554 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13555 resulting value as a tree with type TYPE. The mpfr precision is
13556 set to the precision of TYPE. We assume that this mpfr function
13557 returns zero if the result could be calculated exactly within the
13558 requested precision. In addition, the integer pointer represented
13559 by ARG_SG will be dereferenced and set to the appropriate signgam
13563 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13565 tree result = NULL_TREE;
13569 /* To proceed, MPFR must exactly represent the target floating point
13570 format, which only happens when the target base equals two. Also
13571 verify ARG is a constant and that ARG_SG is an int pointer. */
13572 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13573 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13574 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13575 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13577 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13579 /* In addition to NaN and Inf, the argument cannot be zero or a
13580 negative integer. */
13581 if (real_isfinite (ra)
13582 && ra->cl != rvc_zero
13583 && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13585 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13586 const int prec = fmt->p;
13587 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13592 mpfr_init2 (m, prec);
13593 mpfr_from_real (m, ra, GMP_RNDN);
13594 mpfr_clear_flags ();
13595 inexact = mpfr_lgamma (m, &sg, m, rnd);
13596 result_lg = do_mpfr_ckconv (m, type, inexact);
13602 /* Dereference the arg_sg pointer argument. */
13603 arg_sg = build_fold_indirect_ref (arg_sg);
13604 /* Assign the signgam value into *arg_sg. */
13605 result_sg = fold_build2 (MODIFY_EXPR,
13606 TREE_TYPE (arg_sg), arg_sg,
13607 build_int_cst (NULL, sg));
13608 TREE_SIDE_EFFECTS (result_sg) = 1;
13609 /* Combine the signgam assignment with the lgamma result. */
13610 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13611 result_sg, result_lg));
13619 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13620 function FUNC on it and return the resulting value as a tree with
13621 type TYPE. The mpfr precision is set to the precision of TYPE. We
13622 assume that function FUNC returns zero if the result could be
13623 calculated exactly within the requested precision. */
13626 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13628 tree result = NULL_TREE;
13632 /* To proceed, MPFR must exactly represent the target floating point
13633 format, which only happens when the target base equals two. */
13634 if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13635 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13636 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13638 const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13639 const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13641 if (real_isfinite (re) && real_isfinite (im))
13643 const struct real_format *const fmt =
13644 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13645 const int prec = fmt->p;
13646 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13647 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13651 mpc_init2 (m, prec);
13652 mpfr_from_real (mpc_realref(m), re, rnd);
13653 mpfr_from_real (mpc_imagref(m), im, rnd);
13654 mpfr_clear_flags ();
13655 inexact = func (m, m, crnd);
13656 result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13664 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13665 mpc function FUNC on it and return the resulting value as a tree
13666 with type TYPE. The mpfr precision is set to the precision of
13667 TYPE. We assume that function FUNC returns zero if the result
13668 could be calculated exactly within the requested precision. If
13669 DO_NONFINITE is true, then fold expressions containing Inf or NaN
13670 in the arguments and/or results. */
13673 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13674 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13676 tree result = NULL_TREE;
13681 /* To proceed, MPFR must exactly represent the target floating point
13682 format, which only happens when the target base equals two. */
13683 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13684 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13685 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13686 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13687 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13689 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13690 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13691 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13692 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13695 || (real_isfinite (re0) && real_isfinite (im0)
13696 && real_isfinite (re1) && real_isfinite (im1)))
13698 const struct real_format *const fmt =
13699 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13700 const int prec = fmt->p;
13701 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13702 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13706 mpc_init2 (m0, prec);
13707 mpc_init2 (m1, prec);
13708 mpfr_from_real (mpc_realref(m0), re0, rnd);
13709 mpfr_from_real (mpc_imagref(m0), im0, rnd);
13710 mpfr_from_real (mpc_realref(m1), re1, rnd);
13711 mpfr_from_real (mpc_imagref(m1), im1, rnd);
13712 mpfr_clear_flags ();
13713 inexact = func (m0, m0, m1, crnd);
13714 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13723 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
13724 a normal call should be emitted rather than expanding the function
13725 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13728 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13730 int nargs = gimple_call_num_args (stmt);
13732 return fold_builtin_sprintf_chk_1 (gimple_location (stmt), nargs,
13734 ? gimple_call_arg_ptr (stmt, 0)
13735 : &error_mark_node), fcode);
13738 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
13739 a normal call should be emitted rather than expanding the function
13740 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13741 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13742 passed as second argument. */
13745 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13746 enum built_in_function fcode)
13748 int nargs = gimple_call_num_args (stmt);
13750 return fold_builtin_snprintf_chk_1 (gimple_location (stmt), nargs,
13752 ? gimple_call_arg_ptr (stmt, 0)
13753 : &error_mark_node), maxlen, fcode);
13756 /* Builtins with folding operations that operate on "..." arguments
13757 need special handling; we need to store the arguments in a convenient
13758 data structure before attempting any folding. Fortunately there are
13759 only a few builtins that fall into this category. FNDECL is the
13760 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13761 result of the function call is ignored. */
13764 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13765 bool ignore ATTRIBUTE_UNUSED)
13767 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13768 tree ret = NULL_TREE;
13772 case BUILT_IN_SPRINTF_CHK:
13773 case BUILT_IN_VSPRINTF_CHK:
13774 ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13777 case BUILT_IN_SNPRINTF_CHK:
13778 case BUILT_IN_VSNPRINTF_CHK:
13779 ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13786 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13787 TREE_NO_WARNING (ret) = 1;
13793 /* A wrapper function for builtin folding that prevents warnings for
13794 "statement without effect" and the like, caused by removing the
13795 call node earlier than the warning is generated. */
13798 fold_call_stmt (gimple stmt, bool ignore)
13800 tree ret = NULL_TREE;
13801 tree fndecl = gimple_call_fndecl (stmt);
13802 location_t loc = gimple_location (stmt);
13804 && TREE_CODE (fndecl) == FUNCTION_DECL
13805 && DECL_BUILT_IN (fndecl)
13806 && !gimple_call_va_arg_pack_p (stmt))
13808 int nargs = gimple_call_num_args (stmt);
13809 tree *args = (nargs > 0
13810 ? gimple_call_arg_ptr (stmt, 0)
13811 : &error_mark_node);
13813 if (avoid_folding_inline_builtin (fndecl))
13815 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13817 return targetm.fold_builtin (fndecl, nargs, args, ignore);
13821 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13822 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13824 ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13827 /* Propagate location information from original call to
13828 expansion of builtin. Otherwise things like
13829 maybe_emit_chk_warning, that operate on the expansion
13830 of a builtin, will use the wrong location information. */
13831 if (gimple_has_location (stmt))
13833 tree realret = ret;
13834 if (TREE_CODE (ret) == NOP_EXPR)
13835 realret = TREE_OPERAND (ret, 0);
13836 if (CAN_HAVE_LOCATION_P (realret)
13837 && !EXPR_HAS_LOCATION (realret))
13838 SET_EXPR_LOCATION (realret, loc);
13848 /* Look up the function in built_in_decls that corresponds to DECL
13849 and set ASMSPEC as its user assembler name. DECL must be a
13850 function decl that declares a builtin. */
13853 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13856 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13857 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13860 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13861 set_user_assembler_name (builtin, asmspec);
13862 switch (DECL_FUNCTION_CODE (decl))
13864 case BUILT_IN_MEMCPY:
13865 init_block_move_fn (asmspec);
13866 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13868 case BUILT_IN_MEMSET:
13869 init_block_clear_fn (asmspec);
13870 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13872 case BUILT_IN_MEMMOVE:
13873 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13875 case BUILT_IN_MEMCMP:
13876 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13878 case BUILT_IN_ABORT:
13879 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13882 if (INT_TYPE_SIZE < BITS_PER_WORD)
13884 set_user_assembler_libfunc ("ffs", asmspec);
13885 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13886 MODE_INT, 0), "ffs");
13894 /* Return true if DECL is a builtin that expands to a constant or similarly
13897 is_simple_builtin (tree decl)
13899 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13900 switch (DECL_FUNCTION_CODE (decl))
13902 /* Builtins that expand to constants. */
13903 case BUILT_IN_CONSTANT_P:
13904 case BUILT_IN_EXPECT:
13905 case BUILT_IN_OBJECT_SIZE:
13906 case BUILT_IN_UNREACHABLE:
13907 /* Simple register moves or loads from stack. */
13908 case BUILT_IN_RETURN_ADDRESS:
13909 case BUILT_IN_EXTRACT_RETURN_ADDR:
13910 case BUILT_IN_FROB_RETURN_ADDR:
13911 case BUILT_IN_RETURN:
13912 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13913 case BUILT_IN_FRAME_ADDRESS:
13914 case BUILT_IN_VA_END:
13915 case BUILT_IN_STACK_SAVE:
13916 case BUILT_IN_STACK_RESTORE:
13917 /* Exception state returns or moves registers around. */
13918 case BUILT_IN_EH_FILTER:
13919 case BUILT_IN_EH_POINTER:
13920 case BUILT_IN_EH_COPY_VALUES:
13930 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13931 most probably expanded inline into reasonably simple code. This is a
13932 superset of is_simple_builtin. */
13934 is_inexpensive_builtin (tree decl)
13938 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13940 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13941 switch (DECL_FUNCTION_CODE (decl))
13944 case BUILT_IN_ALLOCA:
13945 case BUILT_IN_BSWAP32:
13946 case BUILT_IN_BSWAP64:
13948 case BUILT_IN_CLZIMAX:
13949 case BUILT_IN_CLZL:
13950 case BUILT_IN_CLZLL:
13952 case BUILT_IN_CTZIMAX:
13953 case BUILT_IN_CTZL:
13954 case BUILT_IN_CTZLL:
13956 case BUILT_IN_FFSIMAX:
13957 case BUILT_IN_FFSL:
13958 case BUILT_IN_FFSLL:
13959 case BUILT_IN_IMAXABS:
13960 case BUILT_IN_FINITE:
13961 case BUILT_IN_FINITEF:
13962 case BUILT_IN_FINITEL:
13963 case BUILT_IN_FINITED32:
13964 case BUILT_IN_FINITED64:
13965 case BUILT_IN_FINITED128:
13966 case BUILT_IN_FPCLASSIFY:
13967 case BUILT_IN_ISFINITE:
13968 case BUILT_IN_ISINF_SIGN:
13969 case BUILT_IN_ISINF:
13970 case BUILT_IN_ISINFF:
13971 case BUILT_IN_ISINFL:
13972 case BUILT_IN_ISINFD32:
13973 case BUILT_IN_ISINFD64:
13974 case BUILT_IN_ISINFD128:
13975 case BUILT_IN_ISNAN:
13976 case BUILT_IN_ISNANF:
13977 case BUILT_IN_ISNANL:
13978 case BUILT_IN_ISNAND32:
13979 case BUILT_IN_ISNAND64:
13980 case BUILT_IN_ISNAND128:
13981 case BUILT_IN_ISNORMAL:
13982 case BUILT_IN_ISGREATER:
13983 case BUILT_IN_ISGREATEREQUAL:
13984 case BUILT_IN_ISLESS:
13985 case BUILT_IN_ISLESSEQUAL:
13986 case BUILT_IN_ISLESSGREATER:
13987 case BUILT_IN_ISUNORDERED:
13988 case BUILT_IN_VA_ARG_PACK:
13989 case BUILT_IN_VA_ARG_PACK_LEN:
13990 case BUILT_IN_VA_COPY:
13991 case BUILT_IN_TRAP:
13992 case BUILT_IN_SAVEREGS:
13993 case BUILT_IN_POPCOUNTL:
13994 case BUILT_IN_POPCOUNTLL:
13995 case BUILT_IN_POPCOUNTIMAX:
13996 case BUILT_IN_POPCOUNT:
13997 case BUILT_IN_PARITYL:
13998 case BUILT_IN_PARITYLL:
13999 case BUILT_IN_PARITYIMAX:
14000 case BUILT_IN_PARITY:
14001 case BUILT_IN_LABS:
14002 case BUILT_IN_LLABS:
14003 case BUILT_IN_PREFETCH:
14007 return is_simple_builtin (decl);