1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
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"
47 #include "langhooks.h"
48 #include "basic-block.h"
49 #include "tree-mudflap.h"
50 #include "tree-flow.h"
51 #include "value-prof.h"
52 #include "diagnostic-core.h"
55 #ifndef SLOW_UNALIGNED_ACCESS
56 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
59 #ifndef PAD_VARARGS_DOWN
60 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
64 struct target_builtins default_target_builtins;
66 struct target_builtins *this_target_builtins = &default_target_builtins;
69 /* Define the names of the builtin function types and codes. */
70 const char *const built_in_class_names[4]
71 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
73 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
74 const char * built_in_names[(int) END_BUILTINS] =
76 #include "builtins.def"
80 /* Setup an array of _DECL trees, make sure each element is
81 initialized to NULL_TREE. */
82 tree built_in_decls[(int) END_BUILTINS];
83 /* Declarations used when constructing the builtin implicitly in the compiler.
84 It may be NULL_TREE when this is invalid (for instance runtime is not
85 required to implement the function call in all cases). */
86 tree implicit_built_in_decls[(int) END_BUILTINS];
88 static const char *c_getstr (tree);
89 static rtx c_readstr (const char *, enum machine_mode);
90 static int target_char_cast (tree, char *);
91 static rtx get_memory_rtx (tree, tree);
92 static int apply_args_size (void);
93 static int apply_result_size (void);
94 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
95 static rtx result_vector (int, rtx);
97 static void expand_builtin_update_setjmp_buf (rtx);
98 static void expand_builtin_prefetch (tree);
99 static rtx expand_builtin_apply_args (void);
100 static rtx expand_builtin_apply_args_1 (void);
101 static rtx expand_builtin_apply (rtx, rtx, rtx);
102 static void expand_builtin_return (rtx);
103 static enum type_class type_to_class (tree);
104 static rtx expand_builtin_classify_type (tree);
105 static void expand_errno_check (tree, rtx);
106 static rtx expand_builtin_mathfn (tree, rtx, rtx);
107 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
108 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
109 static rtx expand_builtin_interclass_mathfn (tree, rtx);
110 static rtx expand_builtin_sincos (tree);
111 static rtx expand_builtin_cexpi (tree, rtx);
112 static rtx expand_builtin_int_roundingfn (tree, rtx);
113 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
114 static rtx expand_builtin_next_arg (void);
115 static rtx expand_builtin_va_start (tree);
116 static rtx expand_builtin_va_end (tree);
117 static rtx expand_builtin_va_copy (tree);
118 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
119 static rtx expand_builtin_strcmp (tree, rtx);
120 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
121 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
122 static rtx expand_builtin_memcpy (tree, rtx);
123 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
124 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
125 enum machine_mode, int);
126 static rtx expand_builtin_strcpy (tree, rtx);
127 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
128 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
129 static rtx expand_builtin_strncpy (tree, rtx);
130 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
131 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
133 static rtx expand_builtin_bzero (tree);
134 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
135 static rtx expand_builtin_alloca (tree, rtx, bool);
136 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
137 static rtx expand_builtin_frame_address (tree, tree);
138 static tree stabilize_va_list_loc (location_t, tree, int);
139 static rtx expand_builtin_expect (tree, rtx);
140 static tree fold_builtin_constant_p (tree);
141 static tree fold_builtin_expect (location_t, tree, tree);
142 static tree fold_builtin_classify_type (tree);
143 static tree fold_builtin_strlen (location_t, tree, tree);
144 static tree fold_builtin_inf (location_t, tree, int);
145 static tree fold_builtin_nan (tree, tree, int);
146 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
147 static bool validate_arg (const_tree, enum tree_code code);
148 static bool integer_valued_real_p (tree);
149 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
150 static bool readonly_data_expr (tree);
151 static rtx expand_builtin_fabs (tree, rtx, rtx);
152 static rtx expand_builtin_signbit (tree, rtx);
153 static tree fold_builtin_sqrt (location_t, tree, tree);
154 static tree fold_builtin_cbrt (location_t, tree, tree);
155 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
156 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
157 static tree fold_builtin_cos (location_t, tree, tree, tree);
158 static tree fold_builtin_cosh (location_t, tree, tree, tree);
159 static tree fold_builtin_tan (tree, tree);
160 static tree fold_builtin_trunc (location_t, tree, tree);
161 static tree fold_builtin_floor (location_t, tree, tree);
162 static tree fold_builtin_ceil (location_t, tree, tree);
163 static tree fold_builtin_round (location_t, tree, tree);
164 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
165 static tree fold_builtin_bitop (tree, tree);
166 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
167 static tree fold_builtin_strchr (location_t, tree, tree, tree);
168 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
169 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
170 static tree fold_builtin_strcmp (location_t, tree, tree);
171 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
172 static tree fold_builtin_signbit (location_t, tree, tree);
173 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
174 static tree fold_builtin_isascii (location_t, tree);
175 static tree fold_builtin_toascii (location_t, tree);
176 static tree fold_builtin_isdigit (location_t, tree);
177 static tree fold_builtin_fabs (location_t, tree, tree);
178 static tree fold_builtin_abs (location_t, tree, tree);
179 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
181 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
182 static tree fold_builtin_0 (location_t, tree, bool);
183 static tree fold_builtin_1 (location_t, tree, tree, bool);
184 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
185 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
186 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
187 static tree fold_builtin_varargs (location_t, tree, tree, bool);
189 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
190 static tree fold_builtin_strstr (location_t, tree, tree, tree);
191 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
192 static tree fold_builtin_strcat (location_t, tree, tree);
193 static tree fold_builtin_strncat (location_t, tree, tree, tree);
194 static tree fold_builtin_strspn (location_t, tree, tree);
195 static tree fold_builtin_strcspn (location_t, tree, tree);
196 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
198 static rtx expand_builtin_object_size (tree);
199 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
200 enum built_in_function);
201 static void maybe_emit_chk_warning (tree, enum built_in_function);
202 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
203 static void maybe_emit_free_warning (tree);
204 static tree fold_builtin_object_size (tree, tree);
205 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
206 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
207 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
208 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
209 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
210 enum built_in_function);
211 static bool init_target_chars (void);
213 static unsigned HOST_WIDE_INT target_newline;
214 static unsigned HOST_WIDE_INT target_percent;
215 static unsigned HOST_WIDE_INT target_c;
216 static unsigned HOST_WIDE_INT target_s;
217 static char target_percent_c[3];
218 static char target_percent_s[3];
219 static char target_percent_s_newline[4];
220 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
221 const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
222 static tree do_mpfr_arg2 (tree, tree, tree,
223 int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
224 static tree do_mpfr_arg3 (tree, tree, tree, tree,
225 int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
226 static tree do_mpfr_sincos (tree, tree, tree);
227 static tree do_mpfr_bessel_n (tree, tree, tree,
228 int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
229 const REAL_VALUE_TYPE *, bool);
230 static tree do_mpfr_remquo (tree, tree, tree);
231 static tree do_mpfr_lgamma_r (tree, tree, tree);
233 /* Return true if NAME starts with __builtin_ or __sync_. */
236 is_builtin_name (const char *name)
238 if (strncmp (name, "__builtin_", 10) == 0)
240 if (strncmp (name, "__sync_", 7) == 0)
246 /* Return true if DECL is a function symbol representing a built-in. */
249 is_builtin_fn (tree decl)
251 return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
255 /* Return true if NODE should be considered for inline expansion regardless
256 of the optimization level. This means whenever a function is invoked with
257 its "internal" name, which normally contains the prefix "__builtin". */
260 called_as_built_in (tree node)
262 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
263 we want the name used to call the function, not the name it
265 const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
266 return is_builtin_name (name);
269 /* Return the alignment in bits of EXP, an object.
270 Don't return more than MAX_ALIGN no matter what. */
273 get_object_alignment (tree exp, unsigned int max_align)
275 HOST_WIDE_INT bitsize, bitpos;
277 enum machine_mode mode;
278 int unsignedp, volatilep;
279 unsigned int align, inner;
281 /* Get the innermost object and the constant (bitpos) and possibly
282 variable (offset) offset of the access. */
283 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
284 &mode, &unsignedp, &volatilep, true);
286 /* Extract alignment information from the innermost object and
287 possibly adjust bitpos and offset. */
288 if (TREE_CODE (exp) == CONST_DECL)
289 exp = DECL_INITIAL (exp);
291 && TREE_CODE (exp) != LABEL_DECL)
292 align = DECL_ALIGN (exp);
293 else if (CONSTANT_CLASS_P (exp))
295 align = TYPE_ALIGN (TREE_TYPE (exp));
296 #ifdef CONSTANT_ALIGNMENT
297 align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
300 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
301 align = TYPE_ALIGN (TREE_TYPE (exp));
302 else if (TREE_CODE (exp) == INDIRECT_REF)
303 align = TYPE_ALIGN (TREE_TYPE (exp));
304 else if (TREE_CODE (exp) == MEM_REF)
306 tree addr = TREE_OPERAND (exp, 0);
307 struct ptr_info_def *pi;
308 if (TREE_CODE (addr) == BIT_AND_EXPR
309 && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
311 align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
312 & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
313 align *= BITS_PER_UNIT;
314 addr = TREE_OPERAND (addr, 0);
317 align = BITS_PER_UNIT;
318 if (TREE_CODE (addr) == SSA_NAME
319 && (pi = SSA_NAME_PTR_INFO (addr)))
321 bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
322 align = MAX (pi->align * BITS_PER_UNIT, align);
324 else if (TREE_CODE (addr) == ADDR_EXPR)
325 align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
327 bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
329 else if (TREE_CODE (exp) == TARGET_MEM_REF)
331 struct ptr_info_def *pi;
332 tree addr = TMR_BASE (exp);
333 if (TREE_CODE (addr) == BIT_AND_EXPR
334 && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
336 align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
337 & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
338 align *= BITS_PER_UNIT;
339 addr = TREE_OPERAND (addr, 0);
342 align = BITS_PER_UNIT;
343 if (TREE_CODE (addr) == SSA_NAME
344 && (pi = SSA_NAME_PTR_INFO (addr)))
346 bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
347 align = MAX (pi->align * BITS_PER_UNIT, align);
349 else if (TREE_CODE (addr) == ADDR_EXPR)
350 align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
352 if (TMR_OFFSET (exp))
353 bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
354 if (TMR_INDEX (exp) && TMR_STEP (exp))
356 unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
357 align = MIN (align, (step & -step) * BITS_PER_UNIT);
359 else if (TMR_INDEX (exp))
360 align = BITS_PER_UNIT;
361 if (TMR_INDEX2 (exp))
362 align = BITS_PER_UNIT;
365 align = BITS_PER_UNIT;
367 /* If there is a non-constant offset part extract the maximum
368 alignment that can prevail. */
374 if (TREE_CODE (offset) == PLUS_EXPR)
376 next_offset = TREE_OPERAND (offset, 0);
377 offset = TREE_OPERAND (offset, 1);
381 if (host_integerp (offset, 1))
383 /* Any overflow in calculating offset_bits won't change
386 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
389 inner = MIN (inner, (offset_bits & -offset_bits));
391 else if (TREE_CODE (offset) == MULT_EXPR
392 && host_integerp (TREE_OPERAND (offset, 1), 1))
394 /* Any overflow in calculating offset_factor won't change
396 unsigned offset_factor
397 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
401 inner = MIN (inner, (offset_factor & -offset_factor));
405 inner = MIN (inner, BITS_PER_UNIT);
408 offset = next_offset;
411 /* Alignment is innermost object alignment adjusted by the constant
412 and non-constant offset parts. */
413 align = MIN (align, inner);
414 bitpos = bitpos & (align - 1);
416 /* align and bitpos now specify known low bits of the pointer.
417 ptr & (align - 1) == bitpos. */
420 align = (bitpos & -bitpos);
422 return MIN (align, max_align);
425 /* Returns true iff we can trust that alignment information has been
426 calculated properly. */
429 can_trust_pointer_alignment (void)
431 /* We rely on TER to compute accurate alignment information. */
432 return (optimize && flag_tree_ter);
435 /* Return the alignment in bits of EXP, a pointer valued expression.
436 But don't return more than MAX_ALIGN no matter what.
437 The alignment returned is, by default, the alignment of the thing that
438 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
440 Otherwise, look at the expression to see if we can do better, i.e., if the
441 expression is actually pointing at an object whose alignment is tighter. */
444 get_pointer_alignment (tree exp, unsigned int max_align)
448 if (TREE_CODE (exp) == ADDR_EXPR)
449 return get_object_alignment (TREE_OPERAND (exp, 0), max_align);
450 else if (TREE_CODE (exp) == SSA_NAME
451 && POINTER_TYPE_P (TREE_TYPE (exp)))
453 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
456 return BITS_PER_UNIT;
457 if (pi->misalign != 0)
458 align = (pi->misalign & -pi->misalign);
461 return MIN (max_align, align * BITS_PER_UNIT);
464 return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
467 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
468 way, because it could contain a zero byte in the middle.
469 TREE_STRING_LENGTH is the size of the character array, not the string.
471 ONLY_VALUE should be nonzero if the result is not going to be emitted
472 into the instruction stream and zero if it is going to be expanded.
473 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
474 is returned, otherwise NULL, since
475 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
476 evaluate the side-effects.
478 The value returned is of type `ssizetype'.
480 Unfortunately, string_constant can't access the values of const char
481 arrays with initializers, so neither can we do so here. */
484 c_strlen (tree src, int only_value)
487 HOST_WIDE_INT offset;
493 if (TREE_CODE (src) == COND_EXPR
494 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
498 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
499 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
500 if (tree_int_cst_equal (len1, len2))
504 if (TREE_CODE (src) == COMPOUND_EXPR
505 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
506 return c_strlen (TREE_OPERAND (src, 1), only_value);
508 if (EXPR_HAS_LOCATION (src))
509 loc = EXPR_LOCATION (src);
511 loc = input_location;
513 src = string_constant (src, &offset_node);
517 max = TREE_STRING_LENGTH (src) - 1;
518 ptr = TREE_STRING_POINTER (src);
520 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
522 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
523 compute the offset to the following null if we don't know where to
524 start searching for it. */
527 for (i = 0; i < max; i++)
531 /* We don't know the starting offset, but we do know that the string
532 has no internal zero bytes. We can assume that the offset falls
533 within the bounds of the string; otherwise, the programmer deserves
534 what he gets. Subtract the offset from the length of the string,
535 and return that. This would perhaps not be valid if we were dealing
536 with named arrays in addition to literal string constants. */
538 return size_diffop_loc (loc, size_int (max), offset_node);
541 /* We have a known offset into the string. Start searching there for
542 a null character if we can represent it as a single HOST_WIDE_INT. */
543 if (offset_node == 0)
545 else if (! host_integerp (offset_node, 0))
548 offset = tree_low_cst (offset_node, 0);
550 /* If the offset is known to be out of bounds, warn, and call strlen at
552 if (offset < 0 || offset > max)
554 /* Suppress multiple warnings for propagated constant strings. */
555 if (! TREE_NO_WARNING (src))
557 warning_at (loc, 0, "offset outside bounds of constant string");
558 TREE_NO_WARNING (src) = 1;
563 /* Use strlen to search for the first zero byte. Since any strings
564 constructed with build_string will have nulls appended, we win even
565 if we get handed something like (char[4])"abcd".
567 Since OFFSET is our starting index into the string, no further
568 calculation is needed. */
569 return ssize_int (strlen (ptr + offset));
572 /* Return a char pointer for a C string if it is a string constant
573 or sum of string constant and integer constant. */
580 src = string_constant (src, &offset_node);
584 if (offset_node == 0)
585 return TREE_STRING_POINTER (src);
586 else if (!host_integerp (offset_node, 1)
587 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
590 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
593 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
594 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
597 c_readstr (const char *str, enum machine_mode mode)
603 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
608 for (i = 0; i < GET_MODE_SIZE (mode); i++)
611 if (WORDS_BIG_ENDIAN)
612 j = GET_MODE_SIZE (mode) - i - 1;
613 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
614 && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
615 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
617 gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
620 ch = (unsigned char) str[i];
621 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
623 return immed_double_const (c[0], c[1], mode);
626 /* Cast a target constant CST to target CHAR and if that value fits into
627 host char type, return zero and put that value into variable pointed to by
631 target_char_cast (tree cst, char *p)
633 unsigned HOST_WIDE_INT val, hostval;
635 if (!host_integerp (cst, 1)
636 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
639 val = tree_low_cst (cst, 1);
640 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
641 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
644 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
645 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
654 /* Similar to save_expr, but assumes that arbitrary code is not executed
655 in between the multiple evaluations. In particular, we assume that a
656 non-addressable local variable will not be modified. */
659 builtin_save_expr (tree exp)
661 if (TREE_ADDRESSABLE (exp) == 0
662 && (TREE_CODE (exp) == PARM_DECL
663 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
666 return save_expr (exp);
669 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
670 times to get the address of either a higher stack frame, or a return
671 address located within it (depending on FNDECL_CODE). */
674 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
678 #ifdef INITIAL_FRAME_ADDRESS_RTX
679 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
683 /* For a zero count with __builtin_return_address, we don't care what
684 frame address we return, because target-specific definitions will
685 override us. Therefore frame pointer elimination is OK, and using
686 the soft frame pointer is OK.
688 For a nonzero count, or a zero count with __builtin_frame_address,
689 we require a stable offset from the current frame pointer to the
690 previous one, so we must use the hard frame pointer, and
691 we must disable frame pointer elimination. */
692 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
693 tem = frame_pointer_rtx;
696 tem = hard_frame_pointer_rtx;
698 /* Tell reload not to eliminate the frame pointer. */
699 crtl->accesses_prior_frames = 1;
703 /* Some machines need special handling before we can access
704 arbitrary frames. For example, on the SPARC, we must first flush
705 all register windows to the stack. */
706 #ifdef SETUP_FRAME_ADDRESSES
708 SETUP_FRAME_ADDRESSES ();
711 /* On the SPARC, the return address is not in the frame, it is in a
712 register. There is no way to access it off of the current frame
713 pointer, but it can be accessed off the previous frame pointer by
714 reading the value from the register window save area. */
715 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
716 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
720 /* Scan back COUNT frames to the specified frame. */
721 for (i = 0; i < count; i++)
723 /* Assume the dynamic chain pointer is in the word that the
724 frame address points to, unless otherwise specified. */
725 #ifdef DYNAMIC_CHAIN_ADDRESS
726 tem = DYNAMIC_CHAIN_ADDRESS (tem);
728 tem = memory_address (Pmode, tem);
729 tem = gen_frame_mem (Pmode, tem);
730 tem = copy_to_reg (tem);
733 /* For __builtin_frame_address, return what we've got. But, on
734 the SPARC for example, we may have to add a bias. */
735 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
736 #ifdef FRAME_ADDR_RTX
737 return FRAME_ADDR_RTX (tem);
742 /* For __builtin_return_address, get the return address from that frame. */
743 #ifdef RETURN_ADDR_RTX
744 tem = RETURN_ADDR_RTX (count, tem);
746 tem = memory_address (Pmode,
747 plus_constant (tem, GET_MODE_SIZE (Pmode)));
748 tem = gen_frame_mem (Pmode, tem);
753 /* Alias set used for setjmp buffer. */
754 static alias_set_type setjmp_alias_set = -1;
756 /* Construct the leading half of a __builtin_setjmp call. Control will
757 return to RECEIVER_LABEL. This is also called directly by the SJLJ
758 exception handling code. */
761 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
763 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
767 if (setjmp_alias_set == -1)
768 setjmp_alias_set = new_alias_set ();
770 buf_addr = convert_memory_address (Pmode, buf_addr);
772 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
774 /* We store the frame pointer and the address of receiver_label in
775 the buffer and use the rest of it for the stack save area, which
776 is machine-dependent. */
778 mem = gen_rtx_MEM (Pmode, buf_addr);
779 set_mem_alias_set (mem, setjmp_alias_set);
780 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
782 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
783 set_mem_alias_set (mem, setjmp_alias_set);
785 emit_move_insn (validize_mem (mem),
786 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
788 stack_save = gen_rtx_MEM (sa_mode,
789 plus_constant (buf_addr,
790 2 * GET_MODE_SIZE (Pmode)));
791 set_mem_alias_set (stack_save, setjmp_alias_set);
792 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
794 /* If there is further processing to do, do it. */
795 #ifdef HAVE_builtin_setjmp_setup
796 if (HAVE_builtin_setjmp_setup)
797 emit_insn (gen_builtin_setjmp_setup (buf_addr));
800 /* Tell optimize_save_area_alloca that extra work is going to
801 need to go on during alloca. */
802 cfun->calls_setjmp = 1;
804 /* We have a nonlocal label. */
805 cfun->has_nonlocal_label = 1;
808 /* Construct the trailing part of a __builtin_setjmp call. This is
809 also called directly by the SJLJ exception handling code. */
812 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
816 /* Clobber the FP when we get here, so we have to make sure it's
817 marked as used by this function. */
818 emit_use (hard_frame_pointer_rtx);
820 /* Mark the static chain as clobbered here so life information
821 doesn't get messed up for it. */
822 chain = targetm.calls.static_chain (current_function_decl, true);
823 if (chain && REG_P (chain))
824 emit_clobber (chain);
826 /* Now put in the code to restore the frame pointer, and argument
827 pointer, if needed. */
828 #ifdef HAVE_nonlocal_goto
829 if (! HAVE_nonlocal_goto)
832 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
833 /* This might change the hard frame pointer in ways that aren't
834 apparent to early optimization passes, so force a clobber. */
835 emit_clobber (hard_frame_pointer_rtx);
838 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
839 if (fixed_regs[ARG_POINTER_REGNUM])
841 #ifdef ELIMINABLE_REGS
843 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
845 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
846 if (elim_regs[i].from == ARG_POINTER_REGNUM
847 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
850 if (i == ARRAY_SIZE (elim_regs))
853 /* Now restore our arg pointer from the address at which it
854 was saved in our stack frame. */
855 emit_move_insn (crtl->args.internal_arg_pointer,
856 copy_to_reg (get_arg_pointer_save_area ()));
861 #ifdef HAVE_builtin_setjmp_receiver
862 if (HAVE_builtin_setjmp_receiver)
863 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
866 #ifdef HAVE_nonlocal_goto_receiver
867 if (HAVE_nonlocal_goto_receiver)
868 emit_insn (gen_nonlocal_goto_receiver ());
873 /* We must not allow the code we just generated to be reordered by
874 scheduling. Specifically, the update of the frame pointer must
875 happen immediately, not later. */
876 emit_insn (gen_blockage ());
879 /* __builtin_longjmp is passed a pointer to an array of five words (not
880 all will be used on all machines). It operates similarly to the C
881 library function of the same name, but is more efficient. Much of
882 the code below is copied from the handling of non-local gotos. */
885 expand_builtin_longjmp (rtx buf_addr, rtx value)
887 rtx fp, lab, stack, insn, last;
888 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
890 /* DRAP is needed for stack realign if longjmp is expanded to current
892 if (SUPPORTS_STACK_ALIGNMENT)
893 crtl->need_drap = true;
895 if (setjmp_alias_set == -1)
896 setjmp_alias_set = new_alias_set ();
898 buf_addr = convert_memory_address (Pmode, buf_addr);
900 buf_addr = force_reg (Pmode, buf_addr);
902 /* We require that the user must pass a second argument of 1, because
903 that is what builtin_setjmp will return. */
904 gcc_assert (value == const1_rtx);
906 last = get_last_insn ();
907 #ifdef HAVE_builtin_longjmp
908 if (HAVE_builtin_longjmp)
909 emit_insn (gen_builtin_longjmp (buf_addr));
913 fp = gen_rtx_MEM (Pmode, buf_addr);
914 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
915 GET_MODE_SIZE (Pmode)));
917 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
918 2 * GET_MODE_SIZE (Pmode)));
919 set_mem_alias_set (fp, setjmp_alias_set);
920 set_mem_alias_set (lab, setjmp_alias_set);
921 set_mem_alias_set (stack, setjmp_alias_set);
923 /* Pick up FP, label, and SP from the block and jump. This code is
924 from expand_goto in stmt.c; see there for detailed comments. */
925 #ifdef HAVE_nonlocal_goto
926 if (HAVE_nonlocal_goto)
927 /* We have to pass a value to the nonlocal_goto pattern that will
928 get copied into the static_chain pointer, but it does not matter
929 what that value is, because builtin_setjmp does not use it. */
930 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
934 lab = copy_to_reg (lab);
936 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
937 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
939 emit_move_insn (hard_frame_pointer_rtx, fp);
940 emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
942 emit_use (hard_frame_pointer_rtx);
943 emit_use (stack_pointer_rtx);
944 emit_indirect_jump (lab);
948 /* Search backwards and mark the jump insn as a non-local goto.
949 Note that this precludes the use of __builtin_longjmp to a
950 __builtin_setjmp target in the same function. However, we've
951 already cautioned the user that these functions are for
952 internal exception handling use only. */
953 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
955 gcc_assert (insn != last);
959 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
962 else if (CALL_P (insn))
967 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
968 and the address of the save area. */
971 expand_builtin_nonlocal_goto (tree exp)
973 tree t_label, t_save_area;
974 rtx r_label, r_save_area, r_fp, r_sp, insn;
976 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
979 t_label = CALL_EXPR_ARG (exp, 0);
980 t_save_area = CALL_EXPR_ARG (exp, 1);
982 r_label = expand_normal (t_label);
983 r_label = convert_memory_address (Pmode, r_label);
984 r_save_area = expand_normal (t_save_area);
985 r_save_area = convert_memory_address (Pmode, r_save_area);
986 /* Copy the address of the save location to a register just in case it was based
987 on the frame pointer. */
988 r_save_area = copy_to_reg (r_save_area);
989 r_fp = gen_rtx_MEM (Pmode, r_save_area);
990 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
991 plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
993 crtl->has_nonlocal_goto = 1;
995 #ifdef HAVE_nonlocal_goto
996 /* ??? We no longer need to pass the static chain value, afaik. */
997 if (HAVE_nonlocal_goto)
998 emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1002 r_label = copy_to_reg (r_label);
1004 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1005 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1007 /* Restore frame pointer for containing function.
1008 This sets the actual hard register used for the frame pointer
1009 to the location of the function's incoming static chain info.
1010 The non-local goto handler will then adjust it to contain the
1011 proper value and reload the argument pointer, if needed. */
1012 emit_move_insn (hard_frame_pointer_rtx, r_fp);
1013 emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
1015 /* USE of hard_frame_pointer_rtx added for consistency;
1016 not clear if really needed. */
1017 emit_use (hard_frame_pointer_rtx);
1018 emit_use (stack_pointer_rtx);
1020 /* If the architecture is using a GP register, we must
1021 conservatively assume that the target function makes use of it.
1022 The prologue of functions with nonlocal gotos must therefore
1023 initialize the GP register to the appropriate value, and we
1024 must then make sure that this value is live at the point
1025 of the jump. (Note that this doesn't necessarily apply
1026 to targets with a nonlocal_goto pattern; they are free
1027 to implement it in their own way. Note also that this is
1028 a no-op if the GP register is a global invariant.) */
1029 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1030 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1031 emit_use (pic_offset_table_rtx);
1033 emit_indirect_jump (r_label);
1036 /* Search backwards to the jump insn and mark it as a
1038 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1042 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1045 else if (CALL_P (insn))
1052 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1053 (not all will be used on all machines) that was passed to __builtin_setjmp.
1054 It updates the stack pointer in that block to correspond to the current
1058 expand_builtin_update_setjmp_buf (rtx buf_addr)
1060 enum machine_mode sa_mode = Pmode;
1064 #ifdef HAVE_save_stack_nonlocal
1065 if (HAVE_save_stack_nonlocal)
1066 sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1068 #ifdef STACK_SAVEAREA_MODE
1069 sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1073 = gen_rtx_MEM (sa_mode,
1076 plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1080 emit_insn (gen_setjmp ());
1083 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1086 /* Expand a call to __builtin_prefetch. For a target that does not support
1087 data prefetch, evaluate the memory address argument in case it has side
1091 expand_builtin_prefetch (tree exp)
1093 tree arg0, arg1, arg2;
1097 if (!validate_arglist (exp, POINTER_TYPE, 0))
1100 arg0 = CALL_EXPR_ARG (exp, 0);
1102 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1103 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1105 nargs = call_expr_nargs (exp);
1107 arg1 = CALL_EXPR_ARG (exp, 1);
1109 arg1 = integer_zero_node;
1111 arg2 = CALL_EXPR_ARG (exp, 2);
1113 arg2 = integer_three_node;
1115 /* Argument 0 is an address. */
1116 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1118 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1119 if (TREE_CODE (arg1) != INTEGER_CST)
1121 error ("second argument to %<__builtin_prefetch%> must be a constant");
1122 arg1 = integer_zero_node;
1124 op1 = expand_normal (arg1);
1125 /* Argument 1 must be either zero or one. */
1126 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1128 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1133 /* Argument 2 (locality) must be a compile-time constant int. */
1134 if (TREE_CODE (arg2) != INTEGER_CST)
1136 error ("third argument to %<__builtin_prefetch%> must be a constant");
1137 arg2 = integer_zero_node;
1139 op2 = expand_normal (arg2);
1140 /* Argument 2 must be 0, 1, 2, or 3. */
1141 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1143 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1147 #ifdef HAVE_prefetch
1150 if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1152 insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1153 || (GET_MODE (op0) != Pmode))
1155 op0 = convert_memory_address (Pmode, op0);
1156 op0 = force_reg (Pmode, op0);
1158 emit_insn (gen_prefetch (op0, op1, op2));
1162 /* Don't do anything with direct references to volatile memory, but
1163 generate code to handle other side effects. */
1164 if (!MEM_P (op0) && side_effects_p (op0))
1168 /* Get a MEM rtx for expression EXP which is the address of an operand
1169 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1170 the maximum length of the block of memory that might be accessed or
1174 get_memory_rtx (tree exp, tree len)
1176 tree orig_exp = exp;
1180 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1181 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1182 if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1183 exp = TREE_OPERAND (exp, 0);
1185 addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1186 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1188 /* Get an expression we can use to find the attributes to assign to MEM.
1189 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1190 we can. First remove any nops. */
1191 while (CONVERT_EXPR_P (exp)
1192 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1193 exp = TREE_OPERAND (exp, 0);
1196 if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1197 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1198 && host_integerp (TREE_OPERAND (exp, 1), 0)
1199 && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1200 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1201 else if (TREE_CODE (exp) == ADDR_EXPR)
1202 exp = TREE_OPERAND (exp, 0);
1203 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1204 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1208 /* Honor attributes derived from exp, except for the alias set
1209 (as builtin stringops may alias with anything) and the size
1210 (as stringops may access multiple array elements). */
1213 set_mem_attributes (mem, exp, 0);
1216 mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1218 /* Allow the string and memory builtins to overflow from one
1219 field into another, see http://gcc.gnu.org/PR23561.
1220 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1221 memory accessed by the string or memory builtin will fit
1222 within the field. */
1223 if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1225 tree mem_expr = MEM_EXPR (mem);
1226 HOST_WIDE_INT offset = -1, length = -1;
1229 while (TREE_CODE (inner) == ARRAY_REF
1230 || CONVERT_EXPR_P (inner)
1231 || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1232 || TREE_CODE (inner) == SAVE_EXPR)
1233 inner = TREE_OPERAND (inner, 0);
1235 gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1237 if (MEM_OFFSET (mem)
1238 && CONST_INT_P (MEM_OFFSET (mem)))
1239 offset = INTVAL (MEM_OFFSET (mem));
1241 if (offset >= 0 && len && host_integerp (len, 0))
1242 length = tree_low_cst (len, 0);
1244 while (TREE_CODE (inner) == COMPONENT_REF)
1246 tree field = TREE_OPERAND (inner, 1);
1247 gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1248 gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1250 /* Bitfields are generally not byte-addressable. */
1251 gcc_assert (!DECL_BIT_FIELD (field)
1252 || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1253 % BITS_PER_UNIT) == 0
1254 && host_integerp (DECL_SIZE (field), 0)
1255 && (TREE_INT_CST_LOW (DECL_SIZE (field))
1256 % BITS_PER_UNIT) == 0));
1258 /* If we can prove that the memory starting at XEXP (mem, 0) and
1259 ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1260 can keep the COMPONENT_REF in MEM_EXPR. But be careful with
1261 fields without DECL_SIZE_UNIT like flexible array members. */
1263 && DECL_SIZE_UNIT (field)
1264 && host_integerp (DECL_SIZE_UNIT (field), 0))
1267 = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1270 && offset + length <= size)
1275 && host_integerp (DECL_FIELD_OFFSET (field), 0))
1276 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1277 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1285 mem_expr = TREE_OPERAND (mem_expr, 0);
1286 inner = TREE_OPERAND (inner, 0);
1289 if (mem_expr == NULL)
1291 if (mem_expr != MEM_EXPR (mem))
1293 set_mem_expr (mem, mem_expr);
1294 set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1297 set_mem_alias_set (mem, 0);
1298 set_mem_size (mem, NULL_RTX);
1304 /* Built-in functions to perform an untyped call and return. */
1306 #define apply_args_mode \
1307 (this_target_builtins->x_apply_args_mode)
1308 #define apply_result_mode \
1309 (this_target_builtins->x_apply_result_mode)
1311 /* Return the size required for the block returned by __builtin_apply_args,
1312 and initialize apply_args_mode. */
1315 apply_args_size (void)
1317 static int size = -1;
1320 enum machine_mode mode;
1322 /* The values computed by this function never change. */
1325 /* The first value is the incoming arg-pointer. */
1326 size = GET_MODE_SIZE (Pmode);
1328 /* The second value is the structure value address unless this is
1329 passed as an "invisible" first argument. */
1330 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1331 size += GET_MODE_SIZE (Pmode);
1333 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1334 if (FUNCTION_ARG_REGNO_P (regno))
1336 mode = reg_raw_mode[regno];
1338 gcc_assert (mode != VOIDmode);
1340 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1341 if (size % align != 0)
1342 size = CEIL (size, align) * align;
1343 size += GET_MODE_SIZE (mode);
1344 apply_args_mode[regno] = mode;
1348 apply_args_mode[regno] = VOIDmode;
1354 /* Return the size required for the block returned by __builtin_apply,
1355 and initialize apply_result_mode. */
1358 apply_result_size (void)
1360 static int size = -1;
1362 enum machine_mode mode;
1364 /* The values computed by this function never change. */
1369 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1370 if (targetm.calls.function_value_regno_p (regno))
1372 mode = reg_raw_mode[regno];
1374 gcc_assert (mode != VOIDmode);
1376 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1377 if (size % align != 0)
1378 size = CEIL (size, align) * align;
1379 size += GET_MODE_SIZE (mode);
1380 apply_result_mode[regno] = mode;
1383 apply_result_mode[regno] = VOIDmode;
1385 /* Allow targets that use untyped_call and untyped_return to override
1386 the size so that machine-specific information can be stored here. */
1387 #ifdef APPLY_RESULT_SIZE
1388 size = APPLY_RESULT_SIZE;
1394 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1395 /* Create a vector describing the result block RESULT. If SAVEP is true,
1396 the result block is used to save the values; otherwise it is used to
1397 restore the values. */
1400 result_vector (int savep, rtx result)
1402 int regno, size, align, nelts;
1403 enum machine_mode mode;
1405 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1408 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1409 if ((mode = apply_result_mode[regno]) != VOIDmode)
1411 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1412 if (size % align != 0)
1413 size = CEIL (size, align) * align;
1414 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1415 mem = adjust_address (result, mode, size);
1416 savevec[nelts++] = (savep
1417 ? gen_rtx_SET (VOIDmode, mem, reg)
1418 : gen_rtx_SET (VOIDmode, reg, mem));
1419 size += GET_MODE_SIZE (mode);
1421 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1423 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1425 /* Save the state required to perform an untyped call with the same
1426 arguments as were passed to the current function. */
1429 expand_builtin_apply_args_1 (void)
1432 int size, align, regno;
1433 enum machine_mode mode;
1434 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1436 /* Create a block where the arg-pointer, structure value address,
1437 and argument registers can be saved. */
1438 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1440 /* Walk past the arg-pointer and structure value address. */
1441 size = GET_MODE_SIZE (Pmode);
1442 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1443 size += GET_MODE_SIZE (Pmode);
1445 /* Save each register used in calling a function to the block. */
1446 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1447 if ((mode = apply_args_mode[regno]) != VOIDmode)
1449 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1450 if (size % align != 0)
1451 size = CEIL (size, align) * align;
1453 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1455 emit_move_insn (adjust_address (registers, mode, size), tem);
1456 size += GET_MODE_SIZE (mode);
1459 /* Save the arg pointer to the block. */
1460 tem = copy_to_reg (crtl->args.internal_arg_pointer);
1461 #ifdef STACK_GROWS_DOWNWARD
1462 /* We need the pointer as the caller actually passed them to us, not
1463 as we might have pretended they were passed. Make sure it's a valid
1464 operand, as emit_move_insn isn't expected to handle a PLUS. */
1466 = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1469 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1471 size = GET_MODE_SIZE (Pmode);
1473 /* Save the structure value address unless this is passed as an
1474 "invisible" first argument. */
1475 if (struct_incoming_value)
1477 emit_move_insn (adjust_address (registers, Pmode, size),
1478 copy_to_reg (struct_incoming_value));
1479 size += GET_MODE_SIZE (Pmode);
1482 /* Return the address of the block. */
1483 return copy_addr_to_reg (XEXP (registers, 0));
1486 /* __builtin_apply_args returns block of memory allocated on
1487 the stack into which is stored the arg pointer, structure
1488 value address, static chain, and all the registers that might
1489 possibly be used in performing a function call. The code is
1490 moved to the start of the function so the incoming values are
1494 expand_builtin_apply_args (void)
1496 /* Don't do __builtin_apply_args more than once in a function.
1497 Save the result of the first call and reuse it. */
1498 if (apply_args_value != 0)
1499 return apply_args_value;
1501 /* When this function is called, it means that registers must be
1502 saved on entry to this function. So we migrate the
1503 call to the first insn of this function. */
1508 temp = expand_builtin_apply_args_1 ();
1512 apply_args_value = temp;
1514 /* Put the insns after the NOTE that starts the function.
1515 If this is inside a start_sequence, make the outer-level insn
1516 chain current, so the code is placed at the start of the
1517 function. If internal_arg_pointer is a non-virtual pseudo,
1518 it needs to be placed after the function that initializes
1520 push_topmost_sequence ();
1521 if (REG_P (crtl->args.internal_arg_pointer)
1522 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1523 emit_insn_before (seq, parm_birth_insn);
1525 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1526 pop_topmost_sequence ();
1531 /* Perform an untyped call and save the state required to perform an
1532 untyped return of whatever value was returned by the given function. */
1535 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1537 int size, align, regno;
1538 enum machine_mode mode;
1539 rtx incoming_args, result, reg, dest, src, call_insn;
1540 rtx old_stack_level = 0;
1541 rtx call_fusage = 0;
1542 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1544 arguments = convert_memory_address (Pmode, arguments);
1546 /* Create a block where the return registers can be saved. */
1547 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1549 /* Fetch the arg pointer from the ARGUMENTS block. */
1550 incoming_args = gen_reg_rtx (Pmode);
1551 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1552 #ifndef STACK_GROWS_DOWNWARD
1553 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1554 incoming_args, 0, OPTAB_LIB_WIDEN);
1557 /* Push a new argument block and copy the arguments. Do not allow
1558 the (potential) memcpy call below to interfere with our stack
1560 do_pending_stack_adjust ();
1563 /* Save the stack with nonlocal if available. */
1564 #ifdef HAVE_save_stack_nonlocal
1565 if (HAVE_save_stack_nonlocal)
1566 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1569 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1571 /* Allocate a block of memory onto the stack and copy the memory
1572 arguments to the outgoing arguments address. We can pass TRUE
1573 as the 4th argument because we just saved the stack pointer
1574 and will restore it right after the call. */
1575 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT, TRUE);
1577 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1578 may have already set current_function_calls_alloca to true.
1579 current_function_calls_alloca won't be set if argsize is zero,
1580 so we have to guarantee need_drap is true here. */
1581 if (SUPPORTS_STACK_ALIGNMENT)
1582 crtl->need_drap = true;
1584 dest = virtual_outgoing_args_rtx;
1585 #ifndef STACK_GROWS_DOWNWARD
1586 if (CONST_INT_P (argsize))
1587 dest = plus_constant (dest, -INTVAL (argsize));
1589 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1591 dest = gen_rtx_MEM (BLKmode, dest);
1592 set_mem_align (dest, PARM_BOUNDARY);
1593 src = gen_rtx_MEM (BLKmode, incoming_args);
1594 set_mem_align (src, PARM_BOUNDARY);
1595 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1597 /* Refer to the argument block. */
1599 arguments = gen_rtx_MEM (BLKmode, arguments);
1600 set_mem_align (arguments, PARM_BOUNDARY);
1602 /* Walk past the arg-pointer and structure value address. */
1603 size = GET_MODE_SIZE (Pmode);
1605 size += GET_MODE_SIZE (Pmode);
1607 /* Restore each of the registers previously saved. Make USE insns
1608 for each of these registers for use in making the call. */
1609 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1610 if ((mode = apply_args_mode[regno]) != VOIDmode)
1612 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1613 if (size % align != 0)
1614 size = CEIL (size, align) * align;
1615 reg = gen_rtx_REG (mode, regno);
1616 emit_move_insn (reg, adjust_address (arguments, mode, size));
1617 use_reg (&call_fusage, reg);
1618 size += GET_MODE_SIZE (mode);
1621 /* Restore the structure value address unless this is passed as an
1622 "invisible" first argument. */
1623 size = GET_MODE_SIZE (Pmode);
1626 rtx value = gen_reg_rtx (Pmode);
1627 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1628 emit_move_insn (struct_value, value);
1629 if (REG_P (struct_value))
1630 use_reg (&call_fusage, struct_value);
1631 size += GET_MODE_SIZE (Pmode);
1634 /* All arguments and registers used for the call are set up by now! */
1635 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1637 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1638 and we don't want to load it into a register as an optimization,
1639 because prepare_call_address already did it if it should be done. */
1640 if (GET_CODE (function) != SYMBOL_REF)
1641 function = memory_address (FUNCTION_MODE, function);
1643 /* Generate the actual call instruction and save the return value. */
1644 #ifdef HAVE_untyped_call
1645 if (HAVE_untyped_call)
1646 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1647 result, result_vector (1, result)));
1650 #ifdef HAVE_call_value
1651 if (HAVE_call_value)
1655 /* Locate the unique return register. It is not possible to
1656 express a call that sets more than one return register using
1657 call_value; use untyped_call for that. In fact, untyped_call
1658 only needs to save the return registers in the given block. */
1659 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1660 if ((mode = apply_result_mode[regno]) != VOIDmode)
1662 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1664 valreg = gen_rtx_REG (mode, regno);
1667 emit_call_insn (GEN_CALL_VALUE (valreg,
1668 gen_rtx_MEM (FUNCTION_MODE, function),
1669 const0_rtx, NULL_RTX, const0_rtx));
1671 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1677 /* Find the CALL insn we just emitted, and attach the register usage
1679 call_insn = last_call_insn ();
1680 add_function_usage_to (call_insn, call_fusage);
1682 /* Restore the stack. */
1683 #ifdef HAVE_save_stack_nonlocal
1684 if (HAVE_save_stack_nonlocal)
1685 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1688 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1692 /* Return the address of the result block. */
1693 result = copy_addr_to_reg (XEXP (result, 0));
1694 return convert_memory_address (ptr_mode, result);
1697 /* Perform an untyped return. */
1700 expand_builtin_return (rtx result)
1702 int size, align, regno;
1703 enum machine_mode mode;
1705 rtx call_fusage = 0;
1707 result = convert_memory_address (Pmode, result);
1709 apply_result_size ();
1710 result = gen_rtx_MEM (BLKmode, result);
1712 #ifdef HAVE_untyped_return
1713 if (HAVE_untyped_return)
1715 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1721 /* Restore the return value and note that each value is used. */
1723 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1724 if ((mode = apply_result_mode[regno]) != VOIDmode)
1726 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1727 if (size % align != 0)
1728 size = CEIL (size, align) * align;
1729 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1730 emit_move_insn (reg, adjust_address (result, mode, size));
1732 push_to_sequence (call_fusage);
1734 call_fusage = get_insns ();
1736 size += GET_MODE_SIZE (mode);
1739 /* Put the USE insns before the return. */
1740 emit_insn (call_fusage);
1742 /* Return whatever values was restored by jumping directly to the end
1744 expand_naked_return ();
1747 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1749 static enum type_class
1750 type_to_class (tree type)
1752 switch (TREE_CODE (type))
1754 case VOID_TYPE: return void_type_class;
1755 case INTEGER_TYPE: return integer_type_class;
1756 case ENUMERAL_TYPE: return enumeral_type_class;
1757 case BOOLEAN_TYPE: return boolean_type_class;
1758 case POINTER_TYPE: return pointer_type_class;
1759 case REFERENCE_TYPE: return reference_type_class;
1760 case OFFSET_TYPE: return offset_type_class;
1761 case REAL_TYPE: return real_type_class;
1762 case COMPLEX_TYPE: return complex_type_class;
1763 case FUNCTION_TYPE: return function_type_class;
1764 case METHOD_TYPE: return method_type_class;
1765 case RECORD_TYPE: return record_type_class;
1767 case QUAL_UNION_TYPE: return union_type_class;
1768 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1769 ? string_type_class : array_type_class);
1770 case LANG_TYPE: return lang_type_class;
1771 default: return no_type_class;
1775 /* Expand a call EXP to __builtin_classify_type. */
1778 expand_builtin_classify_type (tree exp)
1780 if (call_expr_nargs (exp))
1781 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1782 return GEN_INT (no_type_class);
1785 /* This helper macro, meant to be used in mathfn_built_in below,
1786 determines which among a set of three builtin math functions is
1787 appropriate for a given type mode. The `F' and `L' cases are
1788 automatically generated from the `double' case. */
1789 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1790 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1791 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1792 fcodel = BUILT_IN_MATHFN##L ; break;
1793 /* Similar to above, but appends _R after any F/L suffix. */
1794 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1795 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1796 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1797 fcodel = BUILT_IN_MATHFN##L_R ; break;
1799 /* Return mathematic function equivalent to FN but operating directly
1800 on TYPE, if available. If IMPLICIT is true find the function in
1801 implicit_built_in_decls[], otherwise use built_in_decls[]. If we
1802 can't do the conversion, return zero. */
1805 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1807 tree const *const fn_arr
1808 = implicit ? implicit_built_in_decls : built_in_decls;
1809 enum built_in_function fcode, fcodef, fcodel;
1813 CASE_MATHFN (BUILT_IN_ACOS)
1814 CASE_MATHFN (BUILT_IN_ACOSH)
1815 CASE_MATHFN (BUILT_IN_ASIN)
1816 CASE_MATHFN (BUILT_IN_ASINH)
1817 CASE_MATHFN (BUILT_IN_ATAN)
1818 CASE_MATHFN (BUILT_IN_ATAN2)
1819 CASE_MATHFN (BUILT_IN_ATANH)
1820 CASE_MATHFN (BUILT_IN_CBRT)
1821 CASE_MATHFN (BUILT_IN_CEIL)
1822 CASE_MATHFN (BUILT_IN_CEXPI)
1823 CASE_MATHFN (BUILT_IN_COPYSIGN)
1824 CASE_MATHFN (BUILT_IN_COS)
1825 CASE_MATHFN (BUILT_IN_COSH)
1826 CASE_MATHFN (BUILT_IN_DREM)
1827 CASE_MATHFN (BUILT_IN_ERF)
1828 CASE_MATHFN (BUILT_IN_ERFC)
1829 CASE_MATHFN (BUILT_IN_EXP)
1830 CASE_MATHFN (BUILT_IN_EXP10)
1831 CASE_MATHFN (BUILT_IN_EXP2)
1832 CASE_MATHFN (BUILT_IN_EXPM1)
1833 CASE_MATHFN (BUILT_IN_FABS)
1834 CASE_MATHFN (BUILT_IN_FDIM)
1835 CASE_MATHFN (BUILT_IN_FLOOR)
1836 CASE_MATHFN (BUILT_IN_FMA)
1837 CASE_MATHFN (BUILT_IN_FMAX)
1838 CASE_MATHFN (BUILT_IN_FMIN)
1839 CASE_MATHFN (BUILT_IN_FMOD)
1840 CASE_MATHFN (BUILT_IN_FREXP)
1841 CASE_MATHFN (BUILT_IN_GAMMA)
1842 CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1843 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1844 CASE_MATHFN (BUILT_IN_HYPOT)
1845 CASE_MATHFN (BUILT_IN_ILOGB)
1846 CASE_MATHFN (BUILT_IN_INF)
1847 CASE_MATHFN (BUILT_IN_ISINF)
1848 CASE_MATHFN (BUILT_IN_J0)
1849 CASE_MATHFN (BUILT_IN_J1)
1850 CASE_MATHFN (BUILT_IN_JN)
1851 CASE_MATHFN (BUILT_IN_LCEIL)
1852 CASE_MATHFN (BUILT_IN_LDEXP)
1853 CASE_MATHFN (BUILT_IN_LFLOOR)
1854 CASE_MATHFN (BUILT_IN_LGAMMA)
1855 CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1856 CASE_MATHFN (BUILT_IN_LLCEIL)
1857 CASE_MATHFN (BUILT_IN_LLFLOOR)
1858 CASE_MATHFN (BUILT_IN_LLRINT)
1859 CASE_MATHFN (BUILT_IN_LLROUND)
1860 CASE_MATHFN (BUILT_IN_LOG)
1861 CASE_MATHFN (BUILT_IN_LOG10)
1862 CASE_MATHFN (BUILT_IN_LOG1P)
1863 CASE_MATHFN (BUILT_IN_LOG2)
1864 CASE_MATHFN (BUILT_IN_LOGB)
1865 CASE_MATHFN (BUILT_IN_LRINT)
1866 CASE_MATHFN (BUILT_IN_LROUND)
1867 CASE_MATHFN (BUILT_IN_MODF)
1868 CASE_MATHFN (BUILT_IN_NAN)
1869 CASE_MATHFN (BUILT_IN_NANS)
1870 CASE_MATHFN (BUILT_IN_NEARBYINT)
1871 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1872 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1873 CASE_MATHFN (BUILT_IN_POW)
1874 CASE_MATHFN (BUILT_IN_POWI)
1875 CASE_MATHFN (BUILT_IN_POW10)
1876 CASE_MATHFN (BUILT_IN_REMAINDER)
1877 CASE_MATHFN (BUILT_IN_REMQUO)
1878 CASE_MATHFN (BUILT_IN_RINT)
1879 CASE_MATHFN (BUILT_IN_ROUND)
1880 CASE_MATHFN (BUILT_IN_SCALB)
1881 CASE_MATHFN (BUILT_IN_SCALBLN)
1882 CASE_MATHFN (BUILT_IN_SCALBN)
1883 CASE_MATHFN (BUILT_IN_SIGNBIT)
1884 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1885 CASE_MATHFN (BUILT_IN_SIN)
1886 CASE_MATHFN (BUILT_IN_SINCOS)
1887 CASE_MATHFN (BUILT_IN_SINH)
1888 CASE_MATHFN (BUILT_IN_SQRT)
1889 CASE_MATHFN (BUILT_IN_TAN)
1890 CASE_MATHFN (BUILT_IN_TANH)
1891 CASE_MATHFN (BUILT_IN_TGAMMA)
1892 CASE_MATHFN (BUILT_IN_TRUNC)
1893 CASE_MATHFN (BUILT_IN_Y0)
1894 CASE_MATHFN (BUILT_IN_Y1)
1895 CASE_MATHFN (BUILT_IN_YN)
1901 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1902 return fn_arr[fcode];
1903 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1904 return fn_arr[fcodef];
1905 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1906 return fn_arr[fcodel];
1911 /* Like mathfn_built_in_1(), but always use the implicit array. */
1914 mathfn_built_in (tree type, enum built_in_function fn)
1916 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1919 /* If errno must be maintained, expand the RTL to check if the result,
1920 TARGET, of a built-in function call, EXP, is NaN, and if so set
1924 expand_errno_check (tree exp, rtx target)
1926 rtx lab = gen_label_rtx ();
1928 /* Test the result; if it is NaN, set errno=EDOM because
1929 the argument was not in the domain. */
1930 do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1931 NULL_RTX, NULL_RTX, lab,
1932 /* The jump is very likely. */
1933 REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1936 /* If this built-in doesn't throw an exception, set errno directly. */
1937 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1939 #ifdef GEN_ERRNO_RTX
1940 rtx errno_rtx = GEN_ERRNO_RTX;
1943 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1945 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1951 /* Make sure the library call isn't expanded as a tail call. */
1952 CALL_EXPR_TAILCALL (exp) = 0;
1954 /* We can't set errno=EDOM directly; let the library call do it.
1955 Pop the arguments right away in case the call gets deleted. */
1957 expand_call (exp, target, 0);
1962 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1963 Return NULL_RTX if a normal call should be emitted rather than expanding
1964 the function in-line. EXP is the expression that is a call to the builtin
1965 function; if convenient, the result should be placed in TARGET.
1966 SUBTARGET may be used as the target for computing one of EXP's operands. */
1969 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1971 optab builtin_optab;
1973 tree fndecl = get_callee_fndecl (exp);
1974 enum machine_mode mode;
1975 bool errno_set = false;
1978 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1981 arg = CALL_EXPR_ARG (exp, 0);
1983 switch (DECL_FUNCTION_CODE (fndecl))
1985 CASE_FLT_FN (BUILT_IN_SQRT):
1986 errno_set = ! tree_expr_nonnegative_p (arg);
1987 builtin_optab = sqrt_optab;
1989 CASE_FLT_FN (BUILT_IN_EXP):
1990 errno_set = true; builtin_optab = exp_optab; break;
1991 CASE_FLT_FN (BUILT_IN_EXP10):
1992 CASE_FLT_FN (BUILT_IN_POW10):
1993 errno_set = true; builtin_optab = exp10_optab; break;
1994 CASE_FLT_FN (BUILT_IN_EXP2):
1995 errno_set = true; builtin_optab = exp2_optab; break;
1996 CASE_FLT_FN (BUILT_IN_EXPM1):
1997 errno_set = true; builtin_optab = expm1_optab; break;
1998 CASE_FLT_FN (BUILT_IN_LOGB):
1999 errno_set = true; builtin_optab = logb_optab; break;
2000 CASE_FLT_FN (BUILT_IN_LOG):
2001 errno_set = true; builtin_optab = log_optab; break;
2002 CASE_FLT_FN (BUILT_IN_LOG10):
2003 errno_set = true; builtin_optab = log10_optab; break;
2004 CASE_FLT_FN (BUILT_IN_LOG2):
2005 errno_set = true; builtin_optab = log2_optab; break;
2006 CASE_FLT_FN (BUILT_IN_LOG1P):
2007 errno_set = true; builtin_optab = log1p_optab; break;
2008 CASE_FLT_FN (BUILT_IN_ASIN):
2009 builtin_optab = asin_optab; break;
2010 CASE_FLT_FN (BUILT_IN_ACOS):
2011 builtin_optab = acos_optab; break;
2012 CASE_FLT_FN (BUILT_IN_TAN):
2013 builtin_optab = tan_optab; break;
2014 CASE_FLT_FN (BUILT_IN_ATAN):
2015 builtin_optab = atan_optab; break;
2016 CASE_FLT_FN (BUILT_IN_FLOOR):
2017 builtin_optab = floor_optab; break;
2018 CASE_FLT_FN (BUILT_IN_CEIL):
2019 builtin_optab = ceil_optab; break;
2020 CASE_FLT_FN (BUILT_IN_TRUNC):
2021 builtin_optab = btrunc_optab; break;
2022 CASE_FLT_FN (BUILT_IN_ROUND):
2023 builtin_optab = round_optab; break;
2024 CASE_FLT_FN (BUILT_IN_NEARBYINT):
2025 builtin_optab = nearbyint_optab;
2026 if (flag_trapping_math)
2028 /* Else fallthrough and expand as rint. */
2029 CASE_FLT_FN (BUILT_IN_RINT):
2030 builtin_optab = rint_optab; break;
2031 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2032 builtin_optab = significand_optab; break;
2037 /* Make a suitable register to place result in. */
2038 mode = TYPE_MODE (TREE_TYPE (exp));
2040 if (! flag_errno_math || ! HONOR_NANS (mode))
2043 /* Before working hard, check whether the instruction is available. */
2044 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2046 target = gen_reg_rtx (mode);
2048 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2049 need to expand the argument again. This way, we will not perform
2050 side-effects more the once. */
2051 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2053 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2057 /* Compute into TARGET.
2058 Set TARGET to wherever the result comes back. */
2059 target = expand_unop (mode, builtin_optab, op0, target, 0);
2064 expand_errno_check (exp, target);
2066 /* Output the entire sequence. */
2067 insns = get_insns ();
2073 /* If we were unable to expand via the builtin, stop the sequence
2074 (without outputting the insns) and call to the library function
2075 with the stabilized argument list. */
2079 return expand_call (exp, target, target == const0_rtx);
2082 /* Expand a call to the builtin binary math functions (pow and atan2).
2083 Return NULL_RTX if a normal call should be emitted rather than expanding the
2084 function in-line. EXP is the expression that is a call to the builtin
2085 function; if convenient, the result should be placed in TARGET.
2086 SUBTARGET may be used as the target for computing one of EXP's
2090 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2092 optab builtin_optab;
2093 rtx op0, op1, insns;
2094 int op1_type = REAL_TYPE;
2095 tree fndecl = get_callee_fndecl (exp);
2097 enum machine_mode mode;
2098 bool errno_set = true;
2100 switch (DECL_FUNCTION_CODE (fndecl))
2102 CASE_FLT_FN (BUILT_IN_SCALBN):
2103 CASE_FLT_FN (BUILT_IN_SCALBLN):
2104 CASE_FLT_FN (BUILT_IN_LDEXP):
2105 op1_type = INTEGER_TYPE;
2110 if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2113 arg0 = CALL_EXPR_ARG (exp, 0);
2114 arg1 = CALL_EXPR_ARG (exp, 1);
2116 switch (DECL_FUNCTION_CODE (fndecl))
2118 CASE_FLT_FN (BUILT_IN_POW):
2119 builtin_optab = pow_optab; break;
2120 CASE_FLT_FN (BUILT_IN_ATAN2):
2121 builtin_optab = atan2_optab; break;
2122 CASE_FLT_FN (BUILT_IN_SCALB):
2123 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2125 builtin_optab = scalb_optab; break;
2126 CASE_FLT_FN (BUILT_IN_SCALBN):
2127 CASE_FLT_FN (BUILT_IN_SCALBLN):
2128 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2130 /* Fall through... */
2131 CASE_FLT_FN (BUILT_IN_LDEXP):
2132 builtin_optab = ldexp_optab; break;
2133 CASE_FLT_FN (BUILT_IN_FMOD):
2134 builtin_optab = fmod_optab; break;
2135 CASE_FLT_FN (BUILT_IN_REMAINDER):
2136 CASE_FLT_FN (BUILT_IN_DREM):
2137 builtin_optab = remainder_optab; break;
2142 /* Make a suitable register to place result in. */
2143 mode = TYPE_MODE (TREE_TYPE (exp));
2145 /* Before working hard, check whether the instruction is available. */
2146 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2149 target = gen_reg_rtx (mode);
2151 if (! flag_errno_math || ! HONOR_NANS (mode))
2154 /* Always stabilize the argument list. */
2155 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2156 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2158 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2159 op1 = expand_normal (arg1);
2163 /* Compute into TARGET.
2164 Set TARGET to wherever the result comes back. */
2165 target = expand_binop (mode, builtin_optab, op0, op1,
2166 target, 0, OPTAB_DIRECT);
2168 /* If we were unable to expand via the builtin, stop the sequence
2169 (without outputting the insns) and call to the library function
2170 with the stabilized argument list. */
2174 return expand_call (exp, target, target == const0_rtx);
2178 expand_errno_check (exp, target);
2180 /* Output the entire sequence. */
2181 insns = get_insns ();
2188 /* Expand a call to the builtin sin and cos math functions.
2189 Return NULL_RTX if a normal call should be emitted rather than expanding the
2190 function in-line. EXP is the expression that is a call to the builtin
2191 function; if convenient, the result should be placed in TARGET.
2192 SUBTARGET may be used as the target for computing one of EXP's
2196 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2198 optab builtin_optab;
2200 tree fndecl = get_callee_fndecl (exp);
2201 enum machine_mode mode;
2204 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2207 arg = CALL_EXPR_ARG (exp, 0);
2209 switch (DECL_FUNCTION_CODE (fndecl))
2211 CASE_FLT_FN (BUILT_IN_SIN):
2212 CASE_FLT_FN (BUILT_IN_COS):
2213 builtin_optab = sincos_optab; break;
2218 /* Make a suitable register to place result in. */
2219 mode = TYPE_MODE (TREE_TYPE (exp));
2221 /* Check if sincos insn is available, otherwise fallback
2222 to sin or cos insn. */
2223 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2224 switch (DECL_FUNCTION_CODE (fndecl))
2226 CASE_FLT_FN (BUILT_IN_SIN):
2227 builtin_optab = sin_optab; break;
2228 CASE_FLT_FN (BUILT_IN_COS):
2229 builtin_optab = cos_optab; break;
2234 /* Before working hard, check whether the instruction is available. */
2235 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2237 target = gen_reg_rtx (mode);
2239 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2240 need to expand the argument again. This way, we will not perform
2241 side-effects more the once. */
2242 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2244 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2248 /* Compute into TARGET.
2249 Set TARGET to wherever the result comes back. */
2250 if (builtin_optab == sincos_optab)
2254 switch (DECL_FUNCTION_CODE (fndecl))
2256 CASE_FLT_FN (BUILT_IN_SIN):
2257 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2259 CASE_FLT_FN (BUILT_IN_COS):
2260 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2265 gcc_assert (result);
2269 target = expand_unop (mode, builtin_optab, op0, target, 0);
2274 /* Output the entire sequence. */
2275 insns = get_insns ();
2281 /* If we were unable to expand via the builtin, stop the sequence
2282 (without outputting the insns) and call to the library function
2283 with the stabilized argument list. */
2287 target = expand_call (exp, target, target == const0_rtx);
2292 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2293 return an RTL instruction code that implements the functionality.
2294 If that isn't possible or available return CODE_FOR_nothing. */
2296 static enum insn_code
2297 interclass_mathfn_icode (tree arg, tree fndecl)
2299 bool errno_set = false;
2300 optab builtin_optab = 0;
2301 enum machine_mode mode;
2303 switch (DECL_FUNCTION_CODE (fndecl))
2305 CASE_FLT_FN (BUILT_IN_ILOGB):
2306 errno_set = true; builtin_optab = ilogb_optab; break;
2307 CASE_FLT_FN (BUILT_IN_ISINF):
2308 builtin_optab = isinf_optab; break;
2309 case BUILT_IN_ISNORMAL:
2310 case BUILT_IN_ISFINITE:
2311 CASE_FLT_FN (BUILT_IN_FINITE):
2312 case BUILT_IN_FINITED32:
2313 case BUILT_IN_FINITED64:
2314 case BUILT_IN_FINITED128:
2315 case BUILT_IN_ISINFD32:
2316 case BUILT_IN_ISINFD64:
2317 case BUILT_IN_ISINFD128:
2318 /* These builtins have no optabs (yet). */
2324 /* There's no easy way to detect the case we need to set EDOM. */
2325 if (flag_errno_math && errno_set)
2326 return CODE_FOR_nothing;
2328 /* Optab mode depends on the mode of the input argument. */
2329 mode = TYPE_MODE (TREE_TYPE (arg));
2332 return optab_handler (builtin_optab, mode);
2333 return CODE_FOR_nothing;
2336 /* Expand a call to one of the builtin math functions that operate on
2337 floating point argument and output an integer result (ilogb, isinf,
2339 Return 0 if a normal call should be emitted rather than expanding the
2340 function in-line. EXP is the expression that is a call to the builtin
2341 function; if convenient, the result should be placed in TARGET. */
2344 expand_builtin_interclass_mathfn (tree exp, rtx target)
2346 enum insn_code icode = CODE_FOR_nothing;
2348 tree fndecl = get_callee_fndecl (exp);
2349 enum machine_mode mode;
2352 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2355 arg = CALL_EXPR_ARG (exp, 0);
2356 icode = interclass_mathfn_icode (arg, fndecl);
2357 mode = TYPE_MODE (TREE_TYPE (arg));
2359 if (icode != CODE_FOR_nothing)
2361 rtx last = get_last_insn ();
2362 tree orig_arg = arg;
2363 /* Make a suitable register to place result in. */
2365 || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))
2366 || !insn_data[icode].operand[0].predicate (target, GET_MODE (target)))
2367 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2369 gcc_assert (insn_data[icode].operand[0].predicate
2370 (target, GET_MODE (target)));
2372 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2373 need to expand the argument again. This way, we will not perform
2374 side-effects more the once. */
2375 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2377 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2379 if (mode != GET_MODE (op0))
2380 op0 = convert_to_mode (mode, op0, 0);
2382 /* Compute into TARGET.
2383 Set TARGET to wherever the result comes back. */
2384 if (maybe_emit_unop_insn (icode, target, op0, UNKNOWN))
2386 delete_insns_since (last);
2387 CALL_EXPR_ARG (exp, 0) = orig_arg;
2393 /* Expand a call to the builtin sincos math function.
2394 Return NULL_RTX if a normal call should be emitted rather than expanding the
2395 function in-line. EXP is the expression that is a call to the builtin
2399 expand_builtin_sincos (tree exp)
2401 rtx op0, op1, op2, target1, target2;
2402 enum machine_mode mode;
2403 tree arg, sinp, cosp;
2405 location_t loc = EXPR_LOCATION (exp);
2407 if (!validate_arglist (exp, REAL_TYPE,
2408 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2411 arg = CALL_EXPR_ARG (exp, 0);
2412 sinp = CALL_EXPR_ARG (exp, 1);
2413 cosp = CALL_EXPR_ARG (exp, 2);
2415 /* Make a suitable register to place result in. */
2416 mode = TYPE_MODE (TREE_TYPE (arg));
2418 /* Check if sincos insn is available, otherwise emit the call. */
2419 if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2422 target1 = gen_reg_rtx (mode);
2423 target2 = gen_reg_rtx (mode);
2425 op0 = expand_normal (arg);
2426 op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2427 op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2429 /* Compute into target1 and target2.
2430 Set TARGET to wherever the result comes back. */
2431 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2432 gcc_assert (result);
2434 /* Move target1 and target2 to the memory locations indicated
2436 emit_move_insn (op1, target1);
2437 emit_move_insn (op2, target2);
2442 /* Expand a call to the internal cexpi builtin to the sincos math function.
2443 EXP is the expression that is a call to the builtin function; if convenient,
2444 the result should be placed in TARGET. */
2447 expand_builtin_cexpi (tree exp, rtx target)
2449 tree fndecl = get_callee_fndecl (exp);
2451 enum machine_mode mode;
2453 location_t loc = EXPR_LOCATION (exp);
2455 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2458 arg = CALL_EXPR_ARG (exp, 0);
2459 type = TREE_TYPE (arg);
2460 mode = TYPE_MODE (TREE_TYPE (arg));
2462 /* Try expanding via a sincos optab, fall back to emitting a libcall
2463 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2464 is only generated from sincos, cexp or if we have either of them. */
2465 if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2467 op1 = gen_reg_rtx (mode);
2468 op2 = gen_reg_rtx (mode);
2470 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2472 /* Compute into op1 and op2. */
2473 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2475 else if (TARGET_HAS_SINCOS)
2477 tree call, fn = NULL_TREE;
2481 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2482 fn = built_in_decls[BUILT_IN_SINCOSF];
2483 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2484 fn = built_in_decls[BUILT_IN_SINCOS];
2485 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2486 fn = built_in_decls[BUILT_IN_SINCOSL];
2490 op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2491 op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2492 op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2493 op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2494 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2495 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2497 /* Make sure not to fold the sincos call again. */
2498 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2499 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2500 call, 3, arg, top1, top2));
2504 tree call, fn = NULL_TREE, narg;
2505 tree ctype = build_complex_type (type);
2507 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2508 fn = built_in_decls[BUILT_IN_CEXPF];
2509 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2510 fn = built_in_decls[BUILT_IN_CEXP];
2511 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2512 fn = built_in_decls[BUILT_IN_CEXPL];
2516 /* If we don't have a decl for cexp create one. This is the
2517 friendliest fallback if the user calls __builtin_cexpi
2518 without full target C99 function support. */
2519 if (fn == NULL_TREE)
2522 const char *name = NULL;
2524 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2526 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2528 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2531 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2532 fn = build_fn_decl (name, fntype);
2535 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2536 build_real (type, dconst0), arg);
2538 /* Make sure not to fold the cexp call again. */
2539 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2540 return expand_expr (build_call_nary (ctype, call, 1, narg),
2541 target, VOIDmode, EXPAND_NORMAL);
2544 /* Now build the proper return type. */
2545 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2546 make_tree (TREE_TYPE (arg), op2),
2547 make_tree (TREE_TYPE (arg), op1)),
2548 target, VOIDmode, EXPAND_NORMAL);
2551 /* Conveniently construct a function call expression. FNDECL names the
2552 function to be called, N is the number of arguments, and the "..."
2553 parameters are the argument expressions. Unlike build_call_exr
2554 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2557 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2560 tree fntype = TREE_TYPE (fndecl);
2561 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2564 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2566 SET_EXPR_LOCATION (fn, loc);
2570 /* Expand a call to one of the builtin rounding functions gcc defines
2571 as an extension (lfloor and lceil). As these are gcc extensions we
2572 do not need to worry about setting errno to EDOM.
2573 If expanding via optab fails, lower expression to (int)(floor(x)).
2574 EXP is the expression that is a call to the builtin function;
2575 if convenient, the result should be placed in TARGET. */
2578 expand_builtin_int_roundingfn (tree exp, rtx target)
2580 convert_optab builtin_optab;
2581 rtx op0, insns, tmp;
2582 tree fndecl = get_callee_fndecl (exp);
2583 enum built_in_function fallback_fn;
2584 tree fallback_fndecl;
2585 enum machine_mode mode;
2588 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2591 arg = CALL_EXPR_ARG (exp, 0);
2593 switch (DECL_FUNCTION_CODE (fndecl))
2595 CASE_FLT_FN (BUILT_IN_LCEIL):
2596 CASE_FLT_FN (BUILT_IN_LLCEIL):
2597 builtin_optab = lceil_optab;
2598 fallback_fn = BUILT_IN_CEIL;
2601 CASE_FLT_FN (BUILT_IN_LFLOOR):
2602 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2603 builtin_optab = lfloor_optab;
2604 fallback_fn = BUILT_IN_FLOOR;
2611 /* Make a suitable register to place result in. */
2612 mode = TYPE_MODE (TREE_TYPE (exp));
2614 target = gen_reg_rtx (mode);
2616 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2617 need to expand the argument again. This way, we will not perform
2618 side-effects more the once. */
2619 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2621 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2625 /* Compute into TARGET. */
2626 if (expand_sfix_optab (target, op0, builtin_optab))
2628 /* Output the entire sequence. */
2629 insns = get_insns ();
2635 /* If we were unable to expand via the builtin, stop the sequence
2636 (without outputting the insns). */
2639 /* Fall back to floating point rounding optab. */
2640 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2642 /* For non-C99 targets we may end up without a fallback fndecl here
2643 if the user called __builtin_lfloor directly. In this case emit
2644 a call to the floor/ceil variants nevertheless. This should result
2645 in the best user experience for not full C99 targets. */
2646 if (fallback_fndecl == NULL_TREE)
2649 const char *name = NULL;
2651 switch (DECL_FUNCTION_CODE (fndecl))
2653 case BUILT_IN_LCEIL:
2654 case BUILT_IN_LLCEIL:
2657 case BUILT_IN_LCEILF:
2658 case BUILT_IN_LLCEILF:
2661 case BUILT_IN_LCEILL:
2662 case BUILT_IN_LLCEILL:
2665 case BUILT_IN_LFLOOR:
2666 case BUILT_IN_LLFLOOR:
2669 case BUILT_IN_LFLOORF:
2670 case BUILT_IN_LLFLOORF:
2673 case BUILT_IN_LFLOORL:
2674 case BUILT_IN_LLFLOORL:
2681 fntype = build_function_type_list (TREE_TYPE (arg),
2682 TREE_TYPE (arg), NULL_TREE);
2683 fallback_fndecl = build_fn_decl (name, fntype);
2686 exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2688 tmp = expand_normal (exp);
2690 /* Truncate the result of floating point optab to integer
2691 via expand_fix (). */
2692 target = gen_reg_rtx (mode);
2693 expand_fix (target, tmp, 0);
2698 /* Expand a call to one of the builtin math functions doing integer
2700 Return 0 if a normal call should be emitted rather than expanding the
2701 function in-line. EXP is the expression that is a call to the builtin
2702 function; if convenient, the result should be placed in TARGET. */
2705 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2707 convert_optab builtin_optab;
2709 tree fndecl = get_callee_fndecl (exp);
2711 enum machine_mode mode;
2713 /* There's no easy way to detect the case we need to set EDOM. */
2714 if (flag_errno_math)
2717 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2720 arg = CALL_EXPR_ARG (exp, 0);
2722 switch (DECL_FUNCTION_CODE (fndecl))
2724 CASE_FLT_FN (BUILT_IN_LRINT):
2725 CASE_FLT_FN (BUILT_IN_LLRINT):
2726 builtin_optab = lrint_optab; break;
2727 CASE_FLT_FN (BUILT_IN_LROUND):
2728 CASE_FLT_FN (BUILT_IN_LLROUND):
2729 builtin_optab = lround_optab; break;
2734 /* Make a suitable register to place result in. */
2735 mode = TYPE_MODE (TREE_TYPE (exp));
2737 target = gen_reg_rtx (mode);
2739 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2740 need to expand the argument again. This way, we will not perform
2741 side-effects more the once. */
2742 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2744 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2748 if (expand_sfix_optab (target, op0, builtin_optab))
2750 /* Output the entire sequence. */
2751 insns = get_insns ();
2757 /* If we were unable to expand via the builtin, stop the sequence
2758 (without outputting the insns) and call to the library function
2759 with the stabilized argument list. */
2762 target = expand_call (exp, target, target == const0_rtx);
2767 /* To evaluate powi(x,n), the floating point value x raised to the
2768 constant integer exponent n, we use a hybrid algorithm that
2769 combines the "window method" with look-up tables. For an
2770 introduction to exponentiation algorithms and "addition chains",
2771 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2772 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2773 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2774 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2776 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2777 multiplications to inline before calling the system library's pow
2778 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2779 so this default never requires calling pow, powf or powl. */
2781 #ifndef POWI_MAX_MULTS
2782 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2785 /* The size of the "optimal power tree" lookup table. All
2786 exponents less than this value are simply looked up in the
2787 powi_table below. This threshold is also used to size the
2788 cache of pseudo registers that hold intermediate results. */
2789 #define POWI_TABLE_SIZE 256
2791 /* The size, in bits of the window, used in the "window method"
2792 exponentiation algorithm. This is equivalent to a radix of
2793 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2794 #define POWI_WINDOW_SIZE 3
2796 /* The following table is an efficient representation of an
2797 "optimal power tree". For each value, i, the corresponding
2798 value, j, in the table states than an optimal evaluation
2799 sequence for calculating pow(x,i) can be found by evaluating
2800 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2801 100 integers is given in Knuth's "Seminumerical algorithms". */
2803 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2805 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2806 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2807 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2808 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2809 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2810 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2811 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2812 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2813 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2814 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2815 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2816 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2817 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2818 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2819 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2820 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2821 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2822 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2823 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2824 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2825 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2826 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2827 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2828 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2829 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2830 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2831 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2832 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2833 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2834 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2835 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2836 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2840 /* Return the number of multiplications required to calculate
2841 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2842 subroutine of powi_cost. CACHE is an array indicating
2843 which exponents have already been calculated. */
2846 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2848 /* If we've already calculated this exponent, then this evaluation
2849 doesn't require any additional multiplications. */
2854 return powi_lookup_cost (n - powi_table[n], cache)
2855 + powi_lookup_cost (powi_table[n], cache) + 1;
2858 /* Return the number of multiplications required to calculate
2859 powi(x,n) for an arbitrary x, given the exponent N. This
2860 function needs to be kept in sync with expand_powi below. */
2863 powi_cost (HOST_WIDE_INT n)
2865 bool cache[POWI_TABLE_SIZE];
2866 unsigned HOST_WIDE_INT digit;
2867 unsigned HOST_WIDE_INT val;
2873 /* Ignore the reciprocal when calculating the cost. */
2874 val = (n < 0) ? -n : n;
2876 /* Initialize the exponent cache. */
2877 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2882 while (val >= POWI_TABLE_SIZE)
2886 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2887 result += powi_lookup_cost (digit, cache)
2888 + POWI_WINDOW_SIZE + 1;
2889 val >>= POWI_WINDOW_SIZE;
2898 return result + powi_lookup_cost (val, cache);
2901 /* Recursive subroutine of expand_powi. This function takes the array,
2902 CACHE, of already calculated exponents and an exponent N and returns
2903 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2906 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2908 unsigned HOST_WIDE_INT digit;
2912 if (n < POWI_TABLE_SIZE)
2917 target = gen_reg_rtx (mode);
2920 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2921 op1 = expand_powi_1 (mode, powi_table[n], cache);
2925 target = gen_reg_rtx (mode);
2926 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2927 op0 = expand_powi_1 (mode, n - digit, cache);
2928 op1 = expand_powi_1 (mode, digit, cache);
2932 target = gen_reg_rtx (mode);
2933 op0 = expand_powi_1 (mode, n >> 1, cache);
2937 result = expand_mult (mode, op0, op1, target, 0);
2938 if (result != target)
2939 emit_move_insn (target, result);
2943 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2944 floating point operand in mode MODE, and N is the exponent. This
2945 function needs to be kept in sync with powi_cost above. */
2948 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2950 rtx cache[POWI_TABLE_SIZE];
2954 return CONST1_RTX (mode);
2956 memset (cache, 0, sizeof (cache));
2959 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2961 /* If the original exponent was negative, reciprocate the result. */
2963 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2964 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2969 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2970 cbrts. Return NULL_RTX if no simplification can be made or expand the tree
2971 if we can simplify it. */
2973 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
2976 if (TREE_CODE (arg1) == REAL_CST
2977 && !TREE_OVERFLOW (arg1)
2978 && flag_unsafe_math_optimizations)
2980 enum machine_mode mode = TYPE_MODE (type);
2981 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
2982 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
2983 REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
2984 tree op = NULL_TREE;
2988 /* Optimize pow (x, 0.5) into sqrt. */
2989 if (REAL_VALUES_EQUAL (c, dconsthalf))
2990 op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
2994 REAL_VALUE_TYPE dconst1_4 = dconst1;
2995 REAL_VALUE_TYPE dconst3_4;
2996 SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
2998 real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
2999 SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3001 /* Optimize pow (x, 0.25) into sqrt (sqrt (x)). Assume on most
3002 machines that a builtin sqrt instruction is smaller than a
3003 call to pow with 0.25, so do this optimization even if
3005 if (REAL_VALUES_EQUAL (c, dconst1_4))
3007 op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3008 op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3011 /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3012 are optimizing for space. */
3013 else if (optimize_insn_for_speed_p ()
3014 && !TREE_SIDE_EFFECTS (arg0)
3015 && REAL_VALUES_EQUAL (c, dconst3_4))
3017 tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3018 tree sqrt2 = builtin_save_expr (sqrt1);
3019 tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3020 op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3025 /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3026 cbrt/sqrts instead of pow (x, 1./6.). */
3028 && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3030 /* First try 1/3. */
3031 REAL_VALUE_TYPE dconst1_3
3032 = real_value_truncate (mode, dconst_third ());
3034 if (REAL_VALUES_EQUAL (c, dconst1_3))
3035 op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3038 else if (optimize_insn_for_speed_p ())
3040 REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3041 SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3043 if (REAL_VALUES_EQUAL (c, dconst1_6))
3045 op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3046 op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3052 return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3058 /* Expand a call to the pow built-in mathematical function. Return NULL_RTX if
3059 a normal call should be emitted rather than expanding the function
3060 in-line. EXP is the expression that is a call to the builtin
3061 function; if convenient, the result should be placed in TARGET. */
3064 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3068 tree type = TREE_TYPE (exp);
3069 REAL_VALUE_TYPE cint, c, c2;
3072 enum machine_mode mode = TYPE_MODE (type);
3074 if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3077 arg0 = CALL_EXPR_ARG (exp, 0);
3078 arg1 = CALL_EXPR_ARG (exp, 1);
3080 if (TREE_CODE (arg1) != REAL_CST
3081 || TREE_OVERFLOW (arg1))
3082 return expand_builtin_mathfn_2 (exp, target, subtarget);
3084 /* Handle constant exponents. */
3086 /* For integer valued exponents we can expand to an optimal multiplication
3087 sequence using expand_powi. */
3088 c = TREE_REAL_CST (arg1);
3089 n = real_to_integer (&c);
3090 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3091 if (real_identical (&c, &cint)
3092 && ((n >= -1 && n <= 2)
3093 || (flag_unsafe_math_optimizations
3094 && optimize_insn_for_speed_p ()
3095 && powi_cost (n) <= POWI_MAX_MULTS)))
3097 op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3100 op = force_reg (mode, op);
3101 op = expand_powi (op, mode, n);
3106 narg0 = builtin_save_expr (arg0);
3108 /* If the exponent is not integer valued, check if it is half of an integer.
3109 In this case we can expand to sqrt (x) * x**(n/2). */
3110 fn = mathfn_built_in (type, BUILT_IN_SQRT);
3111 if (fn != NULL_TREE)
3113 real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3114 n = real_to_integer (&c2);
3115 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3116 if (real_identical (&c2, &cint)
3117 && ((flag_unsafe_math_optimizations
3118 && optimize_insn_for_speed_p ()
3119 && powi_cost (n/2) <= POWI_MAX_MULTS)
3120 /* Even the c == 0.5 case cannot be done unconditionally
3121 when we need to preserve signed zeros, as
3122 pow (-0, 0.5) is +0, while sqrt(-0) is -0. */
3123 || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3124 /* For c == 1.5 we can assume that x * sqrt (x) is always
3125 smaller than pow (x, 1.5) if sqrt will not be expanded
3128 && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3130 tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3132 /* Use expand_expr in case the newly built call expression
3133 was folded to a non-call. */
3134 op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3137 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3138 op2 = force_reg (mode, op2);
3139 op2 = expand_powi (op2, mode, abs (n / 2));
3140 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3141 0, OPTAB_LIB_WIDEN);
3142 /* If the original exponent was negative, reciprocate the
3145 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3146 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3152 /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3154 op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3159 /* Try if the exponent is a third of an integer. In this case
3160 we can expand to x**(n/3) * cbrt(x)**(n%3). As cbrt (x) is
3161 different from pow (x, 1./3.) due to rounding and behavior
3162 with negative x we need to constrain this transformation to
3163 unsafe math and positive x or finite math. */
3164 fn = mathfn_built_in (type, BUILT_IN_CBRT);
3166 && flag_unsafe_math_optimizations
3167 && (tree_expr_nonnegative_p (arg0)
3168 || !HONOR_NANS (mode)))
3170 REAL_VALUE_TYPE dconst3;
3171 real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3172 real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3173 real_round (&c2, mode, &c2);
3174 n = real_to_integer (&c2);
3175 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3176 real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3177 real_convert (&c2, mode, &c2);
3178 if (real_identical (&c2, &c)
3179 && ((optimize_insn_for_speed_p ()
3180 && powi_cost (n/3) <= POWI_MAX_MULTS)
3183 tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3185 op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3186 if (abs (n) % 3 == 2)
3187 op = expand_simple_binop (mode, MULT, op, op, op,
3188 0, OPTAB_LIB_WIDEN);
3191 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3192 op2 = force_reg (mode, op2);
3193 op2 = expand_powi (op2, mode, abs (n / 3));
3194 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3195 0, OPTAB_LIB_WIDEN);
3196 /* If the original exponent was negative, reciprocate the
3199 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3200 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3206 /* Fall back to optab expansion. */
3207 return expand_builtin_mathfn_2 (exp, target, subtarget);
3210 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
3211 a normal call should be emitted rather than expanding the function
3212 in-line. EXP is the expression that is a call to the builtin
3213 function; if convenient, the result should be placed in TARGET. */
3216 expand_builtin_powi (tree exp, rtx target)
3220 enum machine_mode mode;
3221 enum machine_mode mode2;
3223 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3226 arg0 = CALL_EXPR_ARG (exp, 0);
3227 arg1 = CALL_EXPR_ARG (exp, 1);
3228 mode = TYPE_MODE (TREE_TYPE (exp));
3230 /* Handle constant power. */
3232 if (TREE_CODE (arg1) == INTEGER_CST
3233 && !TREE_OVERFLOW (arg1))
3235 HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3237 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3238 Otherwise, check the number of multiplications required. */
3239 if ((TREE_INT_CST_HIGH (arg1) == 0
3240 || TREE_INT_CST_HIGH (arg1) == -1)
3241 && ((n >= -1 && n <= 2)
3242 || (optimize_insn_for_speed_p ()
3243 && powi_cost (n) <= POWI_MAX_MULTS)))
3245 op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
3246 op0 = force_reg (mode, op0);
3247 return expand_powi (op0, mode, n);
3251 /* Emit a libcall to libgcc. */
3253 /* Mode of the 2nd argument must match that of an int. */
3254 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3256 if (target == NULL_RTX)
3257 target = gen_reg_rtx (mode);
3259 op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
3260 if (GET_MODE (op0) != mode)
3261 op0 = convert_to_mode (mode, op0, 0);
3262 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3263 if (GET_MODE (op1) != mode2)
3264 op1 = convert_to_mode (mode2, op1, 0);
3266 target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3267 target, LCT_CONST, mode, 2,
3268 op0, mode, op1, mode2);
3273 /* Expand expression EXP which is a call to the strlen builtin. Return
3274 NULL_RTX if we failed the caller should emit a normal call, otherwise
3275 try to get the result in TARGET, if convenient. */
3278 expand_builtin_strlen (tree exp, rtx target,
3279 enum machine_mode target_mode)
3281 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3287 tree src = CALL_EXPR_ARG (exp, 0);
3288 rtx result, src_reg, char_rtx, before_strlen;
3289 enum machine_mode insn_mode = target_mode, char_mode;
3290 enum insn_code icode = CODE_FOR_nothing;
3293 /* If the length can be computed at compile-time, return it. */
3294 len = c_strlen (src, 0);
3296 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3298 /* If the length can be computed at compile-time and is constant
3299 integer, but there are side-effects in src, evaluate
3300 src for side-effects, then return len.
3301 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3302 can be optimized into: i++; x = 3; */
3303 len = c_strlen (src, 1);
3304 if (len && TREE_CODE (len) == INTEGER_CST)
3306 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3307 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3310 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3312 /* If SRC is not a pointer type, don't do this operation inline. */
3316 /* Bail out if we can't compute strlen in the right mode. */
3317 while (insn_mode != VOIDmode)
3319 icode = optab_handler (strlen_optab, insn_mode);
3320 if (icode != CODE_FOR_nothing)
3323 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3325 if (insn_mode == VOIDmode)
3328 /* Make a place to write the result of the instruction. */
3332 && GET_MODE (result) == insn_mode
3333 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3334 result = gen_reg_rtx (insn_mode);
3336 /* Make a place to hold the source address. We will not expand
3337 the actual source until we are sure that the expansion will
3338 not fail -- there are trees that cannot be expanded twice. */
3339 src_reg = gen_reg_rtx (Pmode);
3341 /* Mark the beginning of the strlen sequence so we can emit the
3342 source operand later. */
3343 before_strlen = get_last_insn ();
3345 char_rtx = const0_rtx;
3346 char_mode = insn_data[(int) icode].operand[2].mode;
3347 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3349 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3351 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3352 char_rtx, GEN_INT (align));
3357 /* Now that we are assured of success, expand the source. */
3359 pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3361 emit_move_insn (src_reg, pat);
3366 emit_insn_after (pat, before_strlen);
3368 emit_insn_before (pat, get_insns ());
3370 /* Return the value in the proper mode for this function. */
3371 if (GET_MODE (result) == target_mode)
3373 else if (target != 0)
3374 convert_move (target, result, 0);
3376 target = convert_to_mode (target_mode, result, 0);
3382 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3383 bytes from constant string DATA + OFFSET and return it as target
3387 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3388 enum machine_mode mode)
3390 const char *str = (const char *) data;
3392 gcc_assert (offset >= 0
3393 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3394 <= strlen (str) + 1));
3396 return c_readstr (str + offset, mode);
3399 /* Expand a call EXP to the memcpy builtin.
3400 Return NULL_RTX if we failed, the caller should emit a normal call,
3401 otherwise try to get the result in TARGET, if convenient (and in
3402 mode MODE if that's convenient). */
3405 expand_builtin_memcpy (tree exp, rtx target)
3407 if (!validate_arglist (exp,
3408 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3412 tree dest = CALL_EXPR_ARG (exp, 0);
3413 tree src = CALL_EXPR_ARG (exp, 1);
3414 tree len = CALL_EXPR_ARG (exp, 2);
3415 const char *src_str;
3416 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3417 unsigned int dest_align
3418 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3419 rtx dest_mem, src_mem, dest_addr, len_rtx;
3420 HOST_WIDE_INT expected_size = -1;
3421 unsigned int expected_align = 0;
3423 /* If DEST is not a pointer type, call the normal function. */
3424 if (dest_align == 0)
3427 /* If either SRC is not a pointer type, don't do this
3428 operation in-line. */
3432 if (currently_expanding_gimple_stmt)
3433 stringop_block_profile (currently_expanding_gimple_stmt,
3434 &expected_align, &expected_size);
3436 if (expected_align < dest_align)
3437 expected_align = dest_align;
3438 dest_mem = get_memory_rtx (dest, len);
3439 set_mem_align (dest_mem, dest_align);
3440 len_rtx = expand_normal (len);
3441 src_str = c_getstr (src);
3443 /* If SRC is a string constant and block move would be done
3444 by pieces, we can avoid loading the string from memory
3445 and only stored the computed constants. */
3447 && CONST_INT_P (len_rtx)
3448 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3449 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3450 CONST_CAST (char *, src_str),
3453 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3454 builtin_memcpy_read_str,
3455 CONST_CAST (char *, src_str),
3456 dest_align, false, 0);
3457 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3458 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3462 src_mem = get_memory_rtx (src, len);
3463 set_mem_align (src_mem, src_align);
3465 /* Copy word part most expediently. */
3466 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3467 CALL_EXPR_TAILCALL (exp)
3468 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3469 expected_align, expected_size);
3473 dest_addr = force_operand (XEXP (dest_mem, 0), target);
3474 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3480 /* Expand a call EXP to the mempcpy builtin.
3481 Return NULL_RTX if we failed; the caller should emit a normal call,
3482 otherwise try to get the result in TARGET, if convenient (and in
3483 mode MODE if that's convenient). If ENDP is 0 return the
3484 destination pointer, if ENDP is 1 return the end pointer ala
3485 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3489 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3491 if (!validate_arglist (exp,
3492 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3496 tree dest = CALL_EXPR_ARG (exp, 0);
3497 tree src = CALL_EXPR_ARG (exp, 1);
3498 tree len = CALL_EXPR_ARG (exp, 2);
3499 return expand_builtin_mempcpy_args (dest, src, len,
3500 target, mode, /*endp=*/ 1);
3504 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3505 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3506 so that this can also be called without constructing an actual CALL_EXPR.
3507 The other arguments and return value are the same as for
3508 expand_builtin_mempcpy. */
3511 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3512 rtx target, enum machine_mode mode, int endp)
3514 /* If return value is ignored, transform mempcpy into memcpy. */
3515 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3517 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3518 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3520 return expand_expr (result, target, mode, EXPAND_NORMAL);
3524 const char *src_str;
3525 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3526 unsigned int dest_align
3527 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3528 rtx dest_mem, src_mem, len_rtx;
3530 /* If either SRC or DEST is not a pointer type, don't do this
3531 operation in-line. */
3532 if (dest_align == 0 || src_align == 0)
3535 /* If LEN is not constant, call the normal function. */
3536 if (! host_integerp (len, 1))
3539 len_rtx = expand_normal (len);
3540 src_str = c_getstr (src);
3542 /* If SRC is a string constant and block move would be done
3543 by pieces, we can avoid loading the string from memory
3544 and only stored the computed constants. */
3546 && CONST_INT_P (len_rtx)
3547 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3548 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3549 CONST_CAST (char *, src_str),
3552 dest_mem = get_memory_rtx (dest, len);
3553 set_mem_align (dest_mem, dest_align);
3554 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3555 builtin_memcpy_read_str,
3556 CONST_CAST (char *, src_str),
3557 dest_align, false, endp);
3558 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3559 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3563 if (CONST_INT_P (len_rtx)
3564 && can_move_by_pieces (INTVAL (len_rtx),
3565 MIN (dest_align, src_align)))
3567 dest_mem = get_memory_rtx (dest, len);
3568 set_mem_align (dest_mem, dest_align);
3569 src_mem = get_memory_rtx (src, len);
3570 set_mem_align (src_mem, src_align);
3571 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3572 MIN (dest_align, src_align), endp);
3573 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3574 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3583 # define HAVE_movstr 0
3584 # define CODE_FOR_movstr CODE_FOR_nothing
3587 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3588 we failed, the caller should emit a normal call, otherwise try to
3589 get the result in TARGET, if convenient. If ENDP is 0 return the
3590 destination pointer, if ENDP is 1 return the end pointer ala
3591 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3595 expand_movstr (tree dest, tree src, rtx target, int endp)
3601 const struct insn_data_d * data;
3606 dest_mem = get_memory_rtx (dest, NULL);
3607 src_mem = get_memory_rtx (src, NULL);
3608 data = insn_data + CODE_FOR_movstr;
3611 target = force_reg (Pmode, XEXP (dest_mem, 0));
3612 dest_mem = replace_equiv_address (dest_mem, target);
3613 end = gen_reg_rtx (Pmode);
3618 || target == const0_rtx
3619 || ! (*data->operand[0].predicate) (target, Pmode))
3621 end = gen_reg_rtx (Pmode);
3622 if (target != const0_rtx)
3629 if (data->operand[0].mode != VOIDmode)
3630 end = gen_lowpart (data->operand[0].mode, end);
3632 insn = data->genfun (end, dest_mem, src_mem);
3638 /* movstr is supposed to set end to the address of the NUL
3639 terminator. If the caller requested a mempcpy-like return value,
3641 if (endp == 1 && target != const0_rtx)
3643 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3644 emit_move_insn (target, force_operand (tem, NULL_RTX));
3650 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3651 NULL_RTX if we failed the caller should emit a normal call, otherwise
3652 try to get the result in TARGET, if convenient (and in mode MODE if that's
3656 expand_builtin_strcpy (tree exp, rtx target)
3658 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3660 tree dest = CALL_EXPR_ARG (exp, 0);
3661 tree src = CALL_EXPR_ARG (exp, 1);
3662 return expand_builtin_strcpy_args (dest, src, target);
3667 /* Helper function to do the actual work for expand_builtin_strcpy. The
3668 arguments to the builtin_strcpy call DEST and SRC are broken out
3669 so that this can also be called without constructing an actual CALL_EXPR.
3670 The other arguments and return value are the same as for
3671 expand_builtin_strcpy. */
3674 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3676 return expand_movstr (dest, src, target, /*endp=*/0);
3679 /* Expand a call EXP to the stpcpy builtin.
3680 Return NULL_RTX if we failed the caller should emit a normal call,
3681 otherwise try to get the result in TARGET, if convenient (and in
3682 mode MODE if that's convenient). */
3685 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3688 location_t loc = EXPR_LOCATION (exp);
3690 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3693 dst = CALL_EXPR_ARG (exp, 0);
3694 src = CALL_EXPR_ARG (exp, 1);
3696 /* If return value is ignored, transform stpcpy into strcpy. */
3697 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3699 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3700 tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3701 return expand_expr (result, target, mode, EXPAND_NORMAL);
3708 /* Ensure we get an actual string whose length can be evaluated at
3709 compile-time, not an expression containing a string. This is
3710 because the latter will potentially produce pessimized code
3711 when used to produce the return value. */
3712 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3713 return expand_movstr (dst, src, target, /*endp=*/2);
3715 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3716 ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3717 target, mode, /*endp=*/2);
3722 if (TREE_CODE (len) == INTEGER_CST)
3724 rtx len_rtx = expand_normal (len);
3726 if (CONST_INT_P (len_rtx))
3728 ret = expand_builtin_strcpy_args (dst, src, target);
3734 if (mode != VOIDmode)
3735 target = gen_reg_rtx (mode);
3737 target = gen_reg_rtx (GET_MODE (ret));
3739 if (GET_MODE (target) != GET_MODE (ret))
3740 ret = gen_lowpart (GET_MODE (target), ret);
3742 ret = plus_constant (ret, INTVAL (len_rtx));
3743 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3751 return expand_movstr (dst, src, target, /*endp=*/2);
3755 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3756 bytes from constant string DATA + OFFSET and return it as target
3760 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3761 enum machine_mode mode)
3763 const char *str = (const char *) data;
3765 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3768 return c_readstr (str + offset, mode);
3771 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3772 NULL_RTX if we failed the caller should emit a normal call. */
3775 expand_builtin_strncpy (tree exp, rtx target)
3777 location_t loc = EXPR_LOCATION (exp);
3779 if (validate_arglist (exp,
3780 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3782 tree dest = CALL_EXPR_ARG (exp, 0);
3783 tree src = CALL_EXPR_ARG (exp, 1);
3784 tree len = CALL_EXPR_ARG (exp, 2);
3785 tree slen = c_strlen (src, 1);
3787 /* We must be passed a constant len and src parameter. */
3788 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3791 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3793 /* We're required to pad with trailing zeros if the requested
3794 len is greater than strlen(s2)+1. In that case try to
3795 use store_by_pieces, if it fails, punt. */
3796 if (tree_int_cst_lt (slen, len))
3798 unsigned int dest_align
3799 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3800 const char *p = c_getstr (src);
3803 if (!p || dest_align == 0 || !host_integerp (len, 1)
3804 || !can_store_by_pieces (tree_low_cst (len, 1),
3805 builtin_strncpy_read_str,
3806 CONST_CAST (char *, p),
3810 dest_mem = get_memory_rtx (dest, len);
3811 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3812 builtin_strncpy_read_str,
3813 CONST_CAST (char *, p), dest_align, false, 0);
3814 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3815 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3822 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3823 bytes from constant string DATA + OFFSET and return it as target
3827 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3828 enum machine_mode mode)
3830 const char *c = (const char *) data;
3831 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3833 memset (p, *c, GET_MODE_SIZE (mode));
3835 return c_readstr (p, mode);
3838 /* Callback routine for store_by_pieces. Return the RTL of a register
3839 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3840 char value given in the RTL register data. For example, if mode is
3841 4 bytes wide, return the RTL for 0x01010101*data. */
3844 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3845 enum machine_mode mode)
3851 size = GET_MODE_SIZE (mode);
3855 p = XALLOCAVEC (char, size);
3856 memset (p, 1, size);
3857 coeff = c_readstr (p, mode);
3859 target = convert_to_mode (mode, (rtx) data, 1);
3860 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3861 return force_reg (mode, target);
3864 /* Expand expression EXP, which is a call to the memset builtin. Return
3865 NULL_RTX if we failed the caller should emit a normal call, otherwise
3866 try to get the result in TARGET, if convenient (and in mode MODE if that's
3870 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3872 if (!validate_arglist (exp,
3873 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3877 tree dest = CALL_EXPR_ARG (exp, 0);
3878 tree val = CALL_EXPR_ARG (exp, 1);
3879 tree len = CALL_EXPR_ARG (exp, 2);
3880 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3884 /* Helper function to do the actual work for expand_builtin_memset. The
3885 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3886 so that this can also be called without constructing an actual CALL_EXPR.
3887 The other arguments and return value are the same as for
3888 expand_builtin_memset. */
3891 expand_builtin_memset_args (tree dest, tree val, tree len,
3892 rtx target, enum machine_mode mode, tree orig_exp)
3895 enum built_in_function fcode;
3897 unsigned int dest_align;
3898 rtx dest_mem, dest_addr, len_rtx;
3899 HOST_WIDE_INT expected_size = -1;
3900 unsigned int expected_align = 0;
3902 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3904 /* If DEST is not a pointer type, don't do this operation in-line. */
3905 if (dest_align == 0)
3908 if (currently_expanding_gimple_stmt)
3909 stringop_block_profile (currently_expanding_gimple_stmt,
3910 &expected_align, &expected_size);
3912 if (expected_align < dest_align)
3913 expected_align = dest_align;
3915 /* If the LEN parameter is zero, return DEST. */
3916 if (integer_zerop (len))
3918 /* Evaluate and ignore VAL in case it has side-effects. */
3919 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3920 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3923 /* Stabilize the arguments in case we fail. */
3924 dest = builtin_save_expr (dest);
3925 val = builtin_save_expr (val);
3926 len = builtin_save_expr (len);
3928 len_rtx = expand_normal (len);
3929 dest_mem = get_memory_rtx (dest, len);
3931 if (TREE_CODE (val) != INTEGER_CST)
3935 val_rtx = expand_normal (val);
3936 val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3939 /* Assume that we can memset by pieces if we can store
3940 * the coefficients by pieces (in the required modes).
3941 * We can't pass builtin_memset_gen_str as that emits RTL. */
3943 if (host_integerp (len, 1)
3944 && can_store_by_pieces (tree_low_cst (len, 1),
3945 builtin_memset_read_str, &c, dest_align,
3948 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3950 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3951 builtin_memset_gen_str, val_rtx, dest_align,
3954 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3955 dest_align, expected_align,
3959 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3960 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3964 if (target_char_cast (val, &c))
3969 if (host_integerp (len, 1)
3970 && can_store_by_pieces (tree_low_cst (len, 1),
3971 builtin_memset_read_str, &c, dest_align,
3973 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3974 builtin_memset_read_str, &c, dest_align, true, 0);
3975 else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3976 dest_align, expected_align,
3980 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3981 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3985 set_mem_align (dest_mem, dest_align);
3986 dest_addr = clear_storage_hints (dest_mem, len_rtx,
3987 CALL_EXPR_TAILCALL (orig_exp)
3988 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3989 expected_align, expected_size);
3993 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3994 dest_addr = convert_memory_address (ptr_mode, dest_addr);
4000 fndecl = get_callee_fndecl (orig_exp);
4001 fcode = DECL_FUNCTION_CODE (fndecl);
4002 if (fcode == BUILT_IN_MEMSET)
4003 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4005 else if (fcode == BUILT_IN_BZERO)
4006 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4010 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4011 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4012 return expand_call (fn, target, target == const0_rtx);
4015 /* Expand expression EXP, which is a call to the bzero builtin. Return
4016 NULL_RTX if we failed the caller should emit a normal call. */
4019 expand_builtin_bzero (tree exp)
4022 location_t loc = EXPR_LOCATION (exp);
4024 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4027 dest = CALL_EXPR_ARG (exp, 0);
4028 size = CALL_EXPR_ARG (exp, 1);
4030 /* New argument list transforming bzero(ptr x, int y) to
4031 memset(ptr x, int 0, size_t y). This is done this way
4032 so that if it isn't expanded inline, we fallback to
4033 calling bzero instead of memset. */
4035 return expand_builtin_memset_args (dest, integer_zero_node,
4036 fold_convert_loc (loc, sizetype, size),
4037 const0_rtx, VOIDmode, exp);
4040 /* Expand expression EXP, which is a call to the memcmp built-in function.
4041 Return NULL_RTX if we failed and the
4042 caller should emit a normal call, otherwise try to get the result in
4043 TARGET, if convenient (and in mode MODE, if that's convenient). */
4046 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4047 ATTRIBUTE_UNUSED enum machine_mode mode)
4049 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4051 if (!validate_arglist (exp,
4052 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4055 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4057 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4060 tree arg1 = CALL_EXPR_ARG (exp, 0);
4061 tree arg2 = CALL_EXPR_ARG (exp, 1);
4062 tree len = CALL_EXPR_ARG (exp, 2);
4064 unsigned int arg1_align
4065 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4066 unsigned int arg2_align
4067 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4068 enum machine_mode insn_mode;
4070 #ifdef HAVE_cmpmemsi
4072 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4075 #ifdef HAVE_cmpstrnsi
4077 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4082 /* If we don't have POINTER_TYPE, call the function. */
4083 if (arg1_align == 0 || arg2_align == 0)
4086 /* Make a place to write the result of the instruction. */
4089 && REG_P (result) && GET_MODE (result) == insn_mode
4090 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4091 result = gen_reg_rtx (insn_mode);
4093 arg1_rtx = get_memory_rtx (arg1, len);
4094 arg2_rtx = get_memory_rtx (arg2, len);
4095 arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4097 /* Set MEM_SIZE as appropriate. */
4098 if (CONST_INT_P (arg3_rtx))
4100 set_mem_size (arg1_rtx, arg3_rtx);
4101 set_mem_size (arg2_rtx, arg3_rtx);
4104 #ifdef HAVE_cmpmemsi
4106 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4107 GEN_INT (MIN (arg1_align, arg2_align)));
4110 #ifdef HAVE_cmpstrnsi
4112 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4113 GEN_INT (MIN (arg1_align, arg2_align)));
4121 emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4122 TYPE_MODE (integer_type_node), 3,
4123 XEXP (arg1_rtx, 0), Pmode,
4124 XEXP (arg2_rtx, 0), Pmode,
4125 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4126 TYPE_UNSIGNED (sizetype)),
4127 TYPE_MODE (sizetype));
4129 /* Return the value in the proper mode for this function. */
4130 mode = TYPE_MODE (TREE_TYPE (exp));
4131 if (GET_MODE (result) == mode)
4133 else if (target != 0)
4135 convert_move (target, result, 0);
4139 return convert_to_mode (mode, result, 0);
4146 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4147 if we failed the caller should emit a normal call, otherwise try to get
4148 the result in TARGET, if convenient. */
4151 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4153 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4156 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4157 if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4158 || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4160 rtx arg1_rtx, arg2_rtx;
4161 rtx result, insn = NULL_RTX;
4163 tree arg1 = CALL_EXPR_ARG (exp, 0);
4164 tree arg2 = CALL_EXPR_ARG (exp, 1);
4166 unsigned int arg1_align
4167 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4168 unsigned int arg2_align
4169 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4171 /* If we don't have POINTER_TYPE, call the function. */
4172 if (arg1_align == 0 || arg2_align == 0)
4175 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4176 arg1 = builtin_save_expr (arg1);
4177 arg2 = builtin_save_expr (arg2);
4179 arg1_rtx = get_memory_rtx (arg1, NULL);
4180 arg2_rtx = get_memory_rtx (arg2, NULL);
4182 #ifdef HAVE_cmpstrsi
4183 /* Try to call cmpstrsi. */
4186 enum machine_mode insn_mode
4187 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4189 /* Make a place to write the result of the instruction. */
4192 && REG_P (result) && GET_MODE (result) == insn_mode
4193 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4194 result = gen_reg_rtx (insn_mode);
4196 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4197 GEN_INT (MIN (arg1_align, arg2_align)));
4200 #ifdef HAVE_cmpstrnsi
4201 /* Try to determine at least one length and call cmpstrnsi. */
4202 if (!insn && HAVE_cmpstrnsi)
4207 enum machine_mode insn_mode
4208 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4209 tree len1 = c_strlen (arg1, 1);
4210 tree len2 = c_strlen (arg2, 1);
4213 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4215 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4217 /* If we don't have a constant length for the first, use the length
4218 of the second, if we know it. We don't require a constant for
4219 this case; some cost analysis could be done if both are available
4220 but neither is constant. For now, assume they're equally cheap,
4221 unless one has side effects. If both strings have constant lengths,
4228 else if (TREE_SIDE_EFFECTS (len1))
4230 else if (TREE_SIDE_EFFECTS (len2))
4232 else if (TREE_CODE (len1) != INTEGER_CST)
4234 else if (TREE_CODE (len2) != INTEGER_CST)
4236 else if (tree_int_cst_lt (len1, len2))
4241 /* If both arguments have side effects, we cannot optimize. */
4242 if (!len || TREE_SIDE_EFFECTS (len))
4245 arg3_rtx = expand_normal (len);
4247 /* Make a place to write the result of the instruction. */
4250 && REG_P (result) && GET_MODE (result) == insn_mode
4251 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4252 result = gen_reg_rtx (insn_mode);
4254 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4255 GEN_INT (MIN (arg1_align, arg2_align)));
4261 enum machine_mode mode;
4264 /* Return the value in the proper mode for this function. */
4265 mode = TYPE_MODE (TREE_TYPE (exp));
4266 if (GET_MODE (result) == mode)
4269 return convert_to_mode (mode, result, 0);
4270 convert_move (target, result, 0);
4274 /* Expand the library call ourselves using a stabilized argument
4275 list to avoid re-evaluating the function's arguments twice. */
4276 #ifdef HAVE_cmpstrnsi
4279 fndecl = get_callee_fndecl (exp);
4280 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4281 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4282 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4283 return expand_call (fn, target, target == const0_rtx);
4289 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4290 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4291 the result in TARGET, if convenient. */
4294 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4295 ATTRIBUTE_UNUSED enum machine_mode mode)
4297 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4299 if (!validate_arglist (exp,
4300 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4303 /* If c_strlen can determine an expression for one of the string
4304 lengths, and it doesn't have side effects, then emit cmpstrnsi
4305 using length MIN(strlen(string)+1, arg3). */
4306 #ifdef HAVE_cmpstrnsi
4309 tree len, len1, len2;
4310 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4313 tree arg1 = CALL_EXPR_ARG (exp, 0);
4314 tree arg2 = CALL_EXPR_ARG (exp, 1);
4315 tree arg3 = CALL_EXPR_ARG (exp, 2);
4317 unsigned int arg1_align
4318 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4319 unsigned int arg2_align
4320 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4321 enum machine_mode insn_mode
4322 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4324 len1 = c_strlen (arg1, 1);
4325 len2 = c_strlen (arg2, 1);
4328 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4330 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4332 /* If we don't have a constant length for the first, use the length
4333 of the second, if we know it. We don't require a constant for
4334 this case; some cost analysis could be done if both are available
4335 but neither is constant. For now, assume they're equally cheap,
4336 unless one has side effects. If both strings have constant lengths,
4343 else if (TREE_SIDE_EFFECTS (len1))
4345 else if (TREE_SIDE_EFFECTS (len2))
4347 else if (TREE_CODE (len1) != INTEGER_CST)
4349 else if (TREE_CODE (len2) != INTEGER_CST)
4351 else if (tree_int_cst_lt (len1, len2))
4356 /* If both arguments have side effects, we cannot optimize. */
4357 if (!len || TREE_SIDE_EFFECTS (len))
4360 /* The actual new length parameter is MIN(len,arg3). */
4361 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4362 fold_convert_loc (loc, TREE_TYPE (len), arg3));
4364 /* If we don't have POINTER_TYPE, call the function. */
4365 if (arg1_align == 0 || arg2_align == 0)
4368 /* Make a place to write the result of the instruction. */
4371 && REG_P (result) && GET_MODE (result) == insn_mode
4372 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4373 result = gen_reg_rtx (insn_mode);
4375 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4376 arg1 = builtin_save_expr (arg1);
4377 arg2 = builtin_save_expr (arg2);
4378 len = builtin_save_expr (len);
4380 arg1_rtx = get_memory_rtx (arg1, len);
4381 arg2_rtx = get_memory_rtx (arg2, len);
4382 arg3_rtx = expand_normal (len);
4383 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4384 GEN_INT (MIN (arg1_align, arg2_align)));
4389 /* Return the value in the proper mode for this function. */
4390 mode = TYPE_MODE (TREE_TYPE (exp));
4391 if (GET_MODE (result) == mode)
4394 return convert_to_mode (mode, result, 0);
4395 convert_move (target, result, 0);
4399 /* Expand the library call ourselves using a stabilized argument
4400 list to avoid re-evaluating the function's arguments twice. */
4401 fndecl = get_callee_fndecl (exp);
4402 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4404 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4405 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4406 return expand_call (fn, target, target == const0_rtx);
4412 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4413 if that's convenient. */
4416 expand_builtin_saveregs (void)
4420 /* Don't do __builtin_saveregs more than once in a function.
4421 Save the result of the first call and reuse it. */
4422 if (saveregs_value != 0)
4423 return saveregs_value;
4425 /* When this function is called, it means that registers must be
4426 saved on entry to this function. So we migrate the call to the
4427 first insn of this function. */
4431 /* Do whatever the machine needs done in this case. */
4432 val = targetm.calls.expand_builtin_saveregs ();
4437 saveregs_value = val;
4439 /* Put the insns after the NOTE that starts the function. If this
4440 is inside a start_sequence, make the outer-level insn chain current, so
4441 the code is placed at the start of the function. */
4442 push_topmost_sequence ();
4443 emit_insn_after (seq, entry_of_function ());
4444 pop_topmost_sequence ();
4449 /* Expand a call to __builtin_next_arg. */
4452 expand_builtin_next_arg (void)
4454 /* Checking arguments is already done in fold_builtin_next_arg
4455 that must be called before this function. */
4456 return expand_binop (ptr_mode, add_optab,
4457 crtl->args.internal_arg_pointer,
4458 crtl->args.arg_offset_rtx,
4459 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4462 /* Make it easier for the backends by protecting the valist argument
4463 from multiple evaluations. */
4466 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4468 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4470 /* The current way of determining the type of valist is completely
4471 bogus. We should have the information on the va builtin instead. */
4473 vatype = targetm.fn_abi_va_list (cfun->decl);
4475 if (TREE_CODE (vatype) == ARRAY_TYPE)
4477 if (TREE_SIDE_EFFECTS (valist))
4478 valist = save_expr (valist);
4480 /* For this case, the backends will be expecting a pointer to
4481 vatype, but it's possible we've actually been given an array
4482 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4484 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4486 tree p1 = build_pointer_type (TREE_TYPE (vatype));
4487 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4492 tree pt = build_pointer_type (vatype);
4496 if (! TREE_SIDE_EFFECTS (valist))
4499 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4500 TREE_SIDE_EFFECTS (valist) = 1;
4503 if (TREE_SIDE_EFFECTS (valist))
4504 valist = save_expr (valist);
4505 valist = fold_build2_loc (loc, MEM_REF,
4506 vatype, valist, build_int_cst (pt, 0));
4512 /* The "standard" definition of va_list is void*. */
4515 std_build_builtin_va_list (void)
4517 return ptr_type_node;
4520 /* The "standard" abi va_list is va_list_type_node. */
4523 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4525 return va_list_type_node;
4528 /* The "standard" type of va_list is va_list_type_node. */
4531 std_canonical_va_list_type (tree type)
4535 if (INDIRECT_REF_P (type))
4536 type = TREE_TYPE (type);
4537 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4538 type = TREE_TYPE (type);
4539 wtype = va_list_type_node;
4541 /* Treat structure va_list types. */
4542 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4543 htype = TREE_TYPE (htype);
4544 else if (TREE_CODE (wtype) == ARRAY_TYPE)
4546 /* If va_list is an array type, the argument may have decayed
4547 to a pointer type, e.g. by being passed to another function.
4548 In that case, unwrap both types so that we can compare the
4549 underlying records. */
4550 if (TREE_CODE (htype) == ARRAY_TYPE
4551 || POINTER_TYPE_P (htype))
4553 wtype = TREE_TYPE (wtype);
4554 htype = TREE_TYPE (htype);
4557 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4558 return va_list_type_node;
4563 /* The "standard" implementation of va_start: just assign `nextarg' to
4567 std_expand_builtin_va_start (tree valist, rtx nextarg)
4569 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4570 convert_move (va_r, nextarg, 0);
4573 /* Expand EXP, a call to __builtin_va_start. */
4576 expand_builtin_va_start (tree exp)
4580 location_t loc = EXPR_LOCATION (exp);
4582 if (call_expr_nargs (exp) < 2)
4584 error_at (loc, "too few arguments to function %<va_start%>");
4588 if (fold_builtin_next_arg (exp, true))
4591 nextarg = expand_builtin_next_arg ();
4592 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4594 if (targetm.expand_builtin_va_start)
4595 targetm.expand_builtin_va_start (valist, nextarg);
4597 std_expand_builtin_va_start (valist, nextarg);
4602 /* The "standard" implementation of va_arg: read the value from the
4603 current (padded) address and increment by the (padded) size. */
4606 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4609 tree addr, t, type_size, rounded_size, valist_tmp;
4610 unsigned HOST_WIDE_INT align, boundary;
4613 #ifdef ARGS_GROW_DOWNWARD
4614 /* All of the alignment and movement below is for args-grow-up machines.
4615 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4616 implement their own specialized gimplify_va_arg_expr routines. */
4620 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4622 type = build_pointer_type (type);
4624 align = PARM_BOUNDARY / BITS_PER_UNIT;
4625 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4627 /* When we align parameter on stack for caller, if the parameter
4628 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4629 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
4630 here with caller. */
4631 if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4632 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4634 boundary /= BITS_PER_UNIT;
4636 /* Hoist the valist value into a temporary for the moment. */
4637 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4639 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4640 requires greater alignment, we must perform dynamic alignment. */
4641 if (boundary > align
4642 && !integer_zerop (TYPE_SIZE (type)))
4644 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4645 fold_build2 (POINTER_PLUS_EXPR,
4647 valist_tmp, size_int (boundary - 1)));
4648 gimplify_and_add (t, pre_p);
4650 t = fold_convert (sizetype, valist_tmp);
4651 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4652 fold_convert (TREE_TYPE (valist),
4653 fold_build2 (BIT_AND_EXPR, sizetype, t,
4654 size_int (-boundary))));
4655 gimplify_and_add (t, pre_p);
4660 /* If the actual alignment is less than the alignment of the type,
4661 adjust the type accordingly so that we don't assume strict alignment
4662 when dereferencing the pointer. */
4663 boundary *= BITS_PER_UNIT;
4664 if (boundary < TYPE_ALIGN (type))
4666 type = build_variant_type_copy (type);
4667 TYPE_ALIGN (type) = boundary;
4670 /* Compute the rounded size of the type. */
4671 type_size = size_in_bytes (type);
4672 rounded_size = round_up (type_size, align);
4674 /* Reduce rounded_size so it's sharable with the postqueue. */
4675 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4679 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4681 /* Small args are padded downward. */
4682 t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4683 rounded_size, size_int (align));
4684 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4685 size_binop (MINUS_EXPR, rounded_size, type_size));
4686 addr = fold_build2 (POINTER_PLUS_EXPR,
4687 TREE_TYPE (addr), addr, t);
4690 /* Compute new value for AP. */
4691 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4692 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4693 gimplify_and_add (t, pre_p);
4695 addr = fold_convert (build_pointer_type (type), addr);
4698 addr = build_va_arg_indirect_ref (addr);
4700 return build_va_arg_indirect_ref (addr);
4703 /* Build an indirect-ref expression over the given TREE, which represents a
4704 piece of a va_arg() expansion. */
4706 build_va_arg_indirect_ref (tree addr)
4708 addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4710 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4716 /* Return a dummy expression of type TYPE in order to keep going after an
4720 dummy_object (tree type)
4722 tree t = build_int_cst (build_pointer_type (type), 0);
4723 return build2 (MEM_REF, type, t, t);
4726 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4727 builtin function, but a very special sort of operator. */
4729 enum gimplify_status
4730 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4732 tree promoted_type, have_va_type;
4733 tree valist = TREE_OPERAND (*expr_p, 0);
4734 tree type = TREE_TYPE (*expr_p);
4736 location_t loc = EXPR_LOCATION (*expr_p);
4738 /* Verify that valist is of the proper type. */
4739 have_va_type = TREE_TYPE (valist);
4740 if (have_va_type == error_mark_node)
4742 have_va_type = targetm.canonical_va_list_type (have_va_type);
4744 if (have_va_type == NULL_TREE)
4746 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4750 /* Generate a diagnostic for requesting data of a type that cannot
4751 be passed through `...' due to type promotion at the call site. */
4752 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4755 static bool gave_help;
4758 /* Unfortunately, this is merely undefined, rather than a constraint
4759 violation, so we cannot make this an error. If this call is never
4760 executed, the program is still strictly conforming. */
4761 warned = warning_at (loc, 0,
4762 "%qT is promoted to %qT when passed through %<...%>",
4763 type, promoted_type);
4764 if (!gave_help && warned)
4767 inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4768 promoted_type, type);
4771 /* We can, however, treat "undefined" any way we please.
4772 Call abort to encourage the user to fix the program. */
4774 inform (loc, "if this code is reached, the program will abort");
4775 /* Before the abort, allow the evaluation of the va_list
4776 expression to exit or longjmp. */
4777 gimplify_and_add (valist, pre_p);
4778 t = build_call_expr_loc (loc,
4779 implicit_built_in_decls[BUILT_IN_TRAP], 0);
4780 gimplify_and_add (t, pre_p);
4782 /* This is dead code, but go ahead and finish so that the
4783 mode of the result comes out right. */
4784 *expr_p = dummy_object (type);
4789 /* Make it easier for the backends by protecting the valist argument
4790 from multiple evaluations. */
4791 if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4793 /* For this case, the backends will be expecting a pointer to
4794 TREE_TYPE (abi), but it's possible we've
4795 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4797 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4799 tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4800 valist = fold_convert_loc (loc, p1,
4801 build_fold_addr_expr_loc (loc, valist));
4804 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4807 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4809 if (!targetm.gimplify_va_arg_expr)
4810 /* FIXME: Once most targets are converted we should merely
4811 assert this is non-null. */
4814 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4819 /* Expand EXP, a call to __builtin_va_end. */
4822 expand_builtin_va_end (tree exp)
4824 tree valist = CALL_EXPR_ARG (exp, 0);
4826 /* Evaluate for side effects, if needed. I hate macros that don't
4828 if (TREE_SIDE_EFFECTS (valist))
4829 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4834 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4835 builtin rather than just as an assignment in stdarg.h because of the
4836 nastiness of array-type va_list types. */
4839 expand_builtin_va_copy (tree exp)
4842 location_t loc = EXPR_LOCATION (exp);
4844 dst = CALL_EXPR_ARG (exp, 0);
4845 src = CALL_EXPR_ARG (exp, 1);
4847 dst = stabilize_va_list_loc (loc, dst, 1);
4848 src = stabilize_va_list_loc (loc, src, 0);
4850 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4852 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4854 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4855 TREE_SIDE_EFFECTS (t) = 1;
4856 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4860 rtx dstb, srcb, size;
4862 /* Evaluate to pointers. */
4863 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4864 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4865 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4866 NULL_RTX, VOIDmode, EXPAND_NORMAL);
4868 dstb = convert_memory_address (Pmode, dstb);
4869 srcb = convert_memory_address (Pmode, srcb);
4871 /* "Dereference" to BLKmode memories. */
4872 dstb = gen_rtx_MEM (BLKmode, dstb);
4873 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4874 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4875 srcb = gen_rtx_MEM (BLKmode, srcb);
4876 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4877 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4880 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4886 /* Expand a call to one of the builtin functions __builtin_frame_address or
4887 __builtin_return_address. */
4890 expand_builtin_frame_address (tree fndecl, tree exp)
4892 /* The argument must be a nonnegative integer constant.
4893 It counts the number of frames to scan up the stack.
4894 The value is the return address saved in that frame. */
4895 if (call_expr_nargs (exp) == 0)
4896 /* Warning about missing arg was already issued. */
4898 else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4900 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4901 error ("invalid argument to %<__builtin_frame_address%>");
4903 error ("invalid argument to %<__builtin_return_address%>");
4909 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4910 tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4912 /* Some ports cannot access arbitrary stack frames. */
4915 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4916 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4918 warning (0, "unsupported argument to %<__builtin_return_address%>");
4922 /* For __builtin_frame_address, return what we've got. */
4923 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4927 && ! CONSTANT_P (tem))
4928 tem = copy_to_mode_reg (Pmode, tem);
4933 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4934 failed and the caller should emit a normal call, otherwise try to
4935 get the result in TARGET, if convenient. CANNOT_ACCUMULATE is the
4936 same as for allocate_dynamic_stack_space. */
4939 expand_builtin_alloca (tree exp, rtx target, bool cannot_accumulate)
4944 /* Emit normal call if marked not-inlineable. */
4945 if (CALL_CANNOT_INLINE_P (exp))
4948 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4951 /* Compute the argument. */
4952 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4954 /* Allocate the desired space. */
4955 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT,
4957 result = convert_memory_address (ptr_mode, result);
4962 /* Expand a call to a bswap builtin with argument ARG0. MODE
4963 is the mode to expand with. */
4966 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4968 enum machine_mode mode;
4972 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4975 arg = CALL_EXPR_ARG (exp, 0);
4976 mode = TYPE_MODE (TREE_TYPE (arg));
4977 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4979 target = expand_unop (mode, bswap_optab, op0, target, 1);
4981 gcc_assert (target);
4983 return convert_to_mode (mode, target, 0);
4986 /* Expand a call to a unary builtin in EXP.
4987 Return NULL_RTX if a normal call should be emitted rather than expanding the
4988 function in-line. If convenient, the result should be placed in TARGET.
4989 SUBTARGET may be used as the target for computing one of EXP's operands. */
4992 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4993 rtx subtarget, optab op_optab)
4997 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5000 /* Compute the argument. */
5001 op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
5003 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
5004 == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
5005 VOIDmode, EXPAND_NORMAL);
5006 /* Compute op, into TARGET if possible.
5007 Set TARGET to wherever the result comes back. */
5008 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5009 op_optab, op0, target, 1);
5010 gcc_assert (target);
5012 return convert_to_mode (target_mode, target, 0);
5015 /* Expand a call to __builtin_expect. We just return our argument
5016 as the builtin_expect semantic should've been already executed by
5017 tree branch prediction pass. */
5020 expand_builtin_expect (tree exp, rtx target)
5024 if (call_expr_nargs (exp) < 2)
5026 arg = CALL_EXPR_ARG (exp, 0);
5028 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5029 /* When guessing was done, the hints should be already stripped away. */
5030 gcc_assert (!flag_guess_branch_prob
5031 || optimize == 0 || seen_error ());
5036 expand_builtin_trap (void)
5040 emit_insn (gen_trap ());
5043 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5047 /* Expand a call to __builtin_unreachable. We do nothing except emit
5048 a barrier saying that control flow will not pass here.
5050 It is the responsibility of the program being compiled to ensure
5051 that control flow does never reach __builtin_unreachable. */
5053 expand_builtin_unreachable (void)
5058 /* Expand EXP, a call to fabs, fabsf or fabsl.
5059 Return NULL_RTX if a normal call should be emitted rather than expanding
5060 the function inline. If convenient, the result should be placed
5061 in TARGET. SUBTARGET may be used as the target for computing
5065 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5067 enum machine_mode mode;
5071 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5074 arg = CALL_EXPR_ARG (exp, 0);
5075 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5076 mode = TYPE_MODE (TREE_TYPE (arg));
5077 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5078 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5081 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5082 Return NULL is a normal call should be emitted rather than expanding the
5083 function inline. If convenient, the result should be placed in TARGET.
5084 SUBTARGET may be used as the target for computing the operand. */
5087 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5092 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5095 arg = CALL_EXPR_ARG (exp, 0);
5096 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5098 arg = CALL_EXPR_ARG (exp, 1);
5099 op1 = expand_normal (arg);
5101 return expand_copysign (op0, op1, target);
5104 /* Create a new constant string literal and return a char* pointer to it.
5105 The STRING_CST value is the LEN characters at STR. */
5107 build_string_literal (int len, const char *str)
5109 tree t, elem, index, type;
5111 t = build_string (len, str);
5112 elem = build_type_variant (char_type_node, 1, 0);
5113 index = build_index_type (size_int (len - 1));
5114 type = build_array_type (elem, index);
5115 TREE_TYPE (t) = type;
5116 TREE_CONSTANT (t) = 1;
5117 TREE_READONLY (t) = 1;
5118 TREE_STATIC (t) = 1;
5120 type = build_pointer_type (elem);
5121 t = build1 (ADDR_EXPR, type,
5122 build4 (ARRAY_REF, elem,
5123 t, integer_zero_node, NULL_TREE, NULL_TREE));
5127 /* Expand a call to either the entry or exit function profiler. */
5130 expand_builtin_profile_func (bool exitp)
5132 rtx this_rtx, which;
5134 this_rtx = DECL_RTL (current_function_decl);
5135 gcc_assert (MEM_P (this_rtx));
5136 this_rtx = XEXP (this_rtx, 0);
5139 which = profile_function_exit_libfunc;
5141 which = profile_function_entry_libfunc;
5143 emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5144 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5151 /* Expand a call to __builtin___clear_cache. */
5154 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5156 #ifndef HAVE_clear_cache
5157 #ifdef CLEAR_INSN_CACHE
5158 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5159 does something. Just do the default expansion to a call to
5163 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5164 does nothing. There is no need to call it. Do nothing. */
5166 #endif /* CLEAR_INSN_CACHE */
5168 /* We have a "clear_cache" insn, and it will handle everything. */
5170 rtx begin_rtx, end_rtx;
5171 enum insn_code icode;
5173 /* We must not expand to a library call. If we did, any
5174 fallback library function in libgcc that might contain a call to
5175 __builtin___clear_cache() would recurse infinitely. */
5176 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5178 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5182 if (HAVE_clear_cache)
5184 icode = CODE_FOR_clear_cache;
5186 begin = CALL_EXPR_ARG (exp, 0);
5187 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5188 begin_rtx = convert_memory_address (Pmode, begin_rtx);
5189 if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5190 begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5192 end = CALL_EXPR_ARG (exp, 1);
5193 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5194 end_rtx = convert_memory_address (Pmode, end_rtx);
5195 if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5196 end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5198 emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5201 #endif /* HAVE_clear_cache */
5204 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5207 round_trampoline_addr (rtx tramp)
5209 rtx temp, addend, mask;
5211 /* If we don't need too much alignment, we'll have been guaranteed
5212 proper alignment by get_trampoline_type. */
5213 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5216 /* Round address up to desired boundary. */
5217 temp = gen_reg_rtx (Pmode);
5218 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5219 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5221 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
5222 temp, 0, OPTAB_LIB_WIDEN);
5223 tramp = expand_simple_binop (Pmode, AND, temp, mask,
5224 temp, 0, OPTAB_LIB_WIDEN);
5230 expand_builtin_init_trampoline (tree exp)
5232 tree t_tramp, t_func, t_chain;
5233 rtx m_tramp, r_tramp, r_chain, tmp;
5235 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5236 POINTER_TYPE, VOID_TYPE))
5239 t_tramp = CALL_EXPR_ARG (exp, 0);
5240 t_func = CALL_EXPR_ARG (exp, 1);
5241 t_chain = CALL_EXPR_ARG (exp, 2);
5243 r_tramp = expand_normal (t_tramp);
5244 m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5245 MEM_NOTRAP_P (m_tramp) = 1;
5247 /* The TRAMP argument should be the address of a field within the
5248 local function's FRAME decl. Let's see if we can fill in the
5249 to fill in the MEM_ATTRs for this memory. */
5250 if (TREE_CODE (t_tramp) == ADDR_EXPR)
5251 set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5254 tmp = round_trampoline_addr (r_tramp);
5257 m_tramp = change_address (m_tramp, BLKmode, tmp);
5258 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5259 set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5262 /* The FUNC argument should be the address of the nested function.
5263 Extract the actual function decl to pass to the hook. */
5264 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5265 t_func = TREE_OPERAND (t_func, 0);
5266 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5268 r_chain = expand_normal (t_chain);
5270 /* Generate insns to initialize the trampoline. */
5271 targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5273 trampolines_created = 1;
5275 warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5276 "trampoline generated for nested function %qD", t_func);
5282 expand_builtin_adjust_trampoline (tree exp)
5286 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5289 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5290 tramp = round_trampoline_addr (tramp);
5291 if (targetm.calls.trampoline_adjust_address)
5292 tramp = targetm.calls.trampoline_adjust_address (tramp);
5297 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5298 function. The function first checks whether the back end provides
5299 an insn to implement signbit for the respective mode. If not, it
5300 checks whether the floating point format of the value is such that
5301 the sign bit can be extracted. If that is not the case, the
5302 function returns NULL_RTX to indicate that a normal call should be
5303 emitted rather than expanding the function in-line. EXP is the
5304 expression that is a call to the builtin function; if convenient,
5305 the result should be placed in TARGET. */
5307 expand_builtin_signbit (tree exp, rtx target)
5309 const struct real_format *fmt;
5310 enum machine_mode fmode, imode, rmode;
5313 enum insn_code icode;
5315 location_t loc = EXPR_LOCATION (exp);
5317 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5320 arg = CALL_EXPR_ARG (exp, 0);
5321 fmode = TYPE_MODE (TREE_TYPE (arg));
5322 rmode = TYPE_MODE (TREE_TYPE (exp));
5323 fmt = REAL_MODE_FORMAT (fmode);
5325 arg = builtin_save_expr (arg);
5327 /* Expand the argument yielding a RTX expression. */
5328 temp = expand_normal (arg);
5330 /* Check if the back end provides an insn that handles signbit for the
5332 icode = optab_handler (signbit_optab, fmode);
5333 if (icode != CODE_FOR_nothing)
5335 rtx last = get_last_insn ();
5336 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5337 if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5339 delete_insns_since (last);
5342 /* For floating point formats without a sign bit, implement signbit
5344 bitpos = fmt->signbit_ro;
5347 /* But we can't do this if the format supports signed zero. */
5348 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5351 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5352 build_real (TREE_TYPE (arg), dconst0));
5353 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5356 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5358 imode = int_mode_for_mode (fmode);
5359 if (imode == BLKmode)
5361 temp = gen_lowpart (imode, temp);
5366 /* Handle targets with different FP word orders. */
5367 if (FLOAT_WORDS_BIG_ENDIAN)
5368 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5370 word = bitpos / BITS_PER_WORD;
5371 temp = operand_subword_force (temp, word, fmode);
5372 bitpos = bitpos % BITS_PER_WORD;
5375 /* Force the intermediate word_mode (or narrower) result into a
5376 register. This avoids attempting to create paradoxical SUBREGs
5377 of floating point modes below. */
5378 temp = force_reg (imode, temp);
5380 /* If the bitpos is within the "result mode" lowpart, the operation
5381 can be implement with a single bitwise AND. Otherwise, we need
5382 a right shift and an AND. */
5384 if (bitpos < GET_MODE_BITSIZE (rmode))
5386 double_int mask = double_int_setbit (double_int_zero, bitpos);
5388 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5389 temp = gen_lowpart (rmode, temp);
5390 temp = expand_binop (rmode, and_optab, temp,
5391 immed_double_int_const (mask, rmode),
5392 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5396 /* Perform a logical right shift to place the signbit in the least
5397 significant bit, then truncate the result to the desired mode
5398 and mask just this bit. */
5399 temp = expand_shift (RSHIFT_EXPR, imode, temp,
5400 build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5401 temp = gen_lowpart (rmode, temp);
5402 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5403 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5409 /* Expand fork or exec calls. TARGET is the desired target of the
5410 call. EXP is the call. FN is the
5411 identificator of the actual function. IGNORE is nonzero if the
5412 value is to be ignored. */
5415 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5420 /* If we are not profiling, just call the function. */
5421 if (!profile_arc_flag)
5424 /* Otherwise call the wrapper. This should be equivalent for the rest of
5425 compiler, so the code does not diverge, and the wrapper may run the
5426 code necessary for keeping the profiling sane. */
5428 switch (DECL_FUNCTION_CODE (fn))
5431 id = get_identifier ("__gcov_fork");
5434 case BUILT_IN_EXECL:
5435 id = get_identifier ("__gcov_execl");
5438 case BUILT_IN_EXECV:
5439 id = get_identifier ("__gcov_execv");
5442 case BUILT_IN_EXECLP:
5443 id = get_identifier ("__gcov_execlp");
5446 case BUILT_IN_EXECLE:
5447 id = get_identifier ("__gcov_execle");
5450 case BUILT_IN_EXECVP:
5451 id = get_identifier ("__gcov_execvp");
5454 case BUILT_IN_EXECVE:
5455 id = get_identifier ("__gcov_execve");
5462 decl = build_decl (DECL_SOURCE_LOCATION (fn),
5463 FUNCTION_DECL, id, TREE_TYPE (fn));
5464 DECL_EXTERNAL (decl) = 1;
5465 TREE_PUBLIC (decl) = 1;
5466 DECL_ARTIFICIAL (decl) = 1;
5467 TREE_NOTHROW (decl) = 1;
5468 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5469 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5470 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5471 return expand_call (call, target, ignore);
5476 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5477 the pointer in these functions is void*, the tree optimizers may remove
5478 casts. The mode computed in expand_builtin isn't reliable either, due
5479 to __sync_bool_compare_and_swap.
5481 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5482 group of builtins. This gives us log2 of the mode size. */
5484 static inline enum machine_mode
5485 get_builtin_sync_mode (int fcode_diff)
5487 /* The size is not negotiable, so ask not to get BLKmode in return
5488 if the target indicates that a smaller size would be better. */
5489 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5492 /* Expand the memory expression LOC and return the appropriate memory operand
5493 for the builtin_sync operations. */
5496 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5500 addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5501 addr = convert_memory_address (Pmode, addr);
5503 /* Note that we explicitly do not want any alias information for this
5504 memory, so that we kill all other live memories. Otherwise we don't
5505 satisfy the full barrier semantics of the intrinsic. */
5506 mem = validize_mem (gen_rtx_MEM (mode, addr));
5508 /* The alignment needs to be at least according to that of the mode. */
5509 set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5510 get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5511 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5512 MEM_VOLATILE_P (mem) = 1;
5517 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5518 EXP is the CALL_EXPR. CODE is the rtx code
5519 that corresponds to the arithmetic or logical operation from the name;
5520 an exception here is that NOT actually means NAND. TARGET is an optional
5521 place for us to store the results; AFTER is true if this is the
5522 fetch_and_xxx form. IGNORE is true if we don't actually care about
5523 the result of the operation at all. */
5526 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5527 enum rtx_code code, bool after,
5528 rtx target, bool ignore)
5531 enum machine_mode old_mode;
5532 location_t loc = EXPR_LOCATION (exp);
5534 if (code == NOT && warn_sync_nand)
5536 tree fndecl = get_callee_fndecl (exp);
5537 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5539 static bool warned_f_a_n, warned_n_a_f;
5543 case BUILT_IN_FETCH_AND_NAND_1:
5544 case BUILT_IN_FETCH_AND_NAND_2:
5545 case BUILT_IN_FETCH_AND_NAND_4:
5546 case BUILT_IN_FETCH_AND_NAND_8:
5547 case BUILT_IN_FETCH_AND_NAND_16:
5552 fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5553 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5554 warned_f_a_n = true;
5557 case BUILT_IN_NAND_AND_FETCH_1:
5558 case BUILT_IN_NAND_AND_FETCH_2:
5559 case BUILT_IN_NAND_AND_FETCH_4:
5560 case BUILT_IN_NAND_AND_FETCH_8:
5561 case BUILT_IN_NAND_AND_FETCH_16:
5566 fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5567 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5568 warned_n_a_f = true;
5576 /* Expand the operands. */
5577 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5579 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5580 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5581 of CONST_INTs, where we know the old_mode only from the call argument. */
5582 old_mode = GET_MODE (val);
5583 if (old_mode == VOIDmode)
5584 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5585 val = convert_modes (mode, old_mode, val, 1);
5588 return expand_sync_operation (mem, val, code);
5590 return expand_sync_fetch_operation (mem, val, code, after, target);
5593 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5594 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5595 true if this is the boolean form. TARGET is a place for us to store the
5596 results; this is NOT optional if IS_BOOL is true. */
5599 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5600 bool is_bool, rtx target)
5602 rtx old_val, new_val, mem;
5603 enum machine_mode old_mode;
5605 /* Expand the operands. */
5606 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5609 old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5610 mode, EXPAND_NORMAL);
5611 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5612 of CONST_INTs, where we know the old_mode only from the call argument. */
5613 old_mode = GET_MODE (old_val);
5614 if (old_mode == VOIDmode)
5615 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5616 old_val = convert_modes (mode, old_mode, old_val, 1);
5618 new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5619 mode, EXPAND_NORMAL);
5620 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5621 of CONST_INTs, where we know the old_mode only from the call argument. */
5622 old_mode = GET_MODE (new_val);
5623 if (old_mode == VOIDmode)
5624 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5625 new_val = convert_modes (mode, old_mode, new_val, 1);
5628 return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5630 return expand_val_compare_and_swap (mem, old_val, new_val, target);
5633 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5634 general form is actually an atomic exchange, and some targets only
5635 support a reduced form with the second argument being a constant 1.
5636 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5640 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5644 enum machine_mode old_mode;
5646 /* Expand the operands. */
5647 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5648 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5649 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5650 of CONST_INTs, where we know the old_mode only from the call argument. */
5651 old_mode = GET_MODE (val);
5652 if (old_mode == VOIDmode)
5653 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5654 val = convert_modes (mode, old_mode, val, 1);
5656 return expand_sync_lock_test_and_set (mem, val, target);
5659 /* Expand the __sync_synchronize intrinsic. */
5662 expand_builtin_synchronize (void)
5665 VEC (tree, gc) *v_clobbers;
5667 #ifdef HAVE_memory_barrier
5668 if (HAVE_memory_barrier)
5670 emit_insn (gen_memory_barrier ());
5675 if (synchronize_libfunc != NULL_RTX)
5677 emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5681 /* If no explicit memory barrier instruction is available, create an
5682 empty asm stmt with a memory clobber. */
5683 v_clobbers = VEC_alloc (tree, gc, 1);
5684 VEC_quick_push (tree, v_clobbers,
5685 tree_cons (NULL, build_string (6, "memory"), NULL));
5686 x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5687 gimple_asm_set_volatile (x, true);
5688 expand_asm_stmt (x);
5691 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5694 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5696 enum insn_code icode;
5698 rtx val = const0_rtx;
5700 /* Expand the operands. */
5701 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5703 /* If there is an explicit operation in the md file, use it. */
5704 icode = direct_optab_handler (sync_lock_release_optab, mode);
5705 if (icode != CODE_FOR_nothing)
5707 if (!insn_data[icode].operand[1].predicate (val, mode))
5708 val = force_reg (mode, val);
5710 insn = GEN_FCN (icode) (mem, val);
5718 /* Otherwise we can implement this operation by emitting a barrier
5719 followed by a store of zero. */
5720 expand_builtin_synchronize ();
5721 emit_move_insn (mem, val);
5724 /* Expand an expression EXP that calls a built-in function,
5725 with result going to TARGET if that's convenient
5726 (and in mode MODE if that's convenient).
5727 SUBTARGET may be used as the target for computing one of EXP's operands.
5728 IGNORE is nonzero if the value is to be ignored. */
5731 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5734 tree fndecl = get_callee_fndecl (exp);
5735 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5736 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5739 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5740 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5742 /* When not optimizing, generate calls to library functions for a certain
5745 && !called_as_built_in (fndecl)
5746 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5747 && fcode != BUILT_IN_ALLOCA
5748 && fcode != BUILT_IN_FREE)
5749 return expand_call (exp, target, ignore);
5751 /* The built-in function expanders test for target == const0_rtx
5752 to determine whether the function's result will be ignored. */
5754 target = const0_rtx;
5756 /* If the result of a pure or const built-in function is ignored, and
5757 none of its arguments are volatile, we can avoid expanding the
5758 built-in call and just evaluate the arguments for side-effects. */
5759 if (target == const0_rtx
5760 && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5761 && !(flags & ECF_LOOPING_CONST_OR_PURE))
5763 bool volatilep = false;
5765 call_expr_arg_iterator iter;
5767 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5768 if (TREE_THIS_VOLATILE (arg))
5776 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5777 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5784 CASE_FLT_FN (BUILT_IN_FABS):
5785 target = expand_builtin_fabs (exp, target, subtarget);
5790 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5791 target = expand_builtin_copysign (exp, target, subtarget);
5796 /* Just do a normal library call if we were unable to fold
5798 CASE_FLT_FN (BUILT_IN_CABS):
5801 CASE_FLT_FN (BUILT_IN_EXP):
5802 CASE_FLT_FN (BUILT_IN_EXP10):
5803 CASE_FLT_FN (BUILT_IN_POW10):
5804 CASE_FLT_FN (BUILT_IN_EXP2):
5805 CASE_FLT_FN (BUILT_IN_EXPM1):
5806 CASE_FLT_FN (BUILT_IN_LOGB):
5807 CASE_FLT_FN (BUILT_IN_LOG):
5808 CASE_FLT_FN (BUILT_IN_LOG10):
5809 CASE_FLT_FN (BUILT_IN_LOG2):
5810 CASE_FLT_FN (BUILT_IN_LOG1P):
5811 CASE_FLT_FN (BUILT_IN_TAN):
5812 CASE_FLT_FN (BUILT_IN_ASIN):
5813 CASE_FLT_FN (BUILT_IN_ACOS):
5814 CASE_FLT_FN (BUILT_IN_ATAN):
5815 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5816 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5817 because of possible accuracy problems. */
5818 if (! flag_unsafe_math_optimizations)
5820 CASE_FLT_FN (BUILT_IN_SQRT):
5821 CASE_FLT_FN (BUILT_IN_FLOOR):
5822 CASE_FLT_FN (BUILT_IN_CEIL):
5823 CASE_FLT_FN (BUILT_IN_TRUNC):
5824 CASE_FLT_FN (BUILT_IN_ROUND):
5825 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5826 CASE_FLT_FN (BUILT_IN_RINT):
5827 target = expand_builtin_mathfn (exp, target, subtarget);
5832 CASE_FLT_FN (BUILT_IN_ILOGB):
5833 if (! flag_unsafe_math_optimizations)
5835 CASE_FLT_FN (BUILT_IN_ISINF):
5836 CASE_FLT_FN (BUILT_IN_FINITE):
5837 case BUILT_IN_ISFINITE:
5838 case BUILT_IN_ISNORMAL:
5839 target = expand_builtin_interclass_mathfn (exp, target);
5844 CASE_FLT_FN (BUILT_IN_LCEIL):
5845 CASE_FLT_FN (BUILT_IN_LLCEIL):
5846 CASE_FLT_FN (BUILT_IN_LFLOOR):
5847 CASE_FLT_FN (BUILT_IN_LLFLOOR):
5848 target = expand_builtin_int_roundingfn (exp, target);
5853 CASE_FLT_FN (BUILT_IN_LRINT):
5854 CASE_FLT_FN (BUILT_IN_LLRINT):
5855 CASE_FLT_FN (BUILT_IN_LROUND):
5856 CASE_FLT_FN (BUILT_IN_LLROUND):
5857 target = expand_builtin_int_roundingfn_2 (exp, target);
5862 CASE_FLT_FN (BUILT_IN_POW):
5863 target = expand_builtin_pow (exp, target, subtarget);
5868 CASE_FLT_FN (BUILT_IN_POWI):
5869 target = expand_builtin_powi (exp, target);
5874 CASE_FLT_FN (BUILT_IN_ATAN2):
5875 CASE_FLT_FN (BUILT_IN_LDEXP):
5876 CASE_FLT_FN (BUILT_IN_SCALB):
5877 CASE_FLT_FN (BUILT_IN_SCALBN):
5878 CASE_FLT_FN (BUILT_IN_SCALBLN):
5879 if (! flag_unsafe_math_optimizations)
5882 CASE_FLT_FN (BUILT_IN_FMOD):
5883 CASE_FLT_FN (BUILT_IN_REMAINDER):
5884 CASE_FLT_FN (BUILT_IN_DREM):
5885 target = expand_builtin_mathfn_2 (exp, target, subtarget);
5890 CASE_FLT_FN (BUILT_IN_CEXPI):
5891 target = expand_builtin_cexpi (exp, target);
5892 gcc_assert (target);
5895 CASE_FLT_FN (BUILT_IN_SIN):
5896 CASE_FLT_FN (BUILT_IN_COS):
5897 if (! flag_unsafe_math_optimizations)
5899 target = expand_builtin_mathfn_3 (exp, target, subtarget);
5904 CASE_FLT_FN (BUILT_IN_SINCOS):
5905 if (! flag_unsafe_math_optimizations)
5907 target = expand_builtin_sincos (exp);
5912 case BUILT_IN_APPLY_ARGS:
5913 return expand_builtin_apply_args ();
5915 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5916 FUNCTION with a copy of the parameters described by
5917 ARGUMENTS, and ARGSIZE. It returns a block of memory
5918 allocated on the stack into which is stored all the registers
5919 that might possibly be used for returning the result of a
5920 function. ARGUMENTS is the value returned by
5921 __builtin_apply_args. ARGSIZE is the number of bytes of
5922 arguments that must be copied. ??? How should this value be
5923 computed? We'll also need a safe worst case value for varargs
5925 case BUILT_IN_APPLY:
5926 if (!validate_arglist (exp, POINTER_TYPE,
5927 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5928 && !validate_arglist (exp, REFERENCE_TYPE,
5929 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5935 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5936 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5937 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5939 return expand_builtin_apply (ops[0], ops[1], ops[2]);
5942 /* __builtin_return (RESULT) causes the function to return the
5943 value described by RESULT. RESULT is address of the block of
5944 memory returned by __builtin_apply. */
5945 case BUILT_IN_RETURN:
5946 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5947 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5950 case BUILT_IN_SAVEREGS:
5951 return expand_builtin_saveregs ();
5953 case BUILT_IN_VA_ARG_PACK:
5954 /* All valid uses of __builtin_va_arg_pack () are removed during
5956 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5959 case BUILT_IN_VA_ARG_PACK_LEN:
5960 /* All valid uses of __builtin_va_arg_pack_len () are removed during
5962 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5965 /* Return the address of the first anonymous stack arg. */
5966 case BUILT_IN_NEXT_ARG:
5967 if (fold_builtin_next_arg (exp, false))
5969 return expand_builtin_next_arg ();
5971 case BUILT_IN_CLEAR_CACHE:
5972 target = expand_builtin___clear_cache (exp);
5977 case BUILT_IN_CLASSIFY_TYPE:
5978 return expand_builtin_classify_type (exp);
5980 case BUILT_IN_CONSTANT_P:
5983 case BUILT_IN_FRAME_ADDRESS:
5984 case BUILT_IN_RETURN_ADDRESS:
5985 return expand_builtin_frame_address (fndecl, exp);
5987 /* Returns the address of the area where the structure is returned.
5989 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5990 if (call_expr_nargs (exp) != 0
5991 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5992 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5995 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5997 case BUILT_IN_ALLOCA:
5998 /* If the allocation stems from the declaration of a variable-sized
5999 object, it cannot accumulate. */
6000 target = expand_builtin_alloca (exp, target, ALLOCA_FOR_VAR_P (exp));
6005 case BUILT_IN_STACK_SAVE:
6006 return expand_stack_save ();
6008 case BUILT_IN_STACK_RESTORE:
6009 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6012 case BUILT_IN_BSWAP32:
6013 case BUILT_IN_BSWAP64:
6014 target = expand_builtin_bswap (exp, target, subtarget);
6020 CASE_INT_FN (BUILT_IN_FFS):
6021 case BUILT_IN_FFSIMAX:
6022 target = expand_builtin_unop (target_mode, exp, target,
6023 subtarget, ffs_optab);
6028 CASE_INT_FN (BUILT_IN_CLZ):
6029 case BUILT_IN_CLZIMAX:
6030 target = expand_builtin_unop (target_mode, exp, target,
6031 subtarget, clz_optab);
6036 CASE_INT_FN (BUILT_IN_CTZ):
6037 case BUILT_IN_CTZIMAX:
6038 target = expand_builtin_unop (target_mode, exp, target,
6039 subtarget, ctz_optab);
6044 CASE_INT_FN (BUILT_IN_POPCOUNT):
6045 case BUILT_IN_POPCOUNTIMAX:
6046 target = expand_builtin_unop (target_mode, exp, target,
6047 subtarget, popcount_optab);
6052 CASE_INT_FN (BUILT_IN_PARITY):
6053 case BUILT_IN_PARITYIMAX:
6054 target = expand_builtin_unop (target_mode, exp, target,
6055 subtarget, parity_optab);
6060 case BUILT_IN_STRLEN:
6061 target = expand_builtin_strlen (exp, target, target_mode);
6066 case BUILT_IN_STRCPY:
6067 target = expand_builtin_strcpy (exp, target);
6072 case BUILT_IN_STRNCPY:
6073 target = expand_builtin_strncpy (exp, target);
6078 case BUILT_IN_STPCPY:
6079 target = expand_builtin_stpcpy (exp, target, mode);
6084 case BUILT_IN_MEMCPY:
6085 target = expand_builtin_memcpy (exp, target);
6090 case BUILT_IN_MEMPCPY:
6091 target = expand_builtin_mempcpy (exp, target, mode);
6096 case BUILT_IN_MEMSET:
6097 target = expand_builtin_memset (exp, target, mode);
6102 case BUILT_IN_BZERO:
6103 target = expand_builtin_bzero (exp);
6108 case BUILT_IN_STRCMP:
6109 target = expand_builtin_strcmp (exp, target);
6114 case BUILT_IN_STRNCMP:
6115 target = expand_builtin_strncmp (exp, target, mode);
6121 case BUILT_IN_MEMCMP:
6122 target = expand_builtin_memcmp (exp, target, mode);
6127 case BUILT_IN_SETJMP:
6128 /* This should have been lowered to the builtins below. */
6131 case BUILT_IN_SETJMP_SETUP:
6132 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6133 and the receiver label. */
6134 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6136 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6137 VOIDmode, EXPAND_NORMAL);
6138 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6139 rtx label_r = label_rtx (label);
6141 /* This is copied from the handling of non-local gotos. */
6142 expand_builtin_setjmp_setup (buf_addr, label_r);
6143 nonlocal_goto_handler_labels
6144 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6145 nonlocal_goto_handler_labels);
6146 /* ??? Do not let expand_label treat us as such since we would
6147 not want to be both on the list of non-local labels and on
6148 the list of forced labels. */
6149 FORCED_LABEL (label) = 0;
6154 case BUILT_IN_SETJMP_DISPATCHER:
6155 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6156 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6158 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6159 rtx label_r = label_rtx (label);
6161 /* Remove the dispatcher label from the list of non-local labels
6162 since the receiver labels have been added to it above. */
6163 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6168 case BUILT_IN_SETJMP_RECEIVER:
6169 /* __builtin_setjmp_receiver is passed the receiver label. */
6170 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6172 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6173 rtx label_r = label_rtx (label);
6175 expand_builtin_setjmp_receiver (label_r);
6180 /* __builtin_longjmp is passed a pointer to an array of five words.
6181 It's similar to the C library longjmp function but works with
6182 __builtin_setjmp above. */
6183 case BUILT_IN_LONGJMP:
6184 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6186 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6187 VOIDmode, EXPAND_NORMAL);
6188 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6190 if (value != const1_rtx)
6192 error ("%<__builtin_longjmp%> second argument must be 1");
6196 expand_builtin_longjmp (buf_addr, value);
6201 case BUILT_IN_NONLOCAL_GOTO:
6202 target = expand_builtin_nonlocal_goto (exp);
6207 /* This updates the setjmp buffer that is its argument with the value
6208 of the current stack pointer. */
6209 case BUILT_IN_UPDATE_SETJMP_BUF:
6210 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6213 = expand_normal (CALL_EXPR_ARG (exp, 0));
6215 expand_builtin_update_setjmp_buf (buf_addr);
6221 expand_builtin_trap ();
6224 case BUILT_IN_UNREACHABLE:
6225 expand_builtin_unreachable ();
6228 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6229 case BUILT_IN_SIGNBITD32:
6230 case BUILT_IN_SIGNBITD64:
6231 case BUILT_IN_SIGNBITD128:
6232 target = expand_builtin_signbit (exp, target);
6237 /* Various hooks for the DWARF 2 __throw routine. */
6238 case BUILT_IN_UNWIND_INIT:
6239 expand_builtin_unwind_init ();
6241 case BUILT_IN_DWARF_CFA:
6242 return virtual_cfa_rtx;
6243 #ifdef DWARF2_UNWIND_INFO
6244 case BUILT_IN_DWARF_SP_COLUMN:
6245 return expand_builtin_dwarf_sp_column ();
6246 case BUILT_IN_INIT_DWARF_REG_SIZES:
6247 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6250 case BUILT_IN_FROB_RETURN_ADDR:
6251 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6252 case BUILT_IN_EXTRACT_RETURN_ADDR:
6253 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6254 case BUILT_IN_EH_RETURN:
6255 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6256 CALL_EXPR_ARG (exp, 1));
6258 #ifdef EH_RETURN_DATA_REGNO
6259 case BUILT_IN_EH_RETURN_DATA_REGNO:
6260 return expand_builtin_eh_return_data_regno (exp);
6262 case BUILT_IN_EXTEND_POINTER:
6263 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6264 case BUILT_IN_EH_POINTER:
6265 return expand_builtin_eh_pointer (exp);
6266 case BUILT_IN_EH_FILTER:
6267 return expand_builtin_eh_filter (exp);
6268 case BUILT_IN_EH_COPY_VALUES:
6269 return expand_builtin_eh_copy_values (exp);
6271 case BUILT_IN_VA_START:
6272 return expand_builtin_va_start (exp);
6273 case BUILT_IN_VA_END:
6274 return expand_builtin_va_end (exp);
6275 case BUILT_IN_VA_COPY:
6276 return expand_builtin_va_copy (exp);
6277 case BUILT_IN_EXPECT:
6278 return expand_builtin_expect (exp, target);
6279 case BUILT_IN_PREFETCH:
6280 expand_builtin_prefetch (exp);
6283 case BUILT_IN_PROFILE_FUNC_ENTER:
6284 return expand_builtin_profile_func (false);
6285 case BUILT_IN_PROFILE_FUNC_EXIT:
6286 return expand_builtin_profile_func (true);
6288 case BUILT_IN_INIT_TRAMPOLINE:
6289 return expand_builtin_init_trampoline (exp);
6290 case BUILT_IN_ADJUST_TRAMPOLINE:
6291 return expand_builtin_adjust_trampoline (exp);
6294 case BUILT_IN_EXECL:
6295 case BUILT_IN_EXECV:
6296 case BUILT_IN_EXECLP:
6297 case BUILT_IN_EXECLE:
6298 case BUILT_IN_EXECVP:
6299 case BUILT_IN_EXECVE:
6300 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6305 case BUILT_IN_FETCH_AND_ADD_1:
6306 case BUILT_IN_FETCH_AND_ADD_2:
6307 case BUILT_IN_FETCH_AND_ADD_4:
6308 case BUILT_IN_FETCH_AND_ADD_8:
6309 case BUILT_IN_FETCH_AND_ADD_16:
6310 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6311 target = expand_builtin_sync_operation (mode, exp, PLUS,
6312 false, target, ignore);
6317 case BUILT_IN_FETCH_AND_SUB_1:
6318 case BUILT_IN_FETCH_AND_SUB_2:
6319 case BUILT_IN_FETCH_AND_SUB_4:
6320 case BUILT_IN_FETCH_AND_SUB_8:
6321 case BUILT_IN_FETCH_AND_SUB_16:
6322 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6323 target = expand_builtin_sync_operation (mode, exp, MINUS,
6324 false, target, ignore);
6329 case BUILT_IN_FETCH_AND_OR_1:
6330 case BUILT_IN_FETCH_AND_OR_2:
6331 case BUILT_IN_FETCH_AND_OR_4:
6332 case BUILT_IN_FETCH_AND_OR_8:
6333 case BUILT_IN_FETCH_AND_OR_16:
6334 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6335 target = expand_builtin_sync_operation (mode, exp, IOR,
6336 false, target, ignore);
6341 case BUILT_IN_FETCH_AND_AND_1:
6342 case BUILT_IN_FETCH_AND_AND_2:
6343 case BUILT_IN_FETCH_AND_AND_4:
6344 case BUILT_IN_FETCH_AND_AND_8:
6345 case BUILT_IN_FETCH_AND_AND_16:
6346 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6347 target = expand_builtin_sync_operation (mode, exp, AND,
6348 false, target, ignore);
6353 case BUILT_IN_FETCH_AND_XOR_1:
6354 case BUILT_IN_FETCH_AND_XOR_2:
6355 case BUILT_IN_FETCH_AND_XOR_4:
6356 case BUILT_IN_FETCH_AND_XOR_8:
6357 case BUILT_IN_FETCH_AND_XOR_16:
6358 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6359 target = expand_builtin_sync_operation (mode, exp, XOR,
6360 false, target, ignore);
6365 case BUILT_IN_FETCH_AND_NAND_1:
6366 case BUILT_IN_FETCH_AND_NAND_2:
6367 case BUILT_IN_FETCH_AND_NAND_4:
6368 case BUILT_IN_FETCH_AND_NAND_8:
6369 case BUILT_IN_FETCH_AND_NAND_16:
6370 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6371 target = expand_builtin_sync_operation (mode, exp, NOT,
6372 false, target, ignore);
6377 case BUILT_IN_ADD_AND_FETCH_1:
6378 case BUILT_IN_ADD_AND_FETCH_2:
6379 case BUILT_IN_ADD_AND_FETCH_4:
6380 case BUILT_IN_ADD_AND_FETCH_8:
6381 case BUILT_IN_ADD_AND_FETCH_16:
6382 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6383 target = expand_builtin_sync_operation (mode, exp, PLUS,
6384 true, target, ignore);
6389 case BUILT_IN_SUB_AND_FETCH_1:
6390 case BUILT_IN_SUB_AND_FETCH_2:
6391 case BUILT_IN_SUB_AND_FETCH_4:
6392 case BUILT_IN_SUB_AND_FETCH_8:
6393 case BUILT_IN_SUB_AND_FETCH_16:
6394 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6395 target = expand_builtin_sync_operation (mode, exp, MINUS,
6396 true, target, ignore);
6401 case BUILT_IN_OR_AND_FETCH_1:
6402 case BUILT_IN_OR_AND_FETCH_2:
6403 case BUILT_IN_OR_AND_FETCH_4:
6404 case BUILT_IN_OR_AND_FETCH_8:
6405 case BUILT_IN_OR_AND_FETCH_16:
6406 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6407 target = expand_builtin_sync_operation (mode, exp, IOR,
6408 true, target, ignore);
6413 case BUILT_IN_AND_AND_FETCH_1:
6414 case BUILT_IN_AND_AND_FETCH_2:
6415 case BUILT_IN_AND_AND_FETCH_4:
6416 case BUILT_IN_AND_AND_FETCH_8:
6417 case BUILT_IN_AND_AND_FETCH_16:
6418 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6419 target = expand_builtin_sync_operation (mode, exp, AND,
6420 true, target, ignore);
6425 case BUILT_IN_XOR_AND_FETCH_1:
6426 case BUILT_IN_XOR_AND_FETCH_2:
6427 case BUILT_IN_XOR_AND_FETCH_4:
6428 case BUILT_IN_XOR_AND_FETCH_8:
6429 case BUILT_IN_XOR_AND_FETCH_16:
6430 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6431 target = expand_builtin_sync_operation (mode, exp, XOR,
6432 true, target, ignore);
6437 case BUILT_IN_NAND_AND_FETCH_1:
6438 case BUILT_IN_NAND_AND_FETCH_2:
6439 case BUILT_IN_NAND_AND_FETCH_4:
6440 case BUILT_IN_NAND_AND_FETCH_8:
6441 case BUILT_IN_NAND_AND_FETCH_16:
6442 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6443 target = expand_builtin_sync_operation (mode, exp, NOT,
6444 true, target, ignore);
6449 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6450 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6451 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6452 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6453 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6454 if (mode == VOIDmode)
6455 mode = TYPE_MODE (boolean_type_node);
6456 if (!target || !register_operand (target, mode))
6457 target = gen_reg_rtx (mode);
6459 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6460 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6465 case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6466 case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6467 case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6468 case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6469 case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6470 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6471 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6476 case BUILT_IN_LOCK_TEST_AND_SET_1:
6477 case BUILT_IN_LOCK_TEST_AND_SET_2:
6478 case BUILT_IN_LOCK_TEST_AND_SET_4:
6479 case BUILT_IN_LOCK_TEST_AND_SET_8:
6480 case BUILT_IN_LOCK_TEST_AND_SET_16:
6481 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6482 target = expand_builtin_lock_test_and_set (mode, exp, target);
6487 case BUILT_IN_LOCK_RELEASE_1:
6488 case BUILT_IN_LOCK_RELEASE_2:
6489 case BUILT_IN_LOCK_RELEASE_4:
6490 case BUILT_IN_LOCK_RELEASE_8:
6491 case BUILT_IN_LOCK_RELEASE_16:
6492 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6493 expand_builtin_lock_release (mode, exp);
6496 case BUILT_IN_SYNCHRONIZE:
6497 expand_builtin_synchronize ();
6500 case BUILT_IN_OBJECT_SIZE:
6501 return expand_builtin_object_size (exp);
6503 case BUILT_IN_MEMCPY_CHK:
6504 case BUILT_IN_MEMPCPY_CHK:
6505 case BUILT_IN_MEMMOVE_CHK:
6506 case BUILT_IN_MEMSET_CHK:
6507 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6512 case BUILT_IN_STRCPY_CHK:
6513 case BUILT_IN_STPCPY_CHK:
6514 case BUILT_IN_STRNCPY_CHK:
6515 case BUILT_IN_STRCAT_CHK:
6516 case BUILT_IN_STRNCAT_CHK:
6517 case BUILT_IN_SNPRINTF_CHK:
6518 case BUILT_IN_VSNPRINTF_CHK:
6519 maybe_emit_chk_warning (exp, fcode);
6522 case BUILT_IN_SPRINTF_CHK:
6523 case BUILT_IN_VSPRINTF_CHK:
6524 maybe_emit_sprintf_chk_warning (exp, fcode);
6528 maybe_emit_free_warning (exp);
6531 default: /* just do library call, if unknown builtin */
6535 /* The switch statement above can drop through to cause the function
6536 to be called normally. */
6537 return expand_call (exp, target, ignore);
6540 /* Determine whether a tree node represents a call to a built-in
6541 function. If the tree T is a call to a built-in function with
6542 the right number of arguments of the appropriate types, return
6543 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6544 Otherwise the return value is END_BUILTINS. */
6546 enum built_in_function
6547 builtin_mathfn_code (const_tree t)
6549 const_tree fndecl, arg, parmlist;
6550 const_tree argtype, parmtype;
6551 const_call_expr_arg_iterator iter;
6553 if (TREE_CODE (t) != CALL_EXPR
6554 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6555 return END_BUILTINS;
6557 fndecl = get_callee_fndecl (t);
6558 if (fndecl == NULL_TREE
6559 || TREE_CODE (fndecl) != FUNCTION_DECL
6560 || ! DECL_BUILT_IN (fndecl)
6561 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6562 return END_BUILTINS;
6564 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6565 init_const_call_expr_arg_iterator (t, &iter);
6566 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6568 /* If a function doesn't take a variable number of arguments,
6569 the last element in the list will have type `void'. */
6570 parmtype = TREE_VALUE (parmlist);
6571 if (VOID_TYPE_P (parmtype))
6573 if (more_const_call_expr_args_p (&iter))
6574 return END_BUILTINS;
6575 return DECL_FUNCTION_CODE (fndecl);
6578 if (! more_const_call_expr_args_p (&iter))
6579 return END_BUILTINS;
6581 arg = next_const_call_expr_arg (&iter);
6582 argtype = TREE_TYPE (arg);
6584 if (SCALAR_FLOAT_TYPE_P (parmtype))
6586 if (! SCALAR_FLOAT_TYPE_P (argtype))
6587 return END_BUILTINS;
6589 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6591 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6592 return END_BUILTINS;
6594 else if (POINTER_TYPE_P (parmtype))
6596 if (! POINTER_TYPE_P (argtype))
6597 return END_BUILTINS;
6599 else if (INTEGRAL_TYPE_P (parmtype))
6601 if (! INTEGRAL_TYPE_P (argtype))
6602 return END_BUILTINS;
6605 return END_BUILTINS;
6608 /* Variable-length argument list. */
6609 return DECL_FUNCTION_CODE (fndecl);
6612 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6613 evaluate to a constant. */
6616 fold_builtin_constant_p (tree arg)
6618 /* We return 1 for a numeric type that's known to be a constant
6619 value at compile-time or for an aggregate type that's a
6620 literal constant. */
6623 /* If we know this is a constant, emit the constant of one. */
6624 if (CONSTANT_CLASS_P (arg)
6625 || (TREE_CODE (arg) == CONSTRUCTOR
6626 && TREE_CONSTANT (arg)))
6627 return integer_one_node;
6628 if (TREE_CODE (arg) == ADDR_EXPR)
6630 tree op = TREE_OPERAND (arg, 0);
6631 if (TREE_CODE (op) == STRING_CST
6632 || (TREE_CODE (op) == ARRAY_REF
6633 && integer_zerop (TREE_OPERAND (op, 1))
6634 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6635 return integer_one_node;
6638 /* If this expression has side effects, show we don't know it to be a
6639 constant. Likewise if it's a pointer or aggregate type since in
6640 those case we only want literals, since those are only optimized
6641 when generating RTL, not later.
6642 And finally, if we are compiling an initializer, not code, we
6643 need to return a definite result now; there's not going to be any
6644 more optimization done. */
6645 if (TREE_SIDE_EFFECTS (arg)
6646 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6647 || POINTER_TYPE_P (TREE_TYPE (arg))
6649 || folding_initializer)
6650 return integer_zero_node;
6655 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6656 return it as a truthvalue. */
6659 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6661 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6663 fn = built_in_decls[BUILT_IN_EXPECT];
6664 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6665 ret_type = TREE_TYPE (TREE_TYPE (fn));
6666 pred_type = TREE_VALUE (arg_types);
6667 expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6669 pred = fold_convert_loc (loc, pred_type, pred);
6670 expected = fold_convert_loc (loc, expected_type, expected);
6671 call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6673 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6674 build_int_cst (ret_type, 0));
6677 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6678 NULL_TREE if no simplification is possible. */
6681 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6684 enum tree_code code;
6686 /* If this is a builtin_expect within a builtin_expect keep the
6687 inner one. See through a comparison against a constant. It
6688 might have been added to create a thruthvalue. */
6690 if (COMPARISON_CLASS_P (inner)
6691 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6692 inner = TREE_OPERAND (inner, 0);
6694 if (TREE_CODE (inner) == CALL_EXPR
6695 && (fndecl = get_callee_fndecl (inner))
6696 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6697 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6700 /* Distribute the expected value over short-circuiting operators.
6701 See through the cast from truthvalue_type_node to long. */
6703 while (TREE_CODE (inner) == NOP_EXPR
6704 && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6705 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6706 inner = TREE_OPERAND (inner, 0);
6708 code = TREE_CODE (inner);
6709 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6711 tree op0 = TREE_OPERAND (inner, 0);
6712 tree op1 = TREE_OPERAND (inner, 1);
6714 op0 = build_builtin_expect_predicate (loc, op0, arg1);
6715 op1 = build_builtin_expect_predicate (loc, op1, arg1);
6716 inner = build2 (code, TREE_TYPE (inner), op0, op1);
6718 return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6721 /* If the argument isn't invariant then there's nothing else we can do. */
6722 if (!TREE_CONSTANT (arg0))
6725 /* If we expect that a comparison against the argument will fold to
6726 a constant return the constant. In practice, this means a true
6727 constant or the address of a non-weak symbol. */
6730 if (TREE_CODE (inner) == ADDR_EXPR)
6734 inner = TREE_OPERAND (inner, 0);
6736 while (TREE_CODE (inner) == COMPONENT_REF
6737 || TREE_CODE (inner) == ARRAY_REF);
6738 if ((TREE_CODE (inner) == VAR_DECL
6739 || TREE_CODE (inner) == FUNCTION_DECL)
6740 && DECL_WEAK (inner))
6744 /* Otherwise, ARG0 already has the proper type for the return value. */
6748 /* Fold a call to __builtin_classify_type with argument ARG. */
6751 fold_builtin_classify_type (tree arg)
6754 return build_int_cst (NULL_TREE, no_type_class);
6756 return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6759 /* Fold a call to __builtin_strlen with argument ARG. */
6762 fold_builtin_strlen (location_t loc, tree type, tree arg)
6764 if (!validate_arg (arg, POINTER_TYPE))
6768 tree len = c_strlen (arg, 0);
6771 return fold_convert_loc (loc, type, len);
6777 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6780 fold_builtin_inf (location_t loc, tree type, int warn)
6782 REAL_VALUE_TYPE real;
6784 /* __builtin_inff is intended to be usable to define INFINITY on all
6785 targets. If an infinity is not available, INFINITY expands "to a
6786 positive constant of type float that overflows at translation
6787 time", footnote "In this case, using INFINITY will violate the
6788 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6789 Thus we pedwarn to ensure this constraint violation is
6791 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6792 pedwarn (loc, 0, "target format does not support infinity");
6795 return build_real (type, real);
6798 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
6801 fold_builtin_nan (tree arg, tree type, int quiet)
6803 REAL_VALUE_TYPE real;
6806 if (!validate_arg (arg, POINTER_TYPE))
6808 str = c_getstr (arg);
6812 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6815 return build_real (type, real);
6818 /* Return true if the floating point expression T has an integer value.
6819 We also allow +Inf, -Inf and NaN to be considered integer values. */
6822 integer_valued_real_p (tree t)
6824 switch (TREE_CODE (t))
6831 return integer_valued_real_p (TREE_OPERAND (t, 0));
6836 return integer_valued_real_p (TREE_OPERAND (t, 1));
6843 return integer_valued_real_p (TREE_OPERAND (t, 0))
6844 && integer_valued_real_p (TREE_OPERAND (t, 1));
6847 return integer_valued_real_p (TREE_OPERAND (t, 1))
6848 && integer_valued_real_p (TREE_OPERAND (t, 2));
6851 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6855 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6856 if (TREE_CODE (type) == INTEGER_TYPE)
6858 if (TREE_CODE (type) == REAL_TYPE)
6859 return integer_valued_real_p (TREE_OPERAND (t, 0));
6864 switch (builtin_mathfn_code (t))
6866 CASE_FLT_FN (BUILT_IN_CEIL):
6867 CASE_FLT_FN (BUILT_IN_FLOOR):
6868 CASE_FLT_FN (BUILT_IN_NEARBYINT):
6869 CASE_FLT_FN (BUILT_IN_RINT):
6870 CASE_FLT_FN (BUILT_IN_ROUND):
6871 CASE_FLT_FN (BUILT_IN_TRUNC):
6874 CASE_FLT_FN (BUILT_IN_FMIN):
6875 CASE_FLT_FN (BUILT_IN_FMAX):
6876 return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6877 && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6890 /* FNDECL is assumed to be a builtin where truncation can be propagated
6891 across (for instance floor((double)f) == (double)floorf (f).
6892 Do the transformation for a call with argument ARG. */
6895 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6897 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6899 if (!validate_arg (arg, REAL_TYPE))
6902 /* Integer rounding functions are idempotent. */
6903 if (fcode == builtin_mathfn_code (arg))
6906 /* If argument is already integer valued, and we don't need to worry
6907 about setting errno, there's no need to perform rounding. */
6908 if (! flag_errno_math && integer_valued_real_p (arg))
6913 tree arg0 = strip_float_extensions (arg);
6914 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6915 tree newtype = TREE_TYPE (arg0);
6918 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6919 && (decl = mathfn_built_in (newtype, fcode)))
6920 return fold_convert_loc (loc, ftype,
6921 build_call_expr_loc (loc, decl, 1,
6922 fold_convert_loc (loc,
6929 /* FNDECL is assumed to be builtin which can narrow the FP type of
6930 the argument, for instance lround((double)f) -> lroundf (f).
6931 Do the transformation for a call with argument ARG. */
6934 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6936 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6938 if (!validate_arg (arg, REAL_TYPE))
6941 /* If argument is already integer valued, and we don't need to worry
6942 about setting errno, there's no need to perform rounding. */
6943 if (! flag_errno_math && integer_valued_real_p (arg))
6944 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6945 TREE_TYPE (TREE_TYPE (fndecl)), arg);
6949 tree ftype = TREE_TYPE (arg);
6950 tree arg0 = strip_float_extensions (arg);
6951 tree newtype = TREE_TYPE (arg0);
6954 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6955 && (decl = mathfn_built_in (newtype, fcode)))
6956 return build_call_expr_loc (loc, decl, 1,
6957 fold_convert_loc (loc, newtype, arg0));
6960 /* Canonicalize llround (x) to lround (x) on LP64 targets where
6961 sizeof (long long) == sizeof (long). */
6962 if (TYPE_PRECISION (long_long_integer_type_node)
6963 == TYPE_PRECISION (long_integer_type_node))
6965 tree newfn = NULL_TREE;
6968 CASE_FLT_FN (BUILT_IN_LLCEIL):
6969 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6972 CASE_FLT_FN (BUILT_IN_LLFLOOR):
6973 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6976 CASE_FLT_FN (BUILT_IN_LLROUND):
6977 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6980 CASE_FLT_FN (BUILT_IN_LLRINT):
6981 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
6990 tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
6991 return fold_convert_loc (loc,
6992 TREE_TYPE (TREE_TYPE (fndecl)), newcall);
6999 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7000 return type. Return NULL_TREE if no simplification can be made. */
7003 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7007 if (!validate_arg (arg, COMPLEX_TYPE)
7008 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7011 /* Calculate the result when the argument is a constant. */
7012 if (TREE_CODE (arg) == COMPLEX_CST
7013 && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7017 if (TREE_CODE (arg) == COMPLEX_EXPR)
7019 tree real = TREE_OPERAND (arg, 0);
7020 tree imag = TREE_OPERAND (arg, 1);
7022 /* If either part is zero, cabs is fabs of the other. */
7023 if (real_zerop (real))
7024 return fold_build1_loc (loc, ABS_EXPR, type, imag);
7025 if (real_zerop (imag))
7026 return fold_build1_loc (loc, ABS_EXPR, type, real);
7028 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7029 if (flag_unsafe_math_optimizations
7030 && operand_equal_p (real, imag, OEP_PURE_SAME))
7032 const REAL_VALUE_TYPE sqrt2_trunc
7033 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7035 return fold_build2_loc (loc, MULT_EXPR, type,
7036 fold_build1_loc (loc, ABS_EXPR, type, real),
7037 build_real (type, sqrt2_trunc));
7041 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7042 if (TREE_CODE (arg) == NEGATE_EXPR
7043 || TREE_CODE (arg) == CONJ_EXPR)
7044 return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7046 /* Don't do this when optimizing for size. */
7047 if (flag_unsafe_math_optimizations
7048 && optimize && optimize_function_for_speed_p (cfun))
7050 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7052 if (sqrtfn != NULL_TREE)
7054 tree rpart, ipart, result;
7056 arg = builtin_save_expr (arg);
7058 rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7059 ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7061 rpart = builtin_save_expr (rpart);
7062 ipart = builtin_save_expr (ipart);
7064 result = fold_build2_loc (loc, PLUS_EXPR, type,
7065 fold_build2_loc (loc, MULT_EXPR, type,
7067 fold_build2_loc (loc, MULT_EXPR, type,
7070 return build_call_expr_loc (loc, sqrtfn, 1, result);
7077 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7078 complex tree type of the result. If NEG is true, the imaginary
7079 zero is negative. */
7082 build_complex_cproj (tree type, bool neg)
7084 REAL_VALUE_TYPE rinf, rzero = dconst0;
7088 return build_complex (type, build_real (TREE_TYPE (type), rinf),
7089 build_real (TREE_TYPE (type), rzero));
7092 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7093 return type. Return NULL_TREE if no simplification can be made. */
7096 fold_builtin_cproj (location_t loc, tree arg, tree type)
7098 if (!validate_arg (arg, COMPLEX_TYPE)
7099 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7102 /* If there are no infinities, return arg. */
7103 if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7104 return non_lvalue_loc (loc, arg);
7106 /* Calculate the result when the argument is a constant. */
7107 if (TREE_CODE (arg) == COMPLEX_CST)
7109 const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7110 const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7112 if (real_isinf (real) || real_isinf (imag))
7113 return build_complex_cproj (type, imag->sign);
7117 else if (TREE_CODE (arg) == COMPLEX_EXPR)
7119 tree real = TREE_OPERAND (arg, 0);
7120 tree imag = TREE_OPERAND (arg, 1);
7125 /* If the real part is inf and the imag part is known to be
7126 nonnegative, return (inf + 0i). Remember side-effects are
7127 possible in the imag part. */
7128 if (TREE_CODE (real) == REAL_CST
7129 && real_isinf (TREE_REAL_CST_PTR (real))
7130 && tree_expr_nonnegative_p (imag))
7131 return omit_one_operand_loc (loc, type,
7132 build_complex_cproj (type, false),
7135 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7136 Remember side-effects are possible in the real part. */
7137 if (TREE_CODE (imag) == REAL_CST
7138 && real_isinf (TREE_REAL_CST_PTR (imag)))
7140 omit_one_operand_loc (loc, type,
7141 build_complex_cproj (type, TREE_REAL_CST_PTR
7142 (imag)->sign), arg);
7148 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7149 Return NULL_TREE if no simplification can be made. */
7152 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7155 enum built_in_function fcode;
7158 if (!validate_arg (arg, REAL_TYPE))
7161 /* Calculate the result when the argument is a constant. */
7162 if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7165 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7166 fcode = builtin_mathfn_code (arg);
7167 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7169 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7170 arg = fold_build2_loc (loc, MULT_EXPR, type,
7171 CALL_EXPR_ARG (arg, 0),
7172 build_real (type, dconsthalf));
7173 return build_call_expr_loc (loc, expfn, 1, arg);
7176 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7177 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7179 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7183 tree arg0 = CALL_EXPR_ARG (arg, 0);
7185 /* The inner root was either sqrt or cbrt. */
7186 /* This was a conditional expression but it triggered a bug
7188 REAL_VALUE_TYPE dconstroot;
7189 if (BUILTIN_SQRT_P (fcode))
7190 dconstroot = dconsthalf;
7192 dconstroot = dconst_third ();
7194 /* Adjust for the outer root. */
7195 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7196 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7197 tree_root = build_real (type, dconstroot);
7198 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7202 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7203 if (flag_unsafe_math_optimizations
7204 && (fcode == BUILT_IN_POW
7205 || fcode == BUILT_IN_POWF
7206 || fcode == BUILT_IN_POWL))
7208 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7209 tree arg0 = CALL_EXPR_ARG (arg, 0);
7210 tree arg1 = CALL_EXPR_ARG (arg, 1);
7212 if (!tree_expr_nonnegative_p (arg0))
7213 arg0 = build1 (ABS_EXPR, type, arg0);
7214 narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7215 build_real (type, dconsthalf));
7216 return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7222 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7223 Return NULL_TREE if no simplification can be made. */
7226 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7228 const enum built_in_function fcode = builtin_mathfn_code (arg);
7231 if (!validate_arg (arg, REAL_TYPE))
7234 /* Calculate the result when the argument is a constant. */
7235 if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7238 if (flag_unsafe_math_optimizations)
7240 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7241 if (BUILTIN_EXPONENT_P (fcode))
7243 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7244 const REAL_VALUE_TYPE third_trunc =
7245 real_value_truncate (TYPE_MODE (type), dconst_third ());
7246 arg = fold_build2_loc (loc, MULT_EXPR, type,
7247 CALL_EXPR_ARG (arg, 0),
7248 build_real (type, third_trunc));
7249 return build_call_expr_loc (loc, expfn, 1, arg);
7252 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7253 if (BUILTIN_SQRT_P (fcode))
7255 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7259 tree arg0 = CALL_EXPR_ARG (arg, 0);
7261 REAL_VALUE_TYPE dconstroot = dconst_third ();
7263 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7264 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7265 tree_root = build_real (type, dconstroot);
7266 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7270 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7271 if (BUILTIN_CBRT_P (fcode))
7273 tree arg0 = CALL_EXPR_ARG (arg, 0);
7274 if (tree_expr_nonnegative_p (arg0))
7276 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7281 REAL_VALUE_TYPE dconstroot;
7283 real_arithmetic (&dconstroot, MULT_EXPR,
7284 dconst_third_ptr (), dconst_third_ptr ());
7285 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7286 tree_root = build_real (type, dconstroot);
7287 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7292 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7293 if (fcode == BUILT_IN_POW
7294 || fcode == BUILT_IN_POWF
7295 || fcode == BUILT_IN_POWL)
7297 tree arg00 = CALL_EXPR_ARG (arg, 0);
7298 tree arg01 = CALL_EXPR_ARG (arg, 1);
7299 if (tree_expr_nonnegative_p (arg00))
7301 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7302 const REAL_VALUE_TYPE dconstroot
7303 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7304 tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7305 build_real (type, dconstroot));
7306 return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7313 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7314 TYPE is the type of the return value. Return NULL_TREE if no
7315 simplification can be made. */
7318 fold_builtin_cos (location_t loc,
7319 tree arg, tree type, tree fndecl)
7323 if (!validate_arg (arg, REAL_TYPE))
7326 /* Calculate the result when the argument is a constant. */
7327 if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7330 /* Optimize cos(-x) into cos (x). */
7331 if ((narg = fold_strip_sign_ops (arg)))
7332 return build_call_expr_loc (loc, fndecl, 1, narg);
7337 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7338 Return NULL_TREE if no simplification can be made. */
7341 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7343 if (validate_arg (arg, REAL_TYPE))
7347 /* Calculate the result when the argument is a constant. */
7348 if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7351 /* Optimize cosh(-x) into cosh (x). */
7352 if ((narg = fold_strip_sign_ops (arg)))
7353 return build_call_expr_loc (loc, fndecl, 1, narg);
7359 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7360 argument ARG. TYPE is the type of the return value. Return
7361 NULL_TREE if no simplification can be made. */
7364 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7367 if (validate_arg (arg, COMPLEX_TYPE)
7368 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7372 /* Calculate the result when the argument is a constant. */
7373 if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7376 /* Optimize fn(-x) into fn(x). */
7377 if ((tmp = fold_strip_sign_ops (arg)))
7378 return build_call_expr_loc (loc, fndecl, 1, tmp);
7384 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7385 Return NULL_TREE if no simplification can be made. */
7388 fold_builtin_tan (tree arg, tree type)
7390 enum built_in_function fcode;
7393 if (!validate_arg (arg, REAL_TYPE))
7396 /* Calculate the result when the argument is a constant. */
7397 if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7400 /* Optimize tan(atan(x)) = x. */
7401 fcode = builtin_mathfn_code (arg);
7402 if (flag_unsafe_math_optimizations
7403 && (fcode == BUILT_IN_ATAN
7404 || fcode == BUILT_IN_ATANF
7405 || fcode == BUILT_IN_ATANL))
7406 return CALL_EXPR_ARG (arg, 0);
7411 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7412 NULL_TREE if no simplification can be made. */
7415 fold_builtin_sincos (location_t loc,
7416 tree arg0, tree arg1, tree arg2)
7421 if (!validate_arg (arg0, REAL_TYPE)
7422 || !validate_arg (arg1, POINTER_TYPE)
7423 || !validate_arg (arg2, POINTER_TYPE))
7426 type = TREE_TYPE (arg0);
7428 /* Calculate the result when the argument is a constant. */
7429 if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7432 /* Canonicalize sincos to cexpi. */
7433 if (!TARGET_C99_FUNCTIONS)
7435 fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7439 call = build_call_expr_loc (loc, fn, 1, arg0);
7440 call = builtin_save_expr (call);
7442 return build2 (COMPOUND_EXPR, void_type_node,
7443 build2 (MODIFY_EXPR, void_type_node,
7444 build_fold_indirect_ref_loc (loc, arg1),
7445 build1 (IMAGPART_EXPR, type, call)),
7446 build2 (MODIFY_EXPR, void_type_node,
7447 build_fold_indirect_ref_loc (loc, arg2),
7448 build1 (REALPART_EXPR, type, call)));
7451 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7452 NULL_TREE if no simplification can be made. */
7455 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7458 tree realp, imagp, ifn;
7461 if (!validate_arg (arg0, COMPLEX_TYPE)
7462 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7465 /* Calculate the result when the argument is a constant. */
7466 if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7469 rtype = TREE_TYPE (TREE_TYPE (arg0));
7471 /* In case we can figure out the real part of arg0 and it is constant zero
7473 if (!TARGET_C99_FUNCTIONS)
7475 ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7479 if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7480 && real_zerop (realp))
7482 tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7483 return build_call_expr_loc (loc, ifn, 1, narg);
7486 /* In case we can easily decompose real and imaginary parts split cexp
7487 to exp (r) * cexpi (i). */
7488 if (flag_unsafe_math_optimizations
7491 tree rfn, rcall, icall;
7493 rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7497 imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7501 icall = build_call_expr_loc (loc, ifn, 1, imagp);
7502 icall = builtin_save_expr (icall);
7503 rcall = build_call_expr_loc (loc, rfn, 1, realp);
7504 rcall = builtin_save_expr (rcall);
7505 return fold_build2_loc (loc, COMPLEX_EXPR, type,
7506 fold_build2_loc (loc, MULT_EXPR, rtype,
7508 fold_build1_loc (loc, REALPART_EXPR,
7510 fold_build2_loc (loc, MULT_EXPR, rtype,
7512 fold_build1_loc (loc, IMAGPART_EXPR,
7519 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7520 Return NULL_TREE if no simplification can be made. */
7523 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7525 if (!validate_arg (arg, REAL_TYPE))
7528 /* Optimize trunc of constant value. */
7529 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7531 REAL_VALUE_TYPE r, x;
7532 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7534 x = TREE_REAL_CST (arg);
7535 real_trunc (&r, TYPE_MODE (type), &x);
7536 return build_real (type, r);
7539 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7542 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7543 Return NULL_TREE if no simplification can be made. */
7546 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7548 if (!validate_arg (arg, REAL_TYPE))
7551 /* Optimize floor of constant value. */
7552 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7556 x = TREE_REAL_CST (arg);
7557 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7559 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7562 real_floor (&r, TYPE_MODE (type), &x);
7563 return build_real (type, r);
7567 /* Fold floor (x) where x is nonnegative to trunc (x). */
7568 if (tree_expr_nonnegative_p (arg))
7570 tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7572 return build_call_expr_loc (loc, truncfn, 1, arg);
7575 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7578 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7579 Return NULL_TREE if no simplification can be made. */
7582 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7584 if (!validate_arg (arg, REAL_TYPE))
7587 /* Optimize ceil of constant value. */
7588 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7592 x = TREE_REAL_CST (arg);
7593 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7595 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7598 real_ceil (&r, TYPE_MODE (type), &x);
7599 return build_real (type, r);
7603 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7606 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7607 Return NULL_TREE if no simplification can be made. */
7610 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7612 if (!validate_arg (arg, REAL_TYPE))
7615 /* Optimize round of constant value. */
7616 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7620 x = TREE_REAL_CST (arg);
7621 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7623 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7626 real_round (&r, TYPE_MODE (type), &x);
7627 return build_real (type, r);
7631 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7634 /* Fold function call to builtin lround, lroundf or lroundl (or the
7635 corresponding long long versions) and other rounding functions. ARG
7636 is the argument to the call. Return NULL_TREE if no simplification
7640 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7642 if (!validate_arg (arg, REAL_TYPE))
7645 /* Optimize lround of constant value. */
7646 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7648 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7650 if (real_isfinite (&x))
7652 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7653 tree ftype = TREE_TYPE (arg);
7657 switch (DECL_FUNCTION_CODE (fndecl))
7659 CASE_FLT_FN (BUILT_IN_LFLOOR):
7660 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7661 real_floor (&r, TYPE_MODE (ftype), &x);
7664 CASE_FLT_FN (BUILT_IN_LCEIL):
7665 CASE_FLT_FN (BUILT_IN_LLCEIL):
7666 real_ceil (&r, TYPE_MODE (ftype), &x);
7669 CASE_FLT_FN (BUILT_IN_LROUND):
7670 CASE_FLT_FN (BUILT_IN_LLROUND):
7671 real_round (&r, TYPE_MODE (ftype), &x);
7678 real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7679 if (double_int_fits_to_tree_p (itype, val))
7680 return double_int_to_tree (itype, val);
7684 switch (DECL_FUNCTION_CODE (fndecl))
7686 CASE_FLT_FN (BUILT_IN_LFLOOR):
7687 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7688 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
7689 if (tree_expr_nonnegative_p (arg))
7690 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7691 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7696 return fold_fixed_mathfn (loc, fndecl, arg);
7699 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7700 and their long and long long variants (i.e. ffsl and ffsll). ARG is
7701 the argument to the call. Return NULL_TREE if no simplification can
7705 fold_builtin_bitop (tree fndecl, tree arg)
7707 if (!validate_arg (arg, INTEGER_TYPE))
7710 /* Optimize for constant argument. */
7711 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7713 HOST_WIDE_INT hi, width, result;
7714 unsigned HOST_WIDE_INT lo;
7717 type = TREE_TYPE (arg);
7718 width = TYPE_PRECISION (type);
7719 lo = TREE_INT_CST_LOW (arg);
7721 /* Clear all the bits that are beyond the type's precision. */
7722 if (width > HOST_BITS_PER_WIDE_INT)
7724 hi = TREE_INT_CST_HIGH (arg);
7725 if (width < 2 * HOST_BITS_PER_WIDE_INT)
7726 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7731 if (width < HOST_BITS_PER_WIDE_INT)
7732 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7735 switch (DECL_FUNCTION_CODE (fndecl))
7737 CASE_INT_FN (BUILT_IN_FFS):
7739 result = ffs_hwi (lo);
7741 result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7746 CASE_INT_FN (BUILT_IN_CLZ):
7748 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7750 result = width - floor_log2 (lo) - 1;
7751 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7755 CASE_INT_FN (BUILT_IN_CTZ):
7757 result = ctz_hwi (lo);
7759 result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7760 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7764 CASE_INT_FN (BUILT_IN_POPCOUNT):
7767 result++, lo &= lo - 1;
7769 result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7772 CASE_INT_FN (BUILT_IN_PARITY):
7775 result++, lo &= lo - 1;
7777 result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7785 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7791 /* Fold function call to builtin_bswap and the long and long long
7792 variants. Return NULL_TREE if no simplification can be made. */
7794 fold_builtin_bswap (tree fndecl, tree arg)
7796 if (! validate_arg (arg, INTEGER_TYPE))
7799 /* Optimize constant value. */
7800 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7802 HOST_WIDE_INT hi, width, r_hi = 0;
7803 unsigned HOST_WIDE_INT lo, r_lo = 0;
7806 type = TREE_TYPE (arg);
7807 width = TYPE_PRECISION (type);
7808 lo = TREE_INT_CST_LOW (arg);
7809 hi = TREE_INT_CST_HIGH (arg);
7811 switch (DECL_FUNCTION_CODE (fndecl))
7813 case BUILT_IN_BSWAP32:
7814 case BUILT_IN_BSWAP64:
7818 for (s = 0; s < width; s += 8)
7820 int d = width - s - 8;
7821 unsigned HOST_WIDE_INT byte;
7823 if (s < HOST_BITS_PER_WIDE_INT)
7824 byte = (lo >> s) & 0xff;
7826 byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7828 if (d < HOST_BITS_PER_WIDE_INT)
7831 r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7841 if (width < HOST_BITS_PER_WIDE_INT)
7842 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7844 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7850 /* A subroutine of fold_builtin to fold the various logarithmic
7851 functions. Return NULL_TREE if no simplification can me made.
7852 FUNC is the corresponding MPFR logarithm function. */
7855 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7856 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7858 if (validate_arg (arg, REAL_TYPE))
7860 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7862 const enum built_in_function fcode = builtin_mathfn_code (arg);
7864 /* Calculate the result when the argument is a constant. */
7865 if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7868 /* Special case, optimize logN(expN(x)) = x. */
7869 if (flag_unsafe_math_optimizations
7870 && ((func == mpfr_log
7871 && (fcode == BUILT_IN_EXP
7872 || fcode == BUILT_IN_EXPF
7873 || fcode == BUILT_IN_EXPL))
7874 || (func == mpfr_log2
7875 && (fcode == BUILT_IN_EXP2
7876 || fcode == BUILT_IN_EXP2F
7877 || fcode == BUILT_IN_EXP2L))
7878 || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7879 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7881 /* Optimize logN(func()) for various exponential functions. We
7882 want to determine the value "x" and the power "exponent" in
7883 order to transform logN(x**exponent) into exponent*logN(x). */
7884 if (flag_unsafe_math_optimizations)
7886 tree exponent = 0, x = 0;
7890 CASE_FLT_FN (BUILT_IN_EXP):
7891 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7892 x = build_real (type, real_value_truncate (TYPE_MODE (type),
7894 exponent = CALL_EXPR_ARG (arg, 0);
7896 CASE_FLT_FN (BUILT_IN_EXP2):
7897 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7898 x = build_real (type, dconst2);
7899 exponent = CALL_EXPR_ARG (arg, 0);
7901 CASE_FLT_FN (BUILT_IN_EXP10):
7902 CASE_FLT_FN (BUILT_IN_POW10):
7903 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7905 REAL_VALUE_TYPE dconst10;
7906 real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7907 x = build_real (type, dconst10);
7909 exponent = CALL_EXPR_ARG (arg, 0);
7911 CASE_FLT_FN (BUILT_IN_SQRT):
7912 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7913 x = CALL_EXPR_ARG (arg, 0);
7914 exponent = build_real (type, dconsthalf);
7916 CASE_FLT_FN (BUILT_IN_CBRT):
7917 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7918 x = CALL_EXPR_ARG (arg, 0);
7919 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7922 CASE_FLT_FN (BUILT_IN_POW):
7923 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7924 x = CALL_EXPR_ARG (arg, 0);
7925 exponent = CALL_EXPR_ARG (arg, 1);
7931 /* Now perform the optimization. */
7934 tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7935 return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7943 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
7944 NULL_TREE if no simplification can be made. */
7947 fold_builtin_hypot (location_t loc, tree fndecl,
7948 tree arg0, tree arg1, tree type)
7950 tree res, narg0, narg1;
7952 if (!validate_arg (arg0, REAL_TYPE)
7953 || !validate_arg (arg1, REAL_TYPE))
7956 /* Calculate the result when the argument is a constant. */
7957 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7960 /* If either argument to hypot has a negate or abs, strip that off.
7961 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
7962 narg0 = fold_strip_sign_ops (arg0);
7963 narg1 = fold_strip_sign_ops (arg1);
7966 return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7967 narg1 ? narg1 : arg1);
7970 /* If either argument is zero, hypot is fabs of the other. */
7971 if (real_zerop (arg0))
7972 return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7973 else if (real_zerop (arg1))
7974 return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7976 /* hypot(x,x) -> fabs(x)*sqrt(2). */
7977 if (flag_unsafe_math_optimizations
7978 && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7980 const REAL_VALUE_TYPE sqrt2_trunc
7981 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7982 return fold_build2_loc (loc, MULT_EXPR, type,
7983 fold_build1_loc (loc, ABS_EXPR, type, arg0),
7984 build_real (type, sqrt2_trunc));
7991 /* Fold a builtin function call to pow, powf, or powl. Return
7992 NULL_TREE if no simplification can be made. */
7994 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
7998 if (!validate_arg (arg0, REAL_TYPE)
7999 || !validate_arg (arg1, REAL_TYPE))
8002 /* Calculate the result when the argument is a constant. */
8003 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8006 /* Optimize pow(1.0,y) = 1.0. */
8007 if (real_onep (arg0))
8008 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8010 if (TREE_CODE (arg1) == REAL_CST
8011 && !TREE_OVERFLOW (arg1))
8013 REAL_VALUE_TYPE cint;
8017 c = TREE_REAL_CST (arg1);
8019 /* Optimize pow(x,0.0) = 1.0. */
8020 if (REAL_VALUES_EQUAL (c, dconst0))
8021 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8024 /* Optimize pow(x,1.0) = x. */
8025 if (REAL_VALUES_EQUAL (c, dconst1))
8028 /* Optimize pow(x,-1.0) = 1.0/x. */
8029 if (REAL_VALUES_EQUAL (c, dconstm1))
8030 return fold_build2_loc (loc, RDIV_EXPR, type,
8031 build_real (type, dconst1), arg0);
8033 /* Optimize pow(x,0.5) = sqrt(x). */
8034 if (flag_unsafe_math_optimizations
8035 && REAL_VALUES_EQUAL (c, dconsthalf))
8037 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8039 if (sqrtfn != NULL_TREE)
8040 return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8043 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8044 if (flag_unsafe_math_optimizations)
8046 const REAL_VALUE_TYPE dconstroot
8047 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8049 if (REAL_VALUES_EQUAL (c, dconstroot))
8051 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8052 if (cbrtfn != NULL_TREE)
8053 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8057 /* Check for an integer exponent. */
8058 n = real_to_integer (&c);
8059 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8060 if (real_identical (&c, &cint))
8062 /* Attempt to evaluate pow at compile-time, unless this should
8063 raise an exception. */
8064 if (TREE_CODE (arg0) == REAL_CST
8065 && !TREE_OVERFLOW (arg0)
8067 || (!flag_trapping_math && !flag_errno_math)
8068 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8073 x = TREE_REAL_CST (arg0);
8074 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8075 if (flag_unsafe_math_optimizations || !inexact)
8076 return build_real (type, x);
8079 /* Strip sign ops from even integer powers. */
8080 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8082 tree narg0 = fold_strip_sign_ops (arg0);
8084 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8089 if (flag_unsafe_math_optimizations)
8091 const enum built_in_function fcode = builtin_mathfn_code (arg0);
8093 /* Optimize pow(expN(x),y) = expN(x*y). */
8094 if (BUILTIN_EXPONENT_P (fcode))
8096 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8097 tree arg = CALL_EXPR_ARG (arg0, 0);
8098 arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8099 return build_call_expr_loc (loc, expfn, 1, arg);
8102 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8103 if (BUILTIN_SQRT_P (fcode))
8105 tree narg0 = CALL_EXPR_ARG (arg0, 0);
8106 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8107 build_real (type, dconsthalf));
8108 return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8111 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8112 if (BUILTIN_CBRT_P (fcode))
8114 tree arg = CALL_EXPR_ARG (arg0, 0);
8115 if (tree_expr_nonnegative_p (arg))
8117 const REAL_VALUE_TYPE dconstroot
8118 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8119 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8120 build_real (type, dconstroot));
8121 return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8125 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8126 if (fcode == BUILT_IN_POW
8127 || fcode == BUILT_IN_POWF
8128 || fcode == BUILT_IN_POWL)
8130 tree arg00 = CALL_EXPR_ARG (arg0, 0);
8131 if (tree_expr_nonnegative_p (arg00))
8133 tree arg01 = CALL_EXPR_ARG (arg0, 1);
8134 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8135 return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8143 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8144 Return NULL_TREE if no simplification can be made. */
8146 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8147 tree arg0, tree arg1, tree type)
8149 if (!validate_arg (arg0, REAL_TYPE)
8150 || !validate_arg (arg1, INTEGER_TYPE))
8153 /* Optimize pow(1.0,y) = 1.0. */
8154 if (real_onep (arg0))
8155 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8157 if (host_integerp (arg1, 0))
8159 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8161 /* Evaluate powi at compile-time. */
8162 if (TREE_CODE (arg0) == REAL_CST
8163 && !TREE_OVERFLOW (arg0))
8166 x = TREE_REAL_CST (arg0);
8167 real_powi (&x, TYPE_MODE (type), &x, c);
8168 return build_real (type, x);
8171 /* Optimize pow(x,0) = 1.0. */
8173 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8176 /* Optimize pow(x,1) = x. */
8180 /* Optimize pow(x,-1) = 1.0/x. */
8182 return fold_build2_loc (loc, RDIV_EXPR, type,
8183 build_real (type, dconst1), arg0);
8189 /* A subroutine of fold_builtin to fold the various exponent
8190 functions. Return NULL_TREE if no simplification can be made.
8191 FUNC is the corresponding MPFR exponent function. */
8194 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8195 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8197 if (validate_arg (arg, REAL_TYPE))
8199 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8202 /* Calculate the result when the argument is a constant. */
8203 if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8206 /* Optimize expN(logN(x)) = x. */
8207 if (flag_unsafe_math_optimizations)
8209 const enum built_in_function fcode = builtin_mathfn_code (arg);
8211 if ((func == mpfr_exp
8212 && (fcode == BUILT_IN_LOG
8213 || fcode == BUILT_IN_LOGF
8214 || fcode == BUILT_IN_LOGL))
8215 || (func == mpfr_exp2
8216 && (fcode == BUILT_IN_LOG2
8217 || fcode == BUILT_IN_LOG2F
8218 || fcode == BUILT_IN_LOG2L))
8219 || (func == mpfr_exp10
8220 && (fcode == BUILT_IN_LOG10
8221 || fcode == BUILT_IN_LOG10F
8222 || fcode == BUILT_IN_LOG10L)))
8223 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8230 /* Return true if VAR is a VAR_DECL or a component thereof. */
8233 var_decl_component_p (tree var)
8236 while (handled_component_p (inner))
8237 inner = TREE_OPERAND (inner, 0);
8238 return SSA_VAR_P (inner);
8241 /* Fold function call to builtin memset. Return
8242 NULL_TREE if no simplification can be made. */
8245 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8246 tree type, bool ignore)
8248 tree var, ret, etype;
8249 unsigned HOST_WIDE_INT length, cval;
8251 if (! validate_arg (dest, POINTER_TYPE)
8252 || ! validate_arg (c, INTEGER_TYPE)
8253 || ! validate_arg (len, INTEGER_TYPE))
8256 if (! host_integerp (len, 1))
8259 /* If the LEN parameter is zero, return DEST. */
8260 if (integer_zerop (len))
8261 return omit_one_operand_loc (loc, type, dest, c);
8263 if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8268 if (TREE_CODE (var) != ADDR_EXPR)
8271 var = TREE_OPERAND (var, 0);
8272 if (TREE_THIS_VOLATILE (var))
8275 etype = TREE_TYPE (var);
8276 if (TREE_CODE (etype) == ARRAY_TYPE)
8277 etype = TREE_TYPE (etype);
8279 if (!INTEGRAL_TYPE_P (etype)
8280 && !POINTER_TYPE_P (etype))
8283 if (! var_decl_component_p (var))
8286 length = tree_low_cst (len, 1);
8287 if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8288 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8292 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8295 if (integer_zerop (c))
8299 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8302 cval = tree_low_cst (c, 1);
8306 cval |= (cval << 31) << 1;
8309 ret = build_int_cst_type (etype, cval);
8310 var = build_fold_indirect_ref_loc (loc,
8311 fold_convert_loc (loc,
8312 build_pointer_type (etype),
8314 ret = build2 (MODIFY_EXPR, etype, var, ret);
8318 return omit_one_operand_loc (loc, type, dest, ret);
8321 /* Fold function call to builtin memset. Return
8322 NULL_TREE if no simplification can be made. */
8325 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8327 if (! validate_arg (dest, POINTER_TYPE)
8328 || ! validate_arg (size, INTEGER_TYPE))
8334 /* New argument list transforming bzero(ptr x, int y) to
8335 memset(ptr x, int 0, size_t y). This is done this way
8336 so that if it isn't expanded inline, we fallback to
8337 calling bzero instead of memset. */
8339 return fold_builtin_memset (loc, dest, integer_zero_node,
8340 fold_convert_loc (loc, sizetype, size),
8341 void_type_node, ignore);
8344 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8345 NULL_TREE if no simplification can be made.
8346 If ENDP is 0, return DEST (like memcpy).
8347 If ENDP is 1, return DEST+LEN (like mempcpy).
8348 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8349 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8353 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8354 tree len, tree type, bool ignore, int endp)
8356 tree destvar, srcvar, expr;
8358 if (! validate_arg (dest, POINTER_TYPE)
8359 || ! validate_arg (src, POINTER_TYPE)
8360 || ! validate_arg (len, INTEGER_TYPE))
8363 /* If the LEN parameter is zero, return DEST. */
8364 if (integer_zerop (len))
8365 return omit_one_operand_loc (loc, type, dest, src);
8367 /* If SRC and DEST are the same (and not volatile), return
8368 DEST{,+LEN,+LEN-1}. */
8369 if (operand_equal_p (src, dest, 0))
8373 tree srctype, desttype;
8374 unsigned int src_align, dest_align;
8379 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8380 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8382 /* Both DEST and SRC must be pointer types.
8383 ??? This is what old code did. Is the testing for pointer types
8386 If either SRC is readonly or length is 1, we can use memcpy. */
8387 if (!dest_align || !src_align)
8389 if (readonly_data_expr (src)
8390 || (host_integerp (len, 1)
8391 && (MIN (src_align, dest_align) / BITS_PER_UNIT
8392 >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8394 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8397 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8400 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8401 if (TREE_CODE (src) == ADDR_EXPR
8402 && TREE_CODE (dest) == ADDR_EXPR)
8404 tree src_base, dest_base, fn;
8405 HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8406 HOST_WIDE_INT size = -1;
8407 HOST_WIDE_INT maxsize = -1;
8409 srcvar = TREE_OPERAND (src, 0);
8410 src_base = get_ref_base_and_extent (srcvar, &src_offset,
8412 destvar = TREE_OPERAND (dest, 0);
8413 dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8415 if (host_integerp (len, 1))
8416 maxsize = tree_low_cst (len, 1);
8419 src_offset /= BITS_PER_UNIT;
8420 dest_offset /= BITS_PER_UNIT;
8421 if (SSA_VAR_P (src_base)
8422 && SSA_VAR_P (dest_base))
8424 if (operand_equal_p (src_base, dest_base, 0)
8425 && ranges_overlap_p (src_offset, maxsize,
8426 dest_offset, maxsize))
8429 else if (TREE_CODE (src_base) == MEM_REF
8430 && TREE_CODE (dest_base) == MEM_REF)
8433 if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8434 TREE_OPERAND (dest_base, 0), 0))
8436 off = double_int_add (mem_ref_offset (src_base),
8437 shwi_to_double_int (src_offset));
8438 if (!double_int_fits_in_shwi_p (off))
8440 src_offset = off.low;
8441 off = double_int_add (mem_ref_offset (dest_base),
8442 shwi_to_double_int (dest_offset));
8443 if (!double_int_fits_in_shwi_p (off))
8445 dest_offset = off.low;
8446 if (ranges_overlap_p (src_offset, maxsize,
8447 dest_offset, maxsize))
8453 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8456 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8459 /* If the destination and source do not alias optimize into
8461 if ((is_gimple_min_invariant (dest)
8462 || TREE_CODE (dest) == SSA_NAME)
8463 && (is_gimple_min_invariant (src)
8464 || TREE_CODE (src) == SSA_NAME))
8467 ao_ref_init_from_ptr_and_size (&destr, dest, len);
8468 ao_ref_init_from_ptr_and_size (&srcr, src, len);
8469 if (!refs_may_alias_p_1 (&destr, &srcr, false))
8472 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8475 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8482 if (!host_integerp (len, 0))
8485 This logic lose for arguments like (type *)malloc (sizeof (type)),
8486 since we strip the casts of up to VOID return value from malloc.
8487 Perhaps we ought to inherit type from non-VOID argument here? */
8490 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8491 if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8493 tree tem = TREE_OPERAND (src, 0);
8495 if (tem != TREE_OPERAND (src, 0))
8496 src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8498 if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8500 tree tem = TREE_OPERAND (dest, 0);
8502 if (tem != TREE_OPERAND (dest, 0))
8503 dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8505 srctype = TREE_TYPE (TREE_TYPE (src));
8507 && TREE_CODE (srctype) == ARRAY_TYPE
8508 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8510 srctype = TREE_TYPE (srctype);
8512 src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8514 desttype = TREE_TYPE (TREE_TYPE (dest));
8516 && TREE_CODE (desttype) == ARRAY_TYPE
8517 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8519 desttype = TREE_TYPE (desttype);
8521 dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8523 if (!srctype || !desttype
8524 || TREE_ADDRESSABLE (srctype)
8525 || TREE_ADDRESSABLE (desttype)
8526 || !TYPE_SIZE_UNIT (srctype)
8527 || !TYPE_SIZE_UNIT (desttype)
8528 || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8529 || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8532 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8533 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8534 if (dest_align < TYPE_ALIGN (desttype)
8535 || src_align < TYPE_ALIGN (srctype))
8539 dest = builtin_save_expr (dest);
8541 /* Build accesses at offset zero with a ref-all character type. */
8542 off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8543 ptr_mode, true), 0);
8546 STRIP_NOPS (destvar);
8547 if (TREE_CODE (destvar) == ADDR_EXPR
8548 && var_decl_component_p (TREE_OPERAND (destvar, 0))
8549 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8550 destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8552 destvar = NULL_TREE;
8555 STRIP_NOPS (srcvar);
8556 if (TREE_CODE (srcvar) == ADDR_EXPR
8557 && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8558 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8561 || src_align >= TYPE_ALIGN (desttype))
8562 srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8564 else if (!STRICT_ALIGNMENT)
8566 srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8568 srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8576 if (srcvar == NULL_TREE && destvar == NULL_TREE)
8579 if (srcvar == NULL_TREE)
8582 if (src_align >= TYPE_ALIGN (desttype))
8583 srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8586 if (STRICT_ALIGNMENT)
8588 srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8590 srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8593 else if (destvar == NULL_TREE)
8596 if (dest_align >= TYPE_ALIGN (srctype))
8597 destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8600 if (STRICT_ALIGNMENT)
8602 desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8604 destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8608 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8614 if (endp == 0 || endp == 3)
8615 return omit_one_operand_loc (loc, type, dest, expr);
8621 len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8624 len = fold_convert_loc (loc, sizetype, len);
8625 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8626 dest = fold_convert_loc (loc, type, dest);
8628 dest = omit_one_operand_loc (loc, type, dest, expr);
8632 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8633 If LEN is not NULL, it represents the length of the string to be
8634 copied. Return NULL_TREE if no simplification can be made. */
8637 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8641 if (!validate_arg (dest, POINTER_TYPE)
8642 || !validate_arg (src, POINTER_TYPE))
8645 /* If SRC and DEST are the same (and not volatile), return DEST. */
8646 if (operand_equal_p (src, dest, 0))
8647 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8649 if (optimize_function_for_size_p (cfun))
8652 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8658 len = c_strlen (src, 1);
8659 if (! len || TREE_SIDE_EFFECTS (len))
8663 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8664 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8665 build_call_expr_loc (loc, fn, 3, dest, src, len));
8668 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8669 Return NULL_TREE if no simplification can be made. */
8672 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8674 tree fn, len, lenp1, call, type;
8676 if (!validate_arg (dest, POINTER_TYPE)
8677 || !validate_arg (src, POINTER_TYPE))
8680 len = c_strlen (src, 1);
8682 || TREE_CODE (len) != INTEGER_CST)
8685 if (optimize_function_for_size_p (cfun)
8686 /* If length is zero it's small enough. */
8687 && !integer_zerop (len))
8690 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8694 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8695 /* We use dest twice in building our expression. Save it from
8696 multiple expansions. */
8697 dest = builtin_save_expr (dest);
8698 call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8700 type = TREE_TYPE (TREE_TYPE (fndecl));
8701 len = fold_convert_loc (loc, sizetype, len);
8702 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8703 dest = fold_convert_loc (loc, type, dest);
8704 dest = omit_one_operand_loc (loc, type, dest, call);
8708 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8709 If SLEN is not NULL, it represents the length of the source string.
8710 Return NULL_TREE if no simplification can be made. */
8713 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8714 tree src, tree len, tree slen)
8718 if (!validate_arg (dest, POINTER_TYPE)
8719 || !validate_arg (src, POINTER_TYPE)
8720 || !validate_arg (len, INTEGER_TYPE))
8723 /* If the LEN parameter is zero, return DEST. */
8724 if (integer_zerop (len))
8725 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8727 /* We can't compare slen with len as constants below if len is not a
8729 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8733 slen = c_strlen (src, 1);
8735 /* Now, we must be passed a constant src ptr parameter. */
8736 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8739 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8741 /* We do not support simplification of this case, though we do
8742 support it when expanding trees into RTL. */
8743 /* FIXME: generate a call to __builtin_memset. */
8744 if (tree_int_cst_lt (slen, len))
8747 /* OK transform into builtin memcpy. */
8748 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8751 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8752 build_call_expr_loc (loc, fn, 3, dest, src, len));
8755 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8756 arguments to the call, and TYPE is its return type.
8757 Return NULL_TREE if no simplification can be made. */
8760 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8762 if (!validate_arg (arg1, POINTER_TYPE)
8763 || !validate_arg (arg2, INTEGER_TYPE)
8764 || !validate_arg (len, INTEGER_TYPE))
8770 if (TREE_CODE (arg2) != INTEGER_CST
8771 || !host_integerp (len, 1))
8774 p1 = c_getstr (arg1);
8775 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8781 if (target_char_cast (arg2, &c))
8784 r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8787 return build_int_cst (TREE_TYPE (arg1), 0);
8789 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8791 return fold_convert_loc (loc, type, tem);
8797 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8798 Return NULL_TREE if no simplification can be made. */
8801 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8803 const char *p1, *p2;
8805 if (!validate_arg (arg1, POINTER_TYPE)
8806 || !validate_arg (arg2, POINTER_TYPE)
8807 || !validate_arg (len, INTEGER_TYPE))
8810 /* If the LEN parameter is zero, return zero. */
8811 if (integer_zerop (len))
8812 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8815 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8816 if (operand_equal_p (arg1, arg2, 0))
8817 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8819 p1 = c_getstr (arg1);
8820 p2 = c_getstr (arg2);
8822 /* If all arguments are constant, and the value of len is not greater
8823 than the lengths of arg1 and arg2, evaluate at compile-time. */
8824 if (host_integerp (len, 1) && p1 && p2
8825 && compare_tree_int (len, strlen (p1) + 1) <= 0
8826 && compare_tree_int (len, strlen (p2) + 1) <= 0)
8828 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8831 return integer_one_node;
8833 return integer_minus_one_node;
8835 return integer_zero_node;
8838 /* If len parameter is one, return an expression corresponding to
8839 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8840 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8842 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8843 tree cst_uchar_ptr_node
8844 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8847 = fold_convert_loc (loc, integer_type_node,
8848 build1 (INDIRECT_REF, cst_uchar_node,
8849 fold_convert_loc (loc,
8853 = fold_convert_loc (loc, integer_type_node,
8854 build1 (INDIRECT_REF, cst_uchar_node,
8855 fold_convert_loc (loc,
8858 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8864 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8865 Return NULL_TREE if no simplification can be made. */
8868 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8870 const char *p1, *p2;
8872 if (!validate_arg (arg1, POINTER_TYPE)
8873 || !validate_arg (arg2, POINTER_TYPE))
8876 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8877 if (operand_equal_p (arg1, arg2, 0))
8878 return integer_zero_node;
8880 p1 = c_getstr (arg1);
8881 p2 = c_getstr (arg2);
8885 const int i = strcmp (p1, p2);
8887 return integer_minus_one_node;
8889 return integer_one_node;
8891 return integer_zero_node;
8894 /* If the second arg is "", return *(const unsigned char*)arg1. */
8895 if (p2 && *p2 == '\0')
8897 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8898 tree cst_uchar_ptr_node
8899 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8901 return fold_convert_loc (loc, integer_type_node,
8902 build1 (INDIRECT_REF, cst_uchar_node,
8903 fold_convert_loc (loc,
8908 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8909 if (p1 && *p1 == '\0')
8911 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8912 tree cst_uchar_ptr_node
8913 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8916 = fold_convert_loc (loc, integer_type_node,
8917 build1 (INDIRECT_REF, cst_uchar_node,
8918 fold_convert_loc (loc,
8921 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8927 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8928 Return NULL_TREE if no simplification can be made. */
8931 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8933 const char *p1, *p2;
8935 if (!validate_arg (arg1, POINTER_TYPE)
8936 || !validate_arg (arg2, POINTER_TYPE)
8937 || !validate_arg (len, INTEGER_TYPE))
8940 /* If the LEN parameter is zero, return zero. */
8941 if (integer_zerop (len))
8942 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8945 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8946 if (operand_equal_p (arg1, arg2, 0))
8947 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8949 p1 = c_getstr (arg1);
8950 p2 = c_getstr (arg2);
8952 if (host_integerp (len, 1) && p1 && p2)
8954 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8956 return integer_one_node;
8958 return integer_minus_one_node;
8960 return integer_zero_node;
8963 /* If the second arg is "", and the length is greater than zero,
8964 return *(const unsigned char*)arg1. */
8965 if (p2 && *p2 == '\0'
8966 && TREE_CODE (len) == INTEGER_CST
8967 && tree_int_cst_sgn (len) == 1)
8969 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8970 tree cst_uchar_ptr_node
8971 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8973 return fold_convert_loc (loc, integer_type_node,
8974 build1 (INDIRECT_REF, cst_uchar_node,
8975 fold_convert_loc (loc,
8980 /* If the first arg is "", and the length is greater than zero,
8981 return -*(const unsigned char*)arg2. */
8982 if (p1 && *p1 == '\0'
8983 && TREE_CODE (len) == INTEGER_CST
8984 && tree_int_cst_sgn (len) == 1)
8986 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8987 tree cst_uchar_ptr_node
8988 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8990 tree temp = fold_convert_loc (loc, integer_type_node,
8991 build1 (INDIRECT_REF, cst_uchar_node,
8992 fold_convert_loc (loc,
8995 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8998 /* If len parameter is one, return an expression corresponding to
8999 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9000 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9002 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9003 tree cst_uchar_ptr_node
9004 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9006 tree ind1 = fold_convert_loc (loc, integer_type_node,
9007 build1 (INDIRECT_REF, cst_uchar_node,
9008 fold_convert_loc (loc,
9011 tree ind2 = fold_convert_loc (loc, integer_type_node,
9012 build1 (INDIRECT_REF, cst_uchar_node,
9013 fold_convert_loc (loc,
9016 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9022 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9023 ARG. Return NULL_TREE if no simplification can be made. */
9026 fold_builtin_signbit (location_t loc, tree arg, tree type)
9030 if (!validate_arg (arg, REAL_TYPE))
9033 /* If ARG is a compile-time constant, determine the result. */
9034 if (TREE_CODE (arg) == REAL_CST
9035 && !TREE_OVERFLOW (arg))
9039 c = TREE_REAL_CST (arg);
9040 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9041 return fold_convert_loc (loc, type, temp);
9044 /* If ARG is non-negative, the result is always zero. */
9045 if (tree_expr_nonnegative_p (arg))
9046 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9048 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9049 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9050 return fold_build2_loc (loc, LT_EXPR, type, arg,
9051 build_real (TREE_TYPE (arg), dconst0));
9056 /* Fold function call to builtin copysign, copysignf or copysignl with
9057 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9061 fold_builtin_copysign (location_t loc, tree fndecl,
9062 tree arg1, tree arg2, tree type)
9066 if (!validate_arg (arg1, REAL_TYPE)
9067 || !validate_arg (arg2, REAL_TYPE))
9070 /* copysign(X,X) is X. */
9071 if (operand_equal_p (arg1, arg2, 0))
9072 return fold_convert_loc (loc, type, arg1);
9074 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9075 if (TREE_CODE (arg1) == REAL_CST
9076 && TREE_CODE (arg2) == REAL_CST
9077 && !TREE_OVERFLOW (arg1)
9078 && !TREE_OVERFLOW (arg2))
9080 REAL_VALUE_TYPE c1, c2;
9082 c1 = TREE_REAL_CST (arg1);
9083 c2 = TREE_REAL_CST (arg2);
9084 /* c1.sign := c2.sign. */
9085 real_copysign (&c1, &c2);
9086 return build_real (type, c1);
9089 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9090 Remember to evaluate Y for side-effects. */
9091 if (tree_expr_nonnegative_p (arg2))
9092 return omit_one_operand_loc (loc, type,
9093 fold_build1_loc (loc, ABS_EXPR, type, arg1),
9096 /* Strip sign changing operations for the first argument. */
9097 tem = fold_strip_sign_ops (arg1);
9099 return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9104 /* Fold a call to builtin isascii with argument ARG. */
9107 fold_builtin_isascii (location_t loc, tree arg)
9109 if (!validate_arg (arg, INTEGER_TYPE))
9113 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9114 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9115 build_int_cst (NULL_TREE,
9116 ~ (unsigned HOST_WIDE_INT) 0x7f));
9117 return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9118 arg, integer_zero_node);
9122 /* Fold a call to builtin toascii with argument ARG. */
9125 fold_builtin_toascii (location_t loc, tree arg)
9127 if (!validate_arg (arg, INTEGER_TYPE))
9130 /* Transform toascii(c) -> (c & 0x7f). */
9131 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9132 build_int_cst (NULL_TREE, 0x7f));
9135 /* Fold a call to builtin isdigit with argument ARG. */
9138 fold_builtin_isdigit (location_t loc, tree arg)
9140 if (!validate_arg (arg, INTEGER_TYPE))
9144 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9145 /* According to the C standard, isdigit is unaffected by locale.
9146 However, it definitely is affected by the target character set. */
9147 unsigned HOST_WIDE_INT target_digit0
9148 = lang_hooks.to_target_charset ('0');
9150 if (target_digit0 == 0)
9153 arg = fold_convert_loc (loc, unsigned_type_node, arg);
9154 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9155 build_int_cst (unsigned_type_node, target_digit0));
9156 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9157 build_int_cst (unsigned_type_node, 9));
9161 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9164 fold_builtin_fabs (location_t loc, tree arg, tree type)
9166 if (!validate_arg (arg, REAL_TYPE))
9169 arg = fold_convert_loc (loc, type, arg);
9170 if (TREE_CODE (arg) == REAL_CST)
9171 return fold_abs_const (arg, type);
9172 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9175 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9178 fold_builtin_abs (location_t loc, tree arg, tree type)
9180 if (!validate_arg (arg, INTEGER_TYPE))
9183 arg = fold_convert_loc (loc, type, arg);
9184 if (TREE_CODE (arg) == INTEGER_CST)
9185 return fold_abs_const (arg, type);
9186 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9189 /* Fold a call to builtin fmin or fmax. */
9192 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9193 tree type, bool max)
9195 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9197 /* Calculate the result when the argument is a constant. */
9198 tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9203 /* If either argument is NaN, return the other one. Avoid the
9204 transformation if we get (and honor) a signalling NaN. Using
9205 omit_one_operand() ensures we create a non-lvalue. */
9206 if (TREE_CODE (arg0) == REAL_CST
9207 && real_isnan (&TREE_REAL_CST (arg0))
9208 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9209 || ! TREE_REAL_CST (arg0).signalling))
9210 return omit_one_operand_loc (loc, type, arg1, arg0);
9211 if (TREE_CODE (arg1) == REAL_CST
9212 && real_isnan (&TREE_REAL_CST (arg1))
9213 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9214 || ! TREE_REAL_CST (arg1).signalling))
9215 return omit_one_operand_loc (loc, type, arg0, arg1);
9217 /* Transform fmin/fmax(x,x) -> x. */
9218 if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9219 return omit_one_operand_loc (loc, type, arg0, arg1);
9221 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9222 functions to return the numeric arg if the other one is NaN.
9223 These tree codes don't honor that, so only transform if
9224 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9225 handled, so we don't have to worry about it either. */
9226 if (flag_finite_math_only)
9227 return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9228 fold_convert_loc (loc, type, arg0),
9229 fold_convert_loc (loc, type, arg1));
9234 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9237 fold_builtin_carg (location_t loc, tree arg, tree type)
9239 if (validate_arg (arg, COMPLEX_TYPE)
9240 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9242 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9246 tree new_arg = builtin_save_expr (arg);
9247 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9248 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9249 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9256 /* Fold a call to builtin logb/ilogb. */
9259 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9261 if (! validate_arg (arg, REAL_TYPE))
9266 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9268 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9274 /* If arg is Inf or NaN and we're logb, return it. */
9275 if (TREE_CODE (rettype) == REAL_TYPE)
9276 return fold_convert_loc (loc, rettype, arg);
9277 /* Fall through... */
9279 /* Zero may set errno and/or raise an exception for logb, also
9280 for ilogb we don't know FP_ILOGB0. */
9283 /* For normal numbers, proceed iff radix == 2. In GCC,
9284 normalized significands are in the range [0.5, 1.0). We
9285 want the exponent as if they were [1.0, 2.0) so get the
9286 exponent and subtract 1. */
9287 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9288 return fold_convert_loc (loc, rettype,
9289 build_int_cst (NULL_TREE,
9290 REAL_EXP (value)-1));
9298 /* Fold a call to builtin significand, if radix == 2. */
9301 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9303 if (! validate_arg (arg, REAL_TYPE))
9308 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9310 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9317 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9318 return fold_convert_loc (loc, rettype, arg);
9320 /* For normal numbers, proceed iff radix == 2. */
9321 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9323 REAL_VALUE_TYPE result = *value;
9324 /* In GCC, normalized significands are in the range [0.5,
9325 1.0). We want them to be [1.0, 2.0) so set the
9327 SET_REAL_EXP (&result, 1);
9328 return build_real (rettype, result);
9337 /* Fold a call to builtin frexp, we can assume the base is 2. */
9340 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9342 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9347 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9350 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9352 /* Proceed if a valid pointer type was passed in. */
9353 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9355 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9361 /* For +-0, return (*exp = 0, +-0). */
9362 exp = integer_zero_node;
9367 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9368 return omit_one_operand_loc (loc, rettype, arg0, arg1);
9371 /* Since the frexp function always expects base 2, and in
9372 GCC normalized significands are already in the range
9373 [0.5, 1.0), we have exactly what frexp wants. */
9374 REAL_VALUE_TYPE frac_rvt = *value;
9375 SET_REAL_EXP (&frac_rvt, 0);
9376 frac = build_real (rettype, frac_rvt);
9377 exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9384 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9385 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9386 TREE_SIDE_EFFECTS (arg1) = 1;
9387 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9393 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9394 then we can assume the base is two. If it's false, then we have to
9395 check the mode of the TYPE parameter in certain cases. */
9398 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9399 tree type, bool ldexp)
9401 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9406 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9407 if (real_zerop (arg0) || integer_zerop (arg1)
9408 || (TREE_CODE (arg0) == REAL_CST
9409 && !real_isfinite (&TREE_REAL_CST (arg0))))
9410 return omit_one_operand_loc (loc, type, arg0, arg1);
9412 /* If both arguments are constant, then try to evaluate it. */
9413 if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9414 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9415 && host_integerp (arg1, 0))
9417 /* Bound the maximum adjustment to twice the range of the
9418 mode's valid exponents. Use abs to ensure the range is
9419 positive as a sanity check. */
9420 const long max_exp_adj = 2 *
9421 labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9422 - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9424 /* Get the user-requested adjustment. */
9425 const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9427 /* The requested adjustment must be inside this range. This
9428 is a preliminary cap to avoid things like overflow, we
9429 may still fail to compute the result for other reasons. */
9430 if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9432 REAL_VALUE_TYPE initial_result;
9434 real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9436 /* Ensure we didn't overflow. */
9437 if (! real_isinf (&initial_result))
9439 const REAL_VALUE_TYPE trunc_result
9440 = real_value_truncate (TYPE_MODE (type), initial_result);
9442 /* Only proceed if the target mode can hold the
9444 if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9445 return build_real (type, trunc_result);
9454 /* Fold a call to builtin modf. */
9457 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9459 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9464 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9467 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9469 /* Proceed if a valid pointer type was passed in. */
9470 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9472 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9473 REAL_VALUE_TYPE trunc, frac;
9479 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9480 trunc = frac = *value;
9483 /* For +-Inf, return (*arg1 = arg0, +-0). */
9485 frac.sign = value->sign;
9489 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9490 real_trunc (&trunc, VOIDmode, value);
9491 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9492 /* If the original number was negative and already
9493 integral, then the fractional part is -0.0. */
9494 if (value->sign && frac.cl == rvc_zero)
9495 frac.sign = value->sign;
9499 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9500 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9501 build_real (rettype, trunc));
9502 TREE_SIDE_EFFECTS (arg1) = 1;
9503 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9504 build_real (rettype, frac));
9510 /* Given a location LOC, an interclass builtin function decl FNDECL
9511 and its single argument ARG, return an folded expression computing
9512 the same, or NULL_TREE if we either couldn't or didn't want to fold
9513 (the latter happen if there's an RTL instruction available). */
9516 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9518 enum machine_mode mode;
9520 if (!validate_arg (arg, REAL_TYPE))
9523 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9526 mode = TYPE_MODE (TREE_TYPE (arg));
9528 /* If there is no optab, try generic code. */
9529 switch (DECL_FUNCTION_CODE (fndecl))
9533 CASE_FLT_FN (BUILT_IN_ISINF):
9535 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9536 tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9537 tree const type = TREE_TYPE (arg);
9541 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9542 real_from_string (&r, buf);
9543 result = build_call_expr (isgr_fn, 2,
9544 fold_build1_loc (loc, ABS_EXPR, type, arg),
9545 build_real (type, r));
9548 CASE_FLT_FN (BUILT_IN_FINITE):
9549 case BUILT_IN_ISFINITE:
9551 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9552 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9553 tree const type = TREE_TYPE (arg);
9557 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9558 real_from_string (&r, buf);
9559 result = build_call_expr (isle_fn, 2,
9560 fold_build1_loc (loc, ABS_EXPR, type, arg),
9561 build_real (type, r));
9562 /*result = fold_build2_loc (loc, UNGT_EXPR,
9563 TREE_TYPE (TREE_TYPE (fndecl)),
9564 fold_build1_loc (loc, ABS_EXPR, type, arg),
9565 build_real (type, r));
9566 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9567 TREE_TYPE (TREE_TYPE (fndecl)),
9571 case BUILT_IN_ISNORMAL:
9573 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9574 islessequal(fabs(x),DBL_MAX). */
9575 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9576 tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9577 tree const type = TREE_TYPE (arg);
9578 REAL_VALUE_TYPE rmax, rmin;
9581 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9582 real_from_string (&rmax, buf);
9583 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9584 real_from_string (&rmin, buf);
9585 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9586 result = build_call_expr (isle_fn, 2, arg,
9587 build_real (type, rmax));
9588 result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9589 build_call_expr (isge_fn, 2, arg,
9590 build_real (type, rmin)));
9600 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9601 ARG is the argument for the call. */
9604 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9606 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9609 if (!validate_arg (arg, REAL_TYPE))
9612 switch (builtin_index)
9614 case BUILT_IN_ISINF:
9615 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9616 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9618 if (TREE_CODE (arg) == REAL_CST)
9620 r = TREE_REAL_CST (arg);
9621 if (real_isinf (&r))
9622 return real_compare (GT_EXPR, &r, &dconst0)
9623 ? integer_one_node : integer_minus_one_node;
9625 return integer_zero_node;
9630 case BUILT_IN_ISINF_SIGN:
9632 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9633 /* In a boolean context, GCC will fold the inner COND_EXPR to
9634 1. So e.g. "if (isinf_sign(x))" would be folded to just
9635 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9636 tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9637 tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9638 tree tmp = NULL_TREE;
9640 arg = builtin_save_expr (arg);
9642 if (signbit_fn && isinf_fn)
9644 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9645 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9647 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9648 signbit_call, integer_zero_node);
9649 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9650 isinf_call, integer_zero_node);
9652 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9653 integer_minus_one_node, integer_one_node);
9654 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9662 case BUILT_IN_ISFINITE:
9663 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9664 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9665 return omit_one_operand_loc (loc, type, integer_one_node, arg);
9667 if (TREE_CODE (arg) == REAL_CST)
9669 r = TREE_REAL_CST (arg);
9670 return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9675 case BUILT_IN_ISNAN:
9676 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9677 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9679 if (TREE_CODE (arg) == REAL_CST)
9681 r = TREE_REAL_CST (arg);
9682 return real_isnan (&r) ? integer_one_node : integer_zero_node;
9685 arg = builtin_save_expr (arg);
9686 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9693 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9694 This builtin will generate code to return the appropriate floating
9695 point classification depending on the value of the floating point
9696 number passed in. The possible return values must be supplied as
9697 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9698 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9699 one floating point argument which is "type generic". */
9702 fold_builtin_fpclassify (location_t loc, tree exp)
9704 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9705 arg, type, res, tmp;
9706 enum machine_mode mode;
9710 /* Verify the required arguments in the original call. */
9711 if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9712 INTEGER_TYPE, INTEGER_TYPE,
9713 INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9716 fp_nan = CALL_EXPR_ARG (exp, 0);
9717 fp_infinite = CALL_EXPR_ARG (exp, 1);
9718 fp_normal = CALL_EXPR_ARG (exp, 2);
9719 fp_subnormal = CALL_EXPR_ARG (exp, 3);
9720 fp_zero = CALL_EXPR_ARG (exp, 4);
9721 arg = CALL_EXPR_ARG (exp, 5);
9722 type = TREE_TYPE (arg);
9723 mode = TYPE_MODE (type);
9724 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9728 (fabs(x) == Inf ? FP_INFINITE :
9729 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9730 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9732 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9733 build_real (type, dconst0));
9734 res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9735 tmp, fp_zero, fp_subnormal);
9737 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9738 real_from_string (&r, buf);
9739 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9740 arg, build_real (type, r));
9741 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9743 if (HONOR_INFINITIES (mode))
9746 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9747 build_real (type, r));
9748 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9752 if (HONOR_NANS (mode))
9754 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9755 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9761 /* Fold a call to an unordered comparison function such as
9762 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9763 being called and ARG0 and ARG1 are the arguments for the call.
9764 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9765 the opposite of the desired result. UNORDERED_CODE is used
9766 for modes that can hold NaNs and ORDERED_CODE is used for
9770 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9771 enum tree_code unordered_code,
9772 enum tree_code ordered_code)
9774 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9775 enum tree_code code;
9777 enum tree_code code0, code1;
9778 tree cmp_type = NULL_TREE;
9780 type0 = TREE_TYPE (arg0);
9781 type1 = TREE_TYPE (arg1);
9783 code0 = TREE_CODE (type0);
9784 code1 = TREE_CODE (type1);
9786 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9787 /* Choose the wider of two real types. */
9788 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9790 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9792 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9795 arg0 = fold_convert_loc (loc, cmp_type, arg0);
9796 arg1 = fold_convert_loc (loc, cmp_type, arg1);
9798 if (unordered_code == UNORDERED_EXPR)
9800 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9801 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9802 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9805 code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9807 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9808 fold_build2_loc (loc, code, type, arg0, arg1));
9811 /* Fold a call to built-in function FNDECL with 0 arguments.
9812 IGNORE is true if the result of the function call is ignored. This
9813 function returns NULL_TREE if no simplification was possible. */
9816 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9818 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9819 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9822 CASE_FLT_FN (BUILT_IN_INF):
9823 case BUILT_IN_INFD32:
9824 case BUILT_IN_INFD64:
9825 case BUILT_IN_INFD128:
9826 return fold_builtin_inf (loc, type, true);
9828 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9829 return fold_builtin_inf (loc, type, false);
9831 case BUILT_IN_CLASSIFY_TYPE:
9832 return fold_builtin_classify_type (NULL_TREE);
9840 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9841 IGNORE is true if the result of the function call is ignored. This
9842 function returns NULL_TREE if no simplification was possible. */
9845 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9847 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9848 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9851 case BUILT_IN_CONSTANT_P:
9853 tree val = fold_builtin_constant_p (arg0);
9855 /* Gimplification will pull the CALL_EXPR for the builtin out of
9856 an if condition. When not optimizing, we'll not CSE it back.
9857 To avoid link error types of regressions, return false now. */
9858 if (!val && !optimize)
9859 val = integer_zero_node;
9864 case BUILT_IN_CLASSIFY_TYPE:
9865 return fold_builtin_classify_type (arg0);
9867 case BUILT_IN_STRLEN:
9868 return fold_builtin_strlen (loc, type, arg0);
9870 CASE_FLT_FN (BUILT_IN_FABS):
9871 return fold_builtin_fabs (loc, arg0, type);
9875 case BUILT_IN_LLABS:
9876 case BUILT_IN_IMAXABS:
9877 return fold_builtin_abs (loc, arg0, type);
9879 CASE_FLT_FN (BUILT_IN_CONJ):
9880 if (validate_arg (arg0, COMPLEX_TYPE)
9881 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9882 return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9885 CASE_FLT_FN (BUILT_IN_CREAL):
9886 if (validate_arg (arg0, COMPLEX_TYPE)
9887 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9888 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9891 CASE_FLT_FN (BUILT_IN_CIMAG):
9892 if (validate_arg (arg0, COMPLEX_TYPE)
9893 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9894 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9897 CASE_FLT_FN (BUILT_IN_CCOS):
9898 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9900 CASE_FLT_FN (BUILT_IN_CCOSH):
9901 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9903 CASE_FLT_FN (BUILT_IN_CPROJ):
9904 return fold_builtin_cproj(loc, arg0, type);
9906 CASE_FLT_FN (BUILT_IN_CSIN):
9907 if (validate_arg (arg0, COMPLEX_TYPE)
9908 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9909 return do_mpc_arg1 (arg0, type, mpc_sin);
9912 CASE_FLT_FN (BUILT_IN_CSINH):
9913 if (validate_arg (arg0, COMPLEX_TYPE)
9914 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9915 return do_mpc_arg1 (arg0, type, mpc_sinh);
9918 CASE_FLT_FN (BUILT_IN_CTAN):
9919 if (validate_arg (arg0, COMPLEX_TYPE)
9920 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9921 return do_mpc_arg1 (arg0, type, mpc_tan);
9924 CASE_FLT_FN (BUILT_IN_CTANH):
9925 if (validate_arg (arg0, COMPLEX_TYPE)
9926 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9927 return do_mpc_arg1 (arg0, type, mpc_tanh);
9930 CASE_FLT_FN (BUILT_IN_CLOG):
9931 if (validate_arg (arg0, COMPLEX_TYPE)
9932 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9933 return do_mpc_arg1 (arg0, type, mpc_log);
9936 CASE_FLT_FN (BUILT_IN_CSQRT):
9937 if (validate_arg (arg0, COMPLEX_TYPE)
9938 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9939 return do_mpc_arg1 (arg0, type, mpc_sqrt);
9942 CASE_FLT_FN (BUILT_IN_CASIN):
9943 if (validate_arg (arg0, COMPLEX_TYPE)
9944 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9945 return do_mpc_arg1 (arg0, type, mpc_asin);
9948 CASE_FLT_FN (BUILT_IN_CACOS):
9949 if (validate_arg (arg0, COMPLEX_TYPE)
9950 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9951 return do_mpc_arg1 (arg0, type, mpc_acos);
9954 CASE_FLT_FN (BUILT_IN_CATAN):
9955 if (validate_arg (arg0, COMPLEX_TYPE)
9956 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9957 return do_mpc_arg1 (arg0, type, mpc_atan);
9960 CASE_FLT_FN (BUILT_IN_CASINH):
9961 if (validate_arg (arg0, COMPLEX_TYPE)
9962 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9963 return do_mpc_arg1 (arg0, type, mpc_asinh);
9966 CASE_FLT_FN (BUILT_IN_CACOSH):
9967 if (validate_arg (arg0, COMPLEX_TYPE)
9968 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9969 return do_mpc_arg1 (arg0, type, mpc_acosh);
9972 CASE_FLT_FN (BUILT_IN_CATANH):
9973 if (validate_arg (arg0, COMPLEX_TYPE)
9974 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9975 return do_mpc_arg1 (arg0, type, mpc_atanh);
9978 CASE_FLT_FN (BUILT_IN_CABS):
9979 return fold_builtin_cabs (loc, arg0, type, fndecl);
9981 CASE_FLT_FN (BUILT_IN_CARG):
9982 return fold_builtin_carg (loc, arg0, type);
9984 CASE_FLT_FN (BUILT_IN_SQRT):
9985 return fold_builtin_sqrt (loc, arg0, type);
9987 CASE_FLT_FN (BUILT_IN_CBRT):
9988 return fold_builtin_cbrt (loc, arg0, type);
9990 CASE_FLT_FN (BUILT_IN_ASIN):
9991 if (validate_arg (arg0, REAL_TYPE))
9992 return do_mpfr_arg1 (arg0, type, mpfr_asin,
9993 &dconstm1, &dconst1, true);
9996 CASE_FLT_FN (BUILT_IN_ACOS):
9997 if (validate_arg (arg0, REAL_TYPE))
9998 return do_mpfr_arg1 (arg0, type, mpfr_acos,
9999 &dconstm1, &dconst1, true);
10002 CASE_FLT_FN (BUILT_IN_ATAN):
10003 if (validate_arg (arg0, REAL_TYPE))
10004 return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10007 CASE_FLT_FN (BUILT_IN_ASINH):
10008 if (validate_arg (arg0, REAL_TYPE))
10009 return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10012 CASE_FLT_FN (BUILT_IN_ACOSH):
10013 if (validate_arg (arg0, REAL_TYPE))
10014 return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10015 &dconst1, NULL, true);
10018 CASE_FLT_FN (BUILT_IN_ATANH):
10019 if (validate_arg (arg0, REAL_TYPE))
10020 return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10021 &dconstm1, &dconst1, false);
10024 CASE_FLT_FN (BUILT_IN_SIN):
10025 if (validate_arg (arg0, REAL_TYPE))
10026 return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10029 CASE_FLT_FN (BUILT_IN_COS):
10030 return fold_builtin_cos (loc, arg0, type, fndecl);
10032 CASE_FLT_FN (BUILT_IN_TAN):
10033 return fold_builtin_tan (arg0, type);
10035 CASE_FLT_FN (BUILT_IN_CEXP):
10036 return fold_builtin_cexp (loc, arg0, type);
10038 CASE_FLT_FN (BUILT_IN_CEXPI):
10039 if (validate_arg (arg0, REAL_TYPE))
10040 return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10043 CASE_FLT_FN (BUILT_IN_SINH):
10044 if (validate_arg (arg0, REAL_TYPE))
10045 return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10048 CASE_FLT_FN (BUILT_IN_COSH):
10049 return fold_builtin_cosh (loc, arg0, type, fndecl);
10051 CASE_FLT_FN (BUILT_IN_TANH):
10052 if (validate_arg (arg0, REAL_TYPE))
10053 return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10056 CASE_FLT_FN (BUILT_IN_ERF):
10057 if (validate_arg (arg0, REAL_TYPE))
10058 return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10061 CASE_FLT_FN (BUILT_IN_ERFC):
10062 if (validate_arg (arg0, REAL_TYPE))
10063 return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10066 CASE_FLT_FN (BUILT_IN_TGAMMA):
10067 if (validate_arg (arg0, REAL_TYPE))
10068 return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10071 CASE_FLT_FN (BUILT_IN_EXP):
10072 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10074 CASE_FLT_FN (BUILT_IN_EXP2):
10075 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10077 CASE_FLT_FN (BUILT_IN_EXP10):
10078 CASE_FLT_FN (BUILT_IN_POW10):
10079 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10081 CASE_FLT_FN (BUILT_IN_EXPM1):
10082 if (validate_arg (arg0, REAL_TYPE))
10083 return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10086 CASE_FLT_FN (BUILT_IN_LOG):
10087 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10089 CASE_FLT_FN (BUILT_IN_LOG2):
10090 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10092 CASE_FLT_FN (BUILT_IN_LOG10):
10093 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10095 CASE_FLT_FN (BUILT_IN_LOG1P):
10096 if (validate_arg (arg0, REAL_TYPE))
10097 return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10098 &dconstm1, NULL, false);
10101 CASE_FLT_FN (BUILT_IN_J0):
10102 if (validate_arg (arg0, REAL_TYPE))
10103 return do_mpfr_arg1 (arg0, type, mpfr_j0,
10107 CASE_FLT_FN (BUILT_IN_J1):
10108 if (validate_arg (arg0, REAL_TYPE))
10109 return do_mpfr_arg1 (arg0, type, mpfr_j1,
10113 CASE_FLT_FN (BUILT_IN_Y0):
10114 if (validate_arg (arg0, REAL_TYPE))
10115 return do_mpfr_arg1 (arg0, type, mpfr_y0,
10116 &dconst0, NULL, false);
10119 CASE_FLT_FN (BUILT_IN_Y1):
10120 if (validate_arg (arg0, REAL_TYPE))
10121 return do_mpfr_arg1 (arg0, type, mpfr_y1,
10122 &dconst0, NULL, false);
10125 CASE_FLT_FN (BUILT_IN_NAN):
10126 case BUILT_IN_NAND32:
10127 case BUILT_IN_NAND64:
10128 case BUILT_IN_NAND128:
10129 return fold_builtin_nan (arg0, type, true);
10131 CASE_FLT_FN (BUILT_IN_NANS):
10132 return fold_builtin_nan (arg0, type, false);
10134 CASE_FLT_FN (BUILT_IN_FLOOR):
10135 return fold_builtin_floor (loc, fndecl, arg0);
10137 CASE_FLT_FN (BUILT_IN_CEIL):
10138 return fold_builtin_ceil (loc, fndecl, arg0);
10140 CASE_FLT_FN (BUILT_IN_TRUNC):
10141 return fold_builtin_trunc (loc, fndecl, arg0);
10143 CASE_FLT_FN (BUILT_IN_ROUND):
10144 return fold_builtin_round (loc, fndecl, arg0);
10146 CASE_FLT_FN (BUILT_IN_NEARBYINT):
10147 CASE_FLT_FN (BUILT_IN_RINT):
10148 return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10150 CASE_FLT_FN (BUILT_IN_LCEIL):
10151 CASE_FLT_FN (BUILT_IN_LLCEIL):
10152 CASE_FLT_FN (BUILT_IN_LFLOOR):
10153 CASE_FLT_FN (BUILT_IN_LLFLOOR):
10154 CASE_FLT_FN (BUILT_IN_LROUND):
10155 CASE_FLT_FN (BUILT_IN_LLROUND):
10156 return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10158 CASE_FLT_FN (BUILT_IN_LRINT):
10159 CASE_FLT_FN (BUILT_IN_LLRINT):
10160 return fold_fixed_mathfn (loc, fndecl, arg0);
10162 case BUILT_IN_BSWAP32:
10163 case BUILT_IN_BSWAP64:
10164 return fold_builtin_bswap (fndecl, arg0);
10166 CASE_INT_FN (BUILT_IN_FFS):
10167 CASE_INT_FN (BUILT_IN_CLZ):
10168 CASE_INT_FN (BUILT_IN_CTZ):
10169 CASE_INT_FN (BUILT_IN_POPCOUNT):
10170 CASE_INT_FN (BUILT_IN_PARITY):
10171 return fold_builtin_bitop (fndecl, arg0);
10173 CASE_FLT_FN (BUILT_IN_SIGNBIT):
10174 return fold_builtin_signbit (loc, arg0, type);
10176 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10177 return fold_builtin_significand (loc, arg0, type);
10179 CASE_FLT_FN (BUILT_IN_ILOGB):
10180 CASE_FLT_FN (BUILT_IN_LOGB):
10181 return fold_builtin_logb (loc, arg0, type);
10183 case BUILT_IN_ISASCII:
10184 return fold_builtin_isascii (loc, arg0);
10186 case BUILT_IN_TOASCII:
10187 return fold_builtin_toascii (loc, arg0);
10189 case BUILT_IN_ISDIGIT:
10190 return fold_builtin_isdigit (loc, arg0);
10192 CASE_FLT_FN (BUILT_IN_FINITE):
10193 case BUILT_IN_FINITED32:
10194 case BUILT_IN_FINITED64:
10195 case BUILT_IN_FINITED128:
10196 case BUILT_IN_ISFINITE:
10198 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10201 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10204 CASE_FLT_FN (BUILT_IN_ISINF):
10205 case BUILT_IN_ISINFD32:
10206 case BUILT_IN_ISINFD64:
10207 case BUILT_IN_ISINFD128:
10209 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10212 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10215 case BUILT_IN_ISNORMAL:
10216 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10218 case BUILT_IN_ISINF_SIGN:
10219 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10221 CASE_FLT_FN (BUILT_IN_ISNAN):
10222 case BUILT_IN_ISNAND32:
10223 case BUILT_IN_ISNAND64:
10224 case BUILT_IN_ISNAND128:
10225 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10227 case BUILT_IN_PRINTF:
10228 case BUILT_IN_PRINTF_UNLOCKED:
10229 case BUILT_IN_VPRINTF:
10230 return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10232 case BUILT_IN_FREE:
10233 if (integer_zerop (arg0))
10234 return build_empty_stmt (loc);
10245 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10246 IGNORE is true if the result of the function call is ignored. This
10247 function returns NULL_TREE if no simplification was possible. */
10250 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10252 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10253 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10257 CASE_FLT_FN (BUILT_IN_JN):
10258 if (validate_arg (arg0, INTEGER_TYPE)
10259 && validate_arg (arg1, REAL_TYPE))
10260 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10263 CASE_FLT_FN (BUILT_IN_YN):
10264 if (validate_arg (arg0, INTEGER_TYPE)
10265 && validate_arg (arg1, REAL_TYPE))
10266 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10270 CASE_FLT_FN (BUILT_IN_DREM):
10271 CASE_FLT_FN (BUILT_IN_REMAINDER):
10272 if (validate_arg (arg0, REAL_TYPE)
10273 && validate_arg(arg1, REAL_TYPE))
10274 return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10277 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10278 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10279 if (validate_arg (arg0, REAL_TYPE)
10280 && validate_arg(arg1, POINTER_TYPE))
10281 return do_mpfr_lgamma_r (arg0, arg1, type);
10284 CASE_FLT_FN (BUILT_IN_ATAN2):
10285 if (validate_arg (arg0, REAL_TYPE)
10286 && validate_arg(arg1, REAL_TYPE))
10287 return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10290 CASE_FLT_FN (BUILT_IN_FDIM):
10291 if (validate_arg (arg0, REAL_TYPE)
10292 && validate_arg(arg1, REAL_TYPE))
10293 return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10296 CASE_FLT_FN (BUILT_IN_HYPOT):
10297 return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10299 CASE_FLT_FN (BUILT_IN_CPOW):
10300 if (validate_arg (arg0, COMPLEX_TYPE)
10301 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10302 && validate_arg (arg1, COMPLEX_TYPE)
10303 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10304 return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10307 CASE_FLT_FN (BUILT_IN_LDEXP):
10308 return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10309 CASE_FLT_FN (BUILT_IN_SCALBN):
10310 CASE_FLT_FN (BUILT_IN_SCALBLN):
10311 return fold_builtin_load_exponent (loc, arg0, arg1,
10312 type, /*ldexp=*/false);
10314 CASE_FLT_FN (BUILT_IN_FREXP):
10315 return fold_builtin_frexp (loc, arg0, arg1, type);
10317 CASE_FLT_FN (BUILT_IN_MODF):
10318 return fold_builtin_modf (loc, arg0, arg1, type);
10320 case BUILT_IN_BZERO:
10321 return fold_builtin_bzero (loc, arg0, arg1, ignore);
10323 case BUILT_IN_FPUTS:
10324 return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10326 case BUILT_IN_FPUTS_UNLOCKED:
10327 return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10329 case BUILT_IN_STRSTR:
10330 return fold_builtin_strstr (loc, arg0, arg1, type);
10332 case BUILT_IN_STRCAT:
10333 return fold_builtin_strcat (loc, arg0, arg1);
10335 case BUILT_IN_STRSPN:
10336 return fold_builtin_strspn (loc, arg0, arg1);
10338 case BUILT_IN_STRCSPN:
10339 return fold_builtin_strcspn (loc, arg0, arg1);
10341 case BUILT_IN_STRCHR:
10342 case BUILT_IN_INDEX:
10343 return fold_builtin_strchr (loc, arg0, arg1, type);
10345 case BUILT_IN_STRRCHR:
10346 case BUILT_IN_RINDEX:
10347 return fold_builtin_strrchr (loc, arg0, arg1, type);
10349 case BUILT_IN_STRCPY:
10350 return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10352 case BUILT_IN_STPCPY:
10355 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10359 return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10362 return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10365 case BUILT_IN_STRCMP:
10366 return fold_builtin_strcmp (loc, arg0, arg1);
10368 case BUILT_IN_STRPBRK:
10369 return fold_builtin_strpbrk (loc, arg0, arg1, type);
10371 case BUILT_IN_EXPECT:
10372 return fold_builtin_expect (loc, arg0, arg1);
10374 CASE_FLT_FN (BUILT_IN_POW):
10375 return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10377 CASE_FLT_FN (BUILT_IN_POWI):
10378 return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10380 CASE_FLT_FN (BUILT_IN_COPYSIGN):
10381 return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10383 CASE_FLT_FN (BUILT_IN_FMIN):
10384 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10386 CASE_FLT_FN (BUILT_IN_FMAX):
10387 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10389 case BUILT_IN_ISGREATER:
10390 return fold_builtin_unordered_cmp (loc, fndecl,
10391 arg0, arg1, UNLE_EXPR, LE_EXPR);
10392 case BUILT_IN_ISGREATEREQUAL:
10393 return fold_builtin_unordered_cmp (loc, fndecl,
10394 arg0, arg1, UNLT_EXPR, LT_EXPR);
10395 case BUILT_IN_ISLESS:
10396 return fold_builtin_unordered_cmp (loc, fndecl,
10397 arg0, arg1, UNGE_EXPR, GE_EXPR);
10398 case BUILT_IN_ISLESSEQUAL:
10399 return fold_builtin_unordered_cmp (loc, fndecl,
10400 arg0, arg1, UNGT_EXPR, GT_EXPR);
10401 case BUILT_IN_ISLESSGREATER:
10402 return fold_builtin_unordered_cmp (loc, fndecl,
10403 arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10404 case BUILT_IN_ISUNORDERED:
10405 return fold_builtin_unordered_cmp (loc, fndecl,
10406 arg0, arg1, UNORDERED_EXPR,
10409 /* We do the folding for va_start in the expander. */
10410 case BUILT_IN_VA_START:
10413 case BUILT_IN_SPRINTF:
10414 return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10416 case BUILT_IN_OBJECT_SIZE:
10417 return fold_builtin_object_size (arg0, arg1);
10419 case BUILT_IN_PRINTF:
10420 case BUILT_IN_PRINTF_UNLOCKED:
10421 case BUILT_IN_VPRINTF:
10422 return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10424 case BUILT_IN_PRINTF_CHK:
10425 case BUILT_IN_VPRINTF_CHK:
10426 if (!validate_arg (arg0, INTEGER_TYPE)
10427 || TREE_SIDE_EFFECTS (arg0))
10430 return fold_builtin_printf (loc, fndecl,
10431 arg1, NULL_TREE, ignore, fcode);
10434 case BUILT_IN_FPRINTF:
10435 case BUILT_IN_FPRINTF_UNLOCKED:
10436 case BUILT_IN_VFPRINTF:
10437 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10446 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10447 and ARG2. IGNORE is true if the result of the function call is ignored.
10448 This function returns NULL_TREE if no simplification was possible. */
10451 fold_builtin_3 (location_t loc, tree fndecl,
10452 tree arg0, tree arg1, tree arg2, bool ignore)
10454 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10455 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10459 CASE_FLT_FN (BUILT_IN_SINCOS):
10460 return fold_builtin_sincos (loc, arg0, arg1, arg2);
10462 CASE_FLT_FN (BUILT_IN_FMA):
10463 if (validate_arg (arg0, REAL_TYPE)
10464 && validate_arg(arg1, REAL_TYPE)
10465 && validate_arg(arg2, REAL_TYPE))
10466 return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10469 CASE_FLT_FN (BUILT_IN_REMQUO):
10470 if (validate_arg (arg0, REAL_TYPE)
10471 && validate_arg(arg1, REAL_TYPE)
10472 && validate_arg(arg2, POINTER_TYPE))
10473 return do_mpfr_remquo (arg0, arg1, arg2);
10476 case BUILT_IN_MEMSET:
10477 return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10479 case BUILT_IN_BCOPY:
10480 return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10481 void_type_node, true, /*endp=*/3);
10483 case BUILT_IN_MEMCPY:
10484 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10485 type, ignore, /*endp=*/0);
10487 case BUILT_IN_MEMPCPY:
10488 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10489 type, ignore, /*endp=*/1);
10491 case BUILT_IN_MEMMOVE:
10492 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10493 type, ignore, /*endp=*/3);
10495 case BUILT_IN_STRNCAT:
10496 return fold_builtin_strncat (loc, arg0, arg1, arg2);
10498 case BUILT_IN_STRNCPY:
10499 return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10501 case BUILT_IN_STRNCMP:
10502 return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10504 case BUILT_IN_MEMCHR:
10505 return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10507 case BUILT_IN_BCMP:
10508 case BUILT_IN_MEMCMP:
10509 return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10511 case BUILT_IN_SPRINTF:
10512 return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10514 case BUILT_IN_STRCPY_CHK:
10515 case BUILT_IN_STPCPY_CHK:
10516 return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10519 case BUILT_IN_STRCAT_CHK:
10520 return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10522 case BUILT_IN_PRINTF_CHK:
10523 case BUILT_IN_VPRINTF_CHK:
10524 if (!validate_arg (arg0, INTEGER_TYPE)
10525 || TREE_SIDE_EFFECTS (arg0))
10528 return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10531 case BUILT_IN_FPRINTF:
10532 case BUILT_IN_FPRINTF_UNLOCKED:
10533 case BUILT_IN_VFPRINTF:
10534 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10537 case BUILT_IN_FPRINTF_CHK:
10538 case BUILT_IN_VFPRINTF_CHK:
10539 if (!validate_arg (arg1, INTEGER_TYPE)
10540 || TREE_SIDE_EFFECTS (arg1))
10543 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10552 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10553 ARG2, and ARG3. IGNORE is true if the result of the function call is
10554 ignored. This function returns NULL_TREE if no simplification was
10558 fold_builtin_4 (location_t loc, tree fndecl,
10559 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10561 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10565 case BUILT_IN_MEMCPY_CHK:
10566 case BUILT_IN_MEMPCPY_CHK:
10567 case BUILT_IN_MEMMOVE_CHK:
10568 case BUILT_IN_MEMSET_CHK:
10569 return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10571 DECL_FUNCTION_CODE (fndecl));
10573 case BUILT_IN_STRNCPY_CHK:
10574 return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10576 case BUILT_IN_STRNCAT_CHK:
10577 return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10579 case BUILT_IN_FPRINTF_CHK:
10580 case BUILT_IN_VFPRINTF_CHK:
10581 if (!validate_arg (arg1, INTEGER_TYPE)
10582 || TREE_SIDE_EFFECTS (arg1))
10585 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10595 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10596 arguments, where NARGS <= 4. IGNORE is true if the result of the
10597 function call is ignored. This function returns NULL_TREE if no
10598 simplification was possible. Note that this only folds builtins with
10599 fixed argument patterns. Foldings that do varargs-to-varargs
10600 transformations, or that match calls with more than 4 arguments,
10601 need to be handled with fold_builtin_varargs instead. */
10603 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10606 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10608 tree ret = NULL_TREE;
10613 ret = fold_builtin_0 (loc, fndecl, ignore);
10616 ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10619 ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10622 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10625 ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10633 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10634 SET_EXPR_LOCATION (ret, loc);
10635 TREE_NO_WARNING (ret) = 1;
10641 /* Builtins with folding operations that operate on "..." arguments
10642 need special handling; we need to store the arguments in a convenient
10643 data structure before attempting any folding. Fortunately there are
10644 only a few builtins that fall into this category. FNDECL is the
10645 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10646 result of the function call is ignored. */
10649 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10650 bool ignore ATTRIBUTE_UNUSED)
10652 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10653 tree ret = NULL_TREE;
10657 case BUILT_IN_SPRINTF_CHK:
10658 case BUILT_IN_VSPRINTF_CHK:
10659 ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10662 case BUILT_IN_SNPRINTF_CHK:
10663 case BUILT_IN_VSNPRINTF_CHK:
10664 ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10667 case BUILT_IN_FPCLASSIFY:
10668 ret = fold_builtin_fpclassify (loc, exp);
10676 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10677 SET_EXPR_LOCATION (ret, loc);
10678 TREE_NO_WARNING (ret) = 1;
10684 /* Return true if FNDECL shouldn't be folded right now.
10685 If a built-in function has an inline attribute always_inline
10686 wrapper, defer folding it after always_inline functions have
10687 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10688 might not be performed. */
10691 avoid_folding_inline_builtin (tree fndecl)
10693 return (DECL_DECLARED_INLINE_P (fndecl)
10694 && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10696 && !cfun->always_inline_functions_inlined
10697 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10700 /* A wrapper function for builtin folding that prevents warnings for
10701 "statement without effect" and the like, caused by removing the
10702 call node earlier than the warning is generated. */
10705 fold_call_expr (location_t loc, tree exp, bool ignore)
10707 tree ret = NULL_TREE;
10708 tree fndecl = get_callee_fndecl (exp);
10710 && TREE_CODE (fndecl) == FUNCTION_DECL
10711 && DECL_BUILT_IN (fndecl)
10712 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10713 yet. Defer folding until we see all the arguments
10714 (after inlining). */
10715 && !CALL_EXPR_VA_ARG_PACK (exp))
10717 int nargs = call_expr_nargs (exp);
10719 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10720 instead last argument is __builtin_va_arg_pack (). Defer folding
10721 even in that case, until arguments are finalized. */
10722 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10724 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10726 && TREE_CODE (fndecl2) == FUNCTION_DECL
10727 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10728 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10732 if (avoid_folding_inline_builtin (fndecl))
10735 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10736 return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10737 CALL_EXPR_ARGP (exp), ignore);
10740 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10742 tree *args = CALL_EXPR_ARGP (exp);
10743 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10746 ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10754 /* Conveniently construct a function call expression. FNDECL names the
10755 function to be called and N arguments are passed in the array
10759 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10761 tree fntype = TREE_TYPE (fndecl);
10762 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10764 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10767 /* Conveniently construct a function call expression. FNDECL names the
10768 function to be called and the arguments are passed in the vector
10772 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10774 return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10775 VEC_address (tree, vec));
10779 /* Conveniently construct a function call expression. FNDECL names the
10780 function to be called, N is the number of arguments, and the "..."
10781 parameters are the argument expressions. */
10784 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10787 tree *argarray = XALLOCAVEC (tree, n);
10791 for (i = 0; i < n; i++)
10792 argarray[i] = va_arg (ap, tree);
10794 return build_call_expr_loc_array (loc, fndecl, n, argarray);
10797 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10798 varargs macros aren't supported by all bootstrap compilers. */
10801 build_call_expr (tree fndecl, int n, ...)
10804 tree *argarray = XALLOCAVEC (tree, n);
10808 for (i = 0; i < n; i++)
10809 argarray[i] = va_arg (ap, tree);
10811 return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10814 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10815 N arguments are passed in the array ARGARRAY. */
10818 fold_builtin_call_array (location_t loc, tree type,
10823 tree ret = NULL_TREE;
10826 if (TREE_CODE (fn) == ADDR_EXPR)
10828 tree fndecl = TREE_OPERAND (fn, 0);
10829 if (TREE_CODE (fndecl) == FUNCTION_DECL
10830 && DECL_BUILT_IN (fndecl))
10832 /* If last argument is __builtin_va_arg_pack (), arguments to this
10833 function are not finalized yet. Defer folding until they are. */
10834 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10836 tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10838 && TREE_CODE (fndecl2) == FUNCTION_DECL
10839 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10840 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10841 return build_call_array_loc (loc, type, fn, n, argarray);
10843 if (avoid_folding_inline_builtin (fndecl))
10844 return build_call_array_loc (loc, type, fn, n, argarray);
10845 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10847 ret = targetm.fold_builtin (fndecl, n, argarray, false);
10851 return build_call_array_loc (loc, type, fn, n, argarray);
10853 else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10855 /* First try the transformations that don't require consing up
10857 ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10862 /* If we got this far, we need to build an exp. */
10863 exp = build_call_array_loc (loc, type, fn, n, argarray);
10864 ret = fold_builtin_varargs (loc, fndecl, exp, false);
10865 return ret ? ret : exp;
10869 return build_call_array_loc (loc, type, fn, n, argarray);
10872 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10873 along with N new arguments specified as the "..." parameters. SKIP
10874 is the number of arguments in EXP to be omitted. This function is used
10875 to do varargs-to-varargs transformations. */
10878 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10880 int oldnargs = call_expr_nargs (exp);
10881 int nargs = oldnargs - skip + n;
10882 tree fntype = TREE_TYPE (fndecl);
10883 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10891 buffer = XALLOCAVEC (tree, nargs);
10893 for (i = 0; i < n; i++)
10894 buffer[i] = va_arg (ap, tree);
10896 for (j = skip; j < oldnargs; j++, i++)
10897 buffer[i] = CALL_EXPR_ARG (exp, j);
10900 buffer = CALL_EXPR_ARGP (exp) + skip;
10902 return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
10905 /* Validate a single argument ARG against a tree code CODE representing
10909 validate_arg (const_tree arg, enum tree_code code)
10913 else if (code == POINTER_TYPE)
10914 return POINTER_TYPE_P (TREE_TYPE (arg));
10915 else if (code == INTEGER_TYPE)
10916 return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10917 return code == TREE_CODE (TREE_TYPE (arg));
10920 /* This function validates the types of a function call argument list
10921 against a specified list of tree_codes. If the last specifier is a 0,
10922 that represents an ellipses, otherwise the last specifier must be a
10925 This is the GIMPLE version of validate_arglist. Eventually we want to
10926 completely convert builtins.c to work from GIMPLEs and the tree based
10927 validate_arglist will then be removed. */
10930 validate_gimple_arglist (const_gimple call, ...)
10932 enum tree_code code;
10938 va_start (ap, call);
10943 code = (enum tree_code) va_arg (ap, int);
10947 /* This signifies an ellipses, any further arguments are all ok. */
10951 /* This signifies an endlink, if no arguments remain, return
10952 true, otherwise return false. */
10953 res = (i == gimple_call_num_args (call));
10956 /* If no parameters remain or the parameter's code does not
10957 match the specified code, return false. Otherwise continue
10958 checking any remaining arguments. */
10959 arg = gimple_call_arg (call, i++);
10960 if (!validate_arg (arg, code))
10967 /* We need gotos here since we can only have one VA_CLOSE in a
10975 /* This function validates the types of a function call argument list
10976 against a specified list of tree_codes. If the last specifier is a 0,
10977 that represents an ellipses, otherwise the last specifier must be a
10981 validate_arglist (const_tree callexpr, ...)
10983 enum tree_code code;
10986 const_call_expr_arg_iterator iter;
10989 va_start (ap, callexpr);
10990 init_const_call_expr_arg_iterator (callexpr, &iter);
10994 code = (enum tree_code) va_arg (ap, int);
10998 /* This signifies an ellipses, any further arguments are all ok. */
11002 /* This signifies an endlink, if no arguments remain, return
11003 true, otherwise return false. */
11004 res = !more_const_call_expr_args_p (&iter);
11007 /* If no parameters remain or the parameter's code does not
11008 match the specified code, return false. Otherwise continue
11009 checking any remaining arguments. */
11010 arg = next_const_call_expr_arg (&iter);
11011 if (!validate_arg (arg, code))
11018 /* We need gotos here since we can only have one VA_CLOSE in a
11026 /* Default target-specific builtin expander that does nothing. */
11029 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11030 rtx target ATTRIBUTE_UNUSED,
11031 rtx subtarget ATTRIBUTE_UNUSED,
11032 enum machine_mode mode ATTRIBUTE_UNUSED,
11033 int ignore ATTRIBUTE_UNUSED)
11038 /* Returns true is EXP represents data that would potentially reside
11039 in a readonly section. */
11042 readonly_data_expr (tree exp)
11046 if (TREE_CODE (exp) != ADDR_EXPR)
11049 exp = get_base_address (TREE_OPERAND (exp, 0));
11053 /* Make sure we call decl_readonly_section only for trees it
11054 can handle (since it returns true for everything it doesn't
11056 if (TREE_CODE (exp) == STRING_CST
11057 || TREE_CODE (exp) == CONSTRUCTOR
11058 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11059 return decl_readonly_section (exp, 0);
11064 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11065 to the call, and TYPE is its return type.
11067 Return NULL_TREE if no simplification was possible, otherwise return the
11068 simplified form of the call as a tree.
11070 The simplified form may be a constant or other expression which
11071 computes the same value, but in a more efficient manner (including
11072 calls to other builtin functions).
11074 The call may contain arguments which need to be evaluated, but
11075 which are not useful to determine the result of the call. In
11076 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11077 COMPOUND_EXPR will be an argument which must be evaluated.
11078 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11079 COMPOUND_EXPR in the chain will contain the tree for the simplified
11080 form of the builtin function call. */
11083 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11085 if (!validate_arg (s1, POINTER_TYPE)
11086 || !validate_arg (s2, POINTER_TYPE))
11091 const char *p1, *p2;
11093 p2 = c_getstr (s2);
11097 p1 = c_getstr (s1);
11100 const char *r = strstr (p1, p2);
11104 return build_int_cst (TREE_TYPE (s1), 0);
11106 /* Return an offset into the constant string argument. */
11107 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11108 s1, size_int (r - p1));
11109 return fold_convert_loc (loc, type, tem);
11112 /* The argument is const char *, and the result is char *, so we need
11113 a type conversion here to avoid a warning. */
11115 return fold_convert_loc (loc, type, s1);
11120 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11124 /* New argument list transforming strstr(s1, s2) to
11125 strchr(s1, s2[0]). */
11126 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11130 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11131 the call, and TYPE is its return type.
11133 Return NULL_TREE if no simplification was possible, otherwise return the
11134 simplified form of the call as a tree.
11136 The simplified form may be a constant or other expression which
11137 computes the same value, but in a more efficient manner (including
11138 calls to other builtin functions).
11140 The call may contain arguments which need to be evaluated, but
11141 which are not useful to determine the result of the call. In
11142 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11143 COMPOUND_EXPR will be an argument which must be evaluated.
11144 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11145 COMPOUND_EXPR in the chain will contain the tree for the simplified
11146 form of the builtin function call. */
11149 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11151 if (!validate_arg (s1, POINTER_TYPE)
11152 || !validate_arg (s2, INTEGER_TYPE))
11158 if (TREE_CODE (s2) != INTEGER_CST)
11161 p1 = c_getstr (s1);
11168 if (target_char_cast (s2, &c))
11171 r = strchr (p1, c);
11174 return build_int_cst (TREE_TYPE (s1), 0);
11176 /* Return an offset into the constant string argument. */
11177 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11178 s1, size_int (r - p1));
11179 return fold_convert_loc (loc, type, tem);
11185 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11186 the call, and TYPE is its return type.
11188 Return NULL_TREE if no simplification was possible, otherwise return the
11189 simplified form of the call as a tree.
11191 The simplified form may be a constant or other expression which
11192 computes the same value, but in a more efficient manner (including
11193 calls to other builtin functions).
11195 The call may contain arguments which need to be evaluated, but
11196 which are not useful to determine the result of the call. In
11197 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11198 COMPOUND_EXPR will be an argument which must be evaluated.
11199 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11200 COMPOUND_EXPR in the chain will contain the tree for the simplified
11201 form of the builtin function call. */
11204 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11206 if (!validate_arg (s1, POINTER_TYPE)
11207 || !validate_arg (s2, INTEGER_TYPE))
11214 if (TREE_CODE (s2) != INTEGER_CST)
11217 p1 = c_getstr (s1);
11224 if (target_char_cast (s2, &c))
11227 r = strrchr (p1, c);
11230 return build_int_cst (TREE_TYPE (s1), 0);
11232 /* Return an offset into the constant string argument. */
11233 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11234 s1, size_int (r - p1));
11235 return fold_convert_loc (loc, type, tem);
11238 if (! integer_zerop (s2))
11241 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11245 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11246 return build_call_expr_loc (loc, fn, 2, s1, s2);
11250 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11251 to the call, and TYPE is its return type.
11253 Return NULL_TREE if no simplification was possible, otherwise return the
11254 simplified form of the call as a tree.
11256 The simplified form may be a constant or other expression which
11257 computes the same value, but in a more efficient manner (including
11258 calls to other builtin functions).
11260 The call may contain arguments which need to be evaluated, but
11261 which are not useful to determine the result of the call. In
11262 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11263 COMPOUND_EXPR will be an argument which must be evaluated.
11264 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11265 COMPOUND_EXPR in the chain will contain the tree for the simplified
11266 form of the builtin function call. */
11269 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11271 if (!validate_arg (s1, POINTER_TYPE)
11272 || !validate_arg (s2, POINTER_TYPE))
11277 const char *p1, *p2;
11279 p2 = c_getstr (s2);
11283 p1 = c_getstr (s1);
11286 const char *r = strpbrk (p1, p2);
11290 return build_int_cst (TREE_TYPE (s1), 0);
11292 /* Return an offset into the constant string argument. */
11293 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11294 s1, size_int (r - p1));
11295 return fold_convert_loc (loc, type, tem);
11299 /* strpbrk(x, "") == NULL.
11300 Evaluate and ignore s1 in case it had side-effects. */
11301 return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11304 return NULL_TREE; /* Really call strpbrk. */
11306 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11310 /* New argument list transforming strpbrk(s1, s2) to
11311 strchr(s1, s2[0]). */
11312 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11316 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11319 Return NULL_TREE if no simplification was possible, otherwise return the
11320 simplified form of the call as a tree.
11322 The simplified form may be a constant or other expression which
11323 computes the same value, but in a more efficient manner (including
11324 calls to other builtin functions).
11326 The call may contain arguments which need to be evaluated, but
11327 which are not useful to determine the result of the call. In
11328 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11329 COMPOUND_EXPR will be an argument which must be evaluated.
11330 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11331 COMPOUND_EXPR in the chain will contain the tree for the simplified
11332 form of the builtin function call. */
11335 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11337 if (!validate_arg (dst, POINTER_TYPE)
11338 || !validate_arg (src, POINTER_TYPE))
11342 const char *p = c_getstr (src);
11344 /* If the string length is zero, return the dst parameter. */
11345 if (p && *p == '\0')
11348 if (optimize_insn_for_speed_p ())
11350 /* See if we can store by pieces into (dst + strlen(dst)). */
11352 tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11353 tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11355 if (!strlen_fn || !strcpy_fn)
11358 /* If we don't have a movstr we don't want to emit an strcpy
11359 call. We have to do that if the length of the source string
11360 isn't computable (in that case we can use memcpy probably
11361 later expanding to a sequence of mov instructions). If we
11362 have movstr instructions we can emit strcpy calls. */
11365 tree len = c_strlen (src, 1);
11366 if (! len || TREE_SIDE_EFFECTS (len))
11370 /* Stabilize the argument list. */
11371 dst = builtin_save_expr (dst);
11373 /* Create strlen (dst). */
11374 newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11375 /* Create (dst p+ strlen (dst)). */
11377 newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11378 TREE_TYPE (dst), dst, newdst);
11379 newdst = builtin_save_expr (newdst);
11381 call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11382 return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11388 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11389 arguments to the call.
11391 Return NULL_TREE if no simplification was possible, otherwise return the
11392 simplified form of the call as a tree.
11394 The simplified form may be a constant or other expression which
11395 computes the same value, but in a more efficient manner (including
11396 calls to other builtin functions).
11398 The call may contain arguments which need to be evaluated, but
11399 which are not useful to determine the result of the call. In
11400 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11401 COMPOUND_EXPR will be an argument which must be evaluated.
11402 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11403 COMPOUND_EXPR in the chain will contain the tree for the simplified
11404 form of the builtin function call. */
11407 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11409 if (!validate_arg (dst, POINTER_TYPE)
11410 || !validate_arg (src, POINTER_TYPE)
11411 || !validate_arg (len, INTEGER_TYPE))
11415 const char *p = c_getstr (src);
11417 /* If the requested length is zero, or the src parameter string
11418 length is zero, return the dst parameter. */
11419 if (integer_zerop (len) || (p && *p == '\0'))
11420 return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11422 /* If the requested len is greater than or equal to the string
11423 length, call strcat. */
11424 if (TREE_CODE (len) == INTEGER_CST && p
11425 && compare_tree_int (len, strlen (p)) >= 0)
11427 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11429 /* If the replacement _DECL isn't initialized, don't do the
11434 return build_call_expr_loc (loc, fn, 2, dst, src);
11440 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11443 Return NULL_TREE if no simplification was possible, otherwise return the
11444 simplified form of the call as a tree.
11446 The simplified form may be a constant or other expression which
11447 computes the same value, but in a more efficient manner (including
11448 calls to other builtin functions).
11450 The call may contain arguments which need to be evaluated, but
11451 which are not useful to determine the result of the call. In
11452 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11453 COMPOUND_EXPR will be an argument which must be evaluated.
11454 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11455 COMPOUND_EXPR in the chain will contain the tree for the simplified
11456 form of the builtin function call. */
11459 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11461 if (!validate_arg (s1, POINTER_TYPE)
11462 || !validate_arg (s2, POINTER_TYPE))
11466 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11468 /* If both arguments are constants, evaluate at compile-time. */
11471 const size_t r = strspn (p1, p2);
11472 return size_int (r);
11475 /* If either argument is "", return NULL_TREE. */
11476 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11477 /* Evaluate and ignore both arguments in case either one has
11479 return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11485 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11488 Return NULL_TREE if no simplification was possible, otherwise return the
11489 simplified form of the call as a tree.
11491 The simplified form may be a constant or other expression which
11492 computes the same value, but in a more efficient manner (including
11493 calls to other builtin functions).
11495 The call may contain arguments which need to be evaluated, but
11496 which are not useful to determine the result of the call. In
11497 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11498 COMPOUND_EXPR will be an argument which must be evaluated.
11499 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11500 COMPOUND_EXPR in the chain will contain the tree for the simplified
11501 form of the builtin function call. */
11504 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11506 if (!validate_arg (s1, POINTER_TYPE)
11507 || !validate_arg (s2, POINTER_TYPE))
11511 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11513 /* If both arguments are constants, evaluate at compile-time. */
11516 const size_t r = strcspn (p1, p2);
11517 return size_int (r);
11520 /* If the first argument is "", return NULL_TREE. */
11521 if (p1 && *p1 == '\0')
11523 /* Evaluate and ignore argument s2 in case it has
11525 return omit_one_operand_loc (loc, size_type_node,
11526 size_zero_node, s2);
11529 /* If the second argument is "", return __builtin_strlen(s1). */
11530 if (p2 && *p2 == '\0')
11532 tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11534 /* If the replacement _DECL isn't initialized, don't do the
11539 return build_call_expr_loc (loc, fn, 1, s1);
11545 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
11546 to the call. IGNORE is true if the value returned
11547 by the builtin will be ignored. UNLOCKED is true is true if this
11548 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
11549 the known length of the string. Return NULL_TREE if no simplification
11553 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11554 bool ignore, bool unlocked, tree len)
11556 /* If we're using an unlocked function, assume the other unlocked
11557 functions exist explicitly. */
11558 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11559 : implicit_built_in_decls[BUILT_IN_FPUTC];
11560 tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11561 : implicit_built_in_decls[BUILT_IN_FWRITE];
11563 /* If the return value is used, don't do the transformation. */
11567 /* Verify the arguments in the original call. */
11568 if (!validate_arg (arg0, POINTER_TYPE)
11569 || !validate_arg (arg1, POINTER_TYPE))
11573 len = c_strlen (arg0, 0);
11575 /* Get the length of the string passed to fputs. If the length
11576 can't be determined, punt. */
11578 || TREE_CODE (len) != INTEGER_CST)
11581 switch (compare_tree_int (len, 1))
11583 case -1: /* length is 0, delete the call entirely . */
11584 return omit_one_operand_loc (loc, integer_type_node,
11585 integer_zero_node, arg1);;
11587 case 0: /* length is 1, call fputc. */
11589 const char *p = c_getstr (arg0);
11594 return build_call_expr_loc (loc, fn_fputc, 2,
11595 build_int_cst (NULL_TREE, p[0]), arg1);
11601 case 1: /* length is greater than 1, call fwrite. */
11603 /* If optimizing for size keep fputs. */
11604 if (optimize_function_for_size_p (cfun))
11606 /* New argument list transforming fputs(string, stream) to
11607 fwrite(string, 1, len, stream). */
11609 return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11610 size_one_node, len, arg1);
11615 gcc_unreachable ();
11620 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11621 produced. False otherwise. This is done so that we don't output the error
11622 or warning twice or three times. */
11625 fold_builtin_next_arg (tree exp, bool va_start_p)
11627 tree fntype = TREE_TYPE (current_function_decl);
11628 int nargs = call_expr_nargs (exp);
11631 if (!stdarg_p (fntype))
11633 error ("%<va_start%> used in function with fixed args");
11639 if (va_start_p && (nargs != 2))
11641 error ("wrong number of arguments to function %<va_start%>");
11644 arg = CALL_EXPR_ARG (exp, 1);
11646 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11647 when we checked the arguments and if needed issued a warning. */
11652 /* Evidently an out of date version of <stdarg.h>; can't validate
11653 va_start's second argument, but can still work as intended. */
11654 warning (0, "%<__builtin_next_arg%> called without an argument");
11657 else if (nargs > 1)
11659 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11662 arg = CALL_EXPR_ARG (exp, 0);
11665 if (TREE_CODE (arg) == SSA_NAME)
11666 arg = SSA_NAME_VAR (arg);
11668 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11669 or __builtin_next_arg (0) the first time we see it, after checking
11670 the arguments and if needed issuing a warning. */
11671 if (!integer_zerop (arg))
11673 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11675 /* Strip off all nops for the sake of the comparison. This
11676 is not quite the same as STRIP_NOPS. It does more.
11677 We must also strip off INDIRECT_EXPR for C++ reference
11679 while (CONVERT_EXPR_P (arg)
11680 || TREE_CODE (arg) == INDIRECT_REF)
11681 arg = TREE_OPERAND (arg, 0);
11682 if (arg != last_parm)
11684 /* FIXME: Sometimes with the tree optimizers we can get the
11685 not the last argument even though the user used the last
11686 argument. We just warn and set the arg to be the last
11687 argument so that we will get wrong-code because of
11689 warning (0, "second parameter of %<va_start%> not last named argument");
11692 /* Undefined by C99 7.15.1.4p4 (va_start):
11693 "If the parameter parmN is declared with the register storage
11694 class, with a function or array type, or with a type that is
11695 not compatible with the type that results after application of
11696 the default argument promotions, the behavior is undefined."
11698 else if (DECL_REGISTER (arg))
11699 warning (0, "undefined behaviour when second parameter of "
11700 "%<va_start%> is declared with %<register%> storage");
11702 /* We want to verify the second parameter just once before the tree
11703 optimizers are run and then avoid keeping it in the tree,
11704 as otherwise we could warn even for correct code like:
11705 void foo (int i, ...)
11706 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11708 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11710 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11716 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11717 ORIG may be null if this is a 2-argument call. We don't attempt to
11718 simplify calls with more than 3 arguments.
11720 Return NULL_TREE if no simplification was possible, otherwise return the
11721 simplified form of the call as a tree. If IGNORED is true, it means that
11722 the caller does not use the returned value of the function. */
11725 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11726 tree orig, int ignored)
11729 const char *fmt_str = NULL;
11731 /* Verify the required arguments in the original call. We deal with two
11732 types of sprintf() calls: 'sprintf (str, fmt)' and
11733 'sprintf (dest, "%s", orig)'. */
11734 if (!validate_arg (dest, POINTER_TYPE)
11735 || !validate_arg (fmt, POINTER_TYPE))
11737 if (orig && !validate_arg (orig, POINTER_TYPE))
11740 /* Check whether the format is a literal string constant. */
11741 fmt_str = c_getstr (fmt);
11742 if (fmt_str == NULL)
11746 retval = NULL_TREE;
11748 if (!init_target_chars ())
11751 /* If the format doesn't contain % args or %%, use strcpy. */
11752 if (strchr (fmt_str, target_percent) == NULL)
11754 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11759 /* Don't optimize sprintf (buf, "abc", ptr++). */
11763 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11764 'format' is known to contain no % formats. */
11765 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11767 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11770 /* If the format is "%s", use strcpy if the result isn't used. */
11771 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11774 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11779 /* Don't crash on sprintf (str1, "%s"). */
11783 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
11786 retval = c_strlen (orig, 1);
11787 if (!retval || TREE_CODE (retval) != INTEGER_CST)
11790 call = build_call_expr_loc (loc, fn, 2, dest, orig);
11793 if (call && retval)
11795 retval = fold_convert_loc
11796 (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11798 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11804 /* Expand a call EXP to __builtin_object_size. */
11807 expand_builtin_object_size (tree exp)
11810 int object_size_type;
11811 tree fndecl = get_callee_fndecl (exp);
11813 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11815 error ("%Kfirst argument of %D must be a pointer, second integer constant",
11817 expand_builtin_trap ();
11821 ost = CALL_EXPR_ARG (exp, 1);
11824 if (TREE_CODE (ost) != INTEGER_CST
11825 || tree_int_cst_sgn (ost) < 0
11826 || compare_tree_int (ost, 3) > 0)
11828 error ("%Klast argument of %D is not integer constant between 0 and 3",
11830 expand_builtin_trap ();
11834 object_size_type = tree_low_cst (ost, 0);
11836 return object_size_type < 2 ? constm1_rtx : const0_rtx;
11839 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11840 FCODE is the BUILT_IN_* to use.
11841 Return NULL_RTX if we failed; the caller should emit a normal call,
11842 otherwise try to get the result in TARGET, if convenient (and in
11843 mode MODE if that's convenient). */
11846 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11847 enum built_in_function fcode)
11849 tree dest, src, len, size;
11851 if (!validate_arglist (exp,
11853 fcode == BUILT_IN_MEMSET_CHK
11854 ? INTEGER_TYPE : POINTER_TYPE,
11855 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11858 dest = CALL_EXPR_ARG (exp, 0);
11859 src = CALL_EXPR_ARG (exp, 1);
11860 len = CALL_EXPR_ARG (exp, 2);
11861 size = CALL_EXPR_ARG (exp, 3);
11863 if (! host_integerp (size, 1))
11866 if (host_integerp (len, 1) || integer_all_onesp (size))
11870 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11872 warning_at (tree_nonartificial_location (exp),
11873 0, "%Kcall to %D will always overflow destination buffer",
11874 exp, get_callee_fndecl (exp));
11879 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11880 mem{cpy,pcpy,move,set} is available. */
11883 case BUILT_IN_MEMCPY_CHK:
11884 fn = built_in_decls[BUILT_IN_MEMCPY];
11886 case BUILT_IN_MEMPCPY_CHK:
11887 fn = built_in_decls[BUILT_IN_MEMPCPY];
11889 case BUILT_IN_MEMMOVE_CHK:
11890 fn = built_in_decls[BUILT_IN_MEMMOVE];
11892 case BUILT_IN_MEMSET_CHK:
11893 fn = built_in_decls[BUILT_IN_MEMSET];
11902 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
11903 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11904 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11905 return expand_expr (fn, target, mode, EXPAND_NORMAL);
11907 else if (fcode == BUILT_IN_MEMSET_CHK)
11911 unsigned int dest_align
11912 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
11914 /* If DEST is not a pointer type, call the normal function. */
11915 if (dest_align == 0)
11918 /* If SRC and DEST are the same (and not volatile), do nothing. */
11919 if (operand_equal_p (src, dest, 0))
11923 if (fcode != BUILT_IN_MEMPCPY_CHK)
11925 /* Evaluate and ignore LEN in case it has side-effects. */
11926 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
11927 return expand_expr (dest, target, mode, EXPAND_NORMAL);
11930 expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
11931 return expand_expr (expr, target, mode, EXPAND_NORMAL);
11934 /* __memmove_chk special case. */
11935 if (fcode == BUILT_IN_MEMMOVE_CHK)
11937 unsigned int src_align
11938 = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
11940 if (src_align == 0)
11943 /* If src is categorized for a readonly section we can use
11944 normal __memcpy_chk. */
11945 if (readonly_data_expr (src))
11947 tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11950 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
11951 dest, src, len, size);
11952 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11953 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11954 return expand_expr (fn, target, mode, EXPAND_NORMAL);
11961 /* Emit warning if a buffer overflow is detected at compile time. */
11964 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
11968 location_t loc = tree_nonartificial_location (exp);
11972 case BUILT_IN_STRCPY_CHK:
11973 case BUILT_IN_STPCPY_CHK:
11974 /* For __strcat_chk the warning will be emitted only if overflowing
11975 by at least strlen (dest) + 1 bytes. */
11976 case BUILT_IN_STRCAT_CHK:
11977 len = CALL_EXPR_ARG (exp, 1);
11978 size = CALL_EXPR_ARG (exp, 2);
11981 case BUILT_IN_STRNCAT_CHK:
11982 case BUILT_IN_STRNCPY_CHK:
11983 len = CALL_EXPR_ARG (exp, 2);
11984 size = CALL_EXPR_ARG (exp, 3);
11986 case BUILT_IN_SNPRINTF_CHK:
11987 case BUILT_IN_VSNPRINTF_CHK:
11988 len = CALL_EXPR_ARG (exp, 1);
11989 size = CALL_EXPR_ARG (exp, 3);
11992 gcc_unreachable ();
11998 if (! host_integerp (size, 1) || integer_all_onesp (size))
12003 len = c_strlen (len, 1);
12004 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12007 else if (fcode == BUILT_IN_STRNCAT_CHK)
12009 tree src = CALL_EXPR_ARG (exp, 1);
12010 if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12012 src = c_strlen (src, 1);
12013 if (! src || ! host_integerp (src, 1))
12015 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12016 exp, get_callee_fndecl (exp));
12019 else if (tree_int_cst_lt (src, size))
12022 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12025 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12026 exp, get_callee_fndecl (exp));
12029 /* Emit warning if a buffer overflow is detected at compile time
12030 in __sprintf_chk/__vsprintf_chk calls. */
12033 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12035 tree size, len, fmt;
12036 const char *fmt_str;
12037 int nargs = call_expr_nargs (exp);
12039 /* Verify the required arguments in the original call. */
12043 size = CALL_EXPR_ARG (exp, 2);
12044 fmt = CALL_EXPR_ARG (exp, 3);
12046 if (! host_integerp (size, 1) || integer_all_onesp (size))
12049 /* Check whether the format is a literal string constant. */
12050 fmt_str = c_getstr (fmt);
12051 if (fmt_str == NULL)
12054 if (!init_target_chars ())
12057 /* If the format doesn't contain % args or %%, we know its size. */
12058 if (strchr (fmt_str, target_percent) == 0)
12059 len = build_int_cstu (size_type_node, strlen (fmt_str));
12060 /* If the format is "%s" and first ... argument is a string literal,
12062 else if (fcode == BUILT_IN_SPRINTF_CHK
12063 && strcmp (fmt_str, target_percent_s) == 0)
12069 arg = CALL_EXPR_ARG (exp, 4);
12070 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12073 len = c_strlen (arg, 1);
12074 if (!len || ! host_integerp (len, 1))
12080 if (! tree_int_cst_lt (len, size))
12081 warning_at (tree_nonartificial_location (exp),
12082 0, "%Kcall to %D will always overflow destination buffer",
12083 exp, get_callee_fndecl (exp));
12086 /* Emit warning if a free is called with address of a variable. */
12089 maybe_emit_free_warning (tree exp)
12091 tree arg = CALL_EXPR_ARG (exp, 0);
12094 if (TREE_CODE (arg) != ADDR_EXPR)
12097 arg = get_base_address (TREE_OPERAND (arg, 0));
12098 if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12101 if (SSA_VAR_P (arg))
12102 warning_at (tree_nonartificial_location (exp),
12103 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12105 warning_at (tree_nonartificial_location (exp),
12106 0, "%Kattempt to free a non-heap object", exp);
12109 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12113 fold_builtin_object_size (tree ptr, tree ost)
12115 unsigned HOST_WIDE_INT bytes;
12116 int object_size_type;
12118 if (!validate_arg (ptr, POINTER_TYPE)
12119 || !validate_arg (ost, INTEGER_TYPE))
12124 if (TREE_CODE (ost) != INTEGER_CST
12125 || tree_int_cst_sgn (ost) < 0
12126 || compare_tree_int (ost, 3) > 0)
12129 object_size_type = tree_low_cst (ost, 0);
12131 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12132 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12133 and (size_t) 0 for types 2 and 3. */
12134 if (TREE_SIDE_EFFECTS (ptr))
12135 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12137 if (TREE_CODE (ptr) == ADDR_EXPR)
12139 bytes = compute_builtin_object_size (ptr, object_size_type);
12140 if (double_int_fits_to_tree_p (size_type_node,
12141 uhwi_to_double_int (bytes)))
12142 return build_int_cstu (size_type_node, bytes);
12144 else if (TREE_CODE (ptr) == SSA_NAME)
12146 /* If object size is not known yet, delay folding until
12147 later. Maybe subsequent passes will help determining
12149 bytes = compute_builtin_object_size (ptr, object_size_type);
12150 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12151 && double_int_fits_to_tree_p (size_type_node,
12152 uhwi_to_double_int (bytes)))
12153 return build_int_cstu (size_type_node, bytes);
12159 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12160 DEST, SRC, LEN, and SIZE are the arguments to the call.
12161 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12162 code of the builtin. If MAXLEN is not NULL, it is maximum length
12163 passed as third argument. */
12166 fold_builtin_memory_chk (location_t loc, tree fndecl,
12167 tree dest, tree src, tree len, tree size,
12168 tree maxlen, bool ignore,
12169 enum built_in_function fcode)
12173 if (!validate_arg (dest, POINTER_TYPE)
12174 || !validate_arg (src,
12175 (fcode == BUILT_IN_MEMSET_CHK
12176 ? INTEGER_TYPE : POINTER_TYPE))
12177 || !validate_arg (len, INTEGER_TYPE)
12178 || !validate_arg (size, INTEGER_TYPE))
12181 /* If SRC and DEST are the same (and not volatile), return DEST
12182 (resp. DEST+LEN for __mempcpy_chk). */
12183 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12185 if (fcode != BUILT_IN_MEMPCPY_CHK)
12186 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12190 tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12192 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12196 if (! host_integerp (size, 1))
12199 if (! integer_all_onesp (size))
12201 if (! host_integerp (len, 1))
12203 /* If LEN is not constant, try MAXLEN too.
12204 For MAXLEN only allow optimizing into non-_ocs function
12205 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12206 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12208 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12210 /* (void) __mempcpy_chk () can be optimized into
12211 (void) __memcpy_chk (). */
12212 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12216 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12224 if (tree_int_cst_lt (size, maxlen))
12229 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12230 mem{cpy,pcpy,move,set} is available. */
12233 case BUILT_IN_MEMCPY_CHK:
12234 fn = built_in_decls[BUILT_IN_MEMCPY];
12236 case BUILT_IN_MEMPCPY_CHK:
12237 fn = built_in_decls[BUILT_IN_MEMPCPY];
12239 case BUILT_IN_MEMMOVE_CHK:
12240 fn = built_in_decls[BUILT_IN_MEMMOVE];
12242 case BUILT_IN_MEMSET_CHK:
12243 fn = built_in_decls[BUILT_IN_MEMSET];
12252 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12255 /* Fold a call to the __st[rp]cpy_chk builtin.
12256 DEST, SRC, and SIZE are the arguments to the call.
12257 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12258 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12259 strings passed as second argument. */
12262 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12263 tree src, tree size,
12264 tree maxlen, bool ignore,
12265 enum built_in_function fcode)
12269 if (!validate_arg (dest, POINTER_TYPE)
12270 || !validate_arg (src, POINTER_TYPE)
12271 || !validate_arg (size, INTEGER_TYPE))
12274 /* If SRC and DEST are the same (and not volatile), return DEST. */
12275 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12276 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12278 if (! host_integerp (size, 1))
12281 if (! integer_all_onesp (size))
12283 len = c_strlen (src, 1);
12284 if (! len || ! host_integerp (len, 1))
12286 /* If LEN is not constant, try MAXLEN too.
12287 For MAXLEN only allow optimizing into non-_ocs function
12288 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12289 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12291 if (fcode == BUILT_IN_STPCPY_CHK)
12296 /* If return value of __stpcpy_chk is ignored,
12297 optimize into __strcpy_chk. */
12298 fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12302 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12305 if (! len || TREE_SIDE_EFFECTS (len))
12308 /* If c_strlen returned something, but not a constant,
12309 transform __strcpy_chk into __memcpy_chk. */
12310 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12314 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12315 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12316 build_call_expr_loc (loc, fn, 4,
12317 dest, src, len, size));
12323 if (! tree_int_cst_lt (maxlen, size))
12327 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12328 fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12329 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12333 return build_call_expr_loc (loc, fn, 2, dest, src);
12336 /* Fold a call to the __strncpy_chk builtin. DEST, SRC, LEN, and SIZE
12337 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12338 length passed as third argument. */
12341 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12342 tree len, tree size, tree maxlen)
12346 if (!validate_arg (dest, POINTER_TYPE)
12347 || !validate_arg (src, POINTER_TYPE)
12348 || !validate_arg (len, INTEGER_TYPE)
12349 || !validate_arg (size, INTEGER_TYPE))
12352 if (! host_integerp (size, 1))
12355 if (! integer_all_onesp (size))
12357 if (! host_integerp (len, 1))
12359 /* If LEN is not constant, try MAXLEN too.
12360 For MAXLEN only allow optimizing into non-_ocs function
12361 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12362 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12368 if (tree_int_cst_lt (size, maxlen))
12372 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
12373 fn = built_in_decls[BUILT_IN_STRNCPY];
12377 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12380 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12381 are the arguments to the call. */
12384 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12385 tree src, tree size)
12390 if (!validate_arg (dest, POINTER_TYPE)
12391 || !validate_arg (src, POINTER_TYPE)
12392 || !validate_arg (size, INTEGER_TYPE))
12395 p = c_getstr (src);
12396 /* If the SRC parameter is "", return DEST. */
12397 if (p && *p == '\0')
12398 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12400 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12403 /* If __builtin_strcat_chk is used, assume strcat is available. */
12404 fn = built_in_decls[BUILT_IN_STRCAT];
12408 return build_call_expr_loc (loc, fn, 2, dest, src);
12411 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12415 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12416 tree dest, tree src, tree len, tree size)
12421 if (!validate_arg (dest, POINTER_TYPE)
12422 || !validate_arg (src, POINTER_TYPE)
12423 || !validate_arg (size, INTEGER_TYPE)
12424 || !validate_arg (size, INTEGER_TYPE))
12427 p = c_getstr (src);
12428 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
12429 if (p && *p == '\0')
12430 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12431 else if (integer_zerop (len))
12432 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12434 if (! host_integerp (size, 1))
12437 if (! integer_all_onesp (size))
12439 tree src_len = c_strlen (src, 1);
12441 && host_integerp (src_len, 1)
12442 && host_integerp (len, 1)
12443 && ! tree_int_cst_lt (len, src_len))
12445 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
12446 fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12450 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12455 /* If __builtin_strncat_chk is used, assume strncat is available. */
12456 fn = built_in_decls[BUILT_IN_STRNCAT];
12460 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12463 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
12464 a normal call should be emitted rather than expanding the function
12465 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
12468 fold_builtin_sprintf_chk (location_t loc, tree exp,
12469 enum built_in_function fcode)
12471 tree dest, size, len, fn, fmt, flag;
12472 const char *fmt_str;
12473 int nargs = call_expr_nargs (exp);
12475 /* Verify the required arguments in the original call. */
12478 dest = CALL_EXPR_ARG (exp, 0);
12479 if (!validate_arg (dest, POINTER_TYPE))
12481 flag = CALL_EXPR_ARG (exp, 1);
12482 if (!validate_arg (flag, INTEGER_TYPE))
12484 size = CALL_EXPR_ARG (exp, 2);
12485 if (!validate_arg (size, INTEGER_TYPE))
12487 fmt = CALL_EXPR_ARG (exp, 3);
12488 if (!validate_arg (fmt, POINTER_TYPE))
12491 if (! host_integerp (size, 1))
12496 if (!init_target_chars ())
12499 /* Check whether the format is a literal string constant. */
12500 fmt_str = c_getstr (fmt);
12501 if (fmt_str != NULL)
12503 /* If the format doesn't contain % args or %%, we know the size. */
12504 if (strchr (fmt_str, target_percent) == 0)
12506 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12507 len = build_int_cstu (size_type_node, strlen (fmt_str));
12509 /* If the format is "%s" and first ... argument is a string literal,
12510 we know the size too. */
12511 else if (fcode == BUILT_IN_SPRINTF_CHK
12512 && strcmp (fmt_str, target_percent_s) == 0)
12518 arg = CALL_EXPR_ARG (exp, 4);
12519 if (validate_arg (arg, POINTER_TYPE))
12521 len = c_strlen (arg, 1);
12522 if (! len || ! host_integerp (len, 1))
12529 if (! integer_all_onesp (size))
12531 if (! len || ! tree_int_cst_lt (len, size))
12535 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12536 or if format doesn't contain % chars or is "%s". */
12537 if (! integer_zerop (flag))
12539 if (fmt_str == NULL)
12541 if (strchr (fmt_str, target_percent) != NULL
12542 && strcmp (fmt_str, target_percent_s))
12546 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
12547 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12548 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12552 return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12555 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
12556 a normal call should be emitted rather than expanding the function
12557 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
12558 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
12559 passed as second argument. */
12562 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12563 enum built_in_function fcode)
12565 tree dest, size, len, fn, fmt, flag;
12566 const char *fmt_str;
12568 /* Verify the required arguments in the original call. */
12569 if (call_expr_nargs (exp) < 5)
12571 dest = CALL_EXPR_ARG (exp, 0);
12572 if (!validate_arg (dest, POINTER_TYPE))
12574 len = CALL_EXPR_ARG (exp, 1);
12575 if (!validate_arg (len, INTEGER_TYPE))
12577 flag = CALL_EXPR_ARG (exp, 2);
12578 if (!validate_arg (flag, INTEGER_TYPE))
12580 size = CALL_EXPR_ARG (exp, 3);
12581 if (!validate_arg (size, INTEGER_TYPE))
12583 fmt = CALL_EXPR_ARG (exp, 4);
12584 if (!validate_arg (fmt, POINTER_TYPE))
12587 if (! host_integerp (size, 1))
12590 if (! integer_all_onesp (size))
12592 if (! host_integerp (len, 1))
12594 /* If LEN is not constant, try MAXLEN too.
12595 For MAXLEN only allow optimizing into non-_ocs function
12596 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12597 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12603 if (tree_int_cst_lt (size, maxlen))
12607 if (!init_target_chars ())
12610 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12611 or if format doesn't contain % chars or is "%s". */
12612 if (! integer_zerop (flag))
12614 fmt_str = c_getstr (fmt);
12615 if (fmt_str == NULL)
12617 if (strchr (fmt_str, target_percent) != NULL
12618 && strcmp (fmt_str, target_percent_s))
12622 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12624 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12625 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12629 return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12632 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12633 FMT and ARG are the arguments to the call; we don't fold cases with
12634 more than 2 arguments, and ARG may be null if this is a 1-argument case.
12636 Return NULL_TREE if no simplification was possible, otherwise return the
12637 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12638 code of the function to be simplified. */
12641 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12642 tree arg, bool ignore,
12643 enum built_in_function fcode)
12645 tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12646 const char *fmt_str = NULL;
12648 /* If the return value is used, don't do the transformation. */
12652 /* Verify the required arguments in the original call. */
12653 if (!validate_arg (fmt, POINTER_TYPE))
12656 /* Check whether the format is a literal string constant. */
12657 fmt_str = c_getstr (fmt);
12658 if (fmt_str == NULL)
12661 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12663 /* If we're using an unlocked function, assume the other
12664 unlocked functions exist explicitly. */
12665 fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12666 fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12670 fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12671 fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12674 if (!init_target_chars ())
12677 if (strcmp (fmt_str, target_percent_s) == 0
12678 || strchr (fmt_str, target_percent) == NULL)
12682 if (strcmp (fmt_str, target_percent_s) == 0)
12684 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12687 if (!arg || !validate_arg (arg, POINTER_TYPE))
12690 str = c_getstr (arg);
12696 /* The format specifier doesn't contain any '%' characters. */
12697 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12703 /* If the string was "", printf does nothing. */
12704 if (str[0] == '\0')
12705 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12707 /* If the string has length of 1, call putchar. */
12708 if (str[1] == '\0')
12710 /* Given printf("c"), (where c is any one character,)
12711 convert "c"[0] to an int and pass that to the replacement
12713 newarg = build_int_cst (NULL_TREE, str[0]);
12715 call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12719 /* If the string was "string\n", call puts("string"). */
12720 size_t len = strlen (str);
12721 if ((unsigned char)str[len - 1] == target_newline)
12723 /* Create a NUL-terminated string that's one char shorter
12724 than the original, stripping off the trailing '\n'. */
12725 char *newstr = XALLOCAVEC (char, len);
12726 memcpy (newstr, str, len - 1);
12727 newstr[len - 1] = 0;
12729 newarg = build_string_literal (len, newstr);
12731 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12734 /* We'd like to arrange to call fputs(string,stdout) here,
12735 but we need stdout and don't have a way to get it yet. */
12740 /* The other optimizations can be done only on the non-va_list variants. */
12741 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12744 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
12745 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12747 if (!arg || !validate_arg (arg, POINTER_TYPE))
12750 call = build_call_expr_loc (loc, fn_puts, 1, arg);
12753 /* If the format specifier was "%c", call __builtin_putchar(arg). */
12754 else if (strcmp (fmt_str, target_percent_c) == 0)
12756 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12759 call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12765 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12768 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12769 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
12770 more than 3 arguments, and ARG may be null in the 2-argument case.
12772 Return NULL_TREE if no simplification was possible, otherwise return the
12773 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12774 code of the function to be simplified. */
12777 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12778 tree fmt, tree arg, bool ignore,
12779 enum built_in_function fcode)
12781 tree fn_fputc, fn_fputs, call = NULL_TREE;
12782 const char *fmt_str = NULL;
12784 /* If the return value is used, don't do the transformation. */
12788 /* Verify the required arguments in the original call. */
12789 if (!validate_arg (fp, POINTER_TYPE))
12791 if (!validate_arg (fmt, POINTER_TYPE))
12794 /* Check whether the format is a literal string constant. */
12795 fmt_str = c_getstr (fmt);
12796 if (fmt_str == NULL)
12799 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12801 /* If we're using an unlocked function, assume the other
12802 unlocked functions exist explicitly. */
12803 fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12804 fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12808 fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12809 fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12812 if (!init_target_chars ())
12815 /* If the format doesn't contain % args or %%, use strcpy. */
12816 if (strchr (fmt_str, target_percent) == NULL)
12818 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12822 /* If the format specifier was "", fprintf does nothing. */
12823 if (fmt_str[0] == '\0')
12825 /* If FP has side-effects, just wait until gimplification is
12827 if (TREE_SIDE_EFFECTS (fp))
12830 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12833 /* When "string" doesn't contain %, replace all cases of
12834 fprintf (fp, string) with fputs (string, fp). The fputs
12835 builtin will take care of special cases like length == 1. */
12837 call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12840 /* The other optimizations can be done only on the non-va_list variants. */
12841 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12844 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
12845 else if (strcmp (fmt_str, target_percent_s) == 0)
12847 if (!arg || !validate_arg (arg, POINTER_TYPE))
12850 call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12853 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
12854 else if (strcmp (fmt_str, target_percent_c) == 0)
12856 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12859 call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12864 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12867 /* Initialize format string characters in the target charset. */
12870 init_target_chars (void)
12875 target_newline = lang_hooks.to_target_charset ('\n');
12876 target_percent = lang_hooks.to_target_charset ('%');
12877 target_c = lang_hooks.to_target_charset ('c');
12878 target_s = lang_hooks.to_target_charset ('s');
12879 if (target_newline == 0 || target_percent == 0 || target_c == 0
12883 target_percent_c[0] = target_percent;
12884 target_percent_c[1] = target_c;
12885 target_percent_c[2] = '\0';
12887 target_percent_s[0] = target_percent;
12888 target_percent_s[1] = target_s;
12889 target_percent_s[2] = '\0';
12891 target_percent_s_newline[0] = target_percent;
12892 target_percent_s_newline[1] = target_s;
12893 target_percent_s_newline[2] = target_newline;
12894 target_percent_s_newline[3] = '\0';
12901 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
12902 and no overflow/underflow occurred. INEXACT is true if M was not
12903 exactly calculated. TYPE is the tree type for the result. This
12904 function assumes that you cleared the MPFR flags and then
12905 calculated M to see if anything subsequently set a flag prior to
12906 entering this function. Return NULL_TREE if any checks fail. */
12909 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
12911 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12912 overflow/underflow occurred. If -frounding-math, proceed iff the
12913 result of calling FUNC was exact. */
12914 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12915 && (!flag_rounding_math || !inexact))
12917 REAL_VALUE_TYPE rr;
12919 real_from_mpfr (&rr, m, type, GMP_RNDN);
12920 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12921 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
12922 but the mpft_t is not, then we underflowed in the
12924 if (real_isfinite (&rr)
12925 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
12927 REAL_VALUE_TYPE rmode;
12929 real_convert (&rmode, TYPE_MODE (type), &rr);
12930 /* Proceed iff the specified mode can hold the value. */
12931 if (real_identical (&rmode, &rr))
12932 return build_real (type, rmode);
12938 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
12939 number and no overflow/underflow occurred. INEXACT is true if M
12940 was not exactly calculated. TYPE is the tree type for the result.
12941 This function assumes that you cleared the MPFR flags and then
12942 calculated M to see if anything subsequently set a flag prior to
12943 entering this function. Return NULL_TREE if any checks fail, if
12944 FORCE_CONVERT is true, then bypass the checks. */
12947 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
12949 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12950 overflow/underflow occurred. If -frounding-math, proceed iff the
12951 result of calling FUNC was exact. */
12953 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
12954 && !mpfr_overflow_p () && !mpfr_underflow_p ()
12955 && (!flag_rounding_math || !inexact)))
12957 REAL_VALUE_TYPE re, im;
12959 real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
12960 real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
12961 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
12962 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
12963 but the mpft_t is not, then we underflowed in the
12966 || (real_isfinite (&re) && real_isfinite (&im)
12967 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
12968 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
12970 REAL_VALUE_TYPE re_mode, im_mode;
12972 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
12973 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
12974 /* Proceed iff the specified mode can hold the value. */
12976 || (real_identical (&re_mode, &re)
12977 && real_identical (&im_mode, &im)))
12978 return build_complex (type, build_real (TREE_TYPE (type), re_mode),
12979 build_real (TREE_TYPE (type), im_mode));
12985 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
12986 FUNC on it and return the resulting value as a tree with type TYPE.
12987 If MIN and/or MAX are not NULL, then the supplied ARG must be
12988 within those bounds. If INCLUSIVE is true, then MIN/MAX are
12989 acceptable values, otherwise they are not. The mpfr precision is
12990 set to the precision of TYPE. We assume that function FUNC returns
12991 zero if the result could be calculated exactly within the requested
12995 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
12996 const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
12999 tree result = NULL_TREE;
13003 /* To proceed, MPFR must exactly represent the target floating point
13004 format, which only happens when the target base equals two. */
13005 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13006 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13008 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13010 if (real_isfinite (ra)
13011 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13012 && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13014 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13015 const int prec = fmt->p;
13016 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13020 mpfr_init2 (m, prec);
13021 mpfr_from_real (m, ra, GMP_RNDN);
13022 mpfr_clear_flags ();
13023 inexact = func (m, m, rnd);
13024 result = do_mpfr_ckconv (m, type, inexact);
13032 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13033 FUNC on it and return the resulting value as a tree with type TYPE.
13034 The mpfr precision is set to the precision of TYPE. We assume that
13035 function FUNC returns zero if the result could be calculated
13036 exactly within the requested precision. */
13039 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13040 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13042 tree result = NULL_TREE;
13047 /* To proceed, MPFR must exactly represent the target floating point
13048 format, which only happens when the target base equals two. */
13049 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13050 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13051 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13053 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13054 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13056 if (real_isfinite (ra1) && real_isfinite (ra2))
13058 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13059 const int prec = fmt->p;
13060 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13064 mpfr_inits2 (prec, m1, m2, NULL);
13065 mpfr_from_real (m1, ra1, GMP_RNDN);
13066 mpfr_from_real (m2, ra2, GMP_RNDN);
13067 mpfr_clear_flags ();
13068 inexact = func (m1, m1, m2, rnd);
13069 result = do_mpfr_ckconv (m1, type, inexact);
13070 mpfr_clears (m1, m2, NULL);
13077 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13078 FUNC on it and return the resulting value as a tree with type TYPE.
13079 The mpfr precision is set to the precision of TYPE. We assume that
13080 function FUNC returns zero if the result could be calculated
13081 exactly within the requested precision. */
13084 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13085 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13087 tree result = NULL_TREE;
13093 /* To proceed, MPFR must exactly represent the target floating point
13094 format, which only happens when the target base equals two. */
13095 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13096 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13097 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13098 && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13100 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13101 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13102 const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13104 if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13106 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13107 const int prec = fmt->p;
13108 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13112 mpfr_inits2 (prec, m1, m2, m3, NULL);
13113 mpfr_from_real (m1, ra1, GMP_RNDN);
13114 mpfr_from_real (m2, ra2, GMP_RNDN);
13115 mpfr_from_real (m3, ra3, GMP_RNDN);
13116 mpfr_clear_flags ();
13117 inexact = func (m1, m1, m2, m3, rnd);
13118 result = do_mpfr_ckconv (m1, type, inexact);
13119 mpfr_clears (m1, m2, m3, NULL);
13126 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13127 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13128 If ARG_SINP and ARG_COSP are NULL then the result is returned
13129 as a complex value.
13130 The type is taken from the type of ARG and is used for setting the
13131 precision of the calculation and results. */
13134 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13136 tree const type = TREE_TYPE (arg);
13137 tree result = NULL_TREE;
13141 /* To proceed, MPFR must exactly represent the target floating point
13142 format, which only happens when the target base equals two. */
13143 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13144 && TREE_CODE (arg) == REAL_CST
13145 && !TREE_OVERFLOW (arg))
13147 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13149 if (real_isfinite (ra))
13151 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13152 const int prec = fmt->p;
13153 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13154 tree result_s, result_c;
13158 mpfr_inits2 (prec, m, ms, mc, NULL);
13159 mpfr_from_real (m, ra, GMP_RNDN);
13160 mpfr_clear_flags ();
13161 inexact = mpfr_sin_cos (ms, mc, m, rnd);
13162 result_s = do_mpfr_ckconv (ms, type, inexact);
13163 result_c = do_mpfr_ckconv (mc, type, inexact);
13164 mpfr_clears (m, ms, mc, NULL);
13165 if (result_s && result_c)
13167 /* If we are to return in a complex value do so. */
13168 if (!arg_sinp && !arg_cosp)
13169 return build_complex (build_complex_type (type),
13170 result_c, result_s);
13172 /* Dereference the sin/cos pointer arguments. */
13173 arg_sinp = build_fold_indirect_ref (arg_sinp);
13174 arg_cosp = build_fold_indirect_ref (arg_cosp);
13175 /* Proceed if valid pointer type were passed in. */
13176 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13177 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13179 /* Set the values. */
13180 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13182 TREE_SIDE_EFFECTS (result_s) = 1;
13183 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13185 TREE_SIDE_EFFECTS (result_c) = 1;
13186 /* Combine the assignments into a compound expr. */
13187 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13188 result_s, result_c));
13196 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13197 two-argument mpfr order N Bessel function FUNC on them and return
13198 the resulting value as a tree with type TYPE. The mpfr precision
13199 is set to the precision of TYPE. We assume that function FUNC
13200 returns zero if the result could be calculated exactly within the
13201 requested precision. */
13203 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13204 int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13205 const REAL_VALUE_TYPE *min, bool inclusive)
13207 tree result = NULL_TREE;
13212 /* To proceed, MPFR must exactly represent the target floating point
13213 format, which only happens when the target base equals two. */
13214 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13215 && host_integerp (arg1, 0)
13216 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13218 const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13219 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13222 && real_isfinite (ra)
13223 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13225 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13226 const int prec = fmt->p;
13227 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13231 mpfr_init2 (m, prec);
13232 mpfr_from_real (m, ra, GMP_RNDN);
13233 mpfr_clear_flags ();
13234 inexact = func (m, n, m, rnd);
13235 result = do_mpfr_ckconv (m, type, inexact);
13243 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13244 the pointer *(ARG_QUO) and return the result. The type is taken
13245 from the type of ARG0 and is used for setting the precision of the
13246 calculation and results. */
13249 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13251 tree const type = TREE_TYPE (arg0);
13252 tree result = NULL_TREE;
13257 /* To proceed, MPFR must exactly represent the target floating point
13258 format, which only happens when the target base equals two. */
13259 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13260 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13261 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13263 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13264 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13266 if (real_isfinite (ra0) && real_isfinite (ra1))
13268 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13269 const int prec = fmt->p;
13270 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13275 mpfr_inits2 (prec, m0, m1, NULL);
13276 mpfr_from_real (m0, ra0, GMP_RNDN);
13277 mpfr_from_real (m1, ra1, GMP_RNDN);
13278 mpfr_clear_flags ();
13279 mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13280 /* Remquo is independent of the rounding mode, so pass
13281 inexact=0 to do_mpfr_ckconv(). */
13282 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13283 mpfr_clears (m0, m1, NULL);
13286 /* MPFR calculates quo in the host's long so it may
13287 return more bits in quo than the target int can hold
13288 if sizeof(host long) > sizeof(target int). This can
13289 happen even for native compilers in LP64 mode. In
13290 these cases, modulo the quo value with the largest
13291 number that the target int can hold while leaving one
13292 bit for the sign. */
13293 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13294 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13296 /* Dereference the quo pointer argument. */
13297 arg_quo = build_fold_indirect_ref (arg_quo);
13298 /* Proceed iff a valid pointer type was passed in. */
13299 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13301 /* Set the value. */
13302 tree result_quo = fold_build2 (MODIFY_EXPR,
13303 TREE_TYPE (arg_quo), arg_quo,
13304 build_int_cst (NULL, integer_quo));
13305 TREE_SIDE_EFFECTS (result_quo) = 1;
13306 /* Combine the quo assignment with the rem. */
13307 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13308 result_quo, result_rem));
13316 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13317 resulting value as a tree with type TYPE. The mpfr precision is
13318 set to the precision of TYPE. We assume that this mpfr function
13319 returns zero if the result could be calculated exactly within the
13320 requested precision. In addition, the integer pointer represented
13321 by ARG_SG will be dereferenced and set to the appropriate signgam
13325 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13327 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. Also
13333 verify ARG is a constant and that ARG_SG is an int pointer. */
13334 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13335 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13336 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13337 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13339 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13341 /* In addition to NaN and Inf, the argument cannot be zero or a
13342 negative integer. */
13343 if (real_isfinite (ra)
13344 && ra->cl != rvc_zero
13345 && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13347 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13348 const int prec = fmt->p;
13349 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13354 mpfr_init2 (m, prec);
13355 mpfr_from_real (m, ra, GMP_RNDN);
13356 mpfr_clear_flags ();
13357 inexact = mpfr_lgamma (m, &sg, m, rnd);
13358 result_lg = do_mpfr_ckconv (m, type, inexact);
13364 /* Dereference the arg_sg pointer argument. */
13365 arg_sg = build_fold_indirect_ref (arg_sg);
13366 /* Assign the signgam value into *arg_sg. */
13367 result_sg = fold_build2 (MODIFY_EXPR,
13368 TREE_TYPE (arg_sg), arg_sg,
13369 build_int_cst (NULL, sg));
13370 TREE_SIDE_EFFECTS (result_sg) = 1;
13371 /* Combine the signgam assignment with the lgamma result. */
13372 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13373 result_sg, result_lg));
13381 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13382 function FUNC on it and return the resulting value as a tree with
13383 type TYPE. The mpfr precision is set to the precision of TYPE. We
13384 assume that function FUNC returns zero if the result could be
13385 calculated exactly within the requested precision. */
13388 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13390 tree result = NULL_TREE;
13394 /* To proceed, MPFR must exactly represent the target floating point
13395 format, which only happens when the target base equals two. */
13396 if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13397 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13398 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13400 const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13401 const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13403 if (real_isfinite (re) && real_isfinite (im))
13405 const struct real_format *const fmt =
13406 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13407 const int prec = fmt->p;
13408 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13409 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13413 mpc_init2 (m, prec);
13414 mpfr_from_real (mpc_realref(m), re, rnd);
13415 mpfr_from_real (mpc_imagref(m), im, rnd);
13416 mpfr_clear_flags ();
13417 inexact = func (m, m, crnd);
13418 result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13426 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13427 mpc function FUNC on it and return the resulting value as a tree
13428 with type TYPE. The mpfr precision is set to the precision of
13429 TYPE. We assume that function FUNC returns zero if the result
13430 could be calculated exactly within the requested precision. If
13431 DO_NONFINITE is true, then fold expressions containing Inf or NaN
13432 in the arguments and/or results. */
13435 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13436 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13438 tree result = NULL_TREE;
13443 /* To proceed, MPFR must exactly represent the target floating point
13444 format, which only happens when the target base equals two. */
13445 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13446 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13447 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13448 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13449 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13451 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13452 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13453 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13454 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13457 || (real_isfinite (re0) && real_isfinite (im0)
13458 && real_isfinite (re1) && real_isfinite (im1)))
13460 const struct real_format *const fmt =
13461 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13462 const int prec = fmt->p;
13463 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13464 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13468 mpc_init2 (m0, prec);
13469 mpc_init2 (m1, prec);
13470 mpfr_from_real (mpc_realref(m0), re0, rnd);
13471 mpfr_from_real (mpc_imagref(m0), im0, rnd);
13472 mpfr_from_real (mpc_realref(m1), re1, rnd);
13473 mpfr_from_real (mpc_imagref(m1), im1, rnd);
13474 mpfr_clear_flags ();
13475 inexact = func (m0, m0, m1, crnd);
13476 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13486 The functions below provide an alternate interface for folding
13487 builtin function calls presented as GIMPLE_CALL statements rather
13488 than as CALL_EXPRs. The folded result is still expressed as a
13489 tree. There is too much code duplication in the handling of
13490 varargs functions, and a more intrusive re-factoring would permit
13491 better sharing of code between the tree and statement-based
13492 versions of these functions. */
13494 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13495 along with N new arguments specified as the "..." parameters. SKIP
13496 is the number of arguments in STMT to be omitted. This function is used
13497 to do varargs-to-varargs transformations. */
13500 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13502 int oldnargs = gimple_call_num_args (stmt);
13503 int nargs = oldnargs - skip + n;
13504 tree fntype = TREE_TYPE (fndecl);
13505 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13509 location_t loc = gimple_location (stmt);
13511 buffer = XALLOCAVEC (tree, nargs);
13513 for (i = 0; i < n; i++)
13514 buffer[i] = va_arg (ap, tree);
13516 for (j = skip; j < oldnargs; j++, i++)
13517 buffer[i] = gimple_call_arg (stmt, j);
13519 return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13522 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
13523 a normal call should be emitted rather than expanding the function
13524 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13527 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13529 tree dest, size, len, fn, fmt, flag;
13530 const char *fmt_str;
13531 int nargs = gimple_call_num_args (stmt);
13533 /* Verify the required arguments in the original call. */
13536 dest = gimple_call_arg (stmt, 0);
13537 if (!validate_arg (dest, POINTER_TYPE))
13539 flag = gimple_call_arg (stmt, 1);
13540 if (!validate_arg (flag, INTEGER_TYPE))
13542 size = gimple_call_arg (stmt, 2);
13543 if (!validate_arg (size, INTEGER_TYPE))
13545 fmt = gimple_call_arg (stmt, 3);
13546 if (!validate_arg (fmt, POINTER_TYPE))
13549 if (! host_integerp (size, 1))
13554 if (!init_target_chars ())
13557 /* Check whether the format is a literal string constant. */
13558 fmt_str = c_getstr (fmt);
13559 if (fmt_str != NULL)
13561 /* If the format doesn't contain % args or %%, we know the size. */
13562 if (strchr (fmt_str, target_percent) == 0)
13564 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13565 len = build_int_cstu (size_type_node, strlen (fmt_str));
13567 /* If the format is "%s" and first ... argument is a string literal,
13568 we know the size too. */
13569 else if (fcode == BUILT_IN_SPRINTF_CHK
13570 && strcmp (fmt_str, target_percent_s) == 0)
13576 arg = gimple_call_arg (stmt, 4);
13577 if (validate_arg (arg, POINTER_TYPE))
13579 len = c_strlen (arg, 1);
13580 if (! len || ! host_integerp (len, 1))
13587 if (! integer_all_onesp (size))
13589 if (! len || ! tree_int_cst_lt (len, size))
13593 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13594 or if format doesn't contain % chars or is "%s". */
13595 if (! integer_zerop (flag))
13597 if (fmt_str == NULL)
13599 if (strchr (fmt_str, target_percent) != NULL
13600 && strcmp (fmt_str, target_percent_s))
13604 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
13605 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13606 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13610 return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13613 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
13614 a normal call should be emitted rather than expanding the function
13615 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13616 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13617 passed as second argument. */
13620 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13621 enum built_in_function fcode)
13623 tree dest, size, len, fn, fmt, flag;
13624 const char *fmt_str;
13626 /* Verify the required arguments in the original call. */
13627 if (gimple_call_num_args (stmt) < 5)
13629 dest = gimple_call_arg (stmt, 0);
13630 if (!validate_arg (dest, POINTER_TYPE))
13632 len = gimple_call_arg (stmt, 1);
13633 if (!validate_arg (len, INTEGER_TYPE))
13635 flag = gimple_call_arg (stmt, 2);
13636 if (!validate_arg (flag, INTEGER_TYPE))
13638 size = gimple_call_arg (stmt, 3);
13639 if (!validate_arg (size, INTEGER_TYPE))
13641 fmt = gimple_call_arg (stmt, 4);
13642 if (!validate_arg (fmt, POINTER_TYPE))
13645 if (! host_integerp (size, 1))
13648 if (! integer_all_onesp (size))
13650 if (! host_integerp (len, 1))
13652 /* If LEN is not constant, try MAXLEN too.
13653 For MAXLEN only allow optimizing into non-_ocs function
13654 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
13655 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13661 if (tree_int_cst_lt (size, maxlen))
13665 if (!init_target_chars ())
13668 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13669 or if format doesn't contain % chars or is "%s". */
13670 if (! integer_zerop (flag))
13672 fmt_str = c_getstr (fmt);
13673 if (fmt_str == NULL)
13675 if (strchr (fmt_str, target_percent) != NULL
13676 && strcmp (fmt_str, target_percent_s))
13680 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13682 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13683 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13687 return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13690 /* Builtins with folding operations that operate on "..." arguments
13691 need special handling; we need to store the arguments in a convenient
13692 data structure before attempting any folding. Fortunately there are
13693 only a few builtins that fall into this category. FNDECL is the
13694 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13695 result of the function call is ignored. */
13698 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13699 bool ignore ATTRIBUTE_UNUSED)
13701 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13702 tree ret = NULL_TREE;
13706 case BUILT_IN_SPRINTF_CHK:
13707 case BUILT_IN_VSPRINTF_CHK:
13708 ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13711 case BUILT_IN_SNPRINTF_CHK:
13712 case BUILT_IN_VSNPRINTF_CHK:
13713 ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13720 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13721 TREE_NO_WARNING (ret) = 1;
13727 /* A wrapper function for builtin folding that prevents warnings for
13728 "statement without effect" and the like, caused by removing the
13729 call node earlier than the warning is generated. */
13732 fold_call_stmt (gimple stmt, bool ignore)
13734 tree ret = NULL_TREE;
13735 tree fndecl = gimple_call_fndecl (stmt);
13736 location_t loc = gimple_location (stmt);
13738 && TREE_CODE (fndecl) == FUNCTION_DECL
13739 && DECL_BUILT_IN (fndecl)
13740 && !gimple_call_va_arg_pack_p (stmt))
13742 int nargs = gimple_call_num_args (stmt);
13744 if (avoid_folding_inline_builtin (fndecl))
13746 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13748 return targetm.fold_builtin (fndecl, nargs,
13750 ? gimple_call_arg_ptr (stmt, 0)
13751 : &error_mark_node), ignore);
13755 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13757 tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13759 for (i = 0; i < nargs; i++)
13760 args[i] = gimple_call_arg (stmt, i);
13761 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13764 ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13767 /* Propagate location information from original call to
13768 expansion of builtin. Otherwise things like
13769 maybe_emit_chk_warning, that operate on the expansion
13770 of a builtin, will use the wrong location information. */
13771 if (gimple_has_location (stmt))
13773 tree realret = ret;
13774 if (TREE_CODE (ret) == NOP_EXPR)
13775 realret = TREE_OPERAND (ret, 0);
13776 if (CAN_HAVE_LOCATION_P (realret)
13777 && !EXPR_HAS_LOCATION (realret))
13778 SET_EXPR_LOCATION (realret, loc);
13788 /* Look up the function in built_in_decls that corresponds to DECL
13789 and set ASMSPEC as its user assembler name. DECL must be a
13790 function decl that declares a builtin. */
13793 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13796 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13797 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13800 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13801 set_user_assembler_name (builtin, asmspec);
13802 switch (DECL_FUNCTION_CODE (decl))
13804 case BUILT_IN_MEMCPY:
13805 init_block_move_fn (asmspec);
13806 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13808 case BUILT_IN_MEMSET:
13809 init_block_clear_fn (asmspec);
13810 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13812 case BUILT_IN_MEMMOVE:
13813 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13815 case BUILT_IN_MEMCMP:
13816 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13818 case BUILT_IN_ABORT:
13819 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13822 if (INT_TYPE_SIZE < BITS_PER_WORD)
13824 set_user_assembler_libfunc ("ffs", asmspec);
13825 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13826 MODE_INT, 0), "ffs");
13834 /* Return true if DECL is a builtin that expands to a constant or similarly
13837 is_simple_builtin (tree decl)
13839 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13840 switch (DECL_FUNCTION_CODE (decl))
13842 /* Builtins that expand to constants. */
13843 case BUILT_IN_CONSTANT_P:
13844 case BUILT_IN_EXPECT:
13845 case BUILT_IN_OBJECT_SIZE:
13846 case BUILT_IN_UNREACHABLE:
13847 /* Simple register moves or loads from stack. */
13848 case BUILT_IN_RETURN_ADDRESS:
13849 case BUILT_IN_EXTRACT_RETURN_ADDR:
13850 case BUILT_IN_FROB_RETURN_ADDR:
13851 case BUILT_IN_RETURN:
13852 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13853 case BUILT_IN_FRAME_ADDRESS:
13854 case BUILT_IN_VA_END:
13855 case BUILT_IN_STACK_SAVE:
13856 case BUILT_IN_STACK_RESTORE:
13857 /* Exception state returns or moves registers around. */
13858 case BUILT_IN_EH_FILTER:
13859 case BUILT_IN_EH_POINTER:
13860 case BUILT_IN_EH_COPY_VALUES:
13870 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13871 most probably expanded inline into reasonably simple code. This is a
13872 superset of is_simple_builtin. */
13874 is_inexpensive_builtin (tree decl)
13878 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13880 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13881 switch (DECL_FUNCTION_CODE (decl))
13884 case BUILT_IN_ALLOCA:
13885 case BUILT_IN_BSWAP32:
13886 case BUILT_IN_BSWAP64:
13888 case BUILT_IN_CLZIMAX:
13889 case BUILT_IN_CLZL:
13890 case BUILT_IN_CLZLL:
13892 case BUILT_IN_CTZIMAX:
13893 case BUILT_IN_CTZL:
13894 case BUILT_IN_CTZLL:
13896 case BUILT_IN_FFSIMAX:
13897 case BUILT_IN_FFSL:
13898 case BUILT_IN_FFSLL:
13899 case BUILT_IN_IMAXABS:
13900 case BUILT_IN_FINITE:
13901 case BUILT_IN_FINITEF:
13902 case BUILT_IN_FINITEL:
13903 case BUILT_IN_FINITED32:
13904 case BUILT_IN_FINITED64:
13905 case BUILT_IN_FINITED128:
13906 case BUILT_IN_FPCLASSIFY:
13907 case BUILT_IN_ISFINITE:
13908 case BUILT_IN_ISINF_SIGN:
13909 case BUILT_IN_ISINF:
13910 case BUILT_IN_ISINFF:
13911 case BUILT_IN_ISINFL:
13912 case BUILT_IN_ISINFD32:
13913 case BUILT_IN_ISINFD64:
13914 case BUILT_IN_ISINFD128:
13915 case BUILT_IN_ISNAN:
13916 case BUILT_IN_ISNANF:
13917 case BUILT_IN_ISNANL:
13918 case BUILT_IN_ISNAND32:
13919 case BUILT_IN_ISNAND64:
13920 case BUILT_IN_ISNAND128:
13921 case BUILT_IN_ISNORMAL:
13922 case BUILT_IN_ISGREATER:
13923 case BUILT_IN_ISGREATEREQUAL:
13924 case BUILT_IN_ISLESS:
13925 case BUILT_IN_ISLESSEQUAL:
13926 case BUILT_IN_ISLESSGREATER:
13927 case BUILT_IN_ISUNORDERED:
13928 case BUILT_IN_VA_ARG_PACK:
13929 case BUILT_IN_VA_ARG_PACK_LEN:
13930 case BUILT_IN_VA_COPY:
13931 case BUILT_IN_TRAP:
13932 case BUILT_IN_SAVEREGS:
13933 case BUILT_IN_POPCOUNTL:
13934 case BUILT_IN_POPCOUNTLL:
13935 case BUILT_IN_POPCOUNTIMAX:
13936 case BUILT_IN_POPCOUNT:
13937 case BUILT_IN_PARITYL:
13938 case BUILT_IN_PARITYLL:
13939 case BUILT_IN_PARITYIMAX:
13940 case BUILT_IN_PARITY:
13941 case BUILT_IN_LABS:
13942 case BUILT_IN_LLABS:
13943 case BUILT_IN_PREFETCH:
13947 return is_simple_builtin (decl);