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
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.h"
54 #ifndef SLOW_UNALIGNED_ACCESS
55 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
58 #ifndef PAD_VARARGS_DOWN
59 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
65 /* Define the names of the builtin function types and codes. */
66 const char *const built_in_class_names[4]
67 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
69 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
70 const char * built_in_names[(int) END_BUILTINS] =
72 #include "builtins.def"
76 /* Setup an array of _DECL trees, make sure each element is
77 initialized to NULL_TREE. */
78 tree built_in_decls[(int) END_BUILTINS];
79 /* Declarations used when constructing the builtin implicitly in the compiler.
80 It may be NULL_TREE when this is invalid (for instance runtime is not
81 required to implement the function call in all cases). */
82 tree implicit_built_in_decls[(int) END_BUILTINS];
84 static const char *c_getstr (tree);
85 static rtx c_readstr (const char *, enum machine_mode);
86 static int target_char_cast (tree, char *);
87 static rtx get_memory_rtx (tree, tree);
88 static int apply_args_size (void);
89 static int apply_result_size (void);
90 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
91 static rtx result_vector (int, rtx);
93 static void expand_builtin_update_setjmp_buf (rtx);
94 static void expand_builtin_prefetch (tree);
95 static rtx expand_builtin_apply_args (void);
96 static rtx expand_builtin_apply_args_1 (void);
97 static rtx expand_builtin_apply (rtx, rtx, rtx);
98 static void expand_builtin_return (rtx);
99 static enum type_class type_to_class (tree);
100 static rtx expand_builtin_classify_type (tree);
101 static void expand_errno_check (tree, rtx);
102 static rtx expand_builtin_mathfn (tree, rtx, rtx);
103 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
104 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
105 static rtx expand_builtin_interclass_mathfn (tree, rtx, rtx);
106 static rtx expand_builtin_sincos (tree);
107 static rtx expand_builtin_cexpi (tree, rtx, rtx);
108 static rtx expand_builtin_int_roundingfn (tree, rtx);
109 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
110 static rtx expand_builtin_args_info (tree);
111 static rtx expand_builtin_next_arg (void);
112 static rtx expand_builtin_va_start (tree);
113 static rtx expand_builtin_va_end (tree);
114 static rtx expand_builtin_va_copy (tree);
115 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
116 static rtx expand_builtin_strcmp (tree, rtx);
117 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
118 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
119 static rtx expand_builtin_memcpy (tree, rtx);
120 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
121 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
122 enum machine_mode, int);
123 static rtx expand_builtin_strcpy (tree, rtx);
124 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
125 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
126 static rtx expand_builtin_strncpy (tree, rtx);
127 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
128 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
129 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
130 static rtx expand_builtin_bzero (tree);
131 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
132 static rtx expand_builtin_alloca (tree, rtx);
133 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
134 static rtx expand_builtin_frame_address (tree, tree);
135 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
136 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
137 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
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);
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, ALIGN is the inital
271 guessed alignment e.g. from type alignment. */
274 get_object_alignment (tree exp, unsigned int align, unsigned int max_align)
279 if (handled_component_p (exp))
281 HOST_WIDE_INT bitsize, bitpos;
283 enum machine_mode mode;
284 int unsignedp, volatilep;
286 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
287 &mode, &unsignedp, &volatilep, true);
289 inner = MIN (inner, (unsigned) (bitpos & -bitpos));
294 if (TREE_CODE (offset) == PLUS_EXPR)
296 next_offset = TREE_OPERAND (offset, 0);
297 offset = TREE_OPERAND (offset, 1);
301 if (host_integerp (offset, 1))
303 /* Any overflow in calculating offset_bits won't change
306 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
309 inner = MIN (inner, (offset_bits & -offset_bits));
311 else if (TREE_CODE (offset) == MULT_EXPR
312 && host_integerp (TREE_OPERAND (offset, 1), 1))
314 /* Any overflow in calculating offset_factor won't change
316 unsigned offset_factor
317 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
321 inner = MIN (inner, (offset_factor & -offset_factor));
325 inner = MIN (inner, BITS_PER_UNIT);
328 offset = next_offset;
332 align = MIN (inner, DECL_ALIGN (exp));
333 #ifdef CONSTANT_ALIGNMENT
334 else if (CONSTANT_CLASS_P (exp))
335 align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
337 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
338 || TREE_CODE (exp) == INDIRECT_REF)
339 align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
341 align = MIN (align, inner);
342 return MIN (align, max_align);
345 /* Returns true iff we can trust that alignment information has been
346 calculated properly. */
349 can_trust_pointer_alignment (void)
351 /* We rely on TER to compute accurate alignment information. */
352 return (optimize && flag_tree_ter);
355 /* Return the alignment in bits of EXP, a pointer valued expression.
356 But don't return more than MAX_ALIGN no matter what.
357 The alignment returned is, by default, the alignment of the thing that
358 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
360 Otherwise, look at the expression to see if we can do better, i.e., if the
361 expression is actually pointing at an object whose alignment is tighter. */
364 get_pointer_alignment (tree exp, unsigned int max_align)
366 unsigned int align, inner;
368 if (!can_trust_pointer_alignment ())
371 if (!POINTER_TYPE_P (TREE_TYPE (exp)))
374 align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
375 align = MIN (align, max_align);
379 switch (TREE_CODE (exp))
382 exp = TREE_OPERAND (exp, 0);
383 if (! POINTER_TYPE_P (TREE_TYPE (exp)))
386 inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
387 align = MIN (inner, max_align);
390 case POINTER_PLUS_EXPR:
391 /* If sum of pointer + int, restrict our maximum alignment to that
392 imposed by the integer. If not, we can't do any better than
394 if (! host_integerp (TREE_OPERAND (exp, 1), 1))
397 while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
398 & (max_align / BITS_PER_UNIT - 1))
402 exp = TREE_OPERAND (exp, 0);
406 /* See what we are pointing at and look at its alignment. */
407 return get_object_alignment (TREE_OPERAND (exp, 0), align, max_align);
415 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
416 way, because it could contain a zero byte in the middle.
417 TREE_STRING_LENGTH is the size of the character array, not the string.
419 ONLY_VALUE should be nonzero if the result is not going to be emitted
420 into the instruction stream and zero if it is going to be expanded.
421 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
422 is returned, otherwise NULL, since
423 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
424 evaluate the side-effects.
426 The value returned is of type `ssizetype'.
428 Unfortunately, string_constant can't access the values of const char
429 arrays with initializers, so neither can we do so here. */
432 c_strlen (tree src, int only_value)
435 HOST_WIDE_INT offset;
440 if (TREE_CODE (src) == COND_EXPR
441 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
445 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
446 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
447 if (tree_int_cst_equal (len1, len2))
451 if (TREE_CODE (src) == COMPOUND_EXPR
452 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
453 return c_strlen (TREE_OPERAND (src, 1), only_value);
455 src = string_constant (src, &offset_node);
459 max = TREE_STRING_LENGTH (src) - 1;
460 ptr = TREE_STRING_POINTER (src);
462 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
464 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
465 compute the offset to the following null if we don't know where to
466 start searching for it. */
469 for (i = 0; i < max; i++)
473 /* We don't know the starting offset, but we do know that the string
474 has no internal zero bytes. We can assume that the offset falls
475 within the bounds of the string; otherwise, the programmer deserves
476 what he gets. Subtract the offset from the length of the string,
477 and return that. This would perhaps not be valid if we were dealing
478 with named arrays in addition to literal string constants. */
480 return size_diffop_loc (input_location, size_int (max), offset_node);
483 /* We have a known offset into the string. Start searching there for
484 a null character if we can represent it as a single HOST_WIDE_INT. */
485 if (offset_node == 0)
487 else if (! host_integerp (offset_node, 0))
490 offset = tree_low_cst (offset_node, 0);
492 /* If the offset is known to be out of bounds, warn, and call strlen at
494 if (offset < 0 || offset > max)
496 /* Suppress multiple warnings for propagated constant strings. */
497 if (! TREE_NO_WARNING (src))
499 warning (0, "offset outside bounds of constant string");
500 TREE_NO_WARNING (src) = 1;
505 /* Use strlen to search for the first zero byte. Since any strings
506 constructed with build_string will have nulls appended, we win even
507 if we get handed something like (char[4])"abcd".
509 Since OFFSET is our starting index into the string, no further
510 calculation is needed. */
511 return ssize_int (strlen (ptr + offset));
514 /* Return a char pointer for a C string if it is a string constant
515 or sum of string constant and integer constant. */
522 src = string_constant (src, &offset_node);
526 if (offset_node == 0)
527 return TREE_STRING_POINTER (src);
528 else if (!host_integerp (offset_node, 1)
529 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
532 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
535 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
536 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
539 c_readstr (const char *str, enum machine_mode mode)
545 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
550 for (i = 0; i < GET_MODE_SIZE (mode); i++)
553 if (WORDS_BIG_ENDIAN)
554 j = GET_MODE_SIZE (mode) - i - 1;
555 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
556 && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
557 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
559 gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
562 ch = (unsigned char) str[i];
563 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
565 return immed_double_const (c[0], c[1], mode);
568 /* Cast a target constant CST to target CHAR and if that value fits into
569 host char type, return zero and put that value into variable pointed to by
573 target_char_cast (tree cst, char *p)
575 unsigned HOST_WIDE_INT val, hostval;
577 if (!host_integerp (cst, 1)
578 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
581 val = tree_low_cst (cst, 1);
582 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
583 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
586 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
587 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
596 /* Similar to save_expr, but assumes that arbitrary code is not executed
597 in between the multiple evaluations. In particular, we assume that a
598 non-addressable local variable will not be modified. */
601 builtin_save_expr (tree exp)
603 if (TREE_ADDRESSABLE (exp) == 0
604 && (TREE_CODE (exp) == PARM_DECL
605 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
608 return save_expr (exp);
611 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
612 times to get the address of either a higher stack frame, or a return
613 address located within it (depending on FNDECL_CODE). */
616 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
620 #ifdef INITIAL_FRAME_ADDRESS_RTX
621 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
625 /* For a zero count with __builtin_return_address, we don't care what
626 frame address we return, because target-specific definitions will
627 override us. Therefore frame pointer elimination is OK, and using
628 the soft frame pointer is OK.
630 For a nonzero count, or a zero count with __builtin_frame_address,
631 we require a stable offset from the current frame pointer to the
632 previous one, so we must use the hard frame pointer, and
633 we must disable frame pointer elimination. */
634 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
635 tem = frame_pointer_rtx;
638 tem = hard_frame_pointer_rtx;
640 /* Tell reload not to eliminate the frame pointer. */
641 crtl->accesses_prior_frames = 1;
645 /* Some machines need special handling before we can access
646 arbitrary frames. For example, on the SPARC, we must first flush
647 all register windows to the stack. */
648 #ifdef SETUP_FRAME_ADDRESSES
650 SETUP_FRAME_ADDRESSES ();
653 /* On the SPARC, the return address is not in the frame, it is in a
654 register. There is no way to access it off of the current frame
655 pointer, but it can be accessed off the previous frame pointer by
656 reading the value from the register window save area. */
657 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
658 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
662 /* Scan back COUNT frames to the specified frame. */
663 for (i = 0; i < count; i++)
665 /* Assume the dynamic chain pointer is in the word that the
666 frame address points to, unless otherwise specified. */
667 #ifdef DYNAMIC_CHAIN_ADDRESS
668 tem = DYNAMIC_CHAIN_ADDRESS (tem);
670 tem = memory_address (Pmode, tem);
671 tem = gen_frame_mem (Pmode, tem);
672 tem = copy_to_reg (tem);
675 /* For __builtin_frame_address, return what we've got. But, on
676 the SPARC for example, we may have to add a bias. */
677 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
678 #ifdef FRAME_ADDR_RTX
679 return FRAME_ADDR_RTX (tem);
684 /* For __builtin_return_address, get the return address from that frame. */
685 #ifdef RETURN_ADDR_RTX
686 tem = RETURN_ADDR_RTX (count, tem);
688 tem = memory_address (Pmode,
689 plus_constant (tem, GET_MODE_SIZE (Pmode)));
690 tem = gen_frame_mem (Pmode, tem);
695 /* Alias set used for setjmp buffer. */
696 static alias_set_type setjmp_alias_set = -1;
698 /* Construct the leading half of a __builtin_setjmp call. Control will
699 return to RECEIVER_LABEL. This is also called directly by the SJLJ
700 exception handling code. */
703 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
705 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
709 if (setjmp_alias_set == -1)
710 setjmp_alias_set = new_alias_set ();
712 buf_addr = convert_memory_address (Pmode, buf_addr);
714 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
716 /* We store the frame pointer and the address of receiver_label in
717 the buffer and use the rest of it for the stack save area, which
718 is machine-dependent. */
720 mem = gen_rtx_MEM (Pmode, buf_addr);
721 set_mem_alias_set (mem, setjmp_alias_set);
722 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
724 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
725 set_mem_alias_set (mem, setjmp_alias_set);
727 emit_move_insn (validize_mem (mem),
728 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
730 stack_save = gen_rtx_MEM (sa_mode,
731 plus_constant (buf_addr,
732 2 * GET_MODE_SIZE (Pmode)));
733 set_mem_alias_set (stack_save, setjmp_alias_set);
734 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
736 /* If there is further processing to do, do it. */
737 #ifdef HAVE_builtin_setjmp_setup
738 if (HAVE_builtin_setjmp_setup)
739 emit_insn (gen_builtin_setjmp_setup (buf_addr));
742 /* Tell optimize_save_area_alloca that extra work is going to
743 need to go on during alloca. */
744 cfun->calls_setjmp = 1;
746 /* We have a nonlocal label. */
747 cfun->has_nonlocal_label = 1;
750 /* Construct the trailing part of a __builtin_setjmp call. This is
751 also called directly by the SJLJ exception handling code. */
754 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
758 /* Clobber the FP when we get here, so we have to make sure it's
759 marked as used by this function. */
760 emit_use (hard_frame_pointer_rtx);
762 /* Mark the static chain as clobbered here so life information
763 doesn't get messed up for it. */
764 chain = targetm.calls.static_chain (current_function_decl, true);
765 if (chain && REG_P (chain))
766 emit_clobber (chain);
768 /* Now put in the code to restore the frame pointer, and argument
769 pointer, if needed. */
770 #ifdef HAVE_nonlocal_goto
771 if (! HAVE_nonlocal_goto)
774 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
775 /* This might change the hard frame pointer in ways that aren't
776 apparent to early optimization passes, so force a clobber. */
777 emit_clobber (hard_frame_pointer_rtx);
780 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
781 if (fixed_regs[ARG_POINTER_REGNUM])
783 #ifdef ELIMINABLE_REGS
785 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
787 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
788 if (elim_regs[i].from == ARG_POINTER_REGNUM
789 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
792 if (i == ARRAY_SIZE (elim_regs))
795 /* Now restore our arg pointer from the address at which it
796 was saved in our stack frame. */
797 emit_move_insn (crtl->args.internal_arg_pointer,
798 copy_to_reg (get_arg_pointer_save_area ()));
803 #ifdef HAVE_builtin_setjmp_receiver
804 if (HAVE_builtin_setjmp_receiver)
805 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
808 #ifdef HAVE_nonlocal_goto_receiver
809 if (HAVE_nonlocal_goto_receiver)
810 emit_insn (gen_nonlocal_goto_receiver ());
815 /* We must not allow the code we just generated to be reordered by
816 scheduling. Specifically, the update of the frame pointer must
817 happen immediately, not later. */
818 emit_insn (gen_blockage ());
821 /* __builtin_longjmp is passed a pointer to an array of five words (not
822 all will be used on all machines). It operates similarly to the C
823 library function of the same name, but is more efficient. Much of
824 the code below is copied from the handling of non-local gotos. */
827 expand_builtin_longjmp (rtx buf_addr, rtx value)
829 rtx fp, lab, stack, insn, last;
830 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
832 /* DRAP is needed for stack realign if longjmp is expanded to current
834 if (SUPPORTS_STACK_ALIGNMENT)
835 crtl->need_drap = true;
837 if (setjmp_alias_set == -1)
838 setjmp_alias_set = new_alias_set ();
840 buf_addr = convert_memory_address (Pmode, buf_addr);
842 buf_addr = force_reg (Pmode, buf_addr);
844 /* We require that the user must pass a second argument of 1, because
845 that is what builtin_setjmp will return. */
846 gcc_assert (value == const1_rtx);
848 last = get_last_insn ();
849 #ifdef HAVE_builtin_longjmp
850 if (HAVE_builtin_longjmp)
851 emit_insn (gen_builtin_longjmp (buf_addr));
855 fp = gen_rtx_MEM (Pmode, buf_addr);
856 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
857 GET_MODE_SIZE (Pmode)));
859 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
860 2 * GET_MODE_SIZE (Pmode)));
861 set_mem_alias_set (fp, setjmp_alias_set);
862 set_mem_alias_set (lab, setjmp_alias_set);
863 set_mem_alias_set (stack, setjmp_alias_set);
865 /* Pick up FP, label, and SP from the block and jump. This code is
866 from expand_goto in stmt.c; see there for detailed comments. */
867 #ifdef HAVE_nonlocal_goto
868 if (HAVE_nonlocal_goto)
869 /* We have to pass a value to the nonlocal_goto pattern that will
870 get copied into the static_chain pointer, but it does not matter
871 what that value is, because builtin_setjmp does not use it. */
872 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
876 lab = copy_to_reg (lab);
878 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
879 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
881 emit_move_insn (hard_frame_pointer_rtx, fp);
882 emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
884 emit_use (hard_frame_pointer_rtx);
885 emit_use (stack_pointer_rtx);
886 emit_indirect_jump (lab);
890 /* Search backwards and mark the jump insn as a non-local goto.
891 Note that this precludes the use of __builtin_longjmp to a
892 __builtin_setjmp target in the same function. However, we've
893 already cautioned the user that these functions are for
894 internal exception handling use only. */
895 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
897 gcc_assert (insn != last);
901 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
904 else if (CALL_P (insn))
909 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
910 and the address of the save area. */
913 expand_builtin_nonlocal_goto (tree exp)
915 tree t_label, t_save_area;
916 rtx r_label, r_save_area, r_fp, r_sp, insn;
918 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
921 t_label = CALL_EXPR_ARG (exp, 0);
922 t_save_area = CALL_EXPR_ARG (exp, 1);
924 r_label = expand_normal (t_label);
925 r_label = convert_memory_address (Pmode, r_label);
926 r_save_area = expand_normal (t_save_area);
927 r_save_area = convert_memory_address (Pmode, r_save_area);
928 /* Copy the address of the save location to a register just in case it was based
929 on the frame pointer. */
930 r_save_area = copy_to_reg (r_save_area);
931 r_fp = gen_rtx_MEM (Pmode, r_save_area);
932 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
933 plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
935 crtl->has_nonlocal_goto = 1;
937 #ifdef HAVE_nonlocal_goto
938 /* ??? We no longer need to pass the static chain value, afaik. */
939 if (HAVE_nonlocal_goto)
940 emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
944 r_label = copy_to_reg (r_label);
946 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
947 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
949 /* Restore frame pointer for containing function.
950 This sets the actual hard register used for the frame pointer
951 to the location of the function's incoming static chain info.
952 The non-local goto handler will then adjust it to contain the
953 proper value and reload the argument pointer, if needed. */
954 emit_move_insn (hard_frame_pointer_rtx, r_fp);
955 emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
957 /* USE of hard_frame_pointer_rtx added for consistency;
958 not clear if really needed. */
959 emit_use (hard_frame_pointer_rtx);
960 emit_use (stack_pointer_rtx);
962 /* If the architecture is using a GP register, we must
963 conservatively assume that the target function makes use of it.
964 The prologue of functions with nonlocal gotos must therefore
965 initialize the GP register to the appropriate value, and we
966 must then make sure that this value is live at the point
967 of the jump. (Note that this doesn't necessarily apply
968 to targets with a nonlocal_goto pattern; they are free
969 to implement it in their own way. Note also that this is
970 a no-op if the GP register is a global invariant.) */
971 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
972 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
973 emit_use (pic_offset_table_rtx);
975 emit_indirect_jump (r_label);
978 /* Search backwards to the jump insn and mark it as a
980 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
984 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
987 else if (CALL_P (insn))
994 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
995 (not all will be used on all machines) that was passed to __builtin_setjmp.
996 It updates the stack pointer in that block to correspond to the current
1000 expand_builtin_update_setjmp_buf (rtx buf_addr)
1002 enum machine_mode sa_mode = Pmode;
1006 #ifdef HAVE_save_stack_nonlocal
1007 if (HAVE_save_stack_nonlocal)
1008 sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1010 #ifdef STACK_SAVEAREA_MODE
1011 sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1015 = gen_rtx_MEM (sa_mode,
1018 plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1022 emit_insn (gen_setjmp ());
1025 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1028 /* Expand a call to __builtin_prefetch. For a target that does not support
1029 data prefetch, evaluate the memory address argument in case it has side
1033 expand_builtin_prefetch (tree exp)
1035 tree arg0, arg1, arg2;
1039 if (!validate_arglist (exp, POINTER_TYPE, 0))
1042 arg0 = CALL_EXPR_ARG (exp, 0);
1044 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1045 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1047 nargs = call_expr_nargs (exp);
1049 arg1 = CALL_EXPR_ARG (exp, 1);
1051 arg1 = integer_zero_node;
1053 arg2 = CALL_EXPR_ARG (exp, 2);
1055 arg2 = build_int_cst (NULL_TREE, 3);
1057 /* Argument 0 is an address. */
1058 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1060 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1061 if (TREE_CODE (arg1) != INTEGER_CST)
1063 error ("second argument to %<__builtin_prefetch%> must be a constant");
1064 arg1 = integer_zero_node;
1066 op1 = expand_normal (arg1);
1067 /* Argument 1 must be either zero or one. */
1068 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1070 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1075 /* Argument 2 (locality) must be a compile-time constant int. */
1076 if (TREE_CODE (arg2) != INTEGER_CST)
1078 error ("third argument to %<__builtin_prefetch%> must be a constant");
1079 arg2 = integer_zero_node;
1081 op2 = expand_normal (arg2);
1082 /* Argument 2 must be 0, 1, 2, or 3. */
1083 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1085 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1089 #ifdef HAVE_prefetch
1092 if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1094 insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1095 || (GET_MODE (op0) != Pmode))
1097 op0 = convert_memory_address (Pmode, op0);
1098 op0 = force_reg (Pmode, op0);
1100 emit_insn (gen_prefetch (op0, op1, op2));
1104 /* Don't do anything with direct references to volatile memory, but
1105 generate code to handle other side effects. */
1106 if (!MEM_P (op0) && side_effects_p (op0))
1110 /* Get a MEM rtx for expression EXP which is the address of an operand
1111 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1112 the maximum length of the block of memory that might be accessed or
1116 get_memory_rtx (tree exp, tree len)
1118 tree orig_exp = exp;
1122 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1123 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1124 if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1125 exp = TREE_OPERAND (exp, 0);
1127 addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1128 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1130 /* Get an expression we can use to find the attributes to assign to MEM.
1131 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1132 we can. First remove any nops. */
1133 while (CONVERT_EXPR_P (exp)
1134 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1135 exp = TREE_OPERAND (exp, 0);
1138 if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1139 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1140 && host_integerp (TREE_OPERAND (exp, 1), 0)
1141 && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1142 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1143 else if (TREE_CODE (exp) == ADDR_EXPR)
1144 exp = TREE_OPERAND (exp, 0);
1145 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1146 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1150 /* Honor attributes derived from exp, except for the alias set
1151 (as builtin stringops may alias with anything) and the size
1152 (as stringops may access multiple array elements). */
1155 set_mem_attributes (mem, exp, 0);
1158 mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1160 /* Allow the string and memory builtins to overflow from one
1161 field into another, see http://gcc.gnu.org/PR23561.
1162 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1163 memory accessed by the string or memory builtin will fit
1164 within the field. */
1165 if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1167 tree mem_expr = MEM_EXPR (mem);
1168 HOST_WIDE_INT offset = -1, length = -1;
1171 while (TREE_CODE (inner) == ARRAY_REF
1172 || CONVERT_EXPR_P (inner)
1173 || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1174 || TREE_CODE (inner) == SAVE_EXPR)
1175 inner = TREE_OPERAND (inner, 0);
1177 gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1179 if (MEM_OFFSET (mem)
1180 && CONST_INT_P (MEM_OFFSET (mem)))
1181 offset = INTVAL (MEM_OFFSET (mem));
1183 if (offset >= 0 && len && host_integerp (len, 0))
1184 length = tree_low_cst (len, 0);
1186 while (TREE_CODE (inner) == COMPONENT_REF)
1188 tree field = TREE_OPERAND (inner, 1);
1189 gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1190 gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1192 /* Bitfields are generally not byte-addressable. */
1193 gcc_assert (!DECL_BIT_FIELD (field)
1194 || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1195 % BITS_PER_UNIT) == 0
1196 && host_integerp (DECL_SIZE (field), 0)
1197 && (TREE_INT_CST_LOW (DECL_SIZE (field))
1198 % BITS_PER_UNIT) == 0));
1200 /* If we can prove that the memory starting at XEXP (mem, 0) and
1201 ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1202 can keep the COMPONENT_REF in MEM_EXPR. But be careful with
1203 fields without DECL_SIZE_UNIT like flexible array members. */
1205 && DECL_SIZE_UNIT (field)
1206 && host_integerp (DECL_SIZE_UNIT (field), 0))
1209 = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1212 && offset + length <= size)
1217 && host_integerp (DECL_FIELD_OFFSET (field), 0))
1218 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1219 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1227 mem_expr = TREE_OPERAND (mem_expr, 0);
1228 inner = TREE_OPERAND (inner, 0);
1231 if (mem_expr == NULL)
1233 if (mem_expr != MEM_EXPR (mem))
1235 set_mem_expr (mem, mem_expr);
1236 set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1239 set_mem_alias_set (mem, 0);
1240 set_mem_size (mem, NULL_RTX);
1246 /* Built-in functions to perform an untyped call and return. */
1248 /* For each register that may be used for calling a function, this
1249 gives a mode used to copy the register's value. VOIDmode indicates
1250 the register is not used for calling a function. If the machine
1251 has register windows, this gives only the outbound registers.
1252 INCOMING_REGNO gives the corresponding inbound register. */
1253 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1255 /* For each register that may be used for returning values, this gives
1256 a mode used to copy the register's value. VOIDmode indicates the
1257 register is not used for returning values. If the machine has
1258 register windows, this gives only the outbound registers.
1259 INCOMING_REGNO gives the corresponding inbound register. */
1260 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1262 /* For each register that may be used for calling a function, this
1263 gives the offset of that register into the block returned by
1264 __builtin_apply_args. 0 indicates that the register is not
1265 used for calling a function. */
1266 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1268 /* Return the size required for the block returned by __builtin_apply_args,
1269 and initialize apply_args_mode. */
1272 apply_args_size (void)
1274 static int size = -1;
1277 enum machine_mode mode;
1279 /* The values computed by this function never change. */
1282 /* The first value is the incoming arg-pointer. */
1283 size = GET_MODE_SIZE (Pmode);
1285 /* The second value is the structure value address unless this is
1286 passed as an "invisible" first argument. */
1287 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1288 size += GET_MODE_SIZE (Pmode);
1290 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1291 if (FUNCTION_ARG_REGNO_P (regno))
1293 mode = reg_raw_mode[regno];
1295 gcc_assert (mode != VOIDmode);
1297 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1298 if (size % align != 0)
1299 size = CEIL (size, align) * align;
1300 apply_args_reg_offset[regno] = size;
1301 size += GET_MODE_SIZE (mode);
1302 apply_args_mode[regno] = mode;
1306 apply_args_mode[regno] = VOIDmode;
1307 apply_args_reg_offset[regno] = 0;
1313 /* Return the size required for the block returned by __builtin_apply,
1314 and initialize apply_result_mode. */
1317 apply_result_size (void)
1319 static int size = -1;
1321 enum machine_mode mode;
1323 /* The values computed by this function never change. */
1328 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1329 if (FUNCTION_VALUE_REGNO_P (regno))
1331 mode = reg_raw_mode[regno];
1333 gcc_assert (mode != VOIDmode);
1335 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1336 if (size % align != 0)
1337 size = CEIL (size, align) * align;
1338 size += GET_MODE_SIZE (mode);
1339 apply_result_mode[regno] = mode;
1342 apply_result_mode[regno] = VOIDmode;
1344 /* Allow targets that use untyped_call and untyped_return to override
1345 the size so that machine-specific information can be stored here. */
1346 #ifdef APPLY_RESULT_SIZE
1347 size = APPLY_RESULT_SIZE;
1353 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1354 /* Create a vector describing the result block RESULT. If SAVEP is true,
1355 the result block is used to save the values; otherwise it is used to
1356 restore the values. */
1359 result_vector (int savep, rtx result)
1361 int regno, size, align, nelts;
1362 enum machine_mode mode;
1364 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1367 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1368 if ((mode = apply_result_mode[regno]) != VOIDmode)
1370 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1371 if (size % align != 0)
1372 size = CEIL (size, align) * align;
1373 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1374 mem = adjust_address (result, mode, size);
1375 savevec[nelts++] = (savep
1376 ? gen_rtx_SET (VOIDmode, mem, reg)
1377 : gen_rtx_SET (VOIDmode, reg, mem));
1378 size += GET_MODE_SIZE (mode);
1380 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1382 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1384 /* Save the state required to perform an untyped call with the same
1385 arguments as were passed to the current function. */
1388 expand_builtin_apply_args_1 (void)
1391 int size, align, regno;
1392 enum machine_mode mode;
1393 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1395 /* Create a block where the arg-pointer, structure value address,
1396 and argument registers can be saved. */
1397 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1399 /* Walk past the arg-pointer and structure value address. */
1400 size = GET_MODE_SIZE (Pmode);
1401 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1402 size += GET_MODE_SIZE (Pmode);
1404 /* Save each register used in calling a function to the block. */
1405 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1406 if ((mode = apply_args_mode[regno]) != VOIDmode)
1408 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1409 if (size % align != 0)
1410 size = CEIL (size, align) * align;
1412 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1414 emit_move_insn (adjust_address (registers, mode, size), tem);
1415 size += GET_MODE_SIZE (mode);
1418 /* Save the arg pointer to the block. */
1419 tem = copy_to_reg (crtl->args.internal_arg_pointer);
1420 #ifdef STACK_GROWS_DOWNWARD
1421 /* We need the pointer as the caller actually passed them to us, not
1422 as we might have pretended they were passed. Make sure it's a valid
1423 operand, as emit_move_insn isn't expected to handle a PLUS. */
1425 = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1428 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1430 size = GET_MODE_SIZE (Pmode);
1432 /* Save the structure value address unless this is passed as an
1433 "invisible" first argument. */
1434 if (struct_incoming_value)
1436 emit_move_insn (adjust_address (registers, Pmode, size),
1437 copy_to_reg (struct_incoming_value));
1438 size += GET_MODE_SIZE (Pmode);
1441 /* Return the address of the block. */
1442 return copy_addr_to_reg (XEXP (registers, 0));
1445 /* __builtin_apply_args returns block of memory allocated on
1446 the stack into which is stored the arg pointer, structure
1447 value address, static chain, and all the registers that might
1448 possibly be used in performing a function call. The code is
1449 moved to the start of the function so the incoming values are
1453 expand_builtin_apply_args (void)
1455 /* Don't do __builtin_apply_args more than once in a function.
1456 Save the result of the first call and reuse it. */
1457 if (apply_args_value != 0)
1458 return apply_args_value;
1460 /* When this function is called, it means that registers must be
1461 saved on entry to this function. So we migrate the
1462 call to the first insn of this function. */
1467 temp = expand_builtin_apply_args_1 ();
1471 apply_args_value = temp;
1473 /* Put the insns after the NOTE that starts the function.
1474 If this is inside a start_sequence, make the outer-level insn
1475 chain current, so the code is placed at the start of the
1476 function. If internal_arg_pointer is a non-virtual pseudo,
1477 it needs to be placed after the function that initializes
1479 push_topmost_sequence ();
1480 if (REG_P (crtl->args.internal_arg_pointer)
1481 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1482 emit_insn_before (seq, parm_birth_insn);
1484 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1485 pop_topmost_sequence ();
1490 /* Perform an untyped call and save the state required to perform an
1491 untyped return of whatever value was returned by the given function. */
1494 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1496 int size, align, regno;
1497 enum machine_mode mode;
1498 rtx incoming_args, result, reg, dest, src, call_insn;
1499 rtx old_stack_level = 0;
1500 rtx call_fusage = 0;
1501 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1503 arguments = convert_memory_address (Pmode, arguments);
1505 /* Create a block where the return registers can be saved. */
1506 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1508 /* Fetch the arg pointer from the ARGUMENTS block. */
1509 incoming_args = gen_reg_rtx (Pmode);
1510 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1511 #ifndef STACK_GROWS_DOWNWARD
1512 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1513 incoming_args, 0, OPTAB_LIB_WIDEN);
1516 /* Push a new argument block and copy the arguments. Do not allow
1517 the (potential) memcpy call below to interfere with our stack
1519 do_pending_stack_adjust ();
1522 /* Save the stack with nonlocal if available. */
1523 #ifdef HAVE_save_stack_nonlocal
1524 if (HAVE_save_stack_nonlocal)
1525 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1528 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1530 /* Allocate a block of memory onto the stack and copy the memory
1531 arguments to the outgoing arguments address. */
1532 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1534 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1535 may have already set current_function_calls_alloca to true.
1536 current_function_calls_alloca won't be set if argsize is zero,
1537 so we have to guarantee need_drap is true here. */
1538 if (SUPPORTS_STACK_ALIGNMENT)
1539 crtl->need_drap = true;
1541 dest = virtual_outgoing_args_rtx;
1542 #ifndef STACK_GROWS_DOWNWARD
1543 if (CONST_INT_P (argsize))
1544 dest = plus_constant (dest, -INTVAL (argsize));
1546 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1548 dest = gen_rtx_MEM (BLKmode, dest);
1549 set_mem_align (dest, PARM_BOUNDARY);
1550 src = gen_rtx_MEM (BLKmode, incoming_args);
1551 set_mem_align (src, PARM_BOUNDARY);
1552 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1554 /* Refer to the argument block. */
1556 arguments = gen_rtx_MEM (BLKmode, arguments);
1557 set_mem_align (arguments, PARM_BOUNDARY);
1559 /* Walk past the arg-pointer and structure value address. */
1560 size = GET_MODE_SIZE (Pmode);
1562 size += GET_MODE_SIZE (Pmode);
1564 /* Restore each of the registers previously saved. Make USE insns
1565 for each of these registers for use in making the call. */
1566 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1567 if ((mode = apply_args_mode[regno]) != VOIDmode)
1569 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1570 if (size % align != 0)
1571 size = CEIL (size, align) * align;
1572 reg = gen_rtx_REG (mode, regno);
1573 emit_move_insn (reg, adjust_address (arguments, mode, size));
1574 use_reg (&call_fusage, reg);
1575 size += GET_MODE_SIZE (mode);
1578 /* Restore the structure value address unless this is passed as an
1579 "invisible" first argument. */
1580 size = GET_MODE_SIZE (Pmode);
1583 rtx value = gen_reg_rtx (Pmode);
1584 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1585 emit_move_insn (struct_value, value);
1586 if (REG_P (struct_value))
1587 use_reg (&call_fusage, struct_value);
1588 size += GET_MODE_SIZE (Pmode);
1591 /* All arguments and registers used for the call are set up by now! */
1592 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1594 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1595 and we don't want to load it into a register as an optimization,
1596 because prepare_call_address already did it if it should be done. */
1597 if (GET_CODE (function) != SYMBOL_REF)
1598 function = memory_address (FUNCTION_MODE, function);
1600 /* Generate the actual call instruction and save the return value. */
1601 #ifdef HAVE_untyped_call
1602 if (HAVE_untyped_call)
1603 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1604 result, result_vector (1, result)));
1607 #ifdef HAVE_call_value
1608 if (HAVE_call_value)
1612 /* Locate the unique return register. It is not possible to
1613 express a call that sets more than one return register using
1614 call_value; use untyped_call for that. In fact, untyped_call
1615 only needs to save the return registers in the given block. */
1616 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1617 if ((mode = apply_result_mode[regno]) != VOIDmode)
1619 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1621 valreg = gen_rtx_REG (mode, regno);
1624 emit_call_insn (GEN_CALL_VALUE (valreg,
1625 gen_rtx_MEM (FUNCTION_MODE, function),
1626 const0_rtx, NULL_RTX, const0_rtx));
1628 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1634 /* Find the CALL insn we just emitted, and attach the register usage
1636 call_insn = last_call_insn ();
1637 add_function_usage_to (call_insn, call_fusage);
1639 /* Restore the stack. */
1640 #ifdef HAVE_save_stack_nonlocal
1641 if (HAVE_save_stack_nonlocal)
1642 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1645 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1649 /* Return the address of the result block. */
1650 result = copy_addr_to_reg (XEXP (result, 0));
1651 return convert_memory_address (ptr_mode, result);
1654 /* Perform an untyped return. */
1657 expand_builtin_return (rtx result)
1659 int size, align, regno;
1660 enum machine_mode mode;
1662 rtx call_fusage = 0;
1664 result = convert_memory_address (Pmode, result);
1666 apply_result_size ();
1667 result = gen_rtx_MEM (BLKmode, result);
1669 #ifdef HAVE_untyped_return
1670 if (HAVE_untyped_return)
1672 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1678 /* Restore the return value and note that each value is used. */
1680 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1681 if ((mode = apply_result_mode[regno]) != VOIDmode)
1683 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1684 if (size % align != 0)
1685 size = CEIL (size, align) * align;
1686 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1687 emit_move_insn (reg, adjust_address (result, mode, size));
1689 push_to_sequence (call_fusage);
1691 call_fusage = get_insns ();
1693 size += GET_MODE_SIZE (mode);
1696 /* Put the USE insns before the return. */
1697 emit_insn (call_fusage);
1699 /* Return whatever values was restored by jumping directly to the end
1701 expand_naked_return ();
1704 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1706 static enum type_class
1707 type_to_class (tree type)
1709 switch (TREE_CODE (type))
1711 case VOID_TYPE: return void_type_class;
1712 case INTEGER_TYPE: return integer_type_class;
1713 case ENUMERAL_TYPE: return enumeral_type_class;
1714 case BOOLEAN_TYPE: return boolean_type_class;
1715 case POINTER_TYPE: return pointer_type_class;
1716 case REFERENCE_TYPE: return reference_type_class;
1717 case OFFSET_TYPE: return offset_type_class;
1718 case REAL_TYPE: return real_type_class;
1719 case COMPLEX_TYPE: return complex_type_class;
1720 case FUNCTION_TYPE: return function_type_class;
1721 case METHOD_TYPE: return method_type_class;
1722 case RECORD_TYPE: return record_type_class;
1724 case QUAL_UNION_TYPE: return union_type_class;
1725 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1726 ? string_type_class : array_type_class);
1727 case LANG_TYPE: return lang_type_class;
1728 default: return no_type_class;
1732 /* Expand a call EXP to __builtin_classify_type. */
1735 expand_builtin_classify_type (tree exp)
1737 if (call_expr_nargs (exp))
1738 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1739 return GEN_INT (no_type_class);
1742 /* This helper macro, meant to be used in mathfn_built_in below,
1743 determines which among a set of three builtin math functions is
1744 appropriate for a given type mode. The `F' and `L' cases are
1745 automatically generated from the `double' case. */
1746 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1747 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1748 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1749 fcodel = BUILT_IN_MATHFN##L ; break;
1750 /* Similar to above, but appends _R after any F/L suffix. */
1751 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1752 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1753 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1754 fcodel = BUILT_IN_MATHFN##L_R ; break;
1756 /* Return mathematic function equivalent to FN but operating directly
1757 on TYPE, if available. If IMPLICIT is true find the function in
1758 implicit_built_in_decls[], otherwise use built_in_decls[]. If we
1759 can't do the conversion, return zero. */
1762 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1764 tree const *const fn_arr
1765 = implicit ? implicit_built_in_decls : built_in_decls;
1766 enum built_in_function fcode, fcodef, fcodel;
1770 CASE_MATHFN (BUILT_IN_ACOS)
1771 CASE_MATHFN (BUILT_IN_ACOSH)
1772 CASE_MATHFN (BUILT_IN_ASIN)
1773 CASE_MATHFN (BUILT_IN_ASINH)
1774 CASE_MATHFN (BUILT_IN_ATAN)
1775 CASE_MATHFN (BUILT_IN_ATAN2)
1776 CASE_MATHFN (BUILT_IN_ATANH)
1777 CASE_MATHFN (BUILT_IN_CBRT)
1778 CASE_MATHFN (BUILT_IN_CEIL)
1779 CASE_MATHFN (BUILT_IN_CEXPI)
1780 CASE_MATHFN (BUILT_IN_COPYSIGN)
1781 CASE_MATHFN (BUILT_IN_COS)
1782 CASE_MATHFN (BUILT_IN_COSH)
1783 CASE_MATHFN (BUILT_IN_DREM)
1784 CASE_MATHFN (BUILT_IN_ERF)
1785 CASE_MATHFN (BUILT_IN_ERFC)
1786 CASE_MATHFN (BUILT_IN_EXP)
1787 CASE_MATHFN (BUILT_IN_EXP10)
1788 CASE_MATHFN (BUILT_IN_EXP2)
1789 CASE_MATHFN (BUILT_IN_EXPM1)
1790 CASE_MATHFN (BUILT_IN_FABS)
1791 CASE_MATHFN (BUILT_IN_FDIM)
1792 CASE_MATHFN (BUILT_IN_FLOOR)
1793 CASE_MATHFN (BUILT_IN_FMA)
1794 CASE_MATHFN (BUILT_IN_FMAX)
1795 CASE_MATHFN (BUILT_IN_FMIN)
1796 CASE_MATHFN (BUILT_IN_FMOD)
1797 CASE_MATHFN (BUILT_IN_FREXP)
1798 CASE_MATHFN (BUILT_IN_GAMMA)
1799 CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1800 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1801 CASE_MATHFN (BUILT_IN_HYPOT)
1802 CASE_MATHFN (BUILT_IN_ILOGB)
1803 CASE_MATHFN (BUILT_IN_INF)
1804 CASE_MATHFN (BUILT_IN_ISINF)
1805 CASE_MATHFN (BUILT_IN_J0)
1806 CASE_MATHFN (BUILT_IN_J1)
1807 CASE_MATHFN (BUILT_IN_JN)
1808 CASE_MATHFN (BUILT_IN_LCEIL)
1809 CASE_MATHFN (BUILT_IN_LDEXP)
1810 CASE_MATHFN (BUILT_IN_LFLOOR)
1811 CASE_MATHFN (BUILT_IN_LGAMMA)
1812 CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1813 CASE_MATHFN (BUILT_IN_LLCEIL)
1814 CASE_MATHFN (BUILT_IN_LLFLOOR)
1815 CASE_MATHFN (BUILT_IN_LLRINT)
1816 CASE_MATHFN (BUILT_IN_LLROUND)
1817 CASE_MATHFN (BUILT_IN_LOG)
1818 CASE_MATHFN (BUILT_IN_LOG10)
1819 CASE_MATHFN (BUILT_IN_LOG1P)
1820 CASE_MATHFN (BUILT_IN_LOG2)
1821 CASE_MATHFN (BUILT_IN_LOGB)
1822 CASE_MATHFN (BUILT_IN_LRINT)
1823 CASE_MATHFN (BUILT_IN_LROUND)
1824 CASE_MATHFN (BUILT_IN_MODF)
1825 CASE_MATHFN (BUILT_IN_NAN)
1826 CASE_MATHFN (BUILT_IN_NANS)
1827 CASE_MATHFN (BUILT_IN_NEARBYINT)
1828 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1829 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1830 CASE_MATHFN (BUILT_IN_POW)
1831 CASE_MATHFN (BUILT_IN_POWI)
1832 CASE_MATHFN (BUILT_IN_POW10)
1833 CASE_MATHFN (BUILT_IN_REMAINDER)
1834 CASE_MATHFN (BUILT_IN_REMQUO)
1835 CASE_MATHFN (BUILT_IN_RINT)
1836 CASE_MATHFN (BUILT_IN_ROUND)
1837 CASE_MATHFN (BUILT_IN_SCALB)
1838 CASE_MATHFN (BUILT_IN_SCALBLN)
1839 CASE_MATHFN (BUILT_IN_SCALBN)
1840 CASE_MATHFN (BUILT_IN_SIGNBIT)
1841 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1842 CASE_MATHFN (BUILT_IN_SIN)
1843 CASE_MATHFN (BUILT_IN_SINCOS)
1844 CASE_MATHFN (BUILT_IN_SINH)
1845 CASE_MATHFN (BUILT_IN_SQRT)
1846 CASE_MATHFN (BUILT_IN_TAN)
1847 CASE_MATHFN (BUILT_IN_TANH)
1848 CASE_MATHFN (BUILT_IN_TGAMMA)
1849 CASE_MATHFN (BUILT_IN_TRUNC)
1850 CASE_MATHFN (BUILT_IN_Y0)
1851 CASE_MATHFN (BUILT_IN_Y1)
1852 CASE_MATHFN (BUILT_IN_YN)
1858 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1859 return fn_arr[fcode];
1860 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1861 return fn_arr[fcodef];
1862 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1863 return fn_arr[fcodel];
1868 /* Like mathfn_built_in_1(), but always use the implicit array. */
1871 mathfn_built_in (tree type, enum built_in_function fn)
1873 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1876 /* If errno must be maintained, expand the RTL to check if the result,
1877 TARGET, of a built-in function call, EXP, is NaN, and if so set
1881 expand_errno_check (tree exp, rtx target)
1883 rtx lab = gen_label_rtx ();
1885 /* Test the result; if it is NaN, set errno=EDOM because
1886 the argument was not in the domain. */
1887 do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1888 NULL_RTX, NULL_RTX, lab);
1891 /* If this built-in doesn't throw an exception, set errno directly. */
1892 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1894 #ifdef GEN_ERRNO_RTX
1895 rtx errno_rtx = GEN_ERRNO_RTX;
1898 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1900 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1906 /* Make sure the library call isn't expanded as a tail call. */
1907 CALL_EXPR_TAILCALL (exp) = 0;
1909 /* We can't set errno=EDOM directly; let the library call do it.
1910 Pop the arguments right away in case the call gets deleted. */
1912 expand_call (exp, target, 0);
1917 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1918 Return NULL_RTX if a normal call should be emitted rather than expanding
1919 the function in-line. EXP is the expression that is a call to the builtin
1920 function; if convenient, the result should be placed in TARGET.
1921 SUBTARGET may be used as the target for computing one of EXP's operands. */
1924 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1926 optab builtin_optab;
1927 rtx op0, insns, before_call;
1928 tree fndecl = get_callee_fndecl (exp);
1929 enum machine_mode mode;
1930 bool errno_set = false;
1933 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1936 arg = CALL_EXPR_ARG (exp, 0);
1938 switch (DECL_FUNCTION_CODE (fndecl))
1940 CASE_FLT_FN (BUILT_IN_SQRT):
1941 errno_set = ! tree_expr_nonnegative_p (arg);
1942 builtin_optab = sqrt_optab;
1944 CASE_FLT_FN (BUILT_IN_EXP):
1945 errno_set = true; builtin_optab = exp_optab; break;
1946 CASE_FLT_FN (BUILT_IN_EXP10):
1947 CASE_FLT_FN (BUILT_IN_POW10):
1948 errno_set = true; builtin_optab = exp10_optab; break;
1949 CASE_FLT_FN (BUILT_IN_EXP2):
1950 errno_set = true; builtin_optab = exp2_optab; break;
1951 CASE_FLT_FN (BUILT_IN_EXPM1):
1952 errno_set = true; builtin_optab = expm1_optab; break;
1953 CASE_FLT_FN (BUILT_IN_LOGB):
1954 errno_set = true; builtin_optab = logb_optab; break;
1955 CASE_FLT_FN (BUILT_IN_LOG):
1956 errno_set = true; builtin_optab = log_optab; break;
1957 CASE_FLT_FN (BUILT_IN_LOG10):
1958 errno_set = true; builtin_optab = log10_optab; break;
1959 CASE_FLT_FN (BUILT_IN_LOG2):
1960 errno_set = true; builtin_optab = log2_optab; break;
1961 CASE_FLT_FN (BUILT_IN_LOG1P):
1962 errno_set = true; builtin_optab = log1p_optab; break;
1963 CASE_FLT_FN (BUILT_IN_ASIN):
1964 builtin_optab = asin_optab; break;
1965 CASE_FLT_FN (BUILT_IN_ACOS):
1966 builtin_optab = acos_optab; break;
1967 CASE_FLT_FN (BUILT_IN_TAN):
1968 builtin_optab = tan_optab; break;
1969 CASE_FLT_FN (BUILT_IN_ATAN):
1970 builtin_optab = atan_optab; break;
1971 CASE_FLT_FN (BUILT_IN_FLOOR):
1972 builtin_optab = floor_optab; break;
1973 CASE_FLT_FN (BUILT_IN_CEIL):
1974 builtin_optab = ceil_optab; break;
1975 CASE_FLT_FN (BUILT_IN_TRUNC):
1976 builtin_optab = btrunc_optab; break;
1977 CASE_FLT_FN (BUILT_IN_ROUND):
1978 builtin_optab = round_optab; break;
1979 CASE_FLT_FN (BUILT_IN_NEARBYINT):
1980 builtin_optab = nearbyint_optab;
1981 if (flag_trapping_math)
1983 /* Else fallthrough and expand as rint. */
1984 CASE_FLT_FN (BUILT_IN_RINT):
1985 builtin_optab = rint_optab; break;
1986 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
1987 builtin_optab = significand_optab; break;
1992 /* Make a suitable register to place result in. */
1993 mode = TYPE_MODE (TREE_TYPE (exp));
1995 if (! flag_errno_math || ! HONOR_NANS (mode))
1998 /* Before working hard, check whether the instruction is available. */
1999 if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2001 target = gen_reg_rtx (mode);
2003 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2004 need to expand the argument again. This way, we will not perform
2005 side-effects more the once. */
2006 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2008 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2012 /* Compute into TARGET.
2013 Set TARGET to wherever the result comes back. */
2014 target = expand_unop (mode, builtin_optab, op0, target, 0);
2019 expand_errno_check (exp, target);
2021 /* Output the entire sequence. */
2022 insns = get_insns ();
2028 /* If we were unable to expand via the builtin, stop the sequence
2029 (without outputting the insns) and call to the library function
2030 with the stabilized argument list. */
2034 before_call = get_last_insn ();
2036 return expand_call (exp, target, target == const0_rtx);
2039 /* Expand a call to the builtin binary math functions (pow and atan2).
2040 Return NULL_RTX if a normal call should be emitted rather than expanding the
2041 function in-line. EXP is the expression that is a call to the builtin
2042 function; if convenient, the result should be placed in TARGET.
2043 SUBTARGET may be used as the target for computing one of EXP's
2047 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2049 optab builtin_optab;
2050 rtx op0, op1, insns;
2051 int op1_type = REAL_TYPE;
2052 tree fndecl = get_callee_fndecl (exp);
2054 enum machine_mode mode;
2055 bool errno_set = true;
2057 switch (DECL_FUNCTION_CODE (fndecl))
2059 CASE_FLT_FN (BUILT_IN_SCALBN):
2060 CASE_FLT_FN (BUILT_IN_SCALBLN):
2061 CASE_FLT_FN (BUILT_IN_LDEXP):
2062 op1_type = INTEGER_TYPE;
2067 if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2070 arg0 = CALL_EXPR_ARG (exp, 0);
2071 arg1 = CALL_EXPR_ARG (exp, 1);
2073 switch (DECL_FUNCTION_CODE (fndecl))
2075 CASE_FLT_FN (BUILT_IN_POW):
2076 builtin_optab = pow_optab; break;
2077 CASE_FLT_FN (BUILT_IN_ATAN2):
2078 builtin_optab = atan2_optab; break;
2079 CASE_FLT_FN (BUILT_IN_SCALB):
2080 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2082 builtin_optab = scalb_optab; break;
2083 CASE_FLT_FN (BUILT_IN_SCALBN):
2084 CASE_FLT_FN (BUILT_IN_SCALBLN):
2085 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2087 /* Fall through... */
2088 CASE_FLT_FN (BUILT_IN_LDEXP):
2089 builtin_optab = ldexp_optab; break;
2090 CASE_FLT_FN (BUILT_IN_FMOD):
2091 builtin_optab = fmod_optab; break;
2092 CASE_FLT_FN (BUILT_IN_REMAINDER):
2093 CASE_FLT_FN (BUILT_IN_DREM):
2094 builtin_optab = remainder_optab; break;
2099 /* Make a suitable register to place result in. */
2100 mode = TYPE_MODE (TREE_TYPE (exp));
2102 /* Before working hard, check whether the instruction is available. */
2103 if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2106 target = gen_reg_rtx (mode);
2108 if (! flag_errno_math || ! HONOR_NANS (mode))
2111 /* Always stabilize the argument list. */
2112 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2113 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2115 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2116 op1 = expand_normal (arg1);
2120 /* Compute into TARGET.
2121 Set TARGET to wherever the result comes back. */
2122 target = expand_binop (mode, builtin_optab, op0, op1,
2123 target, 0, OPTAB_DIRECT);
2125 /* If we were unable to expand via the builtin, stop the sequence
2126 (without outputting the insns) and call to the library function
2127 with the stabilized argument list. */
2131 return expand_call (exp, target, target == const0_rtx);
2135 expand_errno_check (exp, target);
2137 /* Output the entire sequence. */
2138 insns = get_insns ();
2145 /* Expand a call to the builtin sin and cos math functions.
2146 Return NULL_RTX if a normal call should be emitted rather than expanding the
2147 function in-line. EXP is the expression that is a call to the builtin
2148 function; if convenient, the result should be placed in TARGET.
2149 SUBTARGET may be used as the target for computing one of EXP's
2153 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2155 optab builtin_optab;
2157 tree fndecl = get_callee_fndecl (exp);
2158 enum machine_mode mode;
2161 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2164 arg = CALL_EXPR_ARG (exp, 0);
2166 switch (DECL_FUNCTION_CODE (fndecl))
2168 CASE_FLT_FN (BUILT_IN_SIN):
2169 CASE_FLT_FN (BUILT_IN_COS):
2170 builtin_optab = sincos_optab; break;
2175 /* Make a suitable register to place result in. */
2176 mode = TYPE_MODE (TREE_TYPE (exp));
2178 /* Check if sincos insn is available, otherwise fallback
2179 to sin or cos insn. */
2180 if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2181 switch (DECL_FUNCTION_CODE (fndecl))
2183 CASE_FLT_FN (BUILT_IN_SIN):
2184 builtin_optab = sin_optab; break;
2185 CASE_FLT_FN (BUILT_IN_COS):
2186 builtin_optab = cos_optab; break;
2191 /* Before working hard, check whether the instruction is available. */
2192 if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2194 target = gen_reg_rtx (mode);
2196 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2197 need to expand the argument again. This way, we will not perform
2198 side-effects more the once. */
2199 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2201 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2205 /* Compute into TARGET.
2206 Set TARGET to wherever the result comes back. */
2207 if (builtin_optab == sincos_optab)
2211 switch (DECL_FUNCTION_CODE (fndecl))
2213 CASE_FLT_FN (BUILT_IN_SIN):
2214 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2216 CASE_FLT_FN (BUILT_IN_COS):
2217 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2222 gcc_assert (result);
2226 target = expand_unop (mode, builtin_optab, op0, target, 0);
2231 /* Output the entire sequence. */
2232 insns = get_insns ();
2238 /* If we were unable to expand via the builtin, stop the sequence
2239 (without outputting the insns) and call to the library function
2240 with the stabilized argument list. */
2244 target = expand_call (exp, target, target == const0_rtx);
2249 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2250 return an RTL instruction code that implements the functionality.
2251 If that isn't possible or available return CODE_FOR_nothing. */
2253 static enum insn_code
2254 interclass_mathfn_icode (tree arg, tree fndecl)
2256 bool errno_set = false;
2257 optab builtin_optab = 0;
2258 enum machine_mode mode;
2260 switch (DECL_FUNCTION_CODE (fndecl))
2262 CASE_FLT_FN (BUILT_IN_ILOGB):
2263 errno_set = true; builtin_optab = ilogb_optab; break;
2264 CASE_FLT_FN (BUILT_IN_ISINF):
2265 builtin_optab = isinf_optab; break;
2266 case BUILT_IN_ISNORMAL:
2267 case BUILT_IN_ISFINITE:
2268 CASE_FLT_FN (BUILT_IN_FINITE):
2269 case BUILT_IN_FINITED32:
2270 case BUILT_IN_FINITED64:
2271 case BUILT_IN_FINITED128:
2272 case BUILT_IN_ISINFD32:
2273 case BUILT_IN_ISINFD64:
2274 case BUILT_IN_ISINFD128:
2275 /* These builtins have no optabs (yet). */
2281 /* There's no easy way to detect the case we need to set EDOM. */
2282 if (flag_errno_math && errno_set)
2283 return CODE_FOR_nothing;
2285 /* Optab mode depends on the mode of the input argument. */
2286 mode = TYPE_MODE (TREE_TYPE (arg));
2289 return optab_handler (builtin_optab, mode)->insn_code;
2290 return CODE_FOR_nothing;
2293 /* Expand a call to one of the builtin math functions that operate on
2294 floating point argument and output an integer result (ilogb, isinf,
2296 Return 0 if a normal call should be emitted rather than expanding the
2297 function in-line. EXP is the expression that is a call to the builtin
2298 function; if convenient, the result should be placed in TARGET.
2299 SUBTARGET may be used as the target for computing one of EXP's operands. */
2302 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2304 enum insn_code icode = CODE_FOR_nothing;
2306 tree fndecl = get_callee_fndecl (exp);
2307 enum machine_mode mode;
2310 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2313 arg = CALL_EXPR_ARG (exp, 0);
2314 icode = interclass_mathfn_icode (arg, fndecl);
2315 mode = TYPE_MODE (TREE_TYPE (arg));
2317 if (icode != CODE_FOR_nothing)
2319 /* Make a suitable register to place result in. */
2321 || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2322 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2324 gcc_assert (insn_data[icode].operand[0].predicate
2325 (target, GET_MODE (target)));
2327 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2328 need to expand the argument again. This way, we will not perform
2329 side-effects more the once. */
2330 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2332 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2334 if (mode != GET_MODE (op0))
2335 op0 = convert_to_mode (mode, op0, 0);
2337 /* Compute into TARGET.
2338 Set TARGET to wherever the result comes back. */
2339 emit_unop_insn (icode, target, op0, UNKNOWN);
2346 /* Expand a call to the builtin sincos math function.
2347 Return NULL_RTX if a normal call should be emitted rather than expanding the
2348 function in-line. EXP is the expression that is a call to the builtin
2352 expand_builtin_sincos (tree exp)
2354 rtx op0, op1, op2, target1, target2;
2355 enum machine_mode mode;
2356 tree arg, sinp, cosp;
2358 location_t loc = EXPR_LOCATION (exp);
2360 if (!validate_arglist (exp, REAL_TYPE,
2361 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2364 arg = CALL_EXPR_ARG (exp, 0);
2365 sinp = CALL_EXPR_ARG (exp, 1);
2366 cosp = CALL_EXPR_ARG (exp, 2);
2368 /* Make a suitable register to place result in. */
2369 mode = TYPE_MODE (TREE_TYPE (arg));
2371 /* Check if sincos insn is available, otherwise emit the call. */
2372 if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2375 target1 = gen_reg_rtx (mode);
2376 target2 = gen_reg_rtx (mode);
2378 op0 = expand_normal (arg);
2379 op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2380 op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2382 /* Compute into target1 and target2.
2383 Set TARGET to wherever the result comes back. */
2384 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2385 gcc_assert (result);
2387 /* Move target1 and target2 to the memory locations indicated
2389 emit_move_insn (op1, target1);
2390 emit_move_insn (op2, target2);
2395 /* Expand a call to the internal cexpi builtin to the sincos math function.
2396 EXP is the expression that is a call to the builtin function; if convenient,
2397 the result should be placed in TARGET. SUBTARGET may be used as the target
2398 for computing one of EXP's operands. */
2401 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2403 tree fndecl = get_callee_fndecl (exp);
2405 enum machine_mode mode;
2407 location_t loc = EXPR_LOCATION (exp);
2409 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2412 arg = CALL_EXPR_ARG (exp, 0);
2413 type = TREE_TYPE (arg);
2414 mode = TYPE_MODE (TREE_TYPE (arg));
2416 /* Try expanding via a sincos optab, fall back to emitting a libcall
2417 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2418 is only generated from sincos, cexp or if we have either of them. */
2419 if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2421 op1 = gen_reg_rtx (mode);
2422 op2 = gen_reg_rtx (mode);
2424 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2426 /* Compute into op1 and op2. */
2427 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2429 else if (TARGET_HAS_SINCOS)
2431 tree call, fn = NULL_TREE;
2435 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2436 fn = built_in_decls[BUILT_IN_SINCOSF];
2437 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2438 fn = built_in_decls[BUILT_IN_SINCOS];
2439 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2440 fn = built_in_decls[BUILT_IN_SINCOSL];
2444 op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2445 op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2446 op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2447 op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2448 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2449 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2451 /* Make sure not to fold the sincos call again. */
2452 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2453 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2454 call, 3, arg, top1, top2));
2458 tree call, fn = NULL_TREE, narg;
2459 tree ctype = build_complex_type (type);
2461 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2462 fn = built_in_decls[BUILT_IN_CEXPF];
2463 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2464 fn = built_in_decls[BUILT_IN_CEXP];
2465 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2466 fn = built_in_decls[BUILT_IN_CEXPL];
2470 /* If we don't have a decl for cexp create one. This is the
2471 friendliest fallback if the user calls __builtin_cexpi
2472 without full target C99 function support. */
2473 if (fn == NULL_TREE)
2476 const char *name = NULL;
2478 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2480 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2482 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2485 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2486 fn = build_fn_decl (name, fntype);
2489 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2490 build_real (type, dconst0), arg);
2492 /* Make sure not to fold the cexp call again. */
2493 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2494 return expand_expr (build_call_nary (ctype, call, 1, narg),
2495 target, VOIDmode, EXPAND_NORMAL);
2498 /* Now build the proper return type. */
2499 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2500 make_tree (TREE_TYPE (arg), op2),
2501 make_tree (TREE_TYPE (arg), op1)),
2502 target, VOIDmode, EXPAND_NORMAL);
2505 /* Conveniently construct a function call expression. FNDECL names the
2506 function to be called, N is the number of arguments, and the "..."
2507 parameters are the argument expressions. Unlike build_call_exr
2508 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2511 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2514 tree fntype = TREE_TYPE (fndecl);
2515 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2518 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2520 SET_EXPR_LOCATION (fn, loc);
2523 #define build_call_nofold(...) \
2524 build_call_nofold_loc (UNKNOWN_LOCATION, __VA_ARGS__)
2526 /* Expand a call to one of the builtin rounding functions gcc defines
2527 as an extension (lfloor and lceil). As these are gcc extensions we
2528 do not need to worry about setting errno to EDOM.
2529 If expanding via optab fails, lower expression to (int)(floor(x)).
2530 EXP is the expression that is a call to the builtin function;
2531 if convenient, the result should be placed in TARGET. */
2534 expand_builtin_int_roundingfn (tree exp, rtx target)
2536 convert_optab builtin_optab;
2537 rtx op0, insns, tmp;
2538 tree fndecl = get_callee_fndecl (exp);
2539 enum built_in_function fallback_fn;
2540 tree fallback_fndecl;
2541 enum machine_mode mode;
2544 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2547 arg = CALL_EXPR_ARG (exp, 0);
2549 switch (DECL_FUNCTION_CODE (fndecl))
2551 CASE_FLT_FN (BUILT_IN_LCEIL):
2552 CASE_FLT_FN (BUILT_IN_LLCEIL):
2553 builtin_optab = lceil_optab;
2554 fallback_fn = BUILT_IN_CEIL;
2557 CASE_FLT_FN (BUILT_IN_LFLOOR):
2558 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2559 builtin_optab = lfloor_optab;
2560 fallback_fn = BUILT_IN_FLOOR;
2567 /* Make a suitable register to place result in. */
2568 mode = TYPE_MODE (TREE_TYPE (exp));
2570 target = gen_reg_rtx (mode);
2572 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2573 need to expand the argument again. This way, we will not perform
2574 side-effects more the once. */
2575 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2577 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2581 /* Compute into TARGET. */
2582 if (expand_sfix_optab (target, op0, builtin_optab))
2584 /* Output the entire sequence. */
2585 insns = get_insns ();
2591 /* If we were unable to expand via the builtin, stop the sequence
2592 (without outputting the insns). */
2595 /* Fall back to floating point rounding optab. */
2596 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2598 /* For non-C99 targets we may end up without a fallback fndecl here
2599 if the user called __builtin_lfloor directly. In this case emit
2600 a call to the floor/ceil variants nevertheless. This should result
2601 in the best user experience for not full C99 targets. */
2602 if (fallback_fndecl == NULL_TREE)
2605 const char *name = NULL;
2607 switch (DECL_FUNCTION_CODE (fndecl))
2609 case BUILT_IN_LCEIL:
2610 case BUILT_IN_LLCEIL:
2613 case BUILT_IN_LCEILF:
2614 case BUILT_IN_LLCEILF:
2617 case BUILT_IN_LCEILL:
2618 case BUILT_IN_LLCEILL:
2621 case BUILT_IN_LFLOOR:
2622 case BUILT_IN_LLFLOOR:
2625 case BUILT_IN_LFLOORF:
2626 case BUILT_IN_LLFLOORF:
2629 case BUILT_IN_LFLOORL:
2630 case BUILT_IN_LLFLOORL:
2637 fntype = build_function_type_list (TREE_TYPE (arg),
2638 TREE_TYPE (arg), NULL_TREE);
2639 fallback_fndecl = build_fn_decl (name, fntype);
2642 exp = build_call_nofold (fallback_fndecl, 1, arg);
2644 tmp = expand_normal (exp);
2646 /* Truncate the result of floating point optab to integer
2647 via expand_fix (). */
2648 target = gen_reg_rtx (mode);
2649 expand_fix (target, tmp, 0);
2654 /* Expand a call to one of the builtin math functions doing integer
2656 Return 0 if a normal call should be emitted rather than expanding the
2657 function in-line. EXP is the expression that is a call to the builtin
2658 function; if convenient, the result should be placed in TARGET. */
2661 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2663 convert_optab builtin_optab;
2665 tree fndecl = get_callee_fndecl (exp);
2667 enum machine_mode mode;
2669 /* There's no easy way to detect the case we need to set EDOM. */
2670 if (flag_errno_math)
2673 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2676 arg = CALL_EXPR_ARG (exp, 0);
2678 switch (DECL_FUNCTION_CODE (fndecl))
2680 CASE_FLT_FN (BUILT_IN_LRINT):
2681 CASE_FLT_FN (BUILT_IN_LLRINT):
2682 builtin_optab = lrint_optab; break;
2683 CASE_FLT_FN (BUILT_IN_LROUND):
2684 CASE_FLT_FN (BUILT_IN_LLROUND):
2685 builtin_optab = lround_optab; break;
2690 /* Make a suitable register to place result in. */
2691 mode = TYPE_MODE (TREE_TYPE (exp));
2693 target = gen_reg_rtx (mode);
2695 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2696 need to expand the argument again. This way, we will not perform
2697 side-effects more the once. */
2698 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2700 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2704 if (expand_sfix_optab (target, op0, builtin_optab))
2706 /* Output the entire sequence. */
2707 insns = get_insns ();
2713 /* If we were unable to expand via the builtin, stop the sequence
2714 (without outputting the insns) and call to the library function
2715 with the stabilized argument list. */
2718 target = expand_call (exp, target, target == const0_rtx);
2723 /* To evaluate powi(x,n), the floating point value x raised to the
2724 constant integer exponent n, we use a hybrid algorithm that
2725 combines the "window method" with look-up tables. For an
2726 introduction to exponentiation algorithms and "addition chains",
2727 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2728 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2729 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2730 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2732 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2733 multiplications to inline before calling the system library's pow
2734 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2735 so this default never requires calling pow, powf or powl. */
2737 #ifndef POWI_MAX_MULTS
2738 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2741 /* The size of the "optimal power tree" lookup table. All
2742 exponents less than this value are simply looked up in the
2743 powi_table below. This threshold is also used to size the
2744 cache of pseudo registers that hold intermediate results. */
2745 #define POWI_TABLE_SIZE 256
2747 /* The size, in bits of the window, used in the "window method"
2748 exponentiation algorithm. This is equivalent to a radix of
2749 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2750 #define POWI_WINDOW_SIZE 3
2752 /* The following table is an efficient representation of an
2753 "optimal power tree". For each value, i, the corresponding
2754 value, j, in the table states than an optimal evaluation
2755 sequence for calculating pow(x,i) can be found by evaluating
2756 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2757 100 integers is given in Knuth's "Seminumerical algorithms". */
2759 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2761 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2762 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2763 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2764 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2765 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2766 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2767 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2768 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2769 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2770 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2771 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2772 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2773 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2774 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2775 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2776 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2777 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2778 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2779 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2780 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2781 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2782 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2783 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2784 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2785 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2786 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2787 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2788 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2789 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2790 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2791 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2792 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2796 /* Return the number of multiplications required to calculate
2797 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2798 subroutine of powi_cost. CACHE is an array indicating
2799 which exponents have already been calculated. */
2802 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2804 /* If we've already calculated this exponent, then this evaluation
2805 doesn't require any additional multiplications. */
2810 return powi_lookup_cost (n - powi_table[n], cache)
2811 + powi_lookup_cost (powi_table[n], cache) + 1;
2814 /* Return the number of multiplications required to calculate
2815 powi(x,n) for an arbitrary x, given the exponent N. This
2816 function needs to be kept in sync with expand_powi below. */
2819 powi_cost (HOST_WIDE_INT n)
2821 bool cache[POWI_TABLE_SIZE];
2822 unsigned HOST_WIDE_INT digit;
2823 unsigned HOST_WIDE_INT val;
2829 /* Ignore the reciprocal when calculating the cost. */
2830 val = (n < 0) ? -n : n;
2832 /* Initialize the exponent cache. */
2833 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2838 while (val >= POWI_TABLE_SIZE)
2842 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2843 result += powi_lookup_cost (digit, cache)
2844 + POWI_WINDOW_SIZE + 1;
2845 val >>= POWI_WINDOW_SIZE;
2854 return result + powi_lookup_cost (val, cache);
2857 /* Recursive subroutine of expand_powi. This function takes the array,
2858 CACHE, of already calculated exponents and an exponent N and returns
2859 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2862 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2864 unsigned HOST_WIDE_INT digit;
2868 if (n < POWI_TABLE_SIZE)
2873 target = gen_reg_rtx (mode);
2876 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2877 op1 = expand_powi_1 (mode, powi_table[n], cache);
2881 target = gen_reg_rtx (mode);
2882 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2883 op0 = expand_powi_1 (mode, n - digit, cache);
2884 op1 = expand_powi_1 (mode, digit, cache);
2888 target = gen_reg_rtx (mode);
2889 op0 = expand_powi_1 (mode, n >> 1, cache);
2893 result = expand_mult (mode, op0, op1, target, 0);
2894 if (result != target)
2895 emit_move_insn (target, result);
2899 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2900 floating point operand in mode MODE, and N is the exponent. This
2901 function needs to be kept in sync with powi_cost above. */
2904 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2906 unsigned HOST_WIDE_INT val;
2907 rtx cache[POWI_TABLE_SIZE];
2911 return CONST1_RTX (mode);
2913 val = (n < 0) ? -n : n;
2915 memset (cache, 0, sizeof (cache));
2918 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2920 /* If the original exponent was negative, reciprocate the result. */
2922 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2923 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2928 /* Expand a call to the pow built-in mathematical function. Return NULL_RTX if
2929 a normal call should be emitted rather than expanding the function
2930 in-line. EXP is the expression that is a call to the builtin
2931 function; if convenient, the result should be placed in TARGET. */
2934 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2938 tree type = TREE_TYPE (exp);
2939 REAL_VALUE_TYPE cint, c, c2;
2942 enum machine_mode mode = TYPE_MODE (type);
2944 if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2947 arg0 = CALL_EXPR_ARG (exp, 0);
2948 arg1 = CALL_EXPR_ARG (exp, 1);
2950 if (TREE_CODE (arg1) != REAL_CST
2951 || TREE_OVERFLOW (arg1))
2952 return expand_builtin_mathfn_2 (exp, target, subtarget);
2954 /* Handle constant exponents. */
2956 /* For integer valued exponents we can expand to an optimal multiplication
2957 sequence using expand_powi. */
2958 c = TREE_REAL_CST (arg1);
2959 n = real_to_integer (&c);
2960 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2961 if (real_identical (&c, &cint)
2962 && ((n >= -1 && n <= 2)
2963 || (flag_unsafe_math_optimizations
2964 && optimize_insn_for_speed_p ()
2965 && powi_cost (n) <= POWI_MAX_MULTS)))
2967 op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2970 op = force_reg (mode, op);
2971 op = expand_powi (op, mode, n);
2976 narg0 = builtin_save_expr (arg0);
2978 /* If the exponent is not integer valued, check if it is half of an integer.
2979 In this case we can expand to sqrt (x) * x**(n/2). */
2980 fn = mathfn_built_in (type, BUILT_IN_SQRT);
2981 if (fn != NULL_TREE)
2983 real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2984 n = real_to_integer (&c2);
2985 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2986 if (real_identical (&c2, &cint)
2987 && ((flag_unsafe_math_optimizations
2988 && optimize_insn_for_speed_p ()
2989 && powi_cost (n/2) <= POWI_MAX_MULTS)
2992 tree call_expr = build_call_nofold (fn, 1, narg0);
2993 /* Use expand_expr in case the newly built call expression
2994 was folded to a non-call. */
2995 op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
2998 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
2999 op2 = force_reg (mode, op2);
3000 op2 = expand_powi (op2, mode, abs (n / 2));
3001 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3002 0, OPTAB_LIB_WIDEN);
3003 /* If the original exponent was negative, reciprocate the
3006 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3007 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3013 /* Try if the exponent is a third of an integer. In this case
3014 we can expand to x**(n/3) * cbrt(x)**(n%3). As cbrt (x) is
3015 different from pow (x, 1./3.) due to rounding and behavior
3016 with negative x we need to constrain this transformation to
3017 unsafe math and positive x or finite math. */
3018 fn = mathfn_built_in (type, BUILT_IN_CBRT);
3020 && flag_unsafe_math_optimizations
3021 && (tree_expr_nonnegative_p (arg0)
3022 || !HONOR_NANS (mode)))
3024 REAL_VALUE_TYPE dconst3;
3025 real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3026 real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3027 real_round (&c2, mode, &c2);
3028 n = real_to_integer (&c2);
3029 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3030 real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3031 real_convert (&c2, mode, &c2);
3032 if (real_identical (&c2, &c)
3033 && ((optimize_insn_for_speed_p ()
3034 && powi_cost (n/3) <= POWI_MAX_MULTS)
3037 tree call_expr = build_call_nofold (fn, 1,narg0);
3038 op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3039 if (abs (n) % 3 == 2)
3040 op = expand_simple_binop (mode, MULT, op, op, op,
3041 0, OPTAB_LIB_WIDEN);
3044 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3045 op2 = force_reg (mode, op2);
3046 op2 = expand_powi (op2, mode, abs (n / 3));
3047 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3048 0, OPTAB_LIB_WIDEN);
3049 /* If the original exponent was negative, reciprocate the
3052 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3053 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3059 /* Fall back to optab expansion. */
3060 return expand_builtin_mathfn_2 (exp, target, subtarget);
3063 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
3064 a normal call should be emitted rather than expanding the function
3065 in-line. EXP is the expression that is a call to the builtin
3066 function; if convenient, the result should be placed in TARGET. */
3069 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3073 enum machine_mode mode;
3074 enum machine_mode mode2;
3076 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3079 arg0 = CALL_EXPR_ARG (exp, 0);
3080 arg1 = CALL_EXPR_ARG (exp, 1);
3081 mode = TYPE_MODE (TREE_TYPE (exp));
3083 /* Handle constant power. */
3085 if (TREE_CODE (arg1) == INTEGER_CST
3086 && !TREE_OVERFLOW (arg1))
3088 HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3090 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3091 Otherwise, check the number of multiplications required. */
3092 if ((TREE_INT_CST_HIGH (arg1) == 0
3093 || TREE_INT_CST_HIGH (arg1) == -1)
3094 && ((n >= -1 && n <= 2)
3095 || (optimize_insn_for_speed_p ()
3096 && powi_cost (n) <= POWI_MAX_MULTS)))
3098 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3099 op0 = force_reg (mode, op0);
3100 return expand_powi (op0, mode, n);
3104 /* Emit a libcall to libgcc. */
3106 /* Mode of the 2nd argument must match that of an int. */
3107 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3109 if (target == NULL_RTX)
3110 target = gen_reg_rtx (mode);
3112 op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3113 if (GET_MODE (op0) != mode)
3114 op0 = convert_to_mode (mode, op0, 0);
3115 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3116 if (GET_MODE (op1) != mode2)
3117 op1 = convert_to_mode (mode2, op1, 0);
3119 target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3120 target, LCT_CONST, mode, 2,
3121 op0, mode, op1, mode2);
3126 /* Expand expression EXP which is a call to the strlen builtin. Return
3127 NULL_RTX if we failed the caller should emit a normal call, otherwise
3128 try to get the result in TARGET, if convenient. */
3131 expand_builtin_strlen (tree exp, rtx target,
3132 enum machine_mode target_mode)
3134 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3140 tree src = CALL_EXPR_ARG (exp, 0);
3141 rtx result, src_reg, char_rtx, before_strlen;
3142 enum machine_mode insn_mode = target_mode, char_mode;
3143 enum insn_code icode = CODE_FOR_nothing;
3146 /* If the length can be computed at compile-time, return it. */
3147 len = c_strlen (src, 0);
3149 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3151 /* If the length can be computed at compile-time and is constant
3152 integer, but there are side-effects in src, evaluate
3153 src for side-effects, then return len.
3154 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3155 can be optimized into: i++; x = 3; */
3156 len = c_strlen (src, 1);
3157 if (len && TREE_CODE (len) == INTEGER_CST)
3159 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3160 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3163 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3165 /* If SRC is not a pointer type, don't do this operation inline. */
3169 /* Bail out if we can't compute strlen in the right mode. */
3170 while (insn_mode != VOIDmode)
3172 icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3173 if (icode != CODE_FOR_nothing)
3176 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3178 if (insn_mode == VOIDmode)
3181 /* Make a place to write the result of the instruction. */
3185 && GET_MODE (result) == insn_mode
3186 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3187 result = gen_reg_rtx (insn_mode);
3189 /* Make a place to hold the source address. We will not expand
3190 the actual source until we are sure that the expansion will
3191 not fail -- there are trees that cannot be expanded twice. */
3192 src_reg = gen_reg_rtx (Pmode);
3194 /* Mark the beginning of the strlen sequence so we can emit the
3195 source operand later. */
3196 before_strlen = get_last_insn ();
3198 char_rtx = const0_rtx;
3199 char_mode = insn_data[(int) icode].operand[2].mode;
3200 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3202 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3204 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3205 char_rtx, GEN_INT (align));
3210 /* Now that we are assured of success, expand the source. */
3212 pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3214 emit_move_insn (src_reg, pat);
3219 emit_insn_after (pat, before_strlen);
3221 emit_insn_before (pat, get_insns ());
3223 /* Return the value in the proper mode for this function. */
3224 if (GET_MODE (result) == target_mode)
3226 else if (target != 0)
3227 convert_move (target, result, 0);
3229 target = convert_to_mode (target_mode, result, 0);
3235 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3236 bytes from constant string DATA + OFFSET and return it as target
3240 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3241 enum machine_mode mode)
3243 const char *str = (const char *) data;
3245 gcc_assert (offset >= 0
3246 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3247 <= strlen (str) + 1));
3249 return c_readstr (str + offset, mode);
3252 /* Expand a call EXP to the memcpy builtin.
3253 Return NULL_RTX if we failed, the caller should emit a normal call,
3254 otherwise try to get the result in TARGET, if convenient (and in
3255 mode MODE if that's convenient). */
3258 expand_builtin_memcpy (tree exp, rtx target)
3260 if (!validate_arglist (exp,
3261 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3265 tree dest = CALL_EXPR_ARG (exp, 0);
3266 tree src = CALL_EXPR_ARG (exp, 1);
3267 tree len = CALL_EXPR_ARG (exp, 2);
3268 const char *src_str;
3269 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3270 unsigned int dest_align
3271 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3272 rtx dest_mem, src_mem, dest_addr, len_rtx;
3273 HOST_WIDE_INT expected_size = -1;
3274 unsigned int expected_align = 0;
3275 tree_ann_common_t ann;
3277 /* If DEST is not a pointer type, call the normal function. */
3278 if (dest_align == 0)
3281 /* If either SRC is not a pointer type, don't do this
3282 operation in-line. */
3286 ann = tree_common_ann (exp);
3288 stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3290 if (expected_align < dest_align)
3291 expected_align = dest_align;
3292 dest_mem = get_memory_rtx (dest, len);
3293 set_mem_align (dest_mem, dest_align);
3294 len_rtx = expand_normal (len);
3295 src_str = c_getstr (src);
3297 /* If SRC is a string constant and block move would be done
3298 by pieces, we can avoid loading the string from memory
3299 and only stored the computed constants. */
3301 && CONST_INT_P (len_rtx)
3302 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3303 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3304 CONST_CAST (char *, src_str),
3307 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3308 builtin_memcpy_read_str,
3309 CONST_CAST (char *, src_str),
3310 dest_align, false, 0);
3311 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3312 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3316 src_mem = get_memory_rtx (src, len);
3317 set_mem_align (src_mem, src_align);
3319 /* Copy word part most expediently. */
3320 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3321 CALL_EXPR_TAILCALL (exp)
3322 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3323 expected_align, expected_size);
3327 dest_addr = force_operand (XEXP (dest_mem, 0), target);
3328 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3334 /* Expand a call EXP to the mempcpy builtin.
3335 Return NULL_RTX if we failed; the caller should emit a normal call,
3336 otherwise try to get the result in TARGET, if convenient (and in
3337 mode MODE if that's convenient). If ENDP is 0 return the
3338 destination pointer, if ENDP is 1 return the end pointer ala
3339 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3343 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3345 if (!validate_arglist (exp,
3346 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3350 tree dest = CALL_EXPR_ARG (exp, 0);
3351 tree src = CALL_EXPR_ARG (exp, 1);
3352 tree len = CALL_EXPR_ARG (exp, 2);
3353 return expand_builtin_mempcpy_args (dest, src, len,
3354 target, mode, /*endp=*/ 1);
3358 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3359 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3360 so that this can also be called without constructing an actual CALL_EXPR.
3361 The other arguments and return value are the same as for
3362 expand_builtin_mempcpy. */
3365 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3366 rtx target, enum machine_mode mode, int endp)
3368 /* If return value is ignored, transform mempcpy into memcpy. */
3369 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3371 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3372 tree result = build_call_nofold (fn, 3, dest, src, len);
3373 return expand_expr (result, target, mode, EXPAND_NORMAL);
3377 const char *src_str;
3378 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3379 unsigned int dest_align
3380 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3381 rtx dest_mem, src_mem, len_rtx;
3383 /* If either SRC or DEST is not a pointer type, don't do this
3384 operation in-line. */
3385 if (dest_align == 0 || src_align == 0)
3388 /* If LEN is not constant, call the normal function. */
3389 if (! host_integerp (len, 1))
3392 len_rtx = expand_normal (len);
3393 src_str = c_getstr (src);
3395 /* If SRC is a string constant and block move would be done
3396 by pieces, we can avoid loading the string from memory
3397 and only stored the computed constants. */
3399 && CONST_INT_P (len_rtx)
3400 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3401 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3402 CONST_CAST (char *, src_str),
3405 dest_mem = get_memory_rtx (dest, len);
3406 set_mem_align (dest_mem, dest_align);
3407 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3408 builtin_memcpy_read_str,
3409 CONST_CAST (char *, src_str),
3410 dest_align, false, endp);
3411 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3412 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3416 if (CONST_INT_P (len_rtx)
3417 && can_move_by_pieces (INTVAL (len_rtx),
3418 MIN (dest_align, src_align)))
3420 dest_mem = get_memory_rtx (dest, len);
3421 set_mem_align (dest_mem, dest_align);
3422 src_mem = get_memory_rtx (src, len);
3423 set_mem_align (src_mem, src_align);
3424 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3425 MIN (dest_align, src_align), endp);
3426 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3427 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3436 # define HAVE_movstr 0
3437 # define CODE_FOR_movstr CODE_FOR_nothing
3440 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3441 we failed, the caller should emit a normal call, otherwise try to
3442 get the result in TARGET, if convenient. If ENDP is 0 return the
3443 destination pointer, if ENDP is 1 return the end pointer ala
3444 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3448 expand_movstr (tree dest, tree src, rtx target, int endp)
3454 const struct insn_data * data;
3459 dest_mem = get_memory_rtx (dest, NULL);
3460 src_mem = get_memory_rtx (src, NULL);
3463 target = force_reg (Pmode, XEXP (dest_mem, 0));
3464 dest_mem = replace_equiv_address (dest_mem, target);
3465 end = gen_reg_rtx (Pmode);
3469 if (target == 0 || target == const0_rtx)
3471 end = gen_reg_rtx (Pmode);
3479 data = insn_data + CODE_FOR_movstr;
3481 if (data->operand[0].mode != VOIDmode)
3482 end = gen_lowpart (data->operand[0].mode, end);
3484 insn = data->genfun (end, dest_mem, src_mem);
3490 /* movstr is supposed to set end to the address of the NUL
3491 terminator. If the caller requested a mempcpy-like return value,
3493 if (endp == 1 && target != const0_rtx)
3495 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3496 emit_move_insn (target, force_operand (tem, NULL_RTX));
3502 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3503 NULL_RTX if we failed the caller should emit a normal call, otherwise
3504 try to get the result in TARGET, if convenient (and in mode MODE if that's
3508 expand_builtin_strcpy (tree exp, rtx target)
3510 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3512 tree dest = CALL_EXPR_ARG (exp, 0);
3513 tree src = CALL_EXPR_ARG (exp, 1);
3514 return expand_builtin_strcpy_args (dest, src, target);
3519 /* Helper function to do the actual work for expand_builtin_strcpy. The
3520 arguments to the builtin_strcpy call DEST and SRC are broken out
3521 so that this can also be called without constructing an actual CALL_EXPR.
3522 The other arguments and return value are the same as for
3523 expand_builtin_strcpy. */
3526 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3528 return expand_movstr (dest, src, target, /*endp=*/0);
3531 /* Expand a call EXP to the stpcpy builtin.
3532 Return NULL_RTX if we failed the caller should emit a normal call,
3533 otherwise try to get the result in TARGET, if convenient (and in
3534 mode MODE if that's convenient). */
3537 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3540 location_t loc = EXPR_LOCATION (exp);
3542 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3545 dst = CALL_EXPR_ARG (exp, 0);
3546 src = CALL_EXPR_ARG (exp, 1);
3548 /* If return value is ignored, transform stpcpy into strcpy. */
3549 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3551 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3552 tree result = build_call_nofold (fn, 2, dst, src);
3553 return expand_expr (result, target, mode, EXPAND_NORMAL);
3560 /* Ensure we get an actual string whose length can be evaluated at
3561 compile-time, not an expression containing a string. This is
3562 because the latter will potentially produce pessimized code
3563 when used to produce the return value. */
3564 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3565 return expand_movstr (dst, src, target, /*endp=*/2);
3567 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3568 ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3569 target, mode, /*endp=*/2);
3574 if (TREE_CODE (len) == INTEGER_CST)
3576 rtx len_rtx = expand_normal (len);
3578 if (CONST_INT_P (len_rtx))
3580 ret = expand_builtin_strcpy_args (dst, src, target);
3586 if (mode != VOIDmode)
3587 target = gen_reg_rtx (mode);
3589 target = gen_reg_rtx (GET_MODE (ret));
3591 if (GET_MODE (target) != GET_MODE (ret))
3592 ret = gen_lowpart (GET_MODE (target), ret);
3594 ret = plus_constant (ret, INTVAL (len_rtx));
3595 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3603 return expand_movstr (dst, src, target, /*endp=*/2);
3607 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3608 bytes from constant string DATA + OFFSET and return it as target
3612 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3613 enum machine_mode mode)
3615 const char *str = (const char *) data;
3617 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3620 return c_readstr (str + offset, mode);
3623 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3624 NULL_RTX if we failed the caller should emit a normal call. */
3627 expand_builtin_strncpy (tree exp, rtx target)
3629 location_t loc = EXPR_LOCATION (exp);
3631 if (validate_arglist (exp,
3632 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3634 tree dest = CALL_EXPR_ARG (exp, 0);
3635 tree src = CALL_EXPR_ARG (exp, 1);
3636 tree len = CALL_EXPR_ARG (exp, 2);
3637 tree slen = c_strlen (src, 1);
3639 /* We must be passed a constant len and src parameter. */
3640 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3643 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3645 /* We're required to pad with trailing zeros if the requested
3646 len is greater than strlen(s2)+1. In that case try to
3647 use store_by_pieces, if it fails, punt. */
3648 if (tree_int_cst_lt (slen, len))
3650 unsigned int dest_align
3651 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3652 const char *p = c_getstr (src);
3655 if (!p || dest_align == 0 || !host_integerp (len, 1)
3656 || !can_store_by_pieces (tree_low_cst (len, 1),
3657 builtin_strncpy_read_str,
3658 CONST_CAST (char *, p),
3662 dest_mem = get_memory_rtx (dest, len);
3663 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3664 builtin_strncpy_read_str,
3665 CONST_CAST (char *, p), dest_align, false, 0);
3666 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3667 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3674 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3675 bytes from constant string DATA + OFFSET and return it as target
3679 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3680 enum machine_mode mode)
3682 const char *c = (const char *) data;
3683 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3685 memset (p, *c, GET_MODE_SIZE (mode));
3687 return c_readstr (p, mode);
3690 /* Callback routine for store_by_pieces. Return the RTL of a register
3691 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3692 char value given in the RTL register data. For example, if mode is
3693 4 bytes wide, return the RTL for 0x01010101*data. */
3696 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3697 enum machine_mode mode)
3703 size = GET_MODE_SIZE (mode);
3707 p = XALLOCAVEC (char, size);
3708 memset (p, 1, size);
3709 coeff = c_readstr (p, mode);
3711 target = convert_to_mode (mode, (rtx) data, 1);
3712 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3713 return force_reg (mode, target);
3716 /* Expand expression EXP, which is a call to the memset builtin. Return
3717 NULL_RTX if we failed the caller should emit a normal call, otherwise
3718 try to get the result in TARGET, if convenient (and in mode MODE if that's
3722 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3724 if (!validate_arglist (exp,
3725 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3729 tree dest = CALL_EXPR_ARG (exp, 0);
3730 tree val = CALL_EXPR_ARG (exp, 1);
3731 tree len = CALL_EXPR_ARG (exp, 2);
3732 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3736 /* Helper function to do the actual work for expand_builtin_memset. The
3737 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3738 so that this can also be called without constructing an actual CALL_EXPR.
3739 The other arguments and return value are the same as for
3740 expand_builtin_memset. */
3743 expand_builtin_memset_args (tree dest, tree val, tree len,
3744 rtx target, enum machine_mode mode, tree orig_exp)
3747 enum built_in_function fcode;
3749 unsigned int dest_align;
3750 rtx dest_mem, dest_addr, len_rtx;
3751 HOST_WIDE_INT expected_size = -1;
3752 unsigned int expected_align = 0;
3753 tree_ann_common_t ann;
3755 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3757 /* If DEST is not a pointer type, don't do this operation in-line. */
3758 if (dest_align == 0)
3761 ann = tree_common_ann (orig_exp);
3763 stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3765 if (expected_align < dest_align)
3766 expected_align = dest_align;
3768 /* If the LEN parameter is zero, return DEST. */
3769 if (integer_zerop (len))
3771 /* Evaluate and ignore VAL in case it has side-effects. */
3772 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3773 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3776 /* Stabilize the arguments in case we fail. */
3777 dest = builtin_save_expr (dest);
3778 val = builtin_save_expr (val);
3779 len = builtin_save_expr (len);
3781 len_rtx = expand_normal (len);
3782 dest_mem = get_memory_rtx (dest, len);
3784 if (TREE_CODE (val) != INTEGER_CST)
3788 val_rtx = expand_normal (val);
3789 val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3792 /* Assume that we can memset by pieces if we can store
3793 * the coefficients by pieces (in the required modes).
3794 * We can't pass builtin_memset_gen_str as that emits RTL. */
3796 if (host_integerp (len, 1)
3797 && can_store_by_pieces (tree_low_cst (len, 1),
3798 builtin_memset_read_str, &c, dest_align,
3801 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3803 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3804 builtin_memset_gen_str, val_rtx, dest_align,
3807 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3808 dest_align, expected_align,
3812 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3813 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3817 if (target_char_cast (val, &c))
3822 if (host_integerp (len, 1)
3823 && can_store_by_pieces (tree_low_cst (len, 1),
3824 builtin_memset_read_str, &c, dest_align,
3826 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3827 builtin_memset_read_str, &c, dest_align, true, 0);
3828 else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3829 dest_align, expected_align,
3833 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3834 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3838 set_mem_align (dest_mem, dest_align);
3839 dest_addr = clear_storage_hints (dest_mem, len_rtx,
3840 CALL_EXPR_TAILCALL (orig_exp)
3841 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3842 expected_align, expected_size);
3846 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3847 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3853 fndecl = get_callee_fndecl (orig_exp);
3854 fcode = DECL_FUNCTION_CODE (fndecl);
3855 if (fcode == BUILT_IN_MEMSET)
3856 fn = build_call_nofold (fndecl, 3, dest, val, len);
3857 else if (fcode == BUILT_IN_BZERO)
3858 fn = build_call_nofold (fndecl, 2, dest, len);
3861 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3862 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3863 return expand_call (fn, target, target == const0_rtx);
3866 /* Expand expression EXP, which is a call to the bzero builtin. Return
3867 NULL_RTX if we failed the caller should emit a normal call. */
3870 expand_builtin_bzero (tree exp)
3873 location_t loc = EXPR_LOCATION (exp);
3875 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3878 dest = CALL_EXPR_ARG (exp, 0);
3879 size = CALL_EXPR_ARG (exp, 1);
3881 /* New argument list transforming bzero(ptr x, int y) to
3882 memset(ptr x, int 0, size_t y). This is done this way
3883 so that if it isn't expanded inline, we fallback to
3884 calling bzero instead of memset. */
3886 return expand_builtin_memset_args (dest, integer_zero_node,
3887 fold_convert_loc (loc, sizetype, size),
3888 const0_rtx, VOIDmode, exp);
3891 /* Expand expression EXP, which is a call to the memcmp built-in function.
3892 Return NULL_RTX if we failed and the
3893 caller should emit a normal call, otherwise try to get the result in
3894 TARGET, if convenient (and in mode MODE, if that's convenient). */
3897 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3898 ATTRIBUTE_UNUSED enum machine_mode mode)
3900 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3902 if (!validate_arglist (exp,
3903 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3906 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3908 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3911 tree arg1 = CALL_EXPR_ARG (exp, 0);
3912 tree arg2 = CALL_EXPR_ARG (exp, 1);
3913 tree len = CALL_EXPR_ARG (exp, 2);
3916 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3918 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3919 enum machine_mode insn_mode;
3921 #ifdef HAVE_cmpmemsi
3923 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3926 #ifdef HAVE_cmpstrnsi
3928 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3933 /* If we don't have POINTER_TYPE, call the function. */
3934 if (arg1_align == 0 || arg2_align == 0)
3937 /* Make a place to write the result of the instruction. */
3940 && REG_P (result) && GET_MODE (result) == insn_mode
3941 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3942 result = gen_reg_rtx (insn_mode);
3944 arg1_rtx = get_memory_rtx (arg1, len);
3945 arg2_rtx = get_memory_rtx (arg2, len);
3946 arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3948 /* Set MEM_SIZE as appropriate. */
3949 if (CONST_INT_P (arg3_rtx))
3951 set_mem_size (arg1_rtx, arg3_rtx);
3952 set_mem_size (arg2_rtx, arg3_rtx);
3955 #ifdef HAVE_cmpmemsi
3957 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3958 GEN_INT (MIN (arg1_align, arg2_align)));
3961 #ifdef HAVE_cmpstrnsi
3963 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3964 GEN_INT (MIN (arg1_align, arg2_align)));
3972 emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3973 TYPE_MODE (integer_type_node), 3,
3974 XEXP (arg1_rtx, 0), Pmode,
3975 XEXP (arg2_rtx, 0), Pmode,
3976 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3977 TYPE_UNSIGNED (sizetype)),
3978 TYPE_MODE (sizetype));
3980 /* Return the value in the proper mode for this function. */
3981 mode = TYPE_MODE (TREE_TYPE (exp));
3982 if (GET_MODE (result) == mode)
3984 else if (target != 0)
3986 convert_move (target, result, 0);
3990 return convert_to_mode (mode, result, 0);
3997 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
3998 if we failed the caller should emit a normal call, otherwise try to get
3999 the result in TARGET, if convenient. */
4002 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4004 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4007 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4008 if (cmpstr_optab[SImode] != CODE_FOR_nothing
4009 || cmpstrn_optab[SImode] != CODE_FOR_nothing)
4011 rtx arg1_rtx, arg2_rtx;
4012 rtx result, insn = NULL_RTX;
4014 tree arg1 = CALL_EXPR_ARG (exp, 0);
4015 tree arg2 = CALL_EXPR_ARG (exp, 1);
4018 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4020 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4022 /* If we don't have POINTER_TYPE, call the function. */
4023 if (arg1_align == 0 || arg2_align == 0)
4026 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4027 arg1 = builtin_save_expr (arg1);
4028 arg2 = builtin_save_expr (arg2);
4030 arg1_rtx = get_memory_rtx (arg1, NULL);
4031 arg2_rtx = get_memory_rtx (arg2, NULL);
4033 #ifdef HAVE_cmpstrsi
4034 /* Try to call cmpstrsi. */
4037 enum machine_mode insn_mode
4038 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4040 /* Make a place to write the result of the instruction. */
4043 && REG_P (result) && GET_MODE (result) == insn_mode
4044 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4045 result = gen_reg_rtx (insn_mode);
4047 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4048 GEN_INT (MIN (arg1_align, arg2_align)));
4051 #ifdef HAVE_cmpstrnsi
4052 /* Try to determine at least one length and call cmpstrnsi. */
4053 if (!insn && HAVE_cmpstrnsi)
4058 enum machine_mode insn_mode
4059 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4060 tree len1 = c_strlen (arg1, 1);
4061 tree len2 = c_strlen (arg2, 1);
4064 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4066 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4068 /* If we don't have a constant length for the first, use the length
4069 of the second, if we know it. We don't require a constant for
4070 this case; some cost analysis could be done if both are available
4071 but neither is constant. For now, assume they're equally cheap,
4072 unless one has side effects. If both strings have constant lengths,
4079 else if (TREE_SIDE_EFFECTS (len1))
4081 else if (TREE_SIDE_EFFECTS (len2))
4083 else if (TREE_CODE (len1) != INTEGER_CST)
4085 else if (TREE_CODE (len2) != INTEGER_CST)
4087 else if (tree_int_cst_lt (len1, len2))
4092 /* If both arguments have side effects, we cannot optimize. */
4093 if (!len || TREE_SIDE_EFFECTS (len))
4096 arg3_rtx = expand_normal (len);
4098 /* Make a place to write the result of the instruction. */
4101 && REG_P (result) && GET_MODE (result) == insn_mode
4102 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4103 result = gen_reg_rtx (insn_mode);
4105 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4106 GEN_INT (MIN (arg1_align, arg2_align)));
4112 enum machine_mode mode;
4115 /* Return the value in the proper mode for this function. */
4116 mode = TYPE_MODE (TREE_TYPE (exp));
4117 if (GET_MODE (result) == mode)
4120 return convert_to_mode (mode, result, 0);
4121 convert_move (target, result, 0);
4125 /* Expand the library call ourselves using a stabilized argument
4126 list to avoid re-evaluating the function's arguments twice. */
4127 #ifdef HAVE_cmpstrnsi
4130 fndecl = get_callee_fndecl (exp);
4131 fn = build_call_nofold (fndecl, 2, arg1, arg2);
4132 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4133 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4134 return expand_call (fn, target, target == const0_rtx);
4140 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4141 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4142 the result in TARGET, if convenient. */
4145 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4146 ATTRIBUTE_UNUSED enum machine_mode mode)
4148 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4150 if (!validate_arglist (exp,
4151 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4154 /* If c_strlen can determine an expression for one of the string
4155 lengths, and it doesn't have side effects, then emit cmpstrnsi
4156 using length MIN(strlen(string)+1, arg3). */
4157 #ifdef HAVE_cmpstrnsi
4160 tree len, len1, len2;
4161 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4164 tree arg1 = CALL_EXPR_ARG (exp, 0);
4165 tree arg2 = CALL_EXPR_ARG (exp, 1);
4166 tree arg3 = CALL_EXPR_ARG (exp, 2);
4169 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4171 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4172 enum machine_mode insn_mode
4173 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4175 len1 = c_strlen (arg1, 1);
4176 len2 = c_strlen (arg2, 1);
4179 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4181 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4183 /* If we don't have a constant length for the first, use the length
4184 of the second, if we know it. We don't require a constant for
4185 this case; some cost analysis could be done if both are available
4186 but neither is constant. For now, assume they're equally cheap,
4187 unless one has side effects. If both strings have constant lengths,
4194 else if (TREE_SIDE_EFFECTS (len1))
4196 else if (TREE_SIDE_EFFECTS (len2))
4198 else if (TREE_CODE (len1) != INTEGER_CST)
4200 else if (TREE_CODE (len2) != INTEGER_CST)
4202 else if (tree_int_cst_lt (len1, len2))
4207 /* If both arguments have side effects, we cannot optimize. */
4208 if (!len || TREE_SIDE_EFFECTS (len))
4211 /* The actual new length parameter is MIN(len,arg3). */
4212 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4213 fold_convert_loc (loc, TREE_TYPE (len), arg3));
4215 /* If we don't have POINTER_TYPE, call the function. */
4216 if (arg1_align == 0 || arg2_align == 0)
4219 /* Make a place to write the result of the instruction. */
4222 && REG_P (result) && GET_MODE (result) == insn_mode
4223 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4224 result = gen_reg_rtx (insn_mode);
4226 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4227 arg1 = builtin_save_expr (arg1);
4228 arg2 = builtin_save_expr (arg2);
4229 len = builtin_save_expr (len);
4231 arg1_rtx = get_memory_rtx (arg1, len);
4232 arg2_rtx = get_memory_rtx (arg2, len);
4233 arg3_rtx = expand_normal (len);
4234 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4235 GEN_INT (MIN (arg1_align, arg2_align)));
4240 /* Return the value in the proper mode for this function. */
4241 mode = TYPE_MODE (TREE_TYPE (exp));
4242 if (GET_MODE (result) == mode)
4245 return convert_to_mode (mode, result, 0);
4246 convert_move (target, result, 0);
4250 /* Expand the library call ourselves using a stabilized argument
4251 list to avoid re-evaluating the function's arguments twice. */
4252 fndecl = get_callee_fndecl (exp);
4253 fn = build_call_nofold (fndecl, 3, arg1, arg2, len);
4254 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4255 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4256 return expand_call (fn, target, target == const0_rtx);
4262 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4263 if that's convenient. */
4266 expand_builtin_saveregs (void)
4270 /* Don't do __builtin_saveregs more than once in a function.
4271 Save the result of the first call and reuse it. */
4272 if (saveregs_value != 0)
4273 return saveregs_value;
4275 /* When this function is called, it means that registers must be
4276 saved on entry to this function. So we migrate the call to the
4277 first insn of this function. */
4281 /* Do whatever the machine needs done in this case. */
4282 val = targetm.calls.expand_builtin_saveregs ();
4287 saveregs_value = val;
4289 /* Put the insns after the NOTE that starts the function. If this
4290 is inside a start_sequence, make the outer-level insn chain current, so
4291 the code is placed at the start of the function. */
4292 push_topmost_sequence ();
4293 emit_insn_after (seq, entry_of_function ());
4294 pop_topmost_sequence ();
4299 /* __builtin_args_info (N) returns word N of the arg space info
4300 for the current function. The number and meanings of words
4301 is controlled by the definition of CUMULATIVE_ARGS. */
4304 expand_builtin_args_info (tree exp)
4306 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4307 int *word_ptr = (int *) &crtl->args.info;
4309 gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4311 if (call_expr_nargs (exp) != 0)
4313 if (!host_integerp (CALL_EXPR_ARG (exp, 0), 0))
4314 error ("argument of %<__builtin_args_info%> must be constant");
4317 HOST_WIDE_INT wordnum = tree_low_cst (CALL_EXPR_ARG (exp, 0), 0);
4319 if (wordnum < 0 || wordnum >= nwords)
4320 error ("argument of %<__builtin_args_info%> out of range");
4322 return GEN_INT (word_ptr[wordnum]);
4326 error ("missing argument in %<__builtin_args_info%>");
4331 /* Expand a call to __builtin_next_arg. */
4334 expand_builtin_next_arg (void)
4336 /* Checking arguments is already done in fold_builtin_next_arg
4337 that must be called before this function. */
4338 return expand_binop (ptr_mode, add_optab,
4339 crtl->args.internal_arg_pointer,
4340 crtl->args.arg_offset_rtx,
4341 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4344 /* Make it easier for the backends by protecting the valist argument
4345 from multiple evaluations. */
4348 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4350 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4352 gcc_assert (vatype != NULL_TREE);
4354 if (TREE_CODE (vatype) == ARRAY_TYPE)
4356 if (TREE_SIDE_EFFECTS (valist))
4357 valist = save_expr (valist);
4359 /* For this case, the backends will be expecting a pointer to
4360 vatype, but it's possible we've actually been given an array
4361 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4363 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4365 tree p1 = build_pointer_type (TREE_TYPE (vatype));
4366 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4375 if (! TREE_SIDE_EFFECTS (valist))
4378 pt = build_pointer_type (vatype);
4379 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4380 TREE_SIDE_EFFECTS (valist) = 1;
4383 if (TREE_SIDE_EFFECTS (valist))
4384 valist = save_expr (valist);
4385 valist = build_fold_indirect_ref_loc (loc, valist);
4391 /* The "standard" definition of va_list is void*. */
4394 std_build_builtin_va_list (void)
4396 return ptr_type_node;
4399 /* The "standard" abi va_list is va_list_type_node. */
4402 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4404 return va_list_type_node;
4407 /* The "standard" type of va_list is va_list_type_node. */
4410 std_canonical_va_list_type (tree type)
4414 if (INDIRECT_REF_P (type))
4415 type = TREE_TYPE (type);
4416 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4417 type = TREE_TYPE (type);
4418 wtype = va_list_type_node;
4420 /* Treat structure va_list types. */
4421 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4422 htype = TREE_TYPE (htype);
4423 else if (TREE_CODE (wtype) == ARRAY_TYPE)
4425 /* If va_list is an array type, the argument may have decayed
4426 to a pointer type, e.g. by being passed to another function.
4427 In that case, unwrap both types so that we can compare the
4428 underlying records. */
4429 if (TREE_CODE (htype) == ARRAY_TYPE
4430 || POINTER_TYPE_P (htype))
4432 wtype = TREE_TYPE (wtype);
4433 htype = TREE_TYPE (htype);
4436 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4437 return va_list_type_node;
4442 /* The "standard" implementation of va_start: just assign `nextarg' to
4446 std_expand_builtin_va_start (tree valist, rtx nextarg)
4448 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4449 convert_move (va_r, nextarg, 0);
4452 /* Expand EXP, a call to __builtin_va_start. */
4455 expand_builtin_va_start (tree exp)
4459 location_t loc = EXPR_LOCATION (exp);
4461 if (call_expr_nargs (exp) < 2)
4463 error_at (loc, "too few arguments to function %<va_start%>");
4467 if (fold_builtin_next_arg (exp, true))
4470 nextarg = expand_builtin_next_arg ();
4471 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4473 if (targetm.expand_builtin_va_start)
4474 targetm.expand_builtin_va_start (valist, nextarg);
4476 std_expand_builtin_va_start (valist, nextarg);
4481 /* The "standard" implementation of va_arg: read the value from the
4482 current (padded) address and increment by the (padded) size. */
4485 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4488 tree addr, t, type_size, rounded_size, valist_tmp;
4489 unsigned HOST_WIDE_INT align, boundary;
4492 #ifdef ARGS_GROW_DOWNWARD
4493 /* All of the alignment and movement below is for args-grow-up machines.
4494 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4495 implement their own specialized gimplify_va_arg_expr routines. */
4499 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4501 type = build_pointer_type (type);
4503 align = PARM_BOUNDARY / BITS_PER_UNIT;
4504 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4506 /* When we align parameter on stack for caller, if the parameter
4507 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4508 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
4509 here with caller. */
4510 if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4511 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4513 boundary /= BITS_PER_UNIT;
4515 /* Hoist the valist value into a temporary for the moment. */
4516 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4518 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4519 requires greater alignment, we must perform dynamic alignment. */
4520 if (boundary > align
4521 && !integer_zerop (TYPE_SIZE (type)))
4523 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4524 fold_build2 (POINTER_PLUS_EXPR,
4526 valist_tmp, size_int (boundary - 1)));
4527 gimplify_and_add (t, pre_p);
4529 t = fold_convert (sizetype, valist_tmp);
4530 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4531 fold_convert (TREE_TYPE (valist),
4532 fold_build2 (BIT_AND_EXPR, sizetype, t,
4533 size_int (-boundary))));
4534 gimplify_and_add (t, pre_p);
4539 /* If the actual alignment is less than the alignment of the type,
4540 adjust the type accordingly so that we don't assume strict alignment
4541 when dereferencing the pointer. */
4542 boundary *= BITS_PER_UNIT;
4543 if (boundary < TYPE_ALIGN (type))
4545 type = build_variant_type_copy (type);
4546 TYPE_ALIGN (type) = boundary;
4549 /* Compute the rounded size of the type. */
4550 type_size = size_in_bytes (type);
4551 rounded_size = round_up (type_size, align);
4553 /* Reduce rounded_size so it's sharable with the postqueue. */
4554 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4558 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4560 /* Small args are padded downward. */
4561 t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4562 rounded_size, size_int (align));
4563 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4564 size_binop (MINUS_EXPR, rounded_size, type_size));
4565 addr = fold_build2 (POINTER_PLUS_EXPR,
4566 TREE_TYPE (addr), addr, t);
4569 /* Compute new value for AP. */
4570 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4571 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4572 gimplify_and_add (t, pre_p);
4574 addr = fold_convert (build_pointer_type (type), addr);
4577 addr = build_va_arg_indirect_ref (addr);
4579 return build_va_arg_indirect_ref (addr);
4582 /* Build an indirect-ref expression over the given TREE, which represents a
4583 piece of a va_arg() expansion. */
4585 build_va_arg_indirect_ref (tree addr)
4587 addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4589 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4595 /* Return a dummy expression of type TYPE in order to keep going after an
4599 dummy_object (tree type)
4601 tree t = build_int_cst (build_pointer_type (type), 0);
4602 return build1 (INDIRECT_REF, type, t);
4605 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4606 builtin function, but a very special sort of operator. */
4608 enum gimplify_status
4609 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4611 tree promoted_type, have_va_type;
4612 tree valist = TREE_OPERAND (*expr_p, 0);
4613 tree type = TREE_TYPE (*expr_p);
4615 location_t loc = EXPR_LOCATION (*expr_p);
4617 /* Verify that valist is of the proper type. */
4618 have_va_type = TREE_TYPE (valist);
4619 if (have_va_type == error_mark_node)
4621 have_va_type = targetm.canonical_va_list_type (have_va_type);
4623 if (have_va_type == NULL_TREE)
4625 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4629 /* Generate a diagnostic for requesting data of a type that cannot
4630 be passed through `...' due to type promotion at the call site. */
4631 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4634 static bool gave_help;
4637 /* Unfortunately, this is merely undefined, rather than a constraint
4638 violation, so we cannot make this an error. If this call is never
4639 executed, the program is still strictly conforming. */
4640 warned = warning_at (loc, 0,
4641 "%qT is promoted to %qT when passed through %<...%>",
4642 type, promoted_type);
4643 if (!gave_help && warned)
4646 inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4647 promoted_type, type);
4650 /* We can, however, treat "undefined" any way we please.
4651 Call abort to encourage the user to fix the program. */
4653 inform (loc, "if this code is reached, the program will abort");
4654 /* Before the abort, allow the evaluation of the va_list
4655 expression to exit or longjmp. */
4656 gimplify_and_add (valist, pre_p);
4657 t = build_call_expr_loc (loc,
4658 implicit_built_in_decls[BUILT_IN_TRAP], 0);
4659 gimplify_and_add (t, pre_p);
4661 /* This is dead code, but go ahead and finish so that the
4662 mode of the result comes out right. */
4663 *expr_p = dummy_object (type);
4668 /* Make it easier for the backends by protecting the valist argument
4669 from multiple evaluations. */
4670 if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4672 /* For this case, the backends will be expecting a pointer to
4673 TREE_TYPE (abi), but it's possible we've
4674 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4676 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4678 tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4679 valist = fold_convert_loc (loc, p1,
4680 build_fold_addr_expr_loc (loc, valist));
4683 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4686 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4688 if (!targetm.gimplify_va_arg_expr)
4689 /* FIXME: Once most targets are converted we should merely
4690 assert this is non-null. */
4693 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4698 /* Expand EXP, a call to __builtin_va_end. */
4701 expand_builtin_va_end (tree exp)
4703 tree valist = CALL_EXPR_ARG (exp, 0);
4705 /* Evaluate for side effects, if needed. I hate macros that don't
4707 if (TREE_SIDE_EFFECTS (valist))
4708 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4713 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4714 builtin rather than just as an assignment in stdarg.h because of the
4715 nastiness of array-type va_list types. */
4718 expand_builtin_va_copy (tree exp)
4721 location_t loc = EXPR_LOCATION (exp);
4723 dst = CALL_EXPR_ARG (exp, 0);
4724 src = CALL_EXPR_ARG (exp, 1);
4726 dst = stabilize_va_list_loc (loc, dst, 1);
4727 src = stabilize_va_list_loc (loc, src, 0);
4729 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4731 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4733 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4734 TREE_SIDE_EFFECTS (t) = 1;
4735 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4739 rtx dstb, srcb, size;
4741 /* Evaluate to pointers. */
4742 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4743 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4744 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4745 NULL_RTX, VOIDmode, EXPAND_NORMAL);
4747 dstb = convert_memory_address (Pmode, dstb);
4748 srcb = convert_memory_address (Pmode, srcb);
4750 /* "Dereference" to BLKmode memories. */
4751 dstb = gen_rtx_MEM (BLKmode, dstb);
4752 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4753 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4754 srcb = gen_rtx_MEM (BLKmode, srcb);
4755 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4756 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4759 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4765 /* Expand a call to one of the builtin functions __builtin_frame_address or
4766 __builtin_return_address. */
4769 expand_builtin_frame_address (tree fndecl, tree exp)
4771 /* The argument must be a nonnegative integer constant.
4772 It counts the number of frames to scan up the stack.
4773 The value is the return address saved in that frame. */
4774 if (call_expr_nargs (exp) == 0)
4775 /* Warning about missing arg was already issued. */
4777 else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4779 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4780 error ("invalid argument to %<__builtin_frame_address%>");
4782 error ("invalid argument to %<__builtin_return_address%>");
4788 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4789 tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4791 /* Some ports cannot access arbitrary stack frames. */
4794 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4795 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4797 warning (0, "unsupported argument to %<__builtin_return_address%>");
4801 /* For __builtin_frame_address, return what we've got. */
4802 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4806 && ! CONSTANT_P (tem))
4807 tem = copy_to_mode_reg (Pmode, tem);
4812 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if
4813 we failed and the caller should emit a normal call, otherwise try to get
4814 the result in TARGET, if convenient. */
4817 expand_builtin_alloca (tree exp, rtx target)
4822 /* Emit normal call if marked not-inlineable. */
4823 if (CALL_CANNOT_INLINE_P (exp))
4826 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4829 /* Compute the argument. */
4830 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4832 /* Allocate the desired space. */
4833 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4834 result = convert_memory_address (ptr_mode, result);
4839 /* Expand a call to a bswap builtin with argument ARG0. MODE
4840 is the mode to expand with. */
4843 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4845 enum machine_mode mode;
4849 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4852 arg = CALL_EXPR_ARG (exp, 0);
4853 mode = TYPE_MODE (TREE_TYPE (arg));
4854 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4856 target = expand_unop (mode, bswap_optab, op0, target, 1);
4858 gcc_assert (target);
4860 return convert_to_mode (mode, target, 0);
4863 /* Expand a call to a unary builtin in EXP.
4864 Return NULL_RTX if a normal call should be emitted rather than expanding the
4865 function in-line. If convenient, the result should be placed in TARGET.
4866 SUBTARGET may be used as the target for computing one of EXP's operands. */
4869 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4870 rtx subtarget, optab op_optab)
4874 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4877 /* Compute the argument. */
4878 op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
4879 VOIDmode, EXPAND_NORMAL);
4880 /* Compute op, into TARGET if possible.
4881 Set TARGET to wherever the result comes back. */
4882 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4883 op_optab, op0, target, 1);
4884 gcc_assert (target);
4886 return convert_to_mode (target_mode, target, 0);
4889 /* Expand a call to __builtin_expect. We just return our argument
4890 as the builtin_expect semantic should've been already executed by
4891 tree branch prediction pass. */
4894 expand_builtin_expect (tree exp, rtx target)
4898 if (call_expr_nargs (exp) < 2)
4900 arg = CALL_EXPR_ARG (exp, 0);
4901 c = CALL_EXPR_ARG (exp, 1);
4903 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4904 /* When guessing was done, the hints should be already stripped away. */
4905 gcc_assert (!flag_guess_branch_prob
4906 || optimize == 0 || errorcount || sorrycount);
4911 expand_builtin_trap (void)
4915 emit_insn (gen_trap ());
4918 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4922 /* Expand a call to __builtin_unreachable. We do nothing except emit
4923 a barrier saying that control flow will not pass here.
4925 It is the responsibility of the program being compiled to ensure
4926 that control flow does never reach __builtin_unreachable. */
4928 expand_builtin_unreachable (void)
4933 /* Expand EXP, a call to fabs, fabsf or fabsl.
4934 Return NULL_RTX if a normal call should be emitted rather than expanding
4935 the function inline. If convenient, the result should be placed
4936 in TARGET. SUBTARGET may be used as the target for computing
4940 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4942 enum machine_mode mode;
4946 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4949 arg = CALL_EXPR_ARG (exp, 0);
4950 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4951 mode = TYPE_MODE (TREE_TYPE (arg));
4952 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4953 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4956 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4957 Return NULL is a normal call should be emitted rather than expanding the
4958 function inline. If convenient, the result should be placed in TARGET.
4959 SUBTARGET may be used as the target for computing the operand. */
4962 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4967 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4970 arg = CALL_EXPR_ARG (exp, 0);
4971 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4973 arg = CALL_EXPR_ARG (exp, 1);
4974 op1 = expand_normal (arg);
4976 return expand_copysign (op0, op1, target);
4979 /* Create a new constant string literal and return a char* pointer to it.
4980 The STRING_CST value is the LEN characters at STR. */
4982 build_string_literal (int len, const char *str)
4984 tree t, elem, index, type;
4986 t = build_string (len, str);
4987 elem = build_type_variant (char_type_node, 1, 0);
4988 index = build_index_type (size_int (len - 1));
4989 type = build_array_type (elem, index);
4990 TREE_TYPE (t) = type;
4991 TREE_CONSTANT (t) = 1;
4992 TREE_READONLY (t) = 1;
4993 TREE_STATIC (t) = 1;
4995 type = build_pointer_type (elem);
4996 t = build1 (ADDR_EXPR, type,
4997 build4 (ARRAY_REF, elem,
4998 t, integer_zero_node, NULL_TREE, NULL_TREE));
5002 /* Expand EXP, a call to printf or printf_unlocked.
5003 Return NULL_RTX if a normal call should be emitted rather than transforming
5004 the function inline. If convenient, the result should be placed in
5005 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
5008 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
5011 /* If we're using an unlocked function, assume the other unlocked
5012 functions exist explicitly. */
5013 tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
5014 : implicit_built_in_decls[BUILT_IN_PUTCHAR];
5015 tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
5016 : implicit_built_in_decls[BUILT_IN_PUTS];
5017 const char *fmt_str;
5020 int nargs = call_expr_nargs (exp);
5022 /* If the return value is used, don't do the transformation. */
5023 if (target != const0_rtx)
5026 /* Verify the required arguments in the original call. */
5029 fmt = CALL_EXPR_ARG (exp, 0);
5030 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5033 /* Check whether the format is a literal string constant. */
5034 fmt_str = c_getstr (fmt);
5035 if (fmt_str == NULL)
5038 if (!init_target_chars ())
5041 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
5042 if (strcmp (fmt_str, target_percent_s_newline) == 0)
5045 || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 1))))
5048 fn = build_call_nofold (fn_puts, 1, CALL_EXPR_ARG (exp, 1));
5050 /* If the format specifier was "%c", call __builtin_putchar(arg). */
5051 else if (strcmp (fmt_str, target_percent_c) == 0)
5054 || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))) != INTEGER_TYPE)
5057 fn = build_call_nofold (fn_putchar, 1, CALL_EXPR_ARG (exp, 1));
5061 /* We can't handle anything else with % args or %% ... yet. */
5062 if (strchr (fmt_str, target_percent))
5068 /* If the format specifier was "", printf does nothing. */
5069 if (fmt_str[0] == '\0')
5071 /* If the format specifier has length of 1, call putchar. */
5072 if (fmt_str[1] == '\0')
5074 /* Given printf("c"), (where c is any one character,)
5075 convert "c"[0] to an int and pass that to the replacement
5077 arg = build_int_cst (NULL_TREE, fmt_str[0]);
5079 fn = build_call_nofold (fn_putchar, 1, arg);
5083 /* If the format specifier was "string\n", call puts("string"). */
5084 size_t len = strlen (fmt_str);
5085 if ((unsigned char)fmt_str[len - 1] == target_newline)
5087 /* Create a NUL-terminated string that's one char shorter
5088 than the original, stripping off the trailing '\n'. */
5089 char *newstr = XALLOCAVEC (char, len);
5090 memcpy (newstr, fmt_str, len - 1);
5091 newstr[len - 1] = 0;
5092 arg = build_string_literal (len, newstr);
5094 fn = build_call_nofold (fn_puts, 1, arg);
5097 /* We'd like to arrange to call fputs(string,stdout) here,
5098 but we need stdout and don't have a way to get it yet. */
5105 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
5106 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5107 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5110 /* Expand EXP, a call to fprintf or fprintf_unlocked.
5111 Return NULL_RTX if a normal call should be emitted rather than transforming
5112 the function inline. If convenient, the result should be placed in
5113 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
5116 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
5119 /* If we're using an unlocked function, assume the other unlocked
5120 functions exist explicitly. */
5121 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
5122 : implicit_built_in_decls[BUILT_IN_FPUTC];
5123 tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
5124 : implicit_built_in_decls[BUILT_IN_FPUTS];
5125 const char *fmt_str;
5128 int nargs = call_expr_nargs (exp);
5130 /* If the return value is used, don't do the transformation. */
5131 if (target != const0_rtx)
5134 /* Verify the required arguments in the original call. */
5137 fp = CALL_EXPR_ARG (exp, 0);
5138 if (! POINTER_TYPE_P (TREE_TYPE (fp)))
5140 fmt = CALL_EXPR_ARG (exp, 1);
5141 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5144 /* Check whether the format is a literal string constant. */
5145 fmt_str = c_getstr (fmt);
5146 if (fmt_str == NULL)
5149 if (!init_target_chars ())
5152 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
5153 if (strcmp (fmt_str, target_percent_s) == 0)
5156 || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 2))))
5158 arg = CALL_EXPR_ARG (exp, 2);
5160 fn = build_call_nofold (fn_fputs, 2, arg, fp);
5162 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
5163 else if (strcmp (fmt_str, target_percent_c) == 0)
5166 || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2))) != INTEGER_TYPE)
5168 arg = CALL_EXPR_ARG (exp, 2);
5170 fn = build_call_nofold (fn_fputc, 2, arg, fp);
5174 /* We can't handle anything else with % args or %% ... yet. */
5175 if (strchr (fmt_str, target_percent))
5181 /* If the format specifier was "", fprintf does nothing. */
5182 if (fmt_str[0] == '\0')
5184 /* Evaluate and ignore FILE* argument for side-effects. */
5185 expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5189 /* When "string" doesn't contain %, replace all cases of
5190 fprintf(stream,string) with fputs(string,stream). The fputs
5191 builtin will take care of special cases like length == 1. */
5193 fn = build_call_nofold (fn_fputs, 2, fmt, fp);
5198 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
5199 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5200 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5203 /* Expand a call EXP to sprintf. Return NULL_RTX if
5204 a normal call should be emitted rather than expanding the function
5205 inline. If convenient, the result should be placed in TARGET with
5209 expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
5212 const char *fmt_str;
5213 int nargs = call_expr_nargs (exp);
5215 /* Verify the required arguments in the original call. */
5218 dest = CALL_EXPR_ARG (exp, 0);
5219 if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5221 fmt = CALL_EXPR_ARG (exp, 0);
5222 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5225 /* Check whether the format is a literal string constant. */
5226 fmt_str = c_getstr (fmt);
5227 if (fmt_str == NULL)
5230 if (!init_target_chars ())
5233 /* If the format doesn't contain % args or %%, use strcpy. */
5234 if (strchr (fmt_str, target_percent) == 0)
5236 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5239 if ((nargs > 2) || ! fn)
5241 expand_expr (build_call_nofold (fn, 2, dest, fmt),
5242 const0_rtx, VOIDmode, EXPAND_NORMAL);
5243 if (target == const0_rtx)
5245 exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5246 return expand_expr (exp, target, mode, EXPAND_NORMAL);
5248 /* If the format is "%s", use strcpy if the result isn't used. */
5249 else if (strcmp (fmt_str, target_percent_s) == 0)
5252 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5258 arg = CALL_EXPR_ARG (exp, 2);
5259 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5262 if (target != const0_rtx)
5264 len = c_strlen (arg, 1);
5265 if (! len || TREE_CODE (len) != INTEGER_CST)
5271 expand_expr (build_call_nofold (fn, 2, dest, arg),
5272 const0_rtx, VOIDmode, EXPAND_NORMAL);
5274 if (target == const0_rtx)
5276 return expand_expr (len, target, mode, EXPAND_NORMAL);
5282 /* Expand a call to either the entry or exit function profiler. */
5285 expand_builtin_profile_func (bool exitp)
5287 rtx this_rtx, which;
5289 this_rtx = DECL_RTL (current_function_decl);
5290 gcc_assert (MEM_P (this_rtx));
5291 this_rtx = XEXP (this_rtx, 0);
5294 which = profile_function_exit_libfunc;
5296 which = profile_function_entry_libfunc;
5298 emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5299 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5306 /* Expand a call to __builtin___clear_cache. */
5309 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5311 #ifndef HAVE_clear_cache
5312 #ifdef CLEAR_INSN_CACHE
5313 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5314 does something. Just do the default expansion to a call to
5318 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5319 does nothing. There is no need to call it. Do nothing. */
5321 #endif /* CLEAR_INSN_CACHE */
5323 /* We have a "clear_cache" insn, and it will handle everything. */
5325 rtx begin_rtx, end_rtx;
5326 enum insn_code icode;
5328 /* We must not expand to a library call. If we did, any
5329 fallback library function in libgcc that might contain a call to
5330 __builtin___clear_cache() would recurse infinitely. */
5331 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5333 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5337 if (HAVE_clear_cache)
5339 icode = CODE_FOR_clear_cache;
5341 begin = CALL_EXPR_ARG (exp, 0);
5342 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5343 begin_rtx = convert_memory_address (Pmode, begin_rtx);
5344 if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5345 begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5347 end = CALL_EXPR_ARG (exp, 1);
5348 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5349 end_rtx = convert_memory_address (Pmode, end_rtx);
5350 if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5351 end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5353 emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5356 #endif /* HAVE_clear_cache */
5359 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5362 round_trampoline_addr (rtx tramp)
5364 rtx temp, addend, mask;
5366 /* If we don't need too much alignment, we'll have been guaranteed
5367 proper alignment by get_trampoline_type. */
5368 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5371 /* Round address up to desired boundary. */
5372 temp = gen_reg_rtx (Pmode);
5373 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5374 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5376 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
5377 temp, 0, OPTAB_LIB_WIDEN);
5378 tramp = expand_simple_binop (Pmode, AND, temp, mask,
5379 temp, 0, OPTAB_LIB_WIDEN);
5385 expand_builtin_init_trampoline (tree exp)
5387 tree t_tramp, t_func, t_chain;
5388 rtx m_tramp, r_tramp, r_chain, tmp;
5390 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5391 POINTER_TYPE, VOID_TYPE))
5394 t_tramp = CALL_EXPR_ARG (exp, 0);
5395 t_func = CALL_EXPR_ARG (exp, 1);
5396 t_chain = CALL_EXPR_ARG (exp, 2);
5398 r_tramp = expand_normal (t_tramp);
5399 m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5400 MEM_NOTRAP_P (m_tramp) = 1;
5402 /* The TRAMP argument should be the address of a field within the
5403 local function's FRAME decl. Let's see if we can fill in the
5404 to fill in the MEM_ATTRs for this memory. */
5405 if (TREE_CODE (t_tramp) == ADDR_EXPR)
5406 set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5409 tmp = round_trampoline_addr (r_tramp);
5412 m_tramp = change_address (m_tramp, BLKmode, tmp);
5413 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5414 set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5417 /* The FUNC argument should be the address of the nested function.
5418 Extract the actual function decl to pass to the hook. */
5419 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5420 t_func = TREE_OPERAND (t_func, 0);
5421 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5423 r_chain = expand_normal (t_chain);
5425 /* Generate insns to initialize the trampoline. */
5426 targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5428 trampolines_created = 1;
5433 expand_builtin_adjust_trampoline (tree exp)
5437 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5440 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5441 tramp = round_trampoline_addr (tramp);
5442 if (targetm.calls.trampoline_adjust_address)
5443 tramp = targetm.calls.trampoline_adjust_address (tramp);
5448 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5449 function. The function first checks whether the back end provides
5450 an insn to implement signbit for the respective mode. If not, it
5451 checks whether the floating point format of the value is such that
5452 the sign bit can be extracted. If that is not the case, the
5453 function returns NULL_RTX to indicate that a normal call should be
5454 emitted rather than expanding the function in-line. EXP is the
5455 expression that is a call to the builtin function; if convenient,
5456 the result should be placed in TARGET. */
5458 expand_builtin_signbit (tree exp, rtx target)
5460 const struct real_format *fmt;
5461 enum machine_mode fmode, imode, rmode;
5462 HOST_WIDE_INT hi, lo;
5465 enum insn_code icode;
5467 location_t loc = EXPR_LOCATION (exp);
5469 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5472 arg = CALL_EXPR_ARG (exp, 0);
5473 fmode = TYPE_MODE (TREE_TYPE (arg));
5474 rmode = TYPE_MODE (TREE_TYPE (exp));
5475 fmt = REAL_MODE_FORMAT (fmode);
5477 arg = builtin_save_expr (arg);
5479 /* Expand the argument yielding a RTX expression. */
5480 temp = expand_normal (arg);
5482 /* Check if the back end provides an insn that handles signbit for the
5484 icode = signbit_optab->handlers [(int) fmode].insn_code;
5485 if (icode != CODE_FOR_nothing)
5487 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5488 emit_unop_insn (icode, target, temp, UNKNOWN);
5492 /* For floating point formats without a sign bit, implement signbit
5494 bitpos = fmt->signbit_ro;
5497 /* But we can't do this if the format supports signed zero. */
5498 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5501 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5502 build_real (TREE_TYPE (arg), dconst0));
5503 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5506 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5508 imode = int_mode_for_mode (fmode);
5509 if (imode == BLKmode)
5511 temp = gen_lowpart (imode, temp);
5516 /* Handle targets with different FP word orders. */
5517 if (FLOAT_WORDS_BIG_ENDIAN)
5518 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5520 word = bitpos / BITS_PER_WORD;
5521 temp = operand_subword_force (temp, word, fmode);
5522 bitpos = bitpos % BITS_PER_WORD;
5525 /* Force the intermediate word_mode (or narrower) result into a
5526 register. This avoids attempting to create paradoxical SUBREGs
5527 of floating point modes below. */
5528 temp = force_reg (imode, temp);
5530 /* If the bitpos is within the "result mode" lowpart, the operation
5531 can be implement with a single bitwise AND. Otherwise, we need
5532 a right shift and an AND. */
5534 if (bitpos < GET_MODE_BITSIZE (rmode))
5536 if (bitpos < HOST_BITS_PER_WIDE_INT)
5539 lo = (HOST_WIDE_INT) 1 << bitpos;
5543 hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5547 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5548 temp = gen_lowpart (rmode, temp);
5549 temp = expand_binop (rmode, and_optab, temp,
5550 immed_double_const (lo, hi, rmode),
5551 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5555 /* Perform a logical right shift to place the signbit in the least
5556 significant bit, then truncate the result to the desired mode
5557 and mask just this bit. */
5558 temp = expand_shift (RSHIFT_EXPR, imode, temp,
5559 build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5560 temp = gen_lowpart (rmode, temp);
5561 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5562 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5568 /* Expand fork or exec calls. TARGET is the desired target of the
5569 call. EXP is the call. FN is the
5570 identificator of the actual function. IGNORE is nonzero if the
5571 value is to be ignored. */
5574 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5579 /* If we are not profiling, just call the function. */
5580 if (!profile_arc_flag)
5583 /* Otherwise call the wrapper. This should be equivalent for the rest of
5584 compiler, so the code does not diverge, and the wrapper may run the
5585 code necessary for keeping the profiling sane. */
5587 switch (DECL_FUNCTION_CODE (fn))
5590 id = get_identifier ("__gcov_fork");
5593 case BUILT_IN_EXECL:
5594 id = get_identifier ("__gcov_execl");
5597 case BUILT_IN_EXECV:
5598 id = get_identifier ("__gcov_execv");
5601 case BUILT_IN_EXECLP:
5602 id = get_identifier ("__gcov_execlp");
5605 case BUILT_IN_EXECLE:
5606 id = get_identifier ("__gcov_execle");
5609 case BUILT_IN_EXECVP:
5610 id = get_identifier ("__gcov_execvp");
5613 case BUILT_IN_EXECVE:
5614 id = get_identifier ("__gcov_execve");
5621 decl = build_decl (DECL_SOURCE_LOCATION (fn),
5622 FUNCTION_DECL, id, TREE_TYPE (fn));
5623 DECL_EXTERNAL (decl) = 1;
5624 TREE_PUBLIC (decl) = 1;
5625 DECL_ARTIFICIAL (decl) = 1;
5626 TREE_NOTHROW (decl) = 1;
5627 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5628 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5629 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5630 return expand_call (call, target, ignore);
5635 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5636 the pointer in these functions is void*, the tree optimizers may remove
5637 casts. The mode computed in expand_builtin isn't reliable either, due
5638 to __sync_bool_compare_and_swap.
5640 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5641 group of builtins. This gives us log2 of the mode size. */
5643 static inline enum machine_mode
5644 get_builtin_sync_mode (int fcode_diff)
5646 /* The size is not negotiable, so ask not to get BLKmode in return
5647 if the target indicates that a smaller size would be better. */
5648 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5651 /* Expand the memory expression LOC and return the appropriate memory operand
5652 for the builtin_sync operations. */
5655 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5659 addr = expand_expr (loc, NULL_RTX, Pmode, EXPAND_SUM);
5661 /* Note that we explicitly do not want any alias information for this
5662 memory, so that we kill all other live memories. Otherwise we don't
5663 satisfy the full barrier semantics of the intrinsic. */
5664 mem = validize_mem (gen_rtx_MEM (mode, addr));
5666 set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
5667 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5668 MEM_VOLATILE_P (mem) = 1;
5673 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5674 EXP is the CALL_EXPR. CODE is the rtx code
5675 that corresponds to the arithmetic or logical operation from the name;
5676 an exception here is that NOT actually means NAND. TARGET is an optional
5677 place for us to store the results; AFTER is true if this is the
5678 fetch_and_xxx form. IGNORE is true if we don't actually care about
5679 the result of the operation at all. */
5682 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5683 enum rtx_code code, bool after,
5684 rtx target, bool ignore)
5687 enum machine_mode old_mode;
5688 location_t loc = EXPR_LOCATION (exp);
5690 if (code == NOT && warn_sync_nand)
5692 tree fndecl = get_callee_fndecl (exp);
5693 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5695 static bool warned_f_a_n, warned_n_a_f;
5699 case BUILT_IN_FETCH_AND_NAND_1:
5700 case BUILT_IN_FETCH_AND_NAND_2:
5701 case BUILT_IN_FETCH_AND_NAND_4:
5702 case BUILT_IN_FETCH_AND_NAND_8:
5703 case BUILT_IN_FETCH_AND_NAND_16:
5708 fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5709 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5710 warned_f_a_n = true;
5713 case BUILT_IN_NAND_AND_FETCH_1:
5714 case BUILT_IN_NAND_AND_FETCH_2:
5715 case BUILT_IN_NAND_AND_FETCH_4:
5716 case BUILT_IN_NAND_AND_FETCH_8:
5717 case BUILT_IN_NAND_AND_FETCH_16:
5722 fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5723 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5724 warned_n_a_f = true;
5732 /* Expand the operands. */
5733 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5735 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5736 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5737 of CONST_INTs, where we know the old_mode only from the call argument. */
5738 old_mode = GET_MODE (val);
5739 if (old_mode == VOIDmode)
5740 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5741 val = convert_modes (mode, old_mode, val, 1);
5744 return expand_sync_operation (mem, val, code);
5746 return expand_sync_fetch_operation (mem, val, code, after, target);
5749 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5750 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5751 true if this is the boolean form. TARGET is a place for us to store the
5752 results; this is NOT optional if IS_BOOL is true. */
5755 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5756 bool is_bool, rtx target)
5758 rtx old_val, new_val, mem;
5759 enum machine_mode old_mode;
5761 /* Expand the operands. */
5762 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5765 old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5766 mode, EXPAND_NORMAL);
5767 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5768 of CONST_INTs, where we know the old_mode only from the call argument. */
5769 old_mode = GET_MODE (old_val);
5770 if (old_mode == VOIDmode)
5771 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5772 old_val = convert_modes (mode, old_mode, old_val, 1);
5774 new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5775 mode, EXPAND_NORMAL);
5776 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5777 of CONST_INTs, where we know the old_mode only from the call argument. */
5778 old_mode = GET_MODE (new_val);
5779 if (old_mode == VOIDmode)
5780 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5781 new_val = convert_modes (mode, old_mode, new_val, 1);
5784 return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5786 return expand_val_compare_and_swap (mem, old_val, new_val, target);
5789 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5790 general form is actually an atomic exchange, and some targets only
5791 support a reduced form with the second argument being a constant 1.
5792 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5796 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5800 enum machine_mode old_mode;
5802 /* Expand the operands. */
5803 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5804 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5805 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5806 of CONST_INTs, where we know the old_mode only from the call argument. */
5807 old_mode = GET_MODE (val);
5808 if (old_mode == VOIDmode)
5809 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5810 val = convert_modes (mode, old_mode, val, 1);
5812 return expand_sync_lock_test_and_set (mem, val, target);
5815 /* Expand the __sync_synchronize intrinsic. */
5818 expand_builtin_synchronize (void)
5821 VEC (tree, gc) *v_clobbers;
5823 #ifdef HAVE_memory_barrier
5824 if (HAVE_memory_barrier)
5826 emit_insn (gen_memory_barrier ());
5831 if (synchronize_libfunc != NULL_RTX)
5833 emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5837 /* If no explicit memory barrier instruction is available, create an
5838 empty asm stmt with a memory clobber. */
5839 v_clobbers = VEC_alloc (tree, gc, 1);
5840 VEC_quick_push (tree, v_clobbers,
5841 tree_cons (NULL, build_string (6, "memory"), NULL));
5842 x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5843 gimple_asm_set_volatile (x, true);
5844 expand_asm_stmt (x);
5847 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5850 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5852 enum insn_code icode;
5854 rtx val = const0_rtx;
5856 /* Expand the operands. */
5857 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5859 /* If there is an explicit operation in the md file, use it. */
5860 icode = sync_lock_release[mode];
5861 if (icode != CODE_FOR_nothing)
5863 if (!insn_data[icode].operand[1].predicate (val, mode))
5864 val = force_reg (mode, val);
5866 insn = GEN_FCN (icode) (mem, val);
5874 /* Otherwise we can implement this operation by emitting a barrier
5875 followed by a store of zero. */
5876 expand_builtin_synchronize ();
5877 emit_move_insn (mem, val);
5880 /* Expand an expression EXP that calls a built-in function,
5881 with result going to TARGET if that's convenient
5882 (and in mode MODE if that's convenient).
5883 SUBTARGET may be used as the target for computing one of EXP's operands.
5884 IGNORE is nonzero if the value is to be ignored. */
5887 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5890 tree fndecl = get_callee_fndecl (exp);
5891 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5892 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5894 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5895 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5897 /* When not optimizing, generate calls to library functions for a certain
5900 && !called_as_built_in (fndecl)
5901 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5902 && fcode != BUILT_IN_ALLOCA
5903 && fcode != BUILT_IN_FREE)
5904 return expand_call (exp, target, ignore);
5906 /* The built-in function expanders test for target == const0_rtx
5907 to determine whether the function's result will be ignored. */
5909 target = const0_rtx;
5911 /* If the result of a pure or const built-in function is ignored, and
5912 none of its arguments are volatile, we can avoid expanding the
5913 built-in call and just evaluate the arguments for side-effects. */
5914 if (target == const0_rtx
5915 && (DECL_PURE_P (fndecl) || TREE_READONLY (fndecl)))
5917 bool volatilep = false;
5919 call_expr_arg_iterator iter;
5921 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5922 if (TREE_THIS_VOLATILE (arg))
5930 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5931 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5938 CASE_FLT_FN (BUILT_IN_FABS):
5939 target = expand_builtin_fabs (exp, target, subtarget);
5944 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5945 target = expand_builtin_copysign (exp, target, subtarget);
5950 /* Just do a normal library call if we were unable to fold
5952 CASE_FLT_FN (BUILT_IN_CABS):
5955 CASE_FLT_FN (BUILT_IN_EXP):
5956 CASE_FLT_FN (BUILT_IN_EXP10):
5957 CASE_FLT_FN (BUILT_IN_POW10):
5958 CASE_FLT_FN (BUILT_IN_EXP2):
5959 CASE_FLT_FN (BUILT_IN_EXPM1):
5960 CASE_FLT_FN (BUILT_IN_LOGB):
5961 CASE_FLT_FN (BUILT_IN_LOG):
5962 CASE_FLT_FN (BUILT_IN_LOG10):
5963 CASE_FLT_FN (BUILT_IN_LOG2):
5964 CASE_FLT_FN (BUILT_IN_LOG1P):
5965 CASE_FLT_FN (BUILT_IN_TAN):
5966 CASE_FLT_FN (BUILT_IN_ASIN):
5967 CASE_FLT_FN (BUILT_IN_ACOS):
5968 CASE_FLT_FN (BUILT_IN_ATAN):
5969 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5970 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5971 because of possible accuracy problems. */
5972 if (! flag_unsafe_math_optimizations)
5974 CASE_FLT_FN (BUILT_IN_SQRT):
5975 CASE_FLT_FN (BUILT_IN_FLOOR):
5976 CASE_FLT_FN (BUILT_IN_CEIL):
5977 CASE_FLT_FN (BUILT_IN_TRUNC):
5978 CASE_FLT_FN (BUILT_IN_ROUND):
5979 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5980 CASE_FLT_FN (BUILT_IN_RINT):
5981 target = expand_builtin_mathfn (exp, target, subtarget);
5986 CASE_FLT_FN (BUILT_IN_ILOGB):
5987 if (! flag_unsafe_math_optimizations)
5989 CASE_FLT_FN (BUILT_IN_ISINF):
5990 CASE_FLT_FN (BUILT_IN_FINITE):
5991 case BUILT_IN_ISFINITE:
5992 case BUILT_IN_ISNORMAL:
5993 target = expand_builtin_interclass_mathfn (exp, target, subtarget);
5998 CASE_FLT_FN (BUILT_IN_LCEIL):
5999 CASE_FLT_FN (BUILT_IN_LLCEIL):
6000 CASE_FLT_FN (BUILT_IN_LFLOOR):
6001 CASE_FLT_FN (BUILT_IN_LLFLOOR):
6002 target = expand_builtin_int_roundingfn (exp, target);
6007 CASE_FLT_FN (BUILT_IN_LRINT):
6008 CASE_FLT_FN (BUILT_IN_LLRINT):
6009 CASE_FLT_FN (BUILT_IN_LROUND):
6010 CASE_FLT_FN (BUILT_IN_LLROUND):
6011 target = expand_builtin_int_roundingfn_2 (exp, target);
6016 CASE_FLT_FN (BUILT_IN_POW):
6017 target = expand_builtin_pow (exp, target, subtarget);
6022 CASE_FLT_FN (BUILT_IN_POWI):
6023 target = expand_builtin_powi (exp, target, subtarget);
6028 CASE_FLT_FN (BUILT_IN_ATAN2):
6029 CASE_FLT_FN (BUILT_IN_LDEXP):
6030 CASE_FLT_FN (BUILT_IN_SCALB):
6031 CASE_FLT_FN (BUILT_IN_SCALBN):
6032 CASE_FLT_FN (BUILT_IN_SCALBLN):
6033 if (! flag_unsafe_math_optimizations)
6036 CASE_FLT_FN (BUILT_IN_FMOD):
6037 CASE_FLT_FN (BUILT_IN_REMAINDER):
6038 CASE_FLT_FN (BUILT_IN_DREM):
6039 target = expand_builtin_mathfn_2 (exp, target, subtarget);
6044 CASE_FLT_FN (BUILT_IN_CEXPI):
6045 target = expand_builtin_cexpi (exp, target, subtarget);
6046 gcc_assert (target);
6049 CASE_FLT_FN (BUILT_IN_SIN):
6050 CASE_FLT_FN (BUILT_IN_COS):
6051 if (! flag_unsafe_math_optimizations)
6053 target = expand_builtin_mathfn_3 (exp, target, subtarget);
6058 CASE_FLT_FN (BUILT_IN_SINCOS):
6059 if (! flag_unsafe_math_optimizations)
6061 target = expand_builtin_sincos (exp);
6066 case BUILT_IN_APPLY_ARGS:
6067 return expand_builtin_apply_args ();
6069 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6070 FUNCTION with a copy of the parameters described by
6071 ARGUMENTS, and ARGSIZE. It returns a block of memory
6072 allocated on the stack into which is stored all the registers
6073 that might possibly be used for returning the result of a
6074 function. ARGUMENTS is the value returned by
6075 __builtin_apply_args. ARGSIZE is the number of bytes of
6076 arguments that must be copied. ??? How should this value be
6077 computed? We'll also need a safe worst case value for varargs
6079 case BUILT_IN_APPLY:
6080 if (!validate_arglist (exp, POINTER_TYPE,
6081 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
6082 && !validate_arglist (exp, REFERENCE_TYPE,
6083 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6089 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6090 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6091 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6093 return expand_builtin_apply (ops[0], ops[1], ops[2]);
6096 /* __builtin_return (RESULT) causes the function to return the
6097 value described by RESULT. RESULT is address of the block of
6098 memory returned by __builtin_apply. */
6099 case BUILT_IN_RETURN:
6100 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6101 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6104 case BUILT_IN_SAVEREGS:
6105 return expand_builtin_saveregs ();
6107 case BUILT_IN_ARGS_INFO:
6108 return expand_builtin_args_info (exp);
6110 case BUILT_IN_VA_ARG_PACK:
6111 /* All valid uses of __builtin_va_arg_pack () are removed during
6113 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
6116 case BUILT_IN_VA_ARG_PACK_LEN:
6117 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6119 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
6122 /* Return the address of the first anonymous stack arg. */
6123 case BUILT_IN_NEXT_ARG:
6124 if (fold_builtin_next_arg (exp, false))
6126 return expand_builtin_next_arg ();
6128 case BUILT_IN_CLEAR_CACHE:
6129 target = expand_builtin___clear_cache (exp);
6134 case BUILT_IN_CLASSIFY_TYPE:
6135 return expand_builtin_classify_type (exp);
6137 case BUILT_IN_CONSTANT_P:
6140 case BUILT_IN_FRAME_ADDRESS:
6141 case BUILT_IN_RETURN_ADDRESS:
6142 return expand_builtin_frame_address (fndecl, exp);
6144 /* Returns the address of the area where the structure is returned.
6146 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6147 if (call_expr_nargs (exp) != 0
6148 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6149 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6152 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6154 case BUILT_IN_ALLOCA:
6155 target = expand_builtin_alloca (exp, target);
6160 case BUILT_IN_STACK_SAVE:
6161 return expand_stack_save ();
6163 case BUILT_IN_STACK_RESTORE:
6164 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6167 case BUILT_IN_BSWAP32:
6168 case BUILT_IN_BSWAP64:
6169 target = expand_builtin_bswap (exp, target, subtarget);
6175 CASE_INT_FN (BUILT_IN_FFS):
6176 case BUILT_IN_FFSIMAX:
6177 target = expand_builtin_unop (target_mode, exp, target,
6178 subtarget, ffs_optab);
6183 CASE_INT_FN (BUILT_IN_CLZ):
6184 case BUILT_IN_CLZIMAX:
6185 target = expand_builtin_unop (target_mode, exp, target,
6186 subtarget, clz_optab);
6191 CASE_INT_FN (BUILT_IN_CTZ):
6192 case BUILT_IN_CTZIMAX:
6193 target = expand_builtin_unop (target_mode, exp, target,
6194 subtarget, ctz_optab);
6199 CASE_INT_FN (BUILT_IN_POPCOUNT):
6200 case BUILT_IN_POPCOUNTIMAX:
6201 target = expand_builtin_unop (target_mode, exp, target,
6202 subtarget, popcount_optab);
6207 CASE_INT_FN (BUILT_IN_PARITY):
6208 case BUILT_IN_PARITYIMAX:
6209 target = expand_builtin_unop (target_mode, exp, target,
6210 subtarget, parity_optab);
6215 case BUILT_IN_STRLEN:
6216 target = expand_builtin_strlen (exp, target, target_mode);
6221 case BUILT_IN_STRCPY:
6222 target = expand_builtin_strcpy (exp, target);
6227 case BUILT_IN_STRNCPY:
6228 target = expand_builtin_strncpy (exp, target);
6233 case BUILT_IN_STPCPY:
6234 target = expand_builtin_stpcpy (exp, target, mode);
6239 case BUILT_IN_MEMCPY:
6240 target = expand_builtin_memcpy (exp, target);
6245 case BUILT_IN_MEMPCPY:
6246 target = expand_builtin_mempcpy (exp, target, mode);
6251 case BUILT_IN_MEMSET:
6252 target = expand_builtin_memset (exp, target, mode);
6257 case BUILT_IN_BZERO:
6258 target = expand_builtin_bzero (exp);
6263 case BUILT_IN_STRCMP:
6264 target = expand_builtin_strcmp (exp, target);
6269 case BUILT_IN_STRNCMP:
6270 target = expand_builtin_strncmp (exp, target, mode);
6276 case BUILT_IN_MEMCMP:
6277 target = expand_builtin_memcmp (exp, target, mode);
6282 case BUILT_IN_SETJMP:
6283 /* This should have been lowered to the builtins below. */
6286 case BUILT_IN_SETJMP_SETUP:
6287 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6288 and the receiver label. */
6289 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6291 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6292 VOIDmode, EXPAND_NORMAL);
6293 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6294 rtx label_r = label_rtx (label);
6296 /* This is copied from the handling of non-local gotos. */
6297 expand_builtin_setjmp_setup (buf_addr, label_r);
6298 nonlocal_goto_handler_labels
6299 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6300 nonlocal_goto_handler_labels);
6301 /* ??? Do not let expand_label treat us as such since we would
6302 not want to be both on the list of non-local labels and on
6303 the list of forced labels. */
6304 FORCED_LABEL (label) = 0;
6309 case BUILT_IN_SETJMP_DISPATCHER:
6310 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6311 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6313 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6314 rtx label_r = label_rtx (label);
6316 /* Remove the dispatcher label from the list of non-local labels
6317 since the receiver labels have been added to it above. */
6318 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6323 case BUILT_IN_SETJMP_RECEIVER:
6324 /* __builtin_setjmp_receiver is passed the receiver label. */
6325 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6327 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6328 rtx label_r = label_rtx (label);
6330 expand_builtin_setjmp_receiver (label_r);
6335 /* __builtin_longjmp is passed a pointer to an array of five words.
6336 It's similar to the C library longjmp function but works with
6337 __builtin_setjmp above. */
6338 case BUILT_IN_LONGJMP:
6339 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6341 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6342 VOIDmode, EXPAND_NORMAL);
6343 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6345 if (value != const1_rtx)
6347 error ("%<__builtin_longjmp%> second argument must be 1");
6351 expand_builtin_longjmp (buf_addr, value);
6356 case BUILT_IN_NONLOCAL_GOTO:
6357 target = expand_builtin_nonlocal_goto (exp);
6362 /* This updates the setjmp buffer that is its argument with the value
6363 of the current stack pointer. */
6364 case BUILT_IN_UPDATE_SETJMP_BUF:
6365 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6368 = expand_normal (CALL_EXPR_ARG (exp, 0));
6370 expand_builtin_update_setjmp_buf (buf_addr);
6376 expand_builtin_trap ();
6379 case BUILT_IN_UNREACHABLE:
6380 expand_builtin_unreachable ();
6383 case BUILT_IN_PRINTF:
6384 target = expand_builtin_printf (exp, target, mode, false);
6389 case BUILT_IN_PRINTF_UNLOCKED:
6390 target = expand_builtin_printf (exp, target, mode, true);
6395 case BUILT_IN_FPRINTF:
6396 target = expand_builtin_fprintf (exp, target, mode, false);
6401 case BUILT_IN_FPRINTF_UNLOCKED:
6402 target = expand_builtin_fprintf (exp, target, mode, true);
6407 case BUILT_IN_SPRINTF:
6408 target = expand_builtin_sprintf (exp, target, mode);
6413 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6414 case BUILT_IN_SIGNBITD32:
6415 case BUILT_IN_SIGNBITD64:
6416 case BUILT_IN_SIGNBITD128:
6417 target = expand_builtin_signbit (exp, target);
6422 /* Various hooks for the DWARF 2 __throw routine. */
6423 case BUILT_IN_UNWIND_INIT:
6424 expand_builtin_unwind_init ();
6426 case BUILT_IN_DWARF_CFA:
6427 return virtual_cfa_rtx;
6428 #ifdef DWARF2_UNWIND_INFO
6429 case BUILT_IN_DWARF_SP_COLUMN:
6430 return expand_builtin_dwarf_sp_column ();
6431 case BUILT_IN_INIT_DWARF_REG_SIZES:
6432 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6435 case BUILT_IN_FROB_RETURN_ADDR:
6436 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6437 case BUILT_IN_EXTRACT_RETURN_ADDR:
6438 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6439 case BUILT_IN_EH_RETURN:
6440 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6441 CALL_EXPR_ARG (exp, 1));
6443 #ifdef EH_RETURN_DATA_REGNO
6444 case BUILT_IN_EH_RETURN_DATA_REGNO:
6445 return expand_builtin_eh_return_data_regno (exp);
6447 case BUILT_IN_EXTEND_POINTER:
6448 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6449 case BUILT_IN_EH_POINTER:
6450 return expand_builtin_eh_pointer (exp);
6451 case BUILT_IN_EH_FILTER:
6452 return expand_builtin_eh_filter (exp);
6453 case BUILT_IN_EH_COPY_VALUES:
6454 return expand_builtin_eh_copy_values (exp);
6456 case BUILT_IN_VA_START:
6457 return expand_builtin_va_start (exp);
6458 case BUILT_IN_VA_END:
6459 return expand_builtin_va_end (exp);
6460 case BUILT_IN_VA_COPY:
6461 return expand_builtin_va_copy (exp);
6462 case BUILT_IN_EXPECT:
6463 return expand_builtin_expect (exp, target);
6464 case BUILT_IN_PREFETCH:
6465 expand_builtin_prefetch (exp);
6468 case BUILT_IN_PROFILE_FUNC_ENTER:
6469 return expand_builtin_profile_func (false);
6470 case BUILT_IN_PROFILE_FUNC_EXIT:
6471 return expand_builtin_profile_func (true);
6473 case BUILT_IN_INIT_TRAMPOLINE:
6474 return expand_builtin_init_trampoline (exp);
6475 case BUILT_IN_ADJUST_TRAMPOLINE:
6476 return expand_builtin_adjust_trampoline (exp);
6479 case BUILT_IN_EXECL:
6480 case BUILT_IN_EXECV:
6481 case BUILT_IN_EXECLP:
6482 case BUILT_IN_EXECLE:
6483 case BUILT_IN_EXECVP:
6484 case BUILT_IN_EXECVE:
6485 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6490 case BUILT_IN_FETCH_AND_ADD_1:
6491 case BUILT_IN_FETCH_AND_ADD_2:
6492 case BUILT_IN_FETCH_AND_ADD_4:
6493 case BUILT_IN_FETCH_AND_ADD_8:
6494 case BUILT_IN_FETCH_AND_ADD_16:
6495 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6496 target = expand_builtin_sync_operation (mode, exp, PLUS,
6497 false, target, ignore);
6502 case BUILT_IN_FETCH_AND_SUB_1:
6503 case BUILT_IN_FETCH_AND_SUB_2:
6504 case BUILT_IN_FETCH_AND_SUB_4:
6505 case BUILT_IN_FETCH_AND_SUB_8:
6506 case BUILT_IN_FETCH_AND_SUB_16:
6507 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6508 target = expand_builtin_sync_operation (mode, exp, MINUS,
6509 false, target, ignore);
6514 case BUILT_IN_FETCH_AND_OR_1:
6515 case BUILT_IN_FETCH_AND_OR_2:
6516 case BUILT_IN_FETCH_AND_OR_4:
6517 case BUILT_IN_FETCH_AND_OR_8:
6518 case BUILT_IN_FETCH_AND_OR_16:
6519 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6520 target = expand_builtin_sync_operation (mode, exp, IOR,
6521 false, target, ignore);
6526 case BUILT_IN_FETCH_AND_AND_1:
6527 case BUILT_IN_FETCH_AND_AND_2:
6528 case BUILT_IN_FETCH_AND_AND_4:
6529 case BUILT_IN_FETCH_AND_AND_8:
6530 case BUILT_IN_FETCH_AND_AND_16:
6531 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6532 target = expand_builtin_sync_operation (mode, exp, AND,
6533 false, target, ignore);
6538 case BUILT_IN_FETCH_AND_XOR_1:
6539 case BUILT_IN_FETCH_AND_XOR_2:
6540 case BUILT_IN_FETCH_AND_XOR_4:
6541 case BUILT_IN_FETCH_AND_XOR_8:
6542 case BUILT_IN_FETCH_AND_XOR_16:
6543 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6544 target = expand_builtin_sync_operation (mode, exp, XOR,
6545 false, target, ignore);
6550 case BUILT_IN_FETCH_AND_NAND_1:
6551 case BUILT_IN_FETCH_AND_NAND_2:
6552 case BUILT_IN_FETCH_AND_NAND_4:
6553 case BUILT_IN_FETCH_AND_NAND_8:
6554 case BUILT_IN_FETCH_AND_NAND_16:
6555 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6556 target = expand_builtin_sync_operation (mode, exp, NOT,
6557 false, target, ignore);
6562 case BUILT_IN_ADD_AND_FETCH_1:
6563 case BUILT_IN_ADD_AND_FETCH_2:
6564 case BUILT_IN_ADD_AND_FETCH_4:
6565 case BUILT_IN_ADD_AND_FETCH_8:
6566 case BUILT_IN_ADD_AND_FETCH_16:
6567 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6568 target = expand_builtin_sync_operation (mode, exp, PLUS,
6569 true, target, ignore);
6574 case BUILT_IN_SUB_AND_FETCH_1:
6575 case BUILT_IN_SUB_AND_FETCH_2:
6576 case BUILT_IN_SUB_AND_FETCH_4:
6577 case BUILT_IN_SUB_AND_FETCH_8:
6578 case BUILT_IN_SUB_AND_FETCH_16:
6579 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6580 target = expand_builtin_sync_operation (mode, exp, MINUS,
6581 true, target, ignore);
6586 case BUILT_IN_OR_AND_FETCH_1:
6587 case BUILT_IN_OR_AND_FETCH_2:
6588 case BUILT_IN_OR_AND_FETCH_4:
6589 case BUILT_IN_OR_AND_FETCH_8:
6590 case BUILT_IN_OR_AND_FETCH_16:
6591 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6592 target = expand_builtin_sync_operation (mode, exp, IOR,
6593 true, target, ignore);
6598 case BUILT_IN_AND_AND_FETCH_1:
6599 case BUILT_IN_AND_AND_FETCH_2:
6600 case BUILT_IN_AND_AND_FETCH_4:
6601 case BUILT_IN_AND_AND_FETCH_8:
6602 case BUILT_IN_AND_AND_FETCH_16:
6603 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6604 target = expand_builtin_sync_operation (mode, exp, AND,
6605 true, target, ignore);
6610 case BUILT_IN_XOR_AND_FETCH_1:
6611 case BUILT_IN_XOR_AND_FETCH_2:
6612 case BUILT_IN_XOR_AND_FETCH_4:
6613 case BUILT_IN_XOR_AND_FETCH_8:
6614 case BUILT_IN_XOR_AND_FETCH_16:
6615 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6616 target = expand_builtin_sync_operation (mode, exp, XOR,
6617 true, target, ignore);
6622 case BUILT_IN_NAND_AND_FETCH_1:
6623 case BUILT_IN_NAND_AND_FETCH_2:
6624 case BUILT_IN_NAND_AND_FETCH_4:
6625 case BUILT_IN_NAND_AND_FETCH_8:
6626 case BUILT_IN_NAND_AND_FETCH_16:
6627 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6628 target = expand_builtin_sync_operation (mode, exp, NOT,
6629 true, target, ignore);
6634 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6635 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6636 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6637 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6638 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6639 if (mode == VOIDmode)
6640 mode = TYPE_MODE (boolean_type_node);
6641 if (!target || !register_operand (target, mode))
6642 target = gen_reg_rtx (mode);
6644 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6645 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6650 case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6651 case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6652 case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6653 case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6654 case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6655 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6656 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6661 case BUILT_IN_LOCK_TEST_AND_SET_1:
6662 case BUILT_IN_LOCK_TEST_AND_SET_2:
6663 case BUILT_IN_LOCK_TEST_AND_SET_4:
6664 case BUILT_IN_LOCK_TEST_AND_SET_8:
6665 case BUILT_IN_LOCK_TEST_AND_SET_16:
6666 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6667 target = expand_builtin_lock_test_and_set (mode, exp, target);
6672 case BUILT_IN_LOCK_RELEASE_1:
6673 case BUILT_IN_LOCK_RELEASE_2:
6674 case BUILT_IN_LOCK_RELEASE_4:
6675 case BUILT_IN_LOCK_RELEASE_8:
6676 case BUILT_IN_LOCK_RELEASE_16:
6677 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6678 expand_builtin_lock_release (mode, exp);
6681 case BUILT_IN_SYNCHRONIZE:
6682 expand_builtin_synchronize ();
6685 case BUILT_IN_OBJECT_SIZE:
6686 return expand_builtin_object_size (exp);
6688 case BUILT_IN_MEMCPY_CHK:
6689 case BUILT_IN_MEMPCPY_CHK:
6690 case BUILT_IN_MEMMOVE_CHK:
6691 case BUILT_IN_MEMSET_CHK:
6692 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6697 case BUILT_IN_STRCPY_CHK:
6698 case BUILT_IN_STPCPY_CHK:
6699 case BUILT_IN_STRNCPY_CHK:
6700 case BUILT_IN_STRCAT_CHK:
6701 case BUILT_IN_STRNCAT_CHK:
6702 case BUILT_IN_SNPRINTF_CHK:
6703 case BUILT_IN_VSNPRINTF_CHK:
6704 maybe_emit_chk_warning (exp, fcode);
6707 case BUILT_IN_SPRINTF_CHK:
6708 case BUILT_IN_VSPRINTF_CHK:
6709 maybe_emit_sprintf_chk_warning (exp, fcode);
6713 maybe_emit_free_warning (exp);
6716 default: /* just do library call, if unknown builtin */
6720 /* The switch statement above can drop through to cause the function
6721 to be called normally. */
6722 return expand_call (exp, target, ignore);
6725 /* Determine whether a tree node represents a call to a built-in
6726 function. If the tree T is a call to a built-in function with
6727 the right number of arguments of the appropriate types, return
6728 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6729 Otherwise the return value is END_BUILTINS. */
6731 enum built_in_function
6732 builtin_mathfn_code (const_tree t)
6734 const_tree fndecl, arg, parmlist;
6735 const_tree argtype, parmtype;
6736 const_call_expr_arg_iterator iter;
6738 if (TREE_CODE (t) != CALL_EXPR
6739 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6740 return END_BUILTINS;
6742 fndecl = get_callee_fndecl (t);
6743 if (fndecl == NULL_TREE
6744 || TREE_CODE (fndecl) != FUNCTION_DECL
6745 || ! DECL_BUILT_IN (fndecl)
6746 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6747 return END_BUILTINS;
6749 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6750 init_const_call_expr_arg_iterator (t, &iter);
6751 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6753 /* If a function doesn't take a variable number of arguments,
6754 the last element in the list will have type `void'. */
6755 parmtype = TREE_VALUE (parmlist);
6756 if (VOID_TYPE_P (parmtype))
6758 if (more_const_call_expr_args_p (&iter))
6759 return END_BUILTINS;
6760 return DECL_FUNCTION_CODE (fndecl);
6763 if (! more_const_call_expr_args_p (&iter))
6764 return END_BUILTINS;
6766 arg = next_const_call_expr_arg (&iter);
6767 argtype = TREE_TYPE (arg);
6769 if (SCALAR_FLOAT_TYPE_P (parmtype))
6771 if (! SCALAR_FLOAT_TYPE_P (argtype))
6772 return END_BUILTINS;
6774 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6776 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6777 return END_BUILTINS;
6779 else if (POINTER_TYPE_P (parmtype))
6781 if (! POINTER_TYPE_P (argtype))
6782 return END_BUILTINS;
6784 else if (INTEGRAL_TYPE_P (parmtype))
6786 if (! INTEGRAL_TYPE_P (argtype))
6787 return END_BUILTINS;
6790 return END_BUILTINS;
6793 /* Variable-length argument list. */
6794 return DECL_FUNCTION_CODE (fndecl);
6797 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6798 evaluate to a constant. */
6801 fold_builtin_constant_p (tree arg)
6803 /* We return 1 for a numeric type that's known to be a constant
6804 value at compile-time or for an aggregate type that's a
6805 literal constant. */
6808 /* If we know this is a constant, emit the constant of one. */
6809 if (CONSTANT_CLASS_P (arg)
6810 || (TREE_CODE (arg) == CONSTRUCTOR
6811 && TREE_CONSTANT (arg)))
6812 return integer_one_node;
6813 if (TREE_CODE (arg) == ADDR_EXPR)
6815 tree op = TREE_OPERAND (arg, 0);
6816 if (TREE_CODE (op) == STRING_CST
6817 || (TREE_CODE (op) == ARRAY_REF
6818 && integer_zerop (TREE_OPERAND (op, 1))
6819 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6820 return integer_one_node;
6823 /* If this expression has side effects, show we don't know it to be a
6824 constant. Likewise if it's a pointer or aggregate type since in
6825 those case we only want literals, since those are only optimized
6826 when generating RTL, not later.
6827 And finally, if we are compiling an initializer, not code, we
6828 need to return a definite result now; there's not going to be any
6829 more optimization done. */
6830 if (TREE_SIDE_EFFECTS (arg)
6831 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6832 || POINTER_TYPE_P (TREE_TYPE (arg))
6834 || folding_initializer)
6835 return integer_zero_node;
6840 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6841 return it as a truthvalue. */
6844 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6846 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6848 fn = built_in_decls[BUILT_IN_EXPECT];
6849 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6850 ret_type = TREE_TYPE (TREE_TYPE (fn));
6851 pred_type = TREE_VALUE (arg_types);
6852 expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6854 pred = fold_convert_loc (loc, pred_type, pred);
6855 expected = fold_convert_loc (loc, expected_type, expected);
6856 call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6858 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6859 build_int_cst (ret_type, 0));
6862 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6863 NULL_TREE if no simplification is possible. */
6866 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6869 enum tree_code code;
6871 /* If this is a builtin_expect within a builtin_expect keep the
6872 inner one. See through a comparison against a constant. It
6873 might have been added to create a thruthvalue. */
6875 if (COMPARISON_CLASS_P (inner)
6876 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6877 inner = TREE_OPERAND (inner, 0);
6879 if (TREE_CODE (inner) == CALL_EXPR
6880 && (fndecl = get_callee_fndecl (inner))
6881 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6882 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6885 /* Distribute the expected value over short-circuiting operators.
6886 See through the cast from truthvalue_type_node to long. */
6888 while (TREE_CODE (inner) == NOP_EXPR
6889 && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6890 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6891 inner = TREE_OPERAND (inner, 0);
6893 code = TREE_CODE (inner);
6894 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6896 tree op0 = TREE_OPERAND (inner, 0);
6897 tree op1 = TREE_OPERAND (inner, 1);
6899 op0 = build_builtin_expect_predicate (loc, op0, arg1);
6900 op1 = build_builtin_expect_predicate (loc, op1, arg1);
6901 inner = build2 (code, TREE_TYPE (inner), op0, op1);
6903 return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6906 /* If the argument isn't invariant then there's nothing else we can do. */
6907 if (!TREE_CONSTANT (arg0))
6910 /* If we expect that a comparison against the argument will fold to
6911 a constant return the constant. In practice, this means a true
6912 constant or the address of a non-weak symbol. */
6915 if (TREE_CODE (inner) == ADDR_EXPR)
6919 inner = TREE_OPERAND (inner, 0);
6921 while (TREE_CODE (inner) == COMPONENT_REF
6922 || TREE_CODE (inner) == ARRAY_REF);
6923 if ((TREE_CODE (inner) == VAR_DECL
6924 || TREE_CODE (inner) == FUNCTION_DECL)
6925 && DECL_WEAK (inner))
6929 /* Otherwise, ARG0 already has the proper type for the return value. */
6933 /* Fold a call to __builtin_classify_type with argument ARG. */
6936 fold_builtin_classify_type (tree arg)
6939 return build_int_cst (NULL_TREE, no_type_class);
6941 return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6944 /* Fold a call to __builtin_strlen with argument ARG. */
6947 fold_builtin_strlen (location_t loc, tree arg)
6949 if (!validate_arg (arg, POINTER_TYPE))
6953 tree len = c_strlen (arg, 0);
6957 /* Convert from the internal "sizetype" type to "size_t". */
6959 len = fold_convert_loc (loc, size_type_node, len);
6967 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6970 fold_builtin_inf (location_t loc, tree type, int warn)
6972 REAL_VALUE_TYPE real;
6974 /* __builtin_inff is intended to be usable to define INFINITY on all
6975 targets. If an infinity is not available, INFINITY expands "to a
6976 positive constant of type float that overflows at translation
6977 time", footnote "In this case, using INFINITY will violate the
6978 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6979 Thus we pedwarn to ensure this constraint violation is
6981 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6982 pedwarn (loc, 0, "target format does not support infinity");
6985 return build_real (type, real);
6988 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
6991 fold_builtin_nan (tree arg, tree type, int quiet)
6993 REAL_VALUE_TYPE real;
6996 if (!validate_arg (arg, POINTER_TYPE))
6998 str = c_getstr (arg);
7002 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
7005 return build_real (type, real);
7008 /* Return true if the floating point expression T has an integer value.
7009 We also allow +Inf, -Inf and NaN to be considered integer values. */
7012 integer_valued_real_p (tree t)
7014 switch (TREE_CODE (t))
7021 return integer_valued_real_p (TREE_OPERAND (t, 0));
7026 return integer_valued_real_p (TREE_OPERAND (t, 1));
7033 return integer_valued_real_p (TREE_OPERAND (t, 0))
7034 && integer_valued_real_p (TREE_OPERAND (t, 1));
7037 return integer_valued_real_p (TREE_OPERAND (t, 1))
7038 && integer_valued_real_p (TREE_OPERAND (t, 2));
7041 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7045 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7046 if (TREE_CODE (type) == INTEGER_TYPE)
7048 if (TREE_CODE (type) == REAL_TYPE)
7049 return integer_valued_real_p (TREE_OPERAND (t, 0));
7054 switch (builtin_mathfn_code (t))
7056 CASE_FLT_FN (BUILT_IN_CEIL):
7057 CASE_FLT_FN (BUILT_IN_FLOOR):
7058 CASE_FLT_FN (BUILT_IN_NEARBYINT):
7059 CASE_FLT_FN (BUILT_IN_RINT):
7060 CASE_FLT_FN (BUILT_IN_ROUND):
7061 CASE_FLT_FN (BUILT_IN_TRUNC):
7064 CASE_FLT_FN (BUILT_IN_FMIN):
7065 CASE_FLT_FN (BUILT_IN_FMAX):
7066 return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7067 && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7080 /* FNDECL is assumed to be a builtin where truncation can be propagated
7081 across (for instance floor((double)f) == (double)floorf (f).
7082 Do the transformation for a call with argument ARG. */
7085 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
7087 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7089 if (!validate_arg (arg, REAL_TYPE))
7092 /* Integer rounding functions are idempotent. */
7093 if (fcode == builtin_mathfn_code (arg))
7096 /* If argument is already integer valued, and we don't need to worry
7097 about setting errno, there's no need to perform rounding. */
7098 if (! flag_errno_math && integer_valued_real_p (arg))
7103 tree arg0 = strip_float_extensions (arg);
7104 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7105 tree newtype = TREE_TYPE (arg0);
7108 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7109 && (decl = mathfn_built_in (newtype, fcode)))
7110 return fold_convert_loc (loc, ftype,
7111 build_call_expr_loc (loc, decl, 1,
7112 fold_convert_loc (loc,
7119 /* FNDECL is assumed to be builtin which can narrow the FP type of
7120 the argument, for instance lround((double)f) -> lroundf (f).
7121 Do the transformation for a call with argument ARG. */
7124 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
7126 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7128 if (!validate_arg (arg, REAL_TYPE))
7131 /* If argument is already integer valued, and we don't need to worry
7132 about setting errno, there's no need to perform rounding. */
7133 if (! flag_errno_math && integer_valued_real_p (arg))
7134 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7135 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7139 tree ftype = TREE_TYPE (arg);
7140 tree arg0 = strip_float_extensions (arg);
7141 tree newtype = TREE_TYPE (arg0);
7144 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7145 && (decl = mathfn_built_in (newtype, fcode)))
7146 return build_call_expr_loc (loc, decl, 1,
7147 fold_convert_loc (loc, newtype, arg0));
7150 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7151 sizeof (long long) == sizeof (long). */
7152 if (TYPE_PRECISION (long_long_integer_type_node)
7153 == TYPE_PRECISION (long_integer_type_node))
7155 tree newfn = NULL_TREE;
7158 CASE_FLT_FN (BUILT_IN_LLCEIL):
7159 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7162 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7163 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7166 CASE_FLT_FN (BUILT_IN_LLROUND):
7167 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7170 CASE_FLT_FN (BUILT_IN_LLRINT):
7171 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7180 tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7181 return fold_convert_loc (loc,
7182 TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7189 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7190 return type. Return NULL_TREE if no simplification can be made. */
7193 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7197 if (!validate_arg (arg, COMPLEX_TYPE)
7198 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7201 /* Calculate the result when the argument is a constant. */
7202 if (TREE_CODE (arg) == COMPLEX_CST
7203 && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7207 if (TREE_CODE (arg) == COMPLEX_EXPR)
7209 tree real = TREE_OPERAND (arg, 0);
7210 tree imag = TREE_OPERAND (arg, 1);
7212 /* If either part is zero, cabs is fabs of the other. */
7213 if (real_zerop (real))
7214 return fold_build1_loc (loc, ABS_EXPR, type, imag);
7215 if (real_zerop (imag))
7216 return fold_build1_loc (loc, ABS_EXPR, type, real);
7218 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7219 if (flag_unsafe_math_optimizations
7220 && operand_equal_p (real, imag, OEP_PURE_SAME))
7222 const REAL_VALUE_TYPE sqrt2_trunc
7223 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7225 return fold_build2_loc (loc, MULT_EXPR, type,
7226 fold_build1_loc (loc, ABS_EXPR, type, real),
7227 build_real (type, sqrt2_trunc));
7231 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7232 if (TREE_CODE (arg) == NEGATE_EXPR
7233 || TREE_CODE (arg) == CONJ_EXPR)
7234 return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7236 /* Don't do this when optimizing for size. */
7237 if (flag_unsafe_math_optimizations
7238 && optimize && optimize_function_for_speed_p (cfun))
7240 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7242 if (sqrtfn != NULL_TREE)
7244 tree rpart, ipart, result;
7246 arg = builtin_save_expr (arg);
7248 rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7249 ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7251 rpart = builtin_save_expr (rpart);
7252 ipart = builtin_save_expr (ipart);
7254 result = fold_build2_loc (loc, PLUS_EXPR, type,
7255 fold_build2_loc (loc, MULT_EXPR, type,
7257 fold_build2_loc (loc, MULT_EXPR, type,
7260 return build_call_expr_loc (loc, sqrtfn, 1, result);
7267 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7268 Return NULL_TREE if no simplification can be made. */
7271 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7274 enum built_in_function fcode;
7277 if (!validate_arg (arg, REAL_TYPE))
7280 /* Calculate the result when the argument is a constant. */
7281 if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7284 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7285 fcode = builtin_mathfn_code (arg);
7286 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7288 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7289 arg = fold_build2_loc (loc, MULT_EXPR, type,
7290 CALL_EXPR_ARG (arg, 0),
7291 build_real (type, dconsthalf));
7292 return build_call_expr_loc (loc, expfn, 1, arg);
7295 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7296 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7298 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7302 tree arg0 = CALL_EXPR_ARG (arg, 0);
7304 /* The inner root was either sqrt or cbrt. */
7305 /* This was a conditional expression but it triggered a bug
7307 REAL_VALUE_TYPE dconstroot;
7308 if (BUILTIN_SQRT_P (fcode))
7309 dconstroot = dconsthalf;
7311 dconstroot = dconst_third ();
7313 /* Adjust for the outer root. */
7314 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7315 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7316 tree_root = build_real (type, dconstroot);
7317 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7321 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7322 if (flag_unsafe_math_optimizations
7323 && (fcode == BUILT_IN_POW
7324 || fcode == BUILT_IN_POWF
7325 || fcode == BUILT_IN_POWL))
7327 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7328 tree arg0 = CALL_EXPR_ARG (arg, 0);
7329 tree arg1 = CALL_EXPR_ARG (arg, 1);
7331 if (!tree_expr_nonnegative_p (arg0))
7332 arg0 = build1 (ABS_EXPR, type, arg0);
7333 narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7334 build_real (type, dconsthalf));
7335 return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7341 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7342 Return NULL_TREE if no simplification can be made. */
7345 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7347 const enum built_in_function fcode = builtin_mathfn_code (arg);
7350 if (!validate_arg (arg, REAL_TYPE))
7353 /* Calculate the result when the argument is a constant. */
7354 if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7357 if (flag_unsafe_math_optimizations)
7359 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7360 if (BUILTIN_EXPONENT_P (fcode))
7362 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7363 const REAL_VALUE_TYPE third_trunc =
7364 real_value_truncate (TYPE_MODE (type), dconst_third ());
7365 arg = fold_build2_loc (loc, MULT_EXPR, type,
7366 CALL_EXPR_ARG (arg, 0),
7367 build_real (type, third_trunc));
7368 return build_call_expr_loc (loc, expfn, 1, arg);
7371 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7372 if (BUILTIN_SQRT_P (fcode))
7374 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7378 tree arg0 = CALL_EXPR_ARG (arg, 0);
7380 REAL_VALUE_TYPE dconstroot = dconst_third ();
7382 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7383 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7384 tree_root = build_real (type, dconstroot);
7385 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7389 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7390 if (BUILTIN_CBRT_P (fcode))
7392 tree arg0 = CALL_EXPR_ARG (arg, 0);
7393 if (tree_expr_nonnegative_p (arg0))
7395 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7400 REAL_VALUE_TYPE dconstroot;
7402 real_arithmetic (&dconstroot, MULT_EXPR,
7403 dconst_third_ptr (), dconst_third_ptr ());
7404 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7405 tree_root = build_real (type, dconstroot);
7406 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7411 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7412 if (fcode == BUILT_IN_POW
7413 || fcode == BUILT_IN_POWF
7414 || fcode == BUILT_IN_POWL)
7416 tree arg00 = CALL_EXPR_ARG (arg, 0);
7417 tree arg01 = CALL_EXPR_ARG (arg, 1);
7418 if (tree_expr_nonnegative_p (arg00))
7420 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7421 const REAL_VALUE_TYPE dconstroot
7422 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7423 tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7424 build_real (type, dconstroot));
7425 return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7432 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7433 TYPE is the type of the return value. Return NULL_TREE if no
7434 simplification can be made. */
7437 fold_builtin_cos (location_t loc,
7438 tree arg, tree type, tree fndecl)
7442 if (!validate_arg (arg, REAL_TYPE))
7445 /* Calculate the result when the argument is a constant. */
7446 if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7449 /* Optimize cos(-x) into cos (x). */
7450 if ((narg = fold_strip_sign_ops (arg)))
7451 return build_call_expr_loc (loc, fndecl, 1, narg);
7456 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7457 Return NULL_TREE if no simplification can be made. */
7460 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7462 if (validate_arg (arg, REAL_TYPE))
7466 /* Calculate the result when the argument is a constant. */
7467 if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7470 /* Optimize cosh(-x) into cosh (x). */
7471 if ((narg = fold_strip_sign_ops (arg)))
7472 return build_call_expr_loc (loc, fndecl, 1, narg);
7478 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7479 argument ARG. TYPE is the type of the return value. Return
7480 NULL_TREE if no simplification can be made. */
7483 fold_builtin_ccos (location_t loc,
7484 tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
7485 bool hyper ATTRIBUTE_UNUSED)
7487 if (validate_arg (arg, COMPLEX_TYPE)
7488 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7493 /* Calculate the result when the argument is a constant. */
7494 if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7498 /* Optimize fn(-x) into fn(x). */
7499 if ((tmp = fold_strip_sign_ops (arg)))
7500 return build_call_expr_loc (loc, fndecl, 1, tmp);
7506 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7507 Return NULL_TREE if no simplification can be made. */
7510 fold_builtin_tan (tree arg, tree type)
7512 enum built_in_function fcode;
7515 if (!validate_arg (arg, REAL_TYPE))
7518 /* Calculate the result when the argument is a constant. */
7519 if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7522 /* Optimize tan(atan(x)) = x. */
7523 fcode = builtin_mathfn_code (arg);
7524 if (flag_unsafe_math_optimizations
7525 && (fcode == BUILT_IN_ATAN
7526 || fcode == BUILT_IN_ATANF
7527 || fcode == BUILT_IN_ATANL))
7528 return CALL_EXPR_ARG (arg, 0);
7533 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7534 NULL_TREE if no simplification can be made. */
7537 fold_builtin_sincos (location_t loc,
7538 tree arg0, tree arg1, tree arg2)
7543 if (!validate_arg (arg0, REAL_TYPE)
7544 || !validate_arg (arg1, POINTER_TYPE)
7545 || !validate_arg (arg2, POINTER_TYPE))
7548 type = TREE_TYPE (arg0);
7550 /* Calculate the result when the argument is a constant. */
7551 if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7554 /* Canonicalize sincos to cexpi. */
7555 if (!TARGET_C99_FUNCTIONS)
7557 fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7561 call = build_call_expr_loc (loc, fn, 1, arg0);
7562 call = builtin_save_expr (call);
7564 return build2 (COMPOUND_EXPR, void_type_node,
7565 build2 (MODIFY_EXPR, void_type_node,
7566 build_fold_indirect_ref_loc (loc, arg1),
7567 build1 (IMAGPART_EXPR, type, call)),
7568 build2 (MODIFY_EXPR, void_type_node,
7569 build_fold_indirect_ref_loc (loc, arg2),
7570 build1 (REALPART_EXPR, type, call)));
7573 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7574 NULL_TREE if no simplification can be made. */
7577 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7580 tree realp, imagp, ifn;
7585 if (!validate_arg (arg0, COMPLEX_TYPE)
7586 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7590 /* Calculate the result when the argument is a constant. */
7591 if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7595 rtype = TREE_TYPE (TREE_TYPE (arg0));
7597 /* In case we can figure out the real part of arg0 and it is constant zero
7599 if (!TARGET_C99_FUNCTIONS)
7601 ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7605 if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7606 && real_zerop (realp))
7608 tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7609 return build_call_expr_loc (loc, ifn, 1, narg);
7612 /* In case we can easily decompose real and imaginary parts split cexp
7613 to exp (r) * cexpi (i). */
7614 if (flag_unsafe_math_optimizations
7617 tree rfn, rcall, icall;
7619 rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7623 imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7627 icall = build_call_expr_loc (loc, ifn, 1, imagp);
7628 icall = builtin_save_expr (icall);
7629 rcall = build_call_expr_loc (loc, rfn, 1, realp);
7630 rcall = builtin_save_expr (rcall);
7631 return fold_build2_loc (loc, COMPLEX_EXPR, type,
7632 fold_build2_loc (loc, MULT_EXPR, rtype,
7634 fold_build1_loc (loc, REALPART_EXPR,
7636 fold_build2_loc (loc, MULT_EXPR, rtype,
7638 fold_build1_loc (loc, IMAGPART_EXPR,
7645 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7646 Return NULL_TREE if no simplification can be made. */
7649 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7651 if (!validate_arg (arg, REAL_TYPE))
7654 /* Optimize trunc of constant value. */
7655 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7657 REAL_VALUE_TYPE r, x;
7658 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7660 x = TREE_REAL_CST (arg);
7661 real_trunc (&r, TYPE_MODE (type), &x);
7662 return build_real (type, r);
7665 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7668 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7669 Return NULL_TREE if no simplification can be made. */
7672 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7674 if (!validate_arg (arg, REAL_TYPE))
7677 /* Optimize floor of constant value. */
7678 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7682 x = TREE_REAL_CST (arg);
7683 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7685 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7688 real_floor (&r, TYPE_MODE (type), &x);
7689 return build_real (type, r);
7693 /* Fold floor (x) where x is nonnegative to trunc (x). */
7694 if (tree_expr_nonnegative_p (arg))
7696 tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7698 return build_call_expr_loc (loc, truncfn, 1, arg);
7701 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7704 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7705 Return NULL_TREE if no simplification can be made. */
7708 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7710 if (!validate_arg (arg, REAL_TYPE))
7713 /* Optimize ceil of constant value. */
7714 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7718 x = TREE_REAL_CST (arg);
7719 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7721 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7724 real_ceil (&r, TYPE_MODE (type), &x);
7725 return build_real (type, r);
7729 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7732 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7733 Return NULL_TREE if no simplification can be made. */
7736 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7738 if (!validate_arg (arg, REAL_TYPE))
7741 /* Optimize round of constant value. */
7742 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7746 x = TREE_REAL_CST (arg);
7747 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7749 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7752 real_round (&r, TYPE_MODE (type), &x);
7753 return build_real (type, r);
7757 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7760 /* Fold function call to builtin lround, lroundf or lroundl (or the
7761 corresponding long long versions) and other rounding functions. ARG
7762 is the argument to the call. Return NULL_TREE if no simplification
7766 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7768 if (!validate_arg (arg, REAL_TYPE))
7771 /* Optimize lround of constant value. */
7772 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7774 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7776 if (real_isfinite (&x))
7778 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7779 tree ftype = TREE_TYPE (arg);
7780 unsigned HOST_WIDE_INT lo2;
7781 HOST_WIDE_INT hi, lo;
7784 switch (DECL_FUNCTION_CODE (fndecl))
7786 CASE_FLT_FN (BUILT_IN_LFLOOR):
7787 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7788 real_floor (&r, TYPE_MODE (ftype), &x);
7791 CASE_FLT_FN (BUILT_IN_LCEIL):
7792 CASE_FLT_FN (BUILT_IN_LLCEIL):
7793 real_ceil (&r, TYPE_MODE (ftype), &x);
7796 CASE_FLT_FN (BUILT_IN_LROUND):
7797 CASE_FLT_FN (BUILT_IN_LLROUND):
7798 real_round (&r, TYPE_MODE (ftype), &x);
7805 REAL_VALUE_TO_INT (&lo, &hi, r);
7806 if (!fit_double_type (lo, hi, &lo2, &hi, itype))
7807 return build_int_cst_wide (itype, lo2, hi);
7811 switch (DECL_FUNCTION_CODE (fndecl))
7813 CASE_FLT_FN (BUILT_IN_LFLOOR):
7814 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7815 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
7816 if (tree_expr_nonnegative_p (arg))
7817 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7818 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7823 return fold_fixed_mathfn (loc, fndecl, arg);
7826 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7827 and their long and long long variants (i.e. ffsl and ffsll). ARG is
7828 the argument to the call. Return NULL_TREE if no simplification can
7832 fold_builtin_bitop (tree fndecl, tree arg)
7834 if (!validate_arg (arg, INTEGER_TYPE))
7837 /* Optimize for constant argument. */
7838 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7840 HOST_WIDE_INT hi, width, result;
7841 unsigned HOST_WIDE_INT lo;
7844 type = TREE_TYPE (arg);
7845 width = TYPE_PRECISION (type);
7846 lo = TREE_INT_CST_LOW (arg);
7848 /* Clear all the bits that are beyond the type's precision. */
7849 if (width > HOST_BITS_PER_WIDE_INT)
7851 hi = TREE_INT_CST_HIGH (arg);
7852 if (width < 2 * HOST_BITS_PER_WIDE_INT)
7853 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7858 if (width < HOST_BITS_PER_WIDE_INT)
7859 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7862 switch (DECL_FUNCTION_CODE (fndecl))
7864 CASE_INT_FN (BUILT_IN_FFS):
7866 result = exact_log2 (lo & -lo) + 1;
7868 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
7873 CASE_INT_FN (BUILT_IN_CLZ):
7875 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7877 result = width - floor_log2 (lo) - 1;
7878 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7882 CASE_INT_FN (BUILT_IN_CTZ):
7884 result = exact_log2 (lo & -lo);
7886 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
7887 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7891 CASE_INT_FN (BUILT_IN_POPCOUNT):
7894 result++, lo &= lo - 1;
7896 result++, hi &= hi - 1;
7899 CASE_INT_FN (BUILT_IN_PARITY):
7902 result++, lo &= lo - 1;
7904 result++, hi &= hi - 1;
7912 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7918 /* Fold function call to builtin_bswap and the long and long long
7919 variants. Return NULL_TREE if no simplification can be made. */
7921 fold_builtin_bswap (tree fndecl, tree arg)
7923 if (! validate_arg (arg, INTEGER_TYPE))
7926 /* Optimize constant value. */
7927 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7929 HOST_WIDE_INT hi, width, r_hi = 0;
7930 unsigned HOST_WIDE_INT lo, r_lo = 0;
7933 type = TREE_TYPE (arg);
7934 width = TYPE_PRECISION (type);
7935 lo = TREE_INT_CST_LOW (arg);
7936 hi = TREE_INT_CST_HIGH (arg);
7938 switch (DECL_FUNCTION_CODE (fndecl))
7940 case BUILT_IN_BSWAP32:
7941 case BUILT_IN_BSWAP64:
7945 for (s = 0; s < width; s += 8)
7947 int d = width - s - 8;
7948 unsigned HOST_WIDE_INT byte;
7950 if (s < HOST_BITS_PER_WIDE_INT)
7951 byte = (lo >> s) & 0xff;
7953 byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7955 if (d < HOST_BITS_PER_WIDE_INT)
7958 r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7968 if (width < HOST_BITS_PER_WIDE_INT)
7969 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7971 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7977 /* A subroutine of fold_builtin to fold the various logarithmic
7978 functions. Return NULL_TREE if no simplification can me made.
7979 FUNC is the corresponding MPFR logarithm function. */
7982 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7983 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7985 if (validate_arg (arg, REAL_TYPE))
7987 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7989 const enum built_in_function fcode = builtin_mathfn_code (arg);
7991 /* Calculate the result when the argument is a constant. */
7992 if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7995 /* Special case, optimize logN(expN(x)) = x. */
7996 if (flag_unsafe_math_optimizations
7997 && ((func == mpfr_log
7998 && (fcode == BUILT_IN_EXP
7999 || fcode == BUILT_IN_EXPF
8000 || fcode == BUILT_IN_EXPL))
8001 || (func == mpfr_log2
8002 && (fcode == BUILT_IN_EXP2
8003 || fcode == BUILT_IN_EXP2F
8004 || fcode == BUILT_IN_EXP2L))
8005 || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
8006 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8008 /* Optimize logN(func()) for various exponential functions. We
8009 want to determine the value "x" and the power "exponent" in
8010 order to transform logN(x**exponent) into exponent*logN(x). */
8011 if (flag_unsafe_math_optimizations)
8013 tree exponent = 0, x = 0;
8017 CASE_FLT_FN (BUILT_IN_EXP):
8018 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
8019 x = build_real (type, real_value_truncate (TYPE_MODE (type),
8021 exponent = CALL_EXPR_ARG (arg, 0);
8023 CASE_FLT_FN (BUILT_IN_EXP2):
8024 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
8025 x = build_real (type, dconst2);
8026 exponent = CALL_EXPR_ARG (arg, 0);
8028 CASE_FLT_FN (BUILT_IN_EXP10):
8029 CASE_FLT_FN (BUILT_IN_POW10):
8030 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
8032 REAL_VALUE_TYPE dconst10;
8033 real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8034 x = build_real (type, dconst10);
8036 exponent = CALL_EXPR_ARG (arg, 0);
8038 CASE_FLT_FN (BUILT_IN_SQRT):
8039 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
8040 x = CALL_EXPR_ARG (arg, 0);
8041 exponent = build_real (type, dconsthalf);
8043 CASE_FLT_FN (BUILT_IN_CBRT):
8044 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
8045 x = CALL_EXPR_ARG (arg, 0);
8046 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8049 CASE_FLT_FN (BUILT_IN_POW):
8050 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
8051 x = CALL_EXPR_ARG (arg, 0);
8052 exponent = CALL_EXPR_ARG (arg, 1);
8058 /* Now perform the optimization. */
8061 tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
8062 return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
8070 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8071 NULL_TREE if no simplification can be made. */
8074 fold_builtin_hypot (location_t loc, tree fndecl,
8075 tree arg0, tree arg1, tree type)
8077 tree res, narg0, narg1;
8079 if (!validate_arg (arg0, REAL_TYPE)
8080 || !validate_arg (arg1, REAL_TYPE))
8083 /* Calculate the result when the argument is a constant. */
8084 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8087 /* If either argument to hypot has a negate or abs, strip that off.
8088 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8089 narg0 = fold_strip_sign_ops (arg0);
8090 narg1 = fold_strip_sign_ops (arg1);
8093 return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
8094 narg1 ? narg1 : arg1);
8097 /* If either argument is zero, hypot is fabs of the other. */
8098 if (real_zerop (arg0))
8099 return fold_build1_loc (loc, ABS_EXPR, type, arg1);
8100 else if (real_zerop (arg1))
8101 return fold_build1_loc (loc, ABS_EXPR, type, arg0);
8103 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8104 if (flag_unsafe_math_optimizations
8105 && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8107 const REAL_VALUE_TYPE sqrt2_trunc
8108 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8109 return fold_build2_loc (loc, MULT_EXPR, type,
8110 fold_build1_loc (loc, ABS_EXPR, type, arg0),
8111 build_real (type, sqrt2_trunc));
8118 /* Fold a builtin function call to pow, powf, or powl. Return
8119 NULL_TREE if no simplification can be made. */
8121 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8125 if (!validate_arg (arg0, REAL_TYPE)
8126 || !validate_arg (arg1, REAL_TYPE))
8129 /* Calculate the result when the argument is a constant. */
8130 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8133 /* Optimize pow(1.0,y) = 1.0. */
8134 if (real_onep (arg0))
8135 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8137 if (TREE_CODE (arg1) == REAL_CST
8138 && !TREE_OVERFLOW (arg1))
8140 REAL_VALUE_TYPE cint;
8144 c = TREE_REAL_CST (arg1);
8146 /* Optimize pow(x,0.0) = 1.0. */
8147 if (REAL_VALUES_EQUAL (c, dconst0))
8148 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8151 /* Optimize pow(x,1.0) = x. */
8152 if (REAL_VALUES_EQUAL (c, dconst1))
8155 /* Optimize pow(x,-1.0) = 1.0/x. */
8156 if (REAL_VALUES_EQUAL (c, dconstm1))
8157 return fold_build2_loc (loc, RDIV_EXPR, type,
8158 build_real (type, dconst1), arg0);
8160 /* Optimize pow(x,0.5) = sqrt(x). */
8161 if (flag_unsafe_math_optimizations
8162 && REAL_VALUES_EQUAL (c, dconsthalf))
8164 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8166 if (sqrtfn != NULL_TREE)
8167 return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8170 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8171 if (flag_unsafe_math_optimizations)
8173 const REAL_VALUE_TYPE dconstroot
8174 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8176 if (REAL_VALUES_EQUAL (c, dconstroot))
8178 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8179 if (cbrtfn != NULL_TREE)
8180 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8184 /* Check for an integer exponent. */
8185 n = real_to_integer (&c);
8186 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8187 if (real_identical (&c, &cint))
8189 /* Attempt to evaluate pow at compile-time, unless this should
8190 raise an exception. */
8191 if (TREE_CODE (arg0) == REAL_CST
8192 && !TREE_OVERFLOW (arg0)
8194 || (!flag_trapping_math && !flag_errno_math)
8195 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8200 x = TREE_REAL_CST (arg0);
8201 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8202 if (flag_unsafe_math_optimizations || !inexact)
8203 return build_real (type, x);
8206 /* Strip sign ops from even integer powers. */
8207 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8209 tree narg0 = fold_strip_sign_ops (arg0);
8211 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8216 if (flag_unsafe_math_optimizations)
8218 const enum built_in_function fcode = builtin_mathfn_code (arg0);
8220 /* Optimize pow(expN(x),y) = expN(x*y). */
8221 if (BUILTIN_EXPONENT_P (fcode))
8223 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8224 tree arg = CALL_EXPR_ARG (arg0, 0);
8225 arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8226 return build_call_expr_loc (loc, expfn, 1, arg);
8229 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8230 if (BUILTIN_SQRT_P (fcode))
8232 tree narg0 = CALL_EXPR_ARG (arg0, 0);
8233 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8234 build_real (type, dconsthalf));
8235 return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8238 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8239 if (BUILTIN_CBRT_P (fcode))
8241 tree arg = CALL_EXPR_ARG (arg0, 0);
8242 if (tree_expr_nonnegative_p (arg))
8244 const REAL_VALUE_TYPE dconstroot
8245 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8246 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8247 build_real (type, dconstroot));
8248 return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8252 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8253 if (fcode == BUILT_IN_POW
8254 || fcode == BUILT_IN_POWF
8255 || fcode == BUILT_IN_POWL)
8257 tree arg00 = CALL_EXPR_ARG (arg0, 0);
8258 if (tree_expr_nonnegative_p (arg00))
8260 tree arg01 = CALL_EXPR_ARG (arg0, 1);
8261 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8262 return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8270 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8271 Return NULL_TREE if no simplification can be made. */
8273 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8274 tree arg0, tree arg1, tree type)
8276 if (!validate_arg (arg0, REAL_TYPE)
8277 || !validate_arg (arg1, INTEGER_TYPE))
8280 /* Optimize pow(1.0,y) = 1.0. */
8281 if (real_onep (arg0))
8282 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8284 if (host_integerp (arg1, 0))
8286 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8288 /* Evaluate powi at compile-time. */
8289 if (TREE_CODE (arg0) == REAL_CST
8290 && !TREE_OVERFLOW (arg0))
8293 x = TREE_REAL_CST (arg0);
8294 real_powi (&x, TYPE_MODE (type), &x, c);
8295 return build_real (type, x);
8298 /* Optimize pow(x,0) = 1.0. */
8300 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8303 /* Optimize pow(x,1) = x. */
8307 /* Optimize pow(x,-1) = 1.0/x. */
8309 return fold_build2_loc (loc, RDIV_EXPR, type,
8310 build_real (type, dconst1), arg0);
8316 /* A subroutine of fold_builtin to fold the various exponent
8317 functions. Return NULL_TREE if no simplification can be made.
8318 FUNC is the corresponding MPFR exponent function. */
8321 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8322 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8324 if (validate_arg (arg, REAL_TYPE))
8326 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8329 /* Calculate the result when the argument is a constant. */
8330 if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8333 /* Optimize expN(logN(x)) = x. */
8334 if (flag_unsafe_math_optimizations)
8336 const enum built_in_function fcode = builtin_mathfn_code (arg);
8338 if ((func == mpfr_exp
8339 && (fcode == BUILT_IN_LOG
8340 || fcode == BUILT_IN_LOGF
8341 || fcode == BUILT_IN_LOGL))
8342 || (func == mpfr_exp2
8343 && (fcode == BUILT_IN_LOG2
8344 || fcode == BUILT_IN_LOG2F
8345 || fcode == BUILT_IN_LOG2L))
8346 || (func == mpfr_exp10
8347 && (fcode == BUILT_IN_LOG10
8348 || fcode == BUILT_IN_LOG10F
8349 || fcode == BUILT_IN_LOG10L)))
8350 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8357 /* Return true if VAR is a VAR_DECL or a component thereof. */
8360 var_decl_component_p (tree var)
8363 while (handled_component_p (inner))
8364 inner = TREE_OPERAND (inner, 0);
8365 return SSA_VAR_P (inner);
8368 /* Fold function call to builtin memset. Return
8369 NULL_TREE if no simplification can be made. */
8372 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8373 tree type, bool ignore)
8375 tree var, ret, etype;
8376 unsigned HOST_WIDE_INT length, cval;
8378 if (! validate_arg (dest, POINTER_TYPE)
8379 || ! validate_arg (c, INTEGER_TYPE)
8380 || ! validate_arg (len, INTEGER_TYPE))
8383 if (! host_integerp (len, 1))
8386 /* If the LEN parameter is zero, return DEST. */
8387 if (integer_zerop (len))
8388 return omit_one_operand_loc (loc, type, dest, c);
8390 if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8395 if (TREE_CODE (var) != ADDR_EXPR)
8398 var = TREE_OPERAND (var, 0);
8399 if (TREE_THIS_VOLATILE (var))
8402 etype = TREE_TYPE (var);
8403 if (TREE_CODE (etype) == ARRAY_TYPE)
8404 etype = TREE_TYPE (etype);
8406 if (!INTEGRAL_TYPE_P (etype)
8407 && !POINTER_TYPE_P (etype))
8410 if (! var_decl_component_p (var))
8413 length = tree_low_cst (len, 1);
8414 if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8415 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8419 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8422 if (integer_zerop (c))
8426 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8429 cval = tree_low_cst (c, 1);
8433 cval |= (cval << 31) << 1;
8436 ret = build_int_cst_type (etype, cval);
8437 var = build_fold_indirect_ref_loc (loc,
8438 fold_convert_loc (loc,
8439 build_pointer_type (etype),
8441 ret = build2 (MODIFY_EXPR, etype, var, ret);
8445 return omit_one_operand_loc (loc, type, dest, ret);
8448 /* Fold function call to builtin memset. Return
8449 NULL_TREE if no simplification can be made. */
8452 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8454 if (! validate_arg (dest, POINTER_TYPE)
8455 || ! validate_arg (size, INTEGER_TYPE))
8461 /* New argument list transforming bzero(ptr x, int y) to
8462 memset(ptr x, int 0, size_t y). This is done this way
8463 so that if it isn't expanded inline, we fallback to
8464 calling bzero instead of memset. */
8466 return fold_builtin_memset (loc, dest, integer_zero_node,
8467 fold_convert_loc (loc, sizetype, size),
8468 void_type_node, ignore);
8471 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8472 NULL_TREE if no simplification can be made.
8473 If ENDP is 0, return DEST (like memcpy).
8474 If ENDP is 1, return DEST+LEN (like mempcpy).
8475 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8476 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8480 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8481 tree len, tree type, bool ignore, int endp)
8483 tree destvar, srcvar, expr;
8485 if (! validate_arg (dest, POINTER_TYPE)
8486 || ! validate_arg (src, POINTER_TYPE)
8487 || ! validate_arg (len, INTEGER_TYPE))
8490 /* If the LEN parameter is zero, return DEST. */
8491 if (integer_zerop (len))
8492 return omit_one_operand_loc (loc, type, dest, src);
8494 /* If SRC and DEST are the same (and not volatile), return
8495 DEST{,+LEN,+LEN-1}. */
8496 if (operand_equal_p (src, dest, 0))
8500 tree srctype, desttype;
8501 int src_align, dest_align;
8505 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8506 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8508 /* Both DEST and SRC must be pointer types.
8509 ??? This is what old code did. Is the testing for pointer types
8512 If either SRC is readonly or length is 1, we can use memcpy. */
8513 if (!dest_align || !src_align)
8515 if (readonly_data_expr (src)
8516 || (host_integerp (len, 1)
8517 && (MIN (src_align, dest_align) / BITS_PER_UNIT
8518 >= tree_low_cst (len, 1))))
8520 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8523 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8526 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8527 srcvar = build_fold_indirect_ref_loc (loc, src);
8528 destvar = build_fold_indirect_ref_loc (loc, dest);
8530 && !TREE_THIS_VOLATILE (srcvar)
8532 && !TREE_THIS_VOLATILE (destvar))
8534 tree src_base, dest_base, fn;
8535 HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8536 HOST_WIDE_INT size = -1;
8537 HOST_WIDE_INT maxsize = -1;
8540 if (handled_component_p (src_base))
8541 src_base = get_ref_base_and_extent (src_base, &src_offset,
8543 dest_base = destvar;
8544 if (handled_component_p (dest_base))
8545 dest_base = get_ref_base_and_extent (dest_base, &dest_offset,
8547 if (host_integerp (len, 1))
8549 maxsize = tree_low_cst (len, 1);
8551 > INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT)
8554 maxsize *= BITS_PER_UNIT;
8558 if (SSA_VAR_P (src_base)
8559 && SSA_VAR_P (dest_base))
8561 if (operand_equal_p (src_base, dest_base, 0)
8562 && ranges_overlap_p (src_offset, maxsize,
8563 dest_offset, maxsize))
8566 else if (TREE_CODE (src_base) == INDIRECT_REF
8567 && TREE_CODE (dest_base) == INDIRECT_REF)
8569 if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8570 TREE_OPERAND (dest_base, 0), 0)
8571 || ranges_overlap_p (src_offset, maxsize,
8572 dest_offset, maxsize))
8578 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8581 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8586 if (!host_integerp (len, 0))
8589 This logic lose for arguments like (type *)malloc (sizeof (type)),
8590 since we strip the casts of up to VOID return value from malloc.
8591 Perhaps we ought to inherit type from non-VOID argument here? */
8594 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8595 if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8597 tree tem = TREE_OPERAND (src, 0);
8599 if (tem != TREE_OPERAND (src, 0))
8600 src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8602 if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8604 tree tem = TREE_OPERAND (dest, 0);
8606 if (tem != TREE_OPERAND (dest, 0))
8607 dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8609 srctype = TREE_TYPE (TREE_TYPE (src));
8611 && TREE_CODE (srctype) == ARRAY_TYPE
8612 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8614 srctype = TREE_TYPE (srctype);
8616 src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8618 desttype = TREE_TYPE (TREE_TYPE (dest));
8620 && TREE_CODE (desttype) == ARRAY_TYPE
8621 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8623 desttype = TREE_TYPE (desttype);
8625 dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8627 if (!srctype || !desttype
8628 || !TYPE_SIZE_UNIT (srctype)
8629 || !TYPE_SIZE_UNIT (desttype)
8630 || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8631 || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST
8632 || TYPE_VOLATILE (srctype)
8633 || TYPE_VOLATILE (desttype))
8636 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8637 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8638 if (dest_align < (int) TYPE_ALIGN (desttype)
8639 || src_align < (int) TYPE_ALIGN (srctype))
8643 dest = builtin_save_expr (dest);
8646 if (tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8648 srcvar = build_fold_indirect_ref_loc (loc, src);
8649 if (TREE_THIS_VOLATILE (srcvar))
8651 else if (!tree_int_cst_equal (tree_expr_size (srcvar), len))
8653 /* With memcpy, it is possible to bypass aliasing rules, so without
8654 this check i.e. execute/20060930-2.c would be misoptimized,
8655 because it use conflicting alias set to hold argument for the
8656 memcpy call. This check is probably unnecessary with
8657 -fno-strict-aliasing. Similarly for destvar. See also
8659 else if (!var_decl_component_p (srcvar))
8663 destvar = NULL_TREE;
8664 if (tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8666 destvar = build_fold_indirect_ref_loc (loc, dest);
8667 if (TREE_THIS_VOLATILE (destvar))
8669 else if (!tree_int_cst_equal (tree_expr_size (destvar), len))
8670 destvar = NULL_TREE;
8671 else if (!var_decl_component_p (destvar))
8672 destvar = NULL_TREE;
8675 if (srcvar == NULL_TREE && destvar == NULL_TREE)
8678 if (srcvar == NULL_TREE)
8681 if (TREE_ADDRESSABLE (TREE_TYPE (destvar)))
8684 srctype = build_qualified_type (desttype, 0);
8685 if (src_align < (int) TYPE_ALIGN (srctype))
8687 if (AGGREGATE_TYPE_P (srctype)
8688 || SLOW_UNALIGNED_ACCESS (TYPE_MODE (srctype), src_align))
8691 srctype = build_variant_type_copy (srctype);
8692 TYPE_ALIGN (srctype) = src_align;
8693 TYPE_USER_ALIGN (srctype) = 1;
8694 TYPE_PACKED (srctype) = 1;
8696 srcptype = build_pointer_type_for_mode (srctype, ptr_mode, true);
8697 src = fold_convert_loc (loc, srcptype, src);
8698 srcvar = build_fold_indirect_ref_loc (loc, src);
8700 else if (destvar == NULL_TREE)
8703 if (TREE_ADDRESSABLE (TREE_TYPE (srcvar)))
8706 desttype = build_qualified_type (srctype, 0);
8707 if (dest_align < (int) TYPE_ALIGN (desttype))
8709 if (AGGREGATE_TYPE_P (desttype)
8710 || SLOW_UNALIGNED_ACCESS (TYPE_MODE (desttype), dest_align))
8713 desttype = build_variant_type_copy (desttype);
8714 TYPE_ALIGN (desttype) = dest_align;
8715 TYPE_USER_ALIGN (desttype) = 1;
8716 TYPE_PACKED (desttype) = 1;
8718 destptype = build_pointer_type_for_mode (desttype, ptr_mode, true);
8719 dest = fold_convert_loc (loc, destptype, dest);
8720 destvar = build_fold_indirect_ref_loc (loc, dest);
8723 if (srctype == desttype
8724 || (gimple_in_ssa_p (cfun)
8725 && useless_type_conversion_p (desttype, srctype)))
8727 else if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
8728 || POINTER_TYPE_P (TREE_TYPE (srcvar)))
8729 && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
8730 || POINTER_TYPE_P (TREE_TYPE (destvar))))
8731 expr = fold_convert_loc (loc, TREE_TYPE (destvar), srcvar);
8733 expr = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8734 TREE_TYPE (destvar), srcvar);
8735 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
8741 if (endp == 0 || endp == 3)
8742 return omit_one_operand_loc (loc, type, dest, expr);
8748 len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8751 len = fold_convert_loc (loc, sizetype, len);
8752 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8753 dest = fold_convert_loc (loc, type, dest);
8755 dest = omit_one_operand_loc (loc, type, dest, expr);
8759 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8760 If LEN is not NULL, it represents the length of the string to be
8761 copied. Return NULL_TREE if no simplification can be made. */
8764 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8768 if (!validate_arg (dest, POINTER_TYPE)
8769 || !validate_arg (src, POINTER_TYPE))
8772 /* If SRC and DEST are the same (and not volatile), return DEST. */
8773 if (operand_equal_p (src, dest, 0))
8774 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8776 if (optimize_function_for_size_p (cfun))
8779 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8785 len = c_strlen (src, 1);
8786 if (! len || TREE_SIDE_EFFECTS (len))
8790 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8791 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8792 build_call_expr_loc (loc, fn, 3, dest, src, len));
8795 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8796 Return NULL_TREE if no simplification can be made. */
8799 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8801 tree fn, len, lenp1, call, type;
8803 if (!validate_arg (dest, POINTER_TYPE)
8804 || !validate_arg (src, POINTER_TYPE))
8807 len = c_strlen (src, 1);
8809 || TREE_CODE (len) != INTEGER_CST)
8812 if (optimize_function_for_size_p (cfun)
8813 /* If length is zero it's small enough. */
8814 && !integer_zerop (len))
8817 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8821 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8822 /* We use dest twice in building our expression. Save it from
8823 multiple expansions. */
8824 dest = builtin_save_expr (dest);
8825 call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8827 type = TREE_TYPE (TREE_TYPE (fndecl));
8828 len = fold_convert_loc (loc, sizetype, len);
8829 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8830 dest = fold_convert_loc (loc, type, dest);
8831 dest = omit_one_operand_loc (loc, type, dest, call);
8835 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8836 If SLEN is not NULL, it represents the length of the source string.
8837 Return NULL_TREE if no simplification can be made. */
8840 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8841 tree src, tree len, tree slen)
8845 if (!validate_arg (dest, POINTER_TYPE)
8846 || !validate_arg (src, POINTER_TYPE)
8847 || !validate_arg (len, INTEGER_TYPE))
8850 /* If the LEN parameter is zero, return DEST. */
8851 if (integer_zerop (len))
8852 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8854 /* We can't compare slen with len as constants below if len is not a
8856 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8860 slen = c_strlen (src, 1);
8862 /* Now, we must be passed a constant src ptr parameter. */
8863 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8866 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8868 /* We do not support simplification of this case, though we do
8869 support it when expanding trees into RTL. */
8870 /* FIXME: generate a call to __builtin_memset. */
8871 if (tree_int_cst_lt (slen, len))
8874 /* OK transform into builtin memcpy. */
8875 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8878 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8879 build_call_expr_loc (loc, fn, 3, dest, src, len));
8882 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8883 arguments to the call, and TYPE is its return type.
8884 Return NULL_TREE if no simplification can be made. */
8887 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8889 if (!validate_arg (arg1, POINTER_TYPE)
8890 || !validate_arg (arg2, INTEGER_TYPE)
8891 || !validate_arg (len, INTEGER_TYPE))
8897 if (TREE_CODE (arg2) != INTEGER_CST
8898 || !host_integerp (len, 1))
8901 p1 = c_getstr (arg1);
8902 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8908 if (target_char_cast (arg2, &c))
8911 r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8914 return build_int_cst (TREE_TYPE (arg1), 0);
8916 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8918 return fold_convert_loc (loc, type, tem);
8924 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8925 Return NULL_TREE if no simplification can be made. */
8928 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8930 const char *p1, *p2;
8932 if (!validate_arg (arg1, POINTER_TYPE)
8933 || !validate_arg (arg2, POINTER_TYPE)
8934 || !validate_arg (len, INTEGER_TYPE))
8937 /* If the LEN parameter is zero, return zero. */
8938 if (integer_zerop (len))
8939 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8942 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8943 if (operand_equal_p (arg1, arg2, 0))
8944 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8946 p1 = c_getstr (arg1);
8947 p2 = c_getstr (arg2);
8949 /* If all arguments are constant, and the value of len is not greater
8950 than the lengths of arg1 and arg2, evaluate at compile-time. */
8951 if (host_integerp (len, 1) && p1 && p2
8952 && compare_tree_int (len, strlen (p1) + 1) <= 0
8953 && compare_tree_int (len, strlen (p2) + 1) <= 0)
8955 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8958 return integer_one_node;
8960 return integer_minus_one_node;
8962 return integer_zero_node;
8965 /* If len parameter is one, return an expression corresponding to
8966 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8967 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 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);
8974 = fold_convert_loc (loc, integer_type_node,
8975 build1 (INDIRECT_REF, cst_uchar_node,
8976 fold_convert_loc (loc,
8980 = fold_convert_loc (loc, integer_type_node,
8981 build1 (INDIRECT_REF, cst_uchar_node,
8982 fold_convert_loc (loc,
8985 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8991 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8992 Return NULL_TREE if no simplification can be made. */
8995 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8997 const char *p1, *p2;
8999 if (!validate_arg (arg1, POINTER_TYPE)
9000 || !validate_arg (arg2, POINTER_TYPE))
9003 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9004 if (operand_equal_p (arg1, arg2, 0))
9005 return integer_zero_node;
9007 p1 = c_getstr (arg1);
9008 p2 = c_getstr (arg2);
9012 const int i = strcmp (p1, p2);
9014 return integer_minus_one_node;
9016 return integer_one_node;
9018 return integer_zero_node;
9021 /* If the second arg is "", return *(const unsigned char*)arg1. */
9022 if (p2 && *p2 == '\0')
9024 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9025 tree cst_uchar_ptr_node
9026 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9028 return fold_convert_loc (loc, integer_type_node,
9029 build1 (INDIRECT_REF, cst_uchar_node,
9030 fold_convert_loc (loc,
9035 /* If the first arg is "", return -*(const unsigned char*)arg2. */
9036 if (p1 && *p1 == '\0')
9038 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9039 tree cst_uchar_ptr_node
9040 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9043 = fold_convert_loc (loc, integer_type_node,
9044 build1 (INDIRECT_REF, cst_uchar_node,
9045 fold_convert_loc (loc,
9048 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9054 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9055 Return NULL_TREE if no simplification can be made. */
9058 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
9060 const char *p1, *p2;
9062 if (!validate_arg (arg1, POINTER_TYPE)
9063 || !validate_arg (arg2, POINTER_TYPE)
9064 || !validate_arg (len, INTEGER_TYPE))
9067 /* If the LEN parameter is zero, return zero. */
9068 if (integer_zerop (len))
9069 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9072 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9073 if (operand_equal_p (arg1, arg2, 0))
9074 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9076 p1 = c_getstr (arg1);
9077 p2 = c_getstr (arg2);
9079 if (host_integerp (len, 1) && p1 && p2)
9081 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9083 return integer_one_node;
9085 return integer_minus_one_node;
9087 return integer_zero_node;
9090 /* If the second arg is "", and the length is greater than zero,
9091 return *(const unsigned char*)arg1. */
9092 if (p2 && *p2 == '\0'
9093 && TREE_CODE (len) == INTEGER_CST
9094 && tree_int_cst_sgn (len) == 1)
9096 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9097 tree cst_uchar_ptr_node
9098 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9100 return fold_convert_loc (loc, integer_type_node,
9101 build1 (INDIRECT_REF, cst_uchar_node,
9102 fold_convert_loc (loc,
9107 /* If the first arg is "", and the length is greater than zero,
9108 return -*(const unsigned char*)arg2. */
9109 if (p1 && *p1 == '\0'
9110 && TREE_CODE (len) == INTEGER_CST
9111 && tree_int_cst_sgn (len) == 1)
9113 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9114 tree cst_uchar_ptr_node
9115 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9117 tree temp = fold_convert_loc (loc, integer_type_node,
9118 build1 (INDIRECT_REF, cst_uchar_node,
9119 fold_convert_loc (loc,
9122 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9125 /* If len parameter is one, return an expression corresponding to
9126 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9127 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9129 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9130 tree cst_uchar_ptr_node
9131 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9133 tree ind1 = fold_convert_loc (loc, integer_type_node,
9134 build1 (INDIRECT_REF, cst_uchar_node,
9135 fold_convert_loc (loc,
9138 tree ind2 = fold_convert_loc (loc, integer_type_node,
9139 build1 (INDIRECT_REF, cst_uchar_node,
9140 fold_convert_loc (loc,
9143 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9149 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9150 ARG. Return NULL_TREE if no simplification can be made. */
9153 fold_builtin_signbit (location_t loc, tree arg, tree type)
9157 if (!validate_arg (arg, REAL_TYPE))
9160 /* If ARG is a compile-time constant, determine the result. */
9161 if (TREE_CODE (arg) == REAL_CST
9162 && !TREE_OVERFLOW (arg))
9166 c = TREE_REAL_CST (arg);
9167 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9168 return fold_convert_loc (loc, type, temp);
9171 /* If ARG is non-negative, the result is always zero. */
9172 if (tree_expr_nonnegative_p (arg))
9173 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9175 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9176 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9177 return fold_build2_loc (loc, LT_EXPR, type, arg,
9178 build_real (TREE_TYPE (arg), dconst0));
9183 /* Fold function call to builtin copysign, copysignf or copysignl with
9184 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9188 fold_builtin_copysign (location_t loc, tree fndecl,
9189 tree arg1, tree arg2, tree type)
9193 if (!validate_arg (arg1, REAL_TYPE)
9194 || !validate_arg (arg2, REAL_TYPE))
9197 /* copysign(X,X) is X. */
9198 if (operand_equal_p (arg1, arg2, 0))
9199 return fold_convert_loc (loc, type, arg1);
9201 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9202 if (TREE_CODE (arg1) == REAL_CST
9203 && TREE_CODE (arg2) == REAL_CST
9204 && !TREE_OVERFLOW (arg1)
9205 && !TREE_OVERFLOW (arg2))
9207 REAL_VALUE_TYPE c1, c2;
9209 c1 = TREE_REAL_CST (arg1);
9210 c2 = TREE_REAL_CST (arg2);
9211 /* c1.sign := c2.sign. */
9212 real_copysign (&c1, &c2);
9213 return build_real (type, c1);
9216 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9217 Remember to evaluate Y for side-effects. */
9218 if (tree_expr_nonnegative_p (arg2))
9219 return omit_one_operand_loc (loc, type,
9220 fold_build1_loc (loc, ABS_EXPR, type, arg1),
9223 /* Strip sign changing operations for the first argument. */
9224 tem = fold_strip_sign_ops (arg1);
9226 return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9231 /* Fold a call to builtin isascii with argument ARG. */
9234 fold_builtin_isascii (location_t loc, tree arg)
9236 if (!validate_arg (arg, INTEGER_TYPE))
9240 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9241 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9242 build_int_cst (NULL_TREE,
9243 ~ (unsigned HOST_WIDE_INT) 0x7f));
9244 return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9245 arg, integer_zero_node);
9249 /* Fold a call to builtin toascii with argument ARG. */
9252 fold_builtin_toascii (location_t loc, tree arg)
9254 if (!validate_arg (arg, INTEGER_TYPE))
9257 /* Transform toascii(c) -> (c & 0x7f). */
9258 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9259 build_int_cst (NULL_TREE, 0x7f));
9262 /* Fold a call to builtin isdigit with argument ARG. */
9265 fold_builtin_isdigit (location_t loc, tree arg)
9267 if (!validate_arg (arg, INTEGER_TYPE))
9271 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9272 /* According to the C standard, isdigit is unaffected by locale.
9273 However, it definitely is affected by the target character set. */
9274 unsigned HOST_WIDE_INT target_digit0
9275 = lang_hooks.to_target_charset ('0');
9277 if (target_digit0 == 0)
9280 arg = fold_convert_loc (loc, unsigned_type_node, arg);
9281 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9282 build_int_cst (unsigned_type_node, target_digit0));
9283 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9284 build_int_cst (unsigned_type_node, 9));
9288 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9291 fold_builtin_fabs (location_t loc, tree arg, tree type)
9293 if (!validate_arg (arg, REAL_TYPE))
9296 arg = fold_convert_loc (loc, type, arg);
9297 if (TREE_CODE (arg) == REAL_CST)
9298 return fold_abs_const (arg, type);
9299 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9302 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9305 fold_builtin_abs (location_t loc, tree arg, tree type)
9307 if (!validate_arg (arg, INTEGER_TYPE))
9310 arg = fold_convert_loc (loc, type, arg);
9311 if (TREE_CODE (arg) == INTEGER_CST)
9312 return fold_abs_const (arg, type);
9313 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9316 /* Fold a call to builtin fmin or fmax. */
9319 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9320 tree type, bool max)
9322 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9324 /* Calculate the result when the argument is a constant. */
9325 tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9330 /* If either argument is NaN, return the other one. Avoid the
9331 transformation if we get (and honor) a signalling NaN. Using
9332 omit_one_operand() ensures we create a non-lvalue. */
9333 if (TREE_CODE (arg0) == REAL_CST
9334 && real_isnan (&TREE_REAL_CST (arg0))
9335 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9336 || ! TREE_REAL_CST (arg0).signalling))
9337 return omit_one_operand_loc (loc, type, arg1, arg0);
9338 if (TREE_CODE (arg1) == REAL_CST
9339 && real_isnan (&TREE_REAL_CST (arg1))
9340 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9341 || ! TREE_REAL_CST (arg1).signalling))
9342 return omit_one_operand_loc (loc, type, arg0, arg1);
9344 /* Transform fmin/fmax(x,x) -> x. */
9345 if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9346 return omit_one_operand_loc (loc, type, arg0, arg1);
9348 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9349 functions to return the numeric arg if the other one is NaN.
9350 These tree codes don't honor that, so only transform if
9351 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9352 handled, so we don't have to worry about it either. */
9353 if (flag_finite_math_only)
9354 return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9355 fold_convert_loc (loc, type, arg0),
9356 fold_convert_loc (loc, type, arg1));
9361 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9364 fold_builtin_carg (location_t loc, tree arg, tree type)
9366 if (validate_arg (arg, COMPLEX_TYPE)
9367 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9369 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9373 tree new_arg = builtin_save_expr (arg);
9374 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9375 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9376 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9383 /* Fold a call to builtin logb/ilogb. */
9386 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9388 if (! validate_arg (arg, REAL_TYPE))
9393 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9395 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9401 /* If arg is Inf or NaN and we're logb, return it. */
9402 if (TREE_CODE (rettype) == REAL_TYPE)
9403 return fold_convert_loc (loc, rettype, arg);
9404 /* Fall through... */
9406 /* Zero may set errno and/or raise an exception for logb, also
9407 for ilogb we don't know FP_ILOGB0. */
9410 /* For normal numbers, proceed iff radix == 2. In GCC,
9411 normalized significands are in the range [0.5, 1.0). We
9412 want the exponent as if they were [1.0, 2.0) so get the
9413 exponent and subtract 1. */
9414 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9415 return fold_convert_loc (loc, rettype,
9416 build_int_cst (NULL_TREE,
9417 REAL_EXP (value)-1));
9425 /* Fold a call to builtin significand, if radix == 2. */
9428 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9430 if (! validate_arg (arg, REAL_TYPE))
9435 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9437 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9444 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9445 return fold_convert_loc (loc, rettype, arg);
9447 /* For normal numbers, proceed iff radix == 2. */
9448 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9450 REAL_VALUE_TYPE result = *value;
9451 /* In GCC, normalized significands are in the range [0.5,
9452 1.0). We want them to be [1.0, 2.0) so set the
9454 SET_REAL_EXP (&result, 1);
9455 return build_real (rettype, result);
9464 /* Fold a call to builtin frexp, we can assume the base is 2. */
9467 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9469 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9474 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9477 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9479 /* Proceed if a valid pointer type was passed in. */
9480 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9482 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9488 /* For +-0, return (*exp = 0, +-0). */
9489 exp = integer_zero_node;
9494 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9495 return omit_one_operand_loc (loc, rettype, arg0, arg1);
9498 /* Since the frexp function always expects base 2, and in
9499 GCC normalized significands are already in the range
9500 [0.5, 1.0), we have exactly what frexp wants. */
9501 REAL_VALUE_TYPE frac_rvt = *value;
9502 SET_REAL_EXP (&frac_rvt, 0);
9503 frac = build_real (rettype, frac_rvt);
9504 exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9511 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9512 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9513 TREE_SIDE_EFFECTS (arg1) = 1;
9514 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9520 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9521 then we can assume the base is two. If it's false, then we have to
9522 check the mode of the TYPE parameter in certain cases. */
9525 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9526 tree type, bool ldexp)
9528 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9533 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9534 if (real_zerop (arg0) || integer_zerop (arg1)
9535 || (TREE_CODE (arg0) == REAL_CST
9536 && !real_isfinite (&TREE_REAL_CST (arg0))))
9537 return omit_one_operand_loc (loc, type, arg0, arg1);
9539 /* If both arguments are constant, then try to evaluate it. */
9540 if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9541 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9542 && host_integerp (arg1, 0))
9544 /* Bound the maximum adjustment to twice the range of the
9545 mode's valid exponents. Use abs to ensure the range is
9546 positive as a sanity check. */
9547 const long max_exp_adj = 2 *
9548 labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9549 - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9551 /* Get the user-requested adjustment. */
9552 const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9554 /* The requested adjustment must be inside this range. This
9555 is a preliminary cap to avoid things like overflow, we
9556 may still fail to compute the result for other reasons. */
9557 if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9559 REAL_VALUE_TYPE initial_result;
9561 real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9563 /* Ensure we didn't overflow. */
9564 if (! real_isinf (&initial_result))
9566 const REAL_VALUE_TYPE trunc_result
9567 = real_value_truncate (TYPE_MODE (type), initial_result);
9569 /* Only proceed if the target mode can hold the
9571 if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9572 return build_real (type, trunc_result);
9581 /* Fold a call to builtin modf. */
9584 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9586 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9591 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9594 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9596 /* Proceed if a valid pointer type was passed in. */
9597 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9599 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9600 REAL_VALUE_TYPE trunc, frac;
9606 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9607 trunc = frac = *value;
9610 /* For +-Inf, return (*arg1 = arg0, +-0). */
9612 frac.sign = value->sign;
9616 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9617 real_trunc (&trunc, VOIDmode, value);
9618 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9619 /* If the original number was negative and already
9620 integral, then the fractional part is -0.0. */
9621 if (value->sign && frac.cl == rvc_zero)
9622 frac.sign = value->sign;
9626 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9627 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9628 build_real (rettype, trunc));
9629 TREE_SIDE_EFFECTS (arg1) = 1;
9630 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9631 build_real (rettype, frac));
9637 /* Given a location LOC, an interclass builtin function decl FNDECL
9638 and its single argument ARG, return an folded expression computing
9639 the same, or NULL_TREE if we either couldn't or didn't want to fold
9640 (the latter happen if there's an RTL instruction available). */
9643 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9645 enum machine_mode mode;
9647 if (!validate_arg (arg, REAL_TYPE))
9650 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9653 mode = TYPE_MODE (TREE_TYPE (arg));
9655 /* If there is no optab, try generic code. */
9656 switch (DECL_FUNCTION_CODE (fndecl))
9660 CASE_FLT_FN (BUILT_IN_ISINF):
9662 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9663 tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9664 tree const type = TREE_TYPE (arg);
9668 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9669 real_from_string (&r, buf);
9670 result = build_call_expr (isgr_fn, 2,
9671 fold_build1_loc (loc, ABS_EXPR, type, arg),
9672 build_real (type, r));
9675 CASE_FLT_FN (BUILT_IN_FINITE):
9676 case BUILT_IN_ISFINITE:
9678 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9679 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9680 tree const type = TREE_TYPE (arg);
9684 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9685 real_from_string (&r, buf);
9686 result = build_call_expr (isle_fn, 2,
9687 fold_build1_loc (loc, ABS_EXPR, type, arg),
9688 build_real (type, r));
9689 /*result = fold_build2_loc (loc, UNGT_EXPR,
9690 TREE_TYPE (TREE_TYPE (fndecl)),
9691 fold_build1_loc (loc, ABS_EXPR, type, arg),
9692 build_real (type, r));
9693 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9694 TREE_TYPE (TREE_TYPE (fndecl)),
9698 case BUILT_IN_ISNORMAL:
9700 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9701 islessequal(fabs(x),DBL_MAX). */
9702 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9703 tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9704 tree const type = TREE_TYPE (arg);
9705 REAL_VALUE_TYPE rmax, rmin;
9708 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9709 real_from_string (&rmax, buf);
9710 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9711 real_from_string (&rmin, buf);
9712 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9713 result = build_call_expr (isle_fn, 2, arg,
9714 build_real (type, rmax));
9715 result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9716 build_call_expr (isge_fn, 2, arg,
9717 build_real (type, rmin)));
9727 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9728 ARG is the argument for the call. */
9731 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9733 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9736 if (!validate_arg (arg, REAL_TYPE))
9739 switch (builtin_index)
9741 case BUILT_IN_ISINF:
9742 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9743 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9745 if (TREE_CODE (arg) == REAL_CST)
9747 r = TREE_REAL_CST (arg);
9748 if (real_isinf (&r))
9749 return real_compare (GT_EXPR, &r, &dconst0)
9750 ? integer_one_node : integer_minus_one_node;
9752 return integer_zero_node;
9757 case BUILT_IN_ISINF_SIGN:
9759 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9760 /* In a boolean context, GCC will fold the inner COND_EXPR to
9761 1. So e.g. "if (isinf_sign(x))" would be folded to just
9762 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9763 tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9764 tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9765 tree tmp = NULL_TREE;
9767 arg = builtin_save_expr (arg);
9769 if (signbit_fn && isinf_fn)
9771 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9772 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9774 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9775 signbit_call, integer_zero_node);
9776 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9777 isinf_call, integer_zero_node);
9779 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9780 integer_minus_one_node, integer_one_node);
9781 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9789 case BUILT_IN_ISFINITE:
9790 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9791 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9792 return omit_one_operand_loc (loc, type, integer_one_node, arg);
9794 if (TREE_CODE (arg) == REAL_CST)
9796 r = TREE_REAL_CST (arg);
9797 return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9802 case BUILT_IN_ISNAN:
9803 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9804 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9806 if (TREE_CODE (arg) == REAL_CST)
9808 r = TREE_REAL_CST (arg);
9809 return real_isnan (&r) ? integer_one_node : integer_zero_node;
9812 arg = builtin_save_expr (arg);
9813 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9820 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9821 This builtin will generate code to return the appropriate floating
9822 point classification depending on the value of the floating point
9823 number passed in. The possible return values must be supplied as
9824 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9825 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9826 one floating point argument which is "type generic". */
9829 fold_builtin_fpclassify (location_t loc, tree exp)
9831 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9832 arg, type, res, tmp;
9833 enum machine_mode mode;
9837 /* Verify the required arguments in the original call. */
9838 if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9839 INTEGER_TYPE, INTEGER_TYPE,
9840 INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9843 fp_nan = CALL_EXPR_ARG (exp, 0);
9844 fp_infinite = CALL_EXPR_ARG (exp, 1);
9845 fp_normal = CALL_EXPR_ARG (exp, 2);
9846 fp_subnormal = CALL_EXPR_ARG (exp, 3);
9847 fp_zero = CALL_EXPR_ARG (exp, 4);
9848 arg = CALL_EXPR_ARG (exp, 5);
9849 type = TREE_TYPE (arg);
9850 mode = TYPE_MODE (type);
9851 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9855 (fabs(x) == Inf ? FP_INFINITE :
9856 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9857 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9859 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9860 build_real (type, dconst0));
9861 res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9862 tmp, fp_zero, fp_subnormal);
9864 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9865 real_from_string (&r, buf);
9866 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9867 arg, build_real (type, r));
9868 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9870 if (HONOR_INFINITIES (mode))
9873 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9874 build_real (type, r));
9875 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9879 if (HONOR_NANS (mode))
9881 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9882 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9888 /* Fold a call to an unordered comparison function such as
9889 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9890 being called and ARG0 and ARG1 are the arguments for the call.
9891 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9892 the opposite of the desired result. UNORDERED_CODE is used
9893 for modes that can hold NaNs and ORDERED_CODE is used for
9897 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9898 enum tree_code unordered_code,
9899 enum tree_code ordered_code)
9901 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9902 enum tree_code code;
9904 enum tree_code code0, code1;
9905 tree cmp_type = NULL_TREE;
9907 type0 = TREE_TYPE (arg0);
9908 type1 = TREE_TYPE (arg1);
9910 code0 = TREE_CODE (type0);
9911 code1 = TREE_CODE (type1);
9913 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9914 /* Choose the wider of two real types. */
9915 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9917 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9919 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9922 arg0 = fold_convert_loc (loc, cmp_type, arg0);
9923 arg1 = fold_convert_loc (loc, cmp_type, arg1);
9925 if (unordered_code == UNORDERED_EXPR)
9927 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9928 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9929 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9932 code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9934 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9935 fold_build2_loc (loc, code, type, arg0, arg1));
9938 /* Fold a call to built-in function FNDECL with 0 arguments.
9939 IGNORE is true if the result of the function call is ignored. This
9940 function returns NULL_TREE if no simplification was possible. */
9943 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9945 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9946 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9949 CASE_FLT_FN (BUILT_IN_INF):
9950 case BUILT_IN_INFD32:
9951 case BUILT_IN_INFD64:
9952 case BUILT_IN_INFD128:
9953 return fold_builtin_inf (loc, type, true);
9955 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9956 return fold_builtin_inf (loc, type, false);
9958 case BUILT_IN_CLASSIFY_TYPE:
9959 return fold_builtin_classify_type (NULL_TREE);
9967 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9968 IGNORE is true if the result of the function call is ignored. This
9969 function returns NULL_TREE if no simplification was possible. */
9972 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9974 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9975 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9979 case BUILT_IN_CONSTANT_P:
9981 tree val = fold_builtin_constant_p (arg0);
9983 /* Gimplification will pull the CALL_EXPR for the builtin out of
9984 an if condition. When not optimizing, we'll not CSE it back.
9985 To avoid link error types of regressions, return false now. */
9986 if (!val && !optimize)
9987 val = integer_zero_node;
9992 case BUILT_IN_CLASSIFY_TYPE:
9993 return fold_builtin_classify_type (arg0);
9995 case BUILT_IN_STRLEN:
9996 return fold_builtin_strlen (loc, arg0);
9998 CASE_FLT_FN (BUILT_IN_FABS):
9999 return fold_builtin_fabs (loc, arg0, type);
10002 case BUILT_IN_LABS:
10003 case BUILT_IN_LLABS:
10004 case BUILT_IN_IMAXABS:
10005 return fold_builtin_abs (loc, arg0, type);
10007 CASE_FLT_FN (BUILT_IN_CONJ):
10008 if (validate_arg (arg0, COMPLEX_TYPE)
10009 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10010 return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
10013 CASE_FLT_FN (BUILT_IN_CREAL):
10014 if (validate_arg (arg0, COMPLEX_TYPE)
10015 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10016 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
10019 CASE_FLT_FN (BUILT_IN_CIMAG):
10020 if (validate_arg (arg0, COMPLEX_TYPE)
10021 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10022 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
10025 CASE_FLT_FN (BUILT_IN_CCOS):
10026 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
10028 CASE_FLT_FN (BUILT_IN_CCOSH):
10029 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
10032 CASE_FLT_FN (BUILT_IN_CSIN):
10033 if (validate_arg (arg0, COMPLEX_TYPE)
10034 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10035 return do_mpc_arg1 (arg0, type, mpc_sin);
10038 CASE_FLT_FN (BUILT_IN_CSINH):
10039 if (validate_arg (arg0, COMPLEX_TYPE)
10040 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10041 return do_mpc_arg1 (arg0, type, mpc_sinh);
10044 CASE_FLT_FN (BUILT_IN_CTAN):
10045 if (validate_arg (arg0, COMPLEX_TYPE)
10046 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10047 return do_mpc_arg1 (arg0, type, mpc_tan);
10050 CASE_FLT_FN (BUILT_IN_CTANH):
10051 if (validate_arg (arg0, COMPLEX_TYPE)
10052 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10053 return do_mpc_arg1 (arg0, type, mpc_tanh);
10056 CASE_FLT_FN (BUILT_IN_CLOG):
10057 if (validate_arg (arg0, COMPLEX_TYPE)
10058 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10059 return do_mpc_arg1 (arg0, type, mpc_log);
10062 CASE_FLT_FN (BUILT_IN_CSQRT):
10063 if (validate_arg (arg0, COMPLEX_TYPE)
10064 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10065 return do_mpc_arg1 (arg0, type, mpc_sqrt);
10068 #ifdef HAVE_mpc_arc
10069 CASE_FLT_FN (BUILT_IN_CASIN):
10070 if (validate_arg (arg0, COMPLEX_TYPE)
10071 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10072 return do_mpc_arg1 (arg0, type, mpc_asin);
10075 CASE_FLT_FN (BUILT_IN_CACOS):
10076 if (validate_arg (arg0, COMPLEX_TYPE)
10077 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10078 return do_mpc_arg1 (arg0, type, mpc_acos);
10081 CASE_FLT_FN (BUILT_IN_CATAN):
10082 if (validate_arg (arg0, COMPLEX_TYPE)
10083 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10084 return do_mpc_arg1 (arg0, type, mpc_atan);
10087 CASE_FLT_FN (BUILT_IN_CASINH):
10088 if (validate_arg (arg0, COMPLEX_TYPE)
10089 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10090 return do_mpc_arg1 (arg0, type, mpc_asinh);
10093 CASE_FLT_FN (BUILT_IN_CACOSH):
10094 if (validate_arg (arg0, COMPLEX_TYPE)
10095 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10096 return do_mpc_arg1 (arg0, type, mpc_acosh);
10099 CASE_FLT_FN (BUILT_IN_CATANH):
10100 if (validate_arg (arg0, COMPLEX_TYPE)
10101 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10102 return do_mpc_arg1 (arg0, type, mpc_atanh);
10104 #endif /* HAVE_mpc_arc */
10105 #endif /* HAVE_mpc */
10107 CASE_FLT_FN (BUILT_IN_CABS):
10108 return fold_builtin_cabs (loc, arg0, type, fndecl);
10110 CASE_FLT_FN (BUILT_IN_CARG):
10111 return fold_builtin_carg (loc, arg0, type);
10113 CASE_FLT_FN (BUILT_IN_SQRT):
10114 return fold_builtin_sqrt (loc, arg0, type);
10116 CASE_FLT_FN (BUILT_IN_CBRT):
10117 return fold_builtin_cbrt (loc, arg0, type);
10119 CASE_FLT_FN (BUILT_IN_ASIN):
10120 if (validate_arg (arg0, REAL_TYPE))
10121 return do_mpfr_arg1 (arg0, type, mpfr_asin,
10122 &dconstm1, &dconst1, true);
10125 CASE_FLT_FN (BUILT_IN_ACOS):
10126 if (validate_arg (arg0, REAL_TYPE))
10127 return do_mpfr_arg1 (arg0, type, mpfr_acos,
10128 &dconstm1, &dconst1, true);
10131 CASE_FLT_FN (BUILT_IN_ATAN):
10132 if (validate_arg (arg0, REAL_TYPE))
10133 return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10136 CASE_FLT_FN (BUILT_IN_ASINH):
10137 if (validate_arg (arg0, REAL_TYPE))
10138 return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10141 CASE_FLT_FN (BUILT_IN_ACOSH):
10142 if (validate_arg (arg0, REAL_TYPE))
10143 return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10144 &dconst1, NULL, true);
10147 CASE_FLT_FN (BUILT_IN_ATANH):
10148 if (validate_arg (arg0, REAL_TYPE))
10149 return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10150 &dconstm1, &dconst1, false);
10153 CASE_FLT_FN (BUILT_IN_SIN):
10154 if (validate_arg (arg0, REAL_TYPE))
10155 return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10158 CASE_FLT_FN (BUILT_IN_COS):
10159 return fold_builtin_cos (loc, arg0, type, fndecl);
10161 CASE_FLT_FN (BUILT_IN_TAN):
10162 return fold_builtin_tan (arg0, type);
10164 CASE_FLT_FN (BUILT_IN_CEXP):
10165 return fold_builtin_cexp (loc, arg0, type);
10167 CASE_FLT_FN (BUILT_IN_CEXPI):
10168 if (validate_arg (arg0, REAL_TYPE))
10169 return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10172 CASE_FLT_FN (BUILT_IN_SINH):
10173 if (validate_arg (arg0, REAL_TYPE))
10174 return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10177 CASE_FLT_FN (BUILT_IN_COSH):
10178 return fold_builtin_cosh (loc, arg0, type, fndecl);
10180 CASE_FLT_FN (BUILT_IN_TANH):
10181 if (validate_arg (arg0, REAL_TYPE))
10182 return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10185 CASE_FLT_FN (BUILT_IN_ERF):
10186 if (validate_arg (arg0, REAL_TYPE))
10187 return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10190 CASE_FLT_FN (BUILT_IN_ERFC):
10191 if (validate_arg (arg0, REAL_TYPE))
10192 return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10195 CASE_FLT_FN (BUILT_IN_TGAMMA):
10196 if (validate_arg (arg0, REAL_TYPE))
10197 return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10200 CASE_FLT_FN (BUILT_IN_EXP):
10201 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10203 CASE_FLT_FN (BUILT_IN_EXP2):
10204 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10206 CASE_FLT_FN (BUILT_IN_EXP10):
10207 CASE_FLT_FN (BUILT_IN_POW10):
10208 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10210 CASE_FLT_FN (BUILT_IN_EXPM1):
10211 if (validate_arg (arg0, REAL_TYPE))
10212 return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10215 CASE_FLT_FN (BUILT_IN_LOG):
10216 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10218 CASE_FLT_FN (BUILT_IN_LOG2):
10219 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10221 CASE_FLT_FN (BUILT_IN_LOG10):
10222 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10224 CASE_FLT_FN (BUILT_IN_LOG1P):
10225 if (validate_arg (arg0, REAL_TYPE))
10226 return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10227 &dconstm1, NULL, false);
10230 CASE_FLT_FN (BUILT_IN_J0):
10231 if (validate_arg (arg0, REAL_TYPE))
10232 return do_mpfr_arg1 (arg0, type, mpfr_j0,
10236 CASE_FLT_FN (BUILT_IN_J1):
10237 if (validate_arg (arg0, REAL_TYPE))
10238 return do_mpfr_arg1 (arg0, type, mpfr_j1,
10242 CASE_FLT_FN (BUILT_IN_Y0):
10243 if (validate_arg (arg0, REAL_TYPE))
10244 return do_mpfr_arg1 (arg0, type, mpfr_y0,
10245 &dconst0, NULL, false);
10248 CASE_FLT_FN (BUILT_IN_Y1):
10249 if (validate_arg (arg0, REAL_TYPE))
10250 return do_mpfr_arg1 (arg0, type, mpfr_y1,
10251 &dconst0, NULL, false);
10254 CASE_FLT_FN (BUILT_IN_NAN):
10255 case BUILT_IN_NAND32:
10256 case BUILT_IN_NAND64:
10257 case BUILT_IN_NAND128:
10258 return fold_builtin_nan (arg0, type, true);
10260 CASE_FLT_FN (BUILT_IN_NANS):
10261 return fold_builtin_nan (arg0, type, false);
10263 CASE_FLT_FN (BUILT_IN_FLOOR):
10264 return fold_builtin_floor (loc, fndecl, arg0);
10266 CASE_FLT_FN (BUILT_IN_CEIL):
10267 return fold_builtin_ceil (loc, fndecl, arg0);
10269 CASE_FLT_FN (BUILT_IN_TRUNC):
10270 return fold_builtin_trunc (loc, fndecl, arg0);
10272 CASE_FLT_FN (BUILT_IN_ROUND):
10273 return fold_builtin_round (loc, fndecl, arg0);
10275 CASE_FLT_FN (BUILT_IN_NEARBYINT):
10276 CASE_FLT_FN (BUILT_IN_RINT):
10277 return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10279 CASE_FLT_FN (BUILT_IN_LCEIL):
10280 CASE_FLT_FN (BUILT_IN_LLCEIL):
10281 CASE_FLT_FN (BUILT_IN_LFLOOR):
10282 CASE_FLT_FN (BUILT_IN_LLFLOOR):
10283 CASE_FLT_FN (BUILT_IN_LROUND):
10284 CASE_FLT_FN (BUILT_IN_LLROUND):
10285 return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10287 CASE_FLT_FN (BUILT_IN_LRINT):
10288 CASE_FLT_FN (BUILT_IN_LLRINT):
10289 return fold_fixed_mathfn (loc, fndecl, arg0);
10291 case BUILT_IN_BSWAP32:
10292 case BUILT_IN_BSWAP64:
10293 return fold_builtin_bswap (fndecl, arg0);
10295 CASE_INT_FN (BUILT_IN_FFS):
10296 CASE_INT_FN (BUILT_IN_CLZ):
10297 CASE_INT_FN (BUILT_IN_CTZ):
10298 CASE_INT_FN (BUILT_IN_POPCOUNT):
10299 CASE_INT_FN (BUILT_IN_PARITY):
10300 return fold_builtin_bitop (fndecl, arg0);
10302 CASE_FLT_FN (BUILT_IN_SIGNBIT):
10303 return fold_builtin_signbit (loc, arg0, type);
10305 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10306 return fold_builtin_significand (loc, arg0, type);
10308 CASE_FLT_FN (BUILT_IN_ILOGB):
10309 CASE_FLT_FN (BUILT_IN_LOGB):
10310 return fold_builtin_logb (loc, arg0, type);
10312 case BUILT_IN_ISASCII:
10313 return fold_builtin_isascii (loc, arg0);
10315 case BUILT_IN_TOASCII:
10316 return fold_builtin_toascii (loc, arg0);
10318 case BUILT_IN_ISDIGIT:
10319 return fold_builtin_isdigit (loc, arg0);
10321 CASE_FLT_FN (BUILT_IN_FINITE):
10322 case BUILT_IN_FINITED32:
10323 case BUILT_IN_FINITED64:
10324 case BUILT_IN_FINITED128:
10325 case BUILT_IN_ISFINITE:
10327 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10330 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10333 CASE_FLT_FN (BUILT_IN_ISINF):
10334 case BUILT_IN_ISINFD32:
10335 case BUILT_IN_ISINFD64:
10336 case BUILT_IN_ISINFD128:
10338 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10341 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10344 case BUILT_IN_ISNORMAL:
10345 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10347 case BUILT_IN_ISINF_SIGN:
10348 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10350 CASE_FLT_FN (BUILT_IN_ISNAN):
10351 case BUILT_IN_ISNAND32:
10352 case BUILT_IN_ISNAND64:
10353 case BUILT_IN_ISNAND128:
10354 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10356 case BUILT_IN_PRINTF:
10357 case BUILT_IN_PRINTF_UNLOCKED:
10358 case BUILT_IN_VPRINTF:
10359 return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10369 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10370 IGNORE is true if the result of the function call is ignored. This
10371 function returns NULL_TREE if no simplification was possible. */
10374 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10376 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10377 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10381 CASE_FLT_FN (BUILT_IN_JN):
10382 if (validate_arg (arg0, INTEGER_TYPE)
10383 && validate_arg (arg1, REAL_TYPE))
10384 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10387 CASE_FLT_FN (BUILT_IN_YN):
10388 if (validate_arg (arg0, INTEGER_TYPE)
10389 && validate_arg (arg1, REAL_TYPE))
10390 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10394 CASE_FLT_FN (BUILT_IN_DREM):
10395 CASE_FLT_FN (BUILT_IN_REMAINDER):
10396 if (validate_arg (arg0, REAL_TYPE)
10397 && validate_arg(arg1, REAL_TYPE))
10398 return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10401 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10402 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10403 if (validate_arg (arg0, REAL_TYPE)
10404 && validate_arg(arg1, POINTER_TYPE))
10405 return do_mpfr_lgamma_r (arg0, arg1, type);
10408 CASE_FLT_FN (BUILT_IN_ATAN2):
10409 if (validate_arg (arg0, REAL_TYPE)
10410 && validate_arg(arg1, REAL_TYPE))
10411 return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10414 CASE_FLT_FN (BUILT_IN_FDIM):
10415 if (validate_arg (arg0, REAL_TYPE)
10416 && validate_arg(arg1, REAL_TYPE))
10417 return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10420 CASE_FLT_FN (BUILT_IN_HYPOT):
10421 return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10423 #ifdef HAVE_mpc_pow
10424 CASE_FLT_FN (BUILT_IN_CPOW):
10425 if (validate_arg (arg0, COMPLEX_TYPE)
10426 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10427 && validate_arg (arg1, COMPLEX_TYPE)
10428 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10429 return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10433 CASE_FLT_FN (BUILT_IN_LDEXP):
10434 return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10435 CASE_FLT_FN (BUILT_IN_SCALBN):
10436 CASE_FLT_FN (BUILT_IN_SCALBLN):
10437 return fold_builtin_load_exponent (loc, arg0, arg1,
10438 type, /*ldexp=*/false);
10440 CASE_FLT_FN (BUILT_IN_FREXP):
10441 return fold_builtin_frexp (loc, arg0, arg1, type);
10443 CASE_FLT_FN (BUILT_IN_MODF):
10444 return fold_builtin_modf (loc, arg0, arg1, type);
10446 case BUILT_IN_BZERO:
10447 return fold_builtin_bzero (loc, arg0, arg1, ignore);
10449 case BUILT_IN_FPUTS:
10450 return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10452 case BUILT_IN_FPUTS_UNLOCKED:
10453 return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10455 case BUILT_IN_STRSTR:
10456 return fold_builtin_strstr (loc, arg0, arg1, type);
10458 case BUILT_IN_STRCAT:
10459 return fold_builtin_strcat (loc, arg0, arg1);
10461 case BUILT_IN_STRSPN:
10462 return fold_builtin_strspn (loc, arg0, arg1);
10464 case BUILT_IN_STRCSPN:
10465 return fold_builtin_strcspn (loc, arg0, arg1);
10467 case BUILT_IN_STRCHR:
10468 case BUILT_IN_INDEX:
10469 return fold_builtin_strchr (loc, arg0, arg1, type);
10471 case BUILT_IN_STRRCHR:
10472 case BUILT_IN_RINDEX:
10473 return fold_builtin_strrchr (loc, arg0, arg1, type);
10475 case BUILT_IN_STRCPY:
10476 return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10478 case BUILT_IN_STPCPY:
10481 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10485 return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10488 return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10491 case BUILT_IN_STRCMP:
10492 return fold_builtin_strcmp (loc, arg0, arg1);
10494 case BUILT_IN_STRPBRK:
10495 return fold_builtin_strpbrk (loc, arg0, arg1, type);
10497 case BUILT_IN_EXPECT:
10498 return fold_builtin_expect (loc, arg0, arg1);
10500 CASE_FLT_FN (BUILT_IN_POW):
10501 return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10503 CASE_FLT_FN (BUILT_IN_POWI):
10504 return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10506 CASE_FLT_FN (BUILT_IN_COPYSIGN):
10507 return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10509 CASE_FLT_FN (BUILT_IN_FMIN):
10510 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10512 CASE_FLT_FN (BUILT_IN_FMAX):
10513 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10515 case BUILT_IN_ISGREATER:
10516 return fold_builtin_unordered_cmp (loc, fndecl,
10517 arg0, arg1, UNLE_EXPR, LE_EXPR);
10518 case BUILT_IN_ISGREATEREQUAL:
10519 return fold_builtin_unordered_cmp (loc, fndecl,
10520 arg0, arg1, UNLT_EXPR, LT_EXPR);
10521 case BUILT_IN_ISLESS:
10522 return fold_builtin_unordered_cmp (loc, fndecl,
10523 arg0, arg1, UNGE_EXPR, GE_EXPR);
10524 case BUILT_IN_ISLESSEQUAL:
10525 return fold_builtin_unordered_cmp (loc, fndecl,
10526 arg0, arg1, UNGT_EXPR, GT_EXPR);
10527 case BUILT_IN_ISLESSGREATER:
10528 return fold_builtin_unordered_cmp (loc, fndecl,
10529 arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10530 case BUILT_IN_ISUNORDERED:
10531 return fold_builtin_unordered_cmp (loc, fndecl,
10532 arg0, arg1, UNORDERED_EXPR,
10535 /* We do the folding for va_start in the expander. */
10536 case BUILT_IN_VA_START:
10539 case BUILT_IN_SPRINTF:
10540 return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10542 case BUILT_IN_OBJECT_SIZE:
10543 return fold_builtin_object_size (arg0, arg1);
10545 case BUILT_IN_PRINTF:
10546 case BUILT_IN_PRINTF_UNLOCKED:
10547 case BUILT_IN_VPRINTF:
10548 return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10550 case BUILT_IN_PRINTF_CHK:
10551 case BUILT_IN_VPRINTF_CHK:
10552 if (!validate_arg (arg0, INTEGER_TYPE)
10553 || TREE_SIDE_EFFECTS (arg0))
10556 return fold_builtin_printf (loc, fndecl,
10557 arg1, NULL_TREE, ignore, fcode);
10560 case BUILT_IN_FPRINTF:
10561 case BUILT_IN_FPRINTF_UNLOCKED:
10562 case BUILT_IN_VFPRINTF:
10563 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10572 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10573 and ARG2. IGNORE is true if the result of the function call is ignored.
10574 This function returns NULL_TREE if no simplification was possible. */
10577 fold_builtin_3 (location_t loc, tree fndecl,
10578 tree arg0, tree arg1, tree arg2, bool ignore)
10580 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10581 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10585 CASE_FLT_FN (BUILT_IN_SINCOS):
10586 return fold_builtin_sincos (loc, arg0, arg1, arg2);
10588 CASE_FLT_FN (BUILT_IN_FMA):
10589 if (validate_arg (arg0, REAL_TYPE)
10590 && validate_arg(arg1, REAL_TYPE)
10591 && validate_arg(arg2, REAL_TYPE))
10592 return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10595 CASE_FLT_FN (BUILT_IN_REMQUO):
10596 if (validate_arg (arg0, REAL_TYPE)
10597 && validate_arg(arg1, REAL_TYPE)
10598 && validate_arg(arg2, POINTER_TYPE))
10599 return do_mpfr_remquo (arg0, arg1, arg2);
10602 case BUILT_IN_MEMSET:
10603 return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10605 case BUILT_IN_BCOPY:
10606 return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10607 void_type_node, true, /*endp=*/3);
10609 case BUILT_IN_MEMCPY:
10610 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10611 type, ignore, /*endp=*/0);
10613 case BUILT_IN_MEMPCPY:
10614 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10615 type, ignore, /*endp=*/1);
10617 case BUILT_IN_MEMMOVE:
10618 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10619 type, ignore, /*endp=*/3);
10621 case BUILT_IN_STRNCAT:
10622 return fold_builtin_strncat (loc, arg0, arg1, arg2);
10624 case BUILT_IN_STRNCPY:
10625 return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10627 case BUILT_IN_STRNCMP:
10628 return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10630 case BUILT_IN_MEMCHR:
10631 return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10633 case BUILT_IN_BCMP:
10634 case BUILT_IN_MEMCMP:
10635 return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10637 case BUILT_IN_SPRINTF:
10638 return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10640 case BUILT_IN_STRCPY_CHK:
10641 case BUILT_IN_STPCPY_CHK:
10642 return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10645 case BUILT_IN_STRCAT_CHK:
10646 return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10648 case BUILT_IN_PRINTF_CHK:
10649 case BUILT_IN_VPRINTF_CHK:
10650 if (!validate_arg (arg0, INTEGER_TYPE)
10651 || TREE_SIDE_EFFECTS (arg0))
10654 return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10657 case BUILT_IN_FPRINTF:
10658 case BUILT_IN_FPRINTF_UNLOCKED:
10659 case BUILT_IN_VFPRINTF:
10660 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10663 case BUILT_IN_FPRINTF_CHK:
10664 case BUILT_IN_VFPRINTF_CHK:
10665 if (!validate_arg (arg1, INTEGER_TYPE)
10666 || TREE_SIDE_EFFECTS (arg1))
10669 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10678 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10679 ARG2, and ARG3. IGNORE is true if the result of the function call is
10680 ignored. This function returns NULL_TREE if no simplification was
10684 fold_builtin_4 (location_t loc, tree fndecl,
10685 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10687 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10691 case BUILT_IN_MEMCPY_CHK:
10692 case BUILT_IN_MEMPCPY_CHK:
10693 case BUILT_IN_MEMMOVE_CHK:
10694 case BUILT_IN_MEMSET_CHK:
10695 return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10697 DECL_FUNCTION_CODE (fndecl));
10699 case BUILT_IN_STRNCPY_CHK:
10700 return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10702 case BUILT_IN_STRNCAT_CHK:
10703 return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10705 case BUILT_IN_FPRINTF_CHK:
10706 case BUILT_IN_VFPRINTF_CHK:
10707 if (!validate_arg (arg1, INTEGER_TYPE)
10708 || TREE_SIDE_EFFECTS (arg1))
10711 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10721 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10722 arguments, where NARGS <= 4. IGNORE is true if the result of the
10723 function call is ignored. This function returns NULL_TREE if no
10724 simplification was possible. Note that this only folds builtins with
10725 fixed argument patterns. Foldings that do varargs-to-varargs
10726 transformations, or that match calls with more than 4 arguments,
10727 need to be handled with fold_builtin_varargs instead. */
10729 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10732 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10734 tree ret = NULL_TREE;
10739 ret = fold_builtin_0 (loc, fndecl, ignore);
10742 ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10745 ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10748 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10751 ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10759 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10760 SET_EXPR_LOCATION (ret, loc);
10761 TREE_NO_WARNING (ret) = 1;
10767 /* Builtins with folding operations that operate on "..." arguments
10768 need special handling; we need to store the arguments in a convenient
10769 data structure before attempting any folding. Fortunately there are
10770 only a few builtins that fall into this category. FNDECL is the
10771 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10772 result of the function call is ignored. */
10775 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10776 bool ignore ATTRIBUTE_UNUSED)
10778 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10779 tree ret = NULL_TREE;
10783 case BUILT_IN_SPRINTF_CHK:
10784 case BUILT_IN_VSPRINTF_CHK:
10785 ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10788 case BUILT_IN_SNPRINTF_CHK:
10789 case BUILT_IN_VSNPRINTF_CHK:
10790 ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10793 case BUILT_IN_FPCLASSIFY:
10794 ret = fold_builtin_fpclassify (loc, exp);
10802 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10803 SET_EXPR_LOCATION (ret, loc);
10804 TREE_NO_WARNING (ret) = 1;
10810 /* Return true if FNDECL shouldn't be folded right now.
10811 If a built-in function has an inline attribute always_inline
10812 wrapper, defer folding it after always_inline functions have
10813 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10814 might not be performed. */
10817 avoid_folding_inline_builtin (tree fndecl)
10819 return (DECL_DECLARED_INLINE_P (fndecl)
10820 && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10822 && !cfun->always_inline_functions_inlined
10823 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10826 /* A wrapper function for builtin folding that prevents warnings for
10827 "statement without effect" and the like, caused by removing the
10828 call node earlier than the warning is generated. */
10831 fold_call_expr (location_t loc, tree exp, bool ignore)
10833 tree ret = NULL_TREE;
10834 tree fndecl = get_callee_fndecl (exp);
10836 && TREE_CODE (fndecl) == FUNCTION_DECL
10837 && DECL_BUILT_IN (fndecl)
10838 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10839 yet. Defer folding until we see all the arguments
10840 (after inlining). */
10841 && !CALL_EXPR_VA_ARG_PACK (exp))
10843 int nargs = call_expr_nargs (exp);
10845 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10846 instead last argument is __builtin_va_arg_pack (). Defer folding
10847 even in that case, until arguments are finalized. */
10848 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10850 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10852 && TREE_CODE (fndecl2) == FUNCTION_DECL
10853 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10854 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10858 if (avoid_folding_inline_builtin (fndecl))
10861 /* FIXME: Don't use a list in this interface. */
10862 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10863 return targetm.fold_builtin (fndecl, CALL_EXPR_ARGS (exp), ignore);
10866 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10868 tree *args = CALL_EXPR_ARGP (exp);
10869 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10872 ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10880 /* Conveniently construct a function call expression. FNDECL names the
10881 function to be called and ARGLIST is a TREE_LIST of arguments. */
10884 build_function_call_expr (location_t loc, tree fndecl, tree arglist)
10886 tree fntype = TREE_TYPE (fndecl);
10887 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10888 int n = list_length (arglist);
10889 tree *argarray = (tree *) alloca (n * sizeof (tree));
10892 for (i = 0; i < n; i++, arglist = TREE_CHAIN (arglist))
10893 argarray[i] = TREE_VALUE (arglist);
10894 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10897 /* Conveniently construct a function call expression. FNDECL names the
10898 function to be called, N is the number of arguments, and the "..."
10899 parameters are the argument expressions. */
10902 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10905 tree fntype = TREE_TYPE (fndecl);
10906 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10907 tree *argarray = (tree *) alloca (n * sizeof (tree));
10911 for (i = 0; i < n; i++)
10912 argarray[i] = va_arg (ap, tree);
10914 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10917 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10918 N arguments are passed in the array ARGARRAY. */
10921 fold_builtin_call_array (location_t loc, tree type,
10926 tree ret = NULL_TREE;
10930 if (TREE_CODE (fn) == ADDR_EXPR)
10932 tree fndecl = TREE_OPERAND (fn, 0);
10933 if (TREE_CODE (fndecl) == FUNCTION_DECL
10934 && DECL_BUILT_IN (fndecl))
10936 /* If last argument is __builtin_va_arg_pack (), arguments to this
10937 function are not finalized yet. Defer folding until they are. */
10938 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10940 tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10942 && TREE_CODE (fndecl2) == FUNCTION_DECL
10943 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10944 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10945 return build_call_array_loc (loc, type, fn, n, argarray);
10947 if (avoid_folding_inline_builtin (fndecl))
10948 return build_call_array_loc (loc, type, fn, n, argarray);
10949 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10951 tree arglist = NULL_TREE;
10952 for (i = n - 1; i >= 0; i--)
10953 arglist = tree_cons (NULL_TREE, argarray[i], arglist);
10954 ret = targetm.fold_builtin (fndecl, arglist, false);
10957 return build_call_array_loc (loc, type, fn, n, argarray);
10959 else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10961 /* First try the transformations that don't require consing up
10963 ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10968 /* If we got this far, we need to build an exp. */
10969 exp = build_call_array_loc (loc, type, fn, n, argarray);
10970 ret = fold_builtin_varargs (loc, fndecl, exp, false);
10971 return ret ? ret : exp;
10975 return build_call_array_loc (loc, type, fn, n, argarray);
10978 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10979 along with N new arguments specified as the "..." parameters. SKIP
10980 is the number of arguments in EXP to be omitted. This function is used
10981 to do varargs-to-varargs transformations. */
10984 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10986 int oldnargs = call_expr_nargs (exp);
10987 int nargs = oldnargs - skip + n;
10988 tree fntype = TREE_TYPE (fndecl);
10989 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10997 buffer = XALLOCAVEC (tree, nargs);
10999 for (i = 0; i < n; i++)
11000 buffer[i] = va_arg (ap, tree);
11002 for (j = skip; j < oldnargs; j++, i++)
11003 buffer[i] = CALL_EXPR_ARG (exp, j);
11006 buffer = CALL_EXPR_ARGP (exp) + skip;
11008 return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
11011 /* Validate a single argument ARG against a tree code CODE representing
11015 validate_arg (const_tree arg, enum tree_code code)
11019 else if (code == POINTER_TYPE)
11020 return POINTER_TYPE_P (TREE_TYPE (arg));
11021 else if (code == INTEGER_TYPE)
11022 return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11023 return code == TREE_CODE (TREE_TYPE (arg));
11026 /* This function validates the types of a function call argument list
11027 against a specified list of tree_codes. If the last specifier is a 0,
11028 that represents an ellipses, otherwise the last specifier must be a
11031 This is the GIMPLE version of validate_arglist. Eventually we want to
11032 completely convert builtins.c to work from GIMPLEs and the tree based
11033 validate_arglist will then be removed. */
11036 validate_gimple_arglist (const_gimple call, ...)
11038 enum tree_code code;
11044 va_start (ap, call);
11049 code = (enum tree_code) va_arg (ap, int);
11053 /* This signifies an ellipses, any further arguments are all ok. */
11057 /* This signifies an endlink, if no arguments remain, return
11058 true, otherwise return false. */
11059 res = (i == gimple_call_num_args (call));
11062 /* If no parameters remain or the parameter's code does not
11063 match the specified code, return false. Otherwise continue
11064 checking any remaining arguments. */
11065 arg = gimple_call_arg (call, i++);
11066 if (!validate_arg (arg, code))
11073 /* We need gotos here since we can only have one VA_CLOSE in a
11081 /* This function validates the types of a function call argument list
11082 against a specified list of tree_codes. If the last specifier is a 0,
11083 that represents an ellipses, otherwise the last specifier must be a
11087 validate_arglist (const_tree callexpr, ...)
11089 enum tree_code code;
11092 const_call_expr_arg_iterator iter;
11095 va_start (ap, callexpr);
11096 init_const_call_expr_arg_iterator (callexpr, &iter);
11100 code = (enum tree_code) va_arg (ap, int);
11104 /* This signifies an ellipses, any further arguments are all ok. */
11108 /* This signifies an endlink, if no arguments remain, return
11109 true, otherwise return false. */
11110 res = !more_const_call_expr_args_p (&iter);
11113 /* If no parameters remain or the parameter's code does not
11114 match the specified code, return false. Otherwise continue
11115 checking any remaining arguments. */
11116 arg = next_const_call_expr_arg (&iter);
11117 if (!validate_arg (arg, code))
11124 /* We need gotos here since we can only have one VA_CLOSE in a
11132 /* Default target-specific builtin expander that does nothing. */
11135 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11136 rtx target ATTRIBUTE_UNUSED,
11137 rtx subtarget ATTRIBUTE_UNUSED,
11138 enum machine_mode mode ATTRIBUTE_UNUSED,
11139 int ignore ATTRIBUTE_UNUSED)
11144 /* Returns true is EXP represents data that would potentially reside
11145 in a readonly section. */
11148 readonly_data_expr (tree exp)
11152 if (TREE_CODE (exp) != ADDR_EXPR)
11155 exp = get_base_address (TREE_OPERAND (exp, 0));
11159 /* Make sure we call decl_readonly_section only for trees it
11160 can handle (since it returns true for everything it doesn't
11162 if (TREE_CODE (exp) == STRING_CST
11163 || TREE_CODE (exp) == CONSTRUCTOR
11164 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11165 return decl_readonly_section (exp, 0);
11170 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11171 to the call, and TYPE is its return type.
11173 Return NULL_TREE if no simplification was possible, otherwise return the
11174 simplified form of the call as a tree.
11176 The simplified form may be a constant or other expression which
11177 computes the same value, but in a more efficient manner (including
11178 calls to other builtin functions).
11180 The call may contain arguments which need to be evaluated, but
11181 which are not useful to determine the result of the call. In
11182 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11183 COMPOUND_EXPR will be an argument which must be evaluated.
11184 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11185 COMPOUND_EXPR in the chain will contain the tree for the simplified
11186 form of the builtin function call. */
11189 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11191 if (!validate_arg (s1, POINTER_TYPE)
11192 || !validate_arg (s2, POINTER_TYPE))
11197 const char *p1, *p2;
11199 p2 = c_getstr (s2);
11203 p1 = c_getstr (s1);
11206 const char *r = strstr (p1, p2);
11210 return build_int_cst (TREE_TYPE (s1), 0);
11212 /* Return an offset into the constant string argument. */
11213 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11214 s1, size_int (r - p1));
11215 return fold_convert_loc (loc, type, tem);
11218 /* The argument is const char *, and the result is char *, so we need
11219 a type conversion here to avoid a warning. */
11221 return fold_convert_loc (loc, type, s1);
11226 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11230 /* New argument list transforming strstr(s1, s2) to
11231 strchr(s1, s2[0]). */
11232 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11236 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11237 the call, and TYPE is its return type.
11239 Return NULL_TREE if no simplification was possible, otherwise return the
11240 simplified form of the call as a tree.
11242 The simplified form may be a constant or other expression which
11243 computes the same value, but in a more efficient manner (including
11244 calls to other builtin functions).
11246 The call may contain arguments which need to be evaluated, but
11247 which are not useful to determine the result of the call. In
11248 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11249 COMPOUND_EXPR will be an argument which must be evaluated.
11250 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11251 COMPOUND_EXPR in the chain will contain the tree for the simplified
11252 form of the builtin function call. */
11255 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11257 if (!validate_arg (s1, POINTER_TYPE)
11258 || !validate_arg (s2, INTEGER_TYPE))
11264 if (TREE_CODE (s2) != INTEGER_CST)
11267 p1 = c_getstr (s1);
11274 if (target_char_cast (s2, &c))
11277 r = strchr (p1, c);
11280 return build_int_cst (TREE_TYPE (s1), 0);
11282 /* Return an offset into the constant string argument. */
11283 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11284 s1, size_int (r - p1));
11285 return fold_convert_loc (loc, type, tem);
11291 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11292 the call, and TYPE is its return type.
11294 Return NULL_TREE if no simplification was possible, otherwise return the
11295 simplified form of the call as a tree.
11297 The simplified form may be a constant or other expression which
11298 computes the same value, but in a more efficient manner (including
11299 calls to other builtin functions).
11301 The call may contain arguments which need to be evaluated, but
11302 which are not useful to determine the result of the call. In
11303 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11304 COMPOUND_EXPR will be an argument which must be evaluated.
11305 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11306 COMPOUND_EXPR in the chain will contain the tree for the simplified
11307 form of the builtin function call. */
11310 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11312 if (!validate_arg (s1, POINTER_TYPE)
11313 || !validate_arg (s2, INTEGER_TYPE))
11320 if (TREE_CODE (s2) != INTEGER_CST)
11323 p1 = c_getstr (s1);
11330 if (target_char_cast (s2, &c))
11333 r = strrchr (p1, c);
11336 return build_int_cst (TREE_TYPE (s1), 0);
11338 /* Return an offset into the constant string argument. */
11339 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11340 s1, size_int (r - p1));
11341 return fold_convert_loc (loc, type, tem);
11344 if (! integer_zerop (s2))
11347 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11351 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11352 return build_call_expr_loc (loc, fn, 2, s1, s2);
11356 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11357 to the call, and TYPE is its return type.
11359 Return NULL_TREE if no simplification was possible, otherwise return the
11360 simplified form of the call as a tree.
11362 The simplified form may be a constant or other expression which
11363 computes the same value, but in a more efficient manner (including
11364 calls to other builtin functions).
11366 The call may contain arguments which need to be evaluated, but
11367 which are not useful to determine the result of the call. In
11368 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11369 COMPOUND_EXPR will be an argument which must be evaluated.
11370 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11371 COMPOUND_EXPR in the chain will contain the tree for the simplified
11372 form of the builtin function call. */
11375 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11377 if (!validate_arg (s1, POINTER_TYPE)
11378 || !validate_arg (s2, POINTER_TYPE))
11383 const char *p1, *p2;
11385 p2 = c_getstr (s2);
11389 p1 = c_getstr (s1);
11392 const char *r = strpbrk (p1, p2);
11396 return build_int_cst (TREE_TYPE (s1), 0);
11398 /* Return an offset into the constant string argument. */
11399 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11400 s1, size_int (r - p1));
11401 return fold_convert_loc (loc, type, tem);
11405 /* strpbrk(x, "") == NULL.
11406 Evaluate and ignore s1 in case it had side-effects. */
11407 return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11410 return NULL_TREE; /* Really call strpbrk. */
11412 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11416 /* New argument list transforming strpbrk(s1, s2) to
11417 strchr(s1, s2[0]). */
11418 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11422 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11425 Return NULL_TREE if no simplification was possible, otherwise return the
11426 simplified form of the call as a tree.
11428 The simplified form may be a constant or other expression which
11429 computes the same value, but in a more efficient manner (including
11430 calls to other builtin functions).
11432 The call may contain arguments which need to be evaluated, but
11433 which are not useful to determine the result of the call. In
11434 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11435 COMPOUND_EXPR will be an argument which must be evaluated.
11436 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11437 COMPOUND_EXPR in the chain will contain the tree for the simplified
11438 form of the builtin function call. */
11441 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11443 if (!validate_arg (dst, POINTER_TYPE)
11444 || !validate_arg (src, POINTER_TYPE))
11448 const char *p = c_getstr (src);
11450 /* If the string length is zero, return the dst parameter. */
11451 if (p && *p == '\0')
11454 if (optimize_insn_for_speed_p ())
11456 /* See if we can store by pieces into (dst + strlen(dst)). */
11458 tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11459 tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11461 if (!strlen_fn || !strcpy_fn)
11464 /* If we don't have a movstr we don't want to emit an strcpy
11465 call. We have to do that if the length of the source string
11466 isn't computable (in that case we can use memcpy probably
11467 later expanding to a sequence of mov instructions). If we
11468 have movstr instructions we can emit strcpy calls. */
11471 tree len = c_strlen (src, 1);
11472 if (! len || TREE_SIDE_EFFECTS (len))
11476 /* Stabilize the argument list. */
11477 dst = builtin_save_expr (dst);
11479 /* Create strlen (dst). */
11480 newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11481 /* Create (dst p+ strlen (dst)). */
11483 newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11484 TREE_TYPE (dst), dst, newdst);
11485 newdst = builtin_save_expr (newdst);
11487 call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11488 return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11494 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11495 arguments to the call.
11497 Return NULL_TREE if no simplification was possible, otherwise return the
11498 simplified form of the call as a tree.
11500 The simplified form may be a constant or other expression which
11501 computes the same value, but in a more efficient manner (including
11502 calls to other builtin functions).
11504 The call may contain arguments which need to be evaluated, but
11505 which are not useful to determine the result of the call. In
11506 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11507 COMPOUND_EXPR will be an argument which must be evaluated.
11508 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11509 COMPOUND_EXPR in the chain will contain the tree for the simplified
11510 form of the builtin function call. */
11513 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11515 if (!validate_arg (dst, POINTER_TYPE)
11516 || !validate_arg (src, POINTER_TYPE)
11517 || !validate_arg (len, INTEGER_TYPE))
11521 const char *p = c_getstr (src);
11523 /* If the requested length is zero, or the src parameter string
11524 length is zero, return the dst parameter. */
11525 if (integer_zerop (len) || (p && *p == '\0'))
11526 return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11528 /* If the requested len is greater than or equal to the string
11529 length, call strcat. */
11530 if (TREE_CODE (len) == INTEGER_CST && p
11531 && compare_tree_int (len, strlen (p)) >= 0)
11533 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11535 /* If the replacement _DECL isn't initialized, don't do the
11540 return build_call_expr_loc (loc, fn, 2, dst, src);
11546 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11549 Return NULL_TREE if no simplification was possible, otherwise return the
11550 simplified form of the call as a tree.
11552 The simplified form may be a constant or other expression which
11553 computes the same value, but in a more efficient manner (including
11554 calls to other builtin functions).
11556 The call may contain arguments which need to be evaluated, but
11557 which are not useful to determine the result of the call. In
11558 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11559 COMPOUND_EXPR will be an argument which must be evaluated.
11560 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11561 COMPOUND_EXPR in the chain will contain the tree for the simplified
11562 form of the builtin function call. */
11565 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11567 if (!validate_arg (s1, POINTER_TYPE)
11568 || !validate_arg (s2, POINTER_TYPE))
11572 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11574 /* If both arguments are constants, evaluate at compile-time. */
11577 const size_t r = strspn (p1, p2);
11578 return size_int (r);
11581 /* If either argument is "", return NULL_TREE. */
11582 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11583 /* Evaluate and ignore both arguments in case either one has
11585 return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11591 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11594 Return NULL_TREE if no simplification was possible, otherwise return the
11595 simplified form of the call as a tree.
11597 The simplified form may be a constant or other expression which
11598 computes the same value, but in a more efficient manner (including
11599 calls to other builtin functions).
11601 The call may contain arguments which need to be evaluated, but
11602 which are not useful to determine the result of the call. In
11603 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11604 COMPOUND_EXPR will be an argument which must be evaluated.
11605 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11606 COMPOUND_EXPR in the chain will contain the tree for the simplified
11607 form of the builtin function call. */
11610 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11612 if (!validate_arg (s1, POINTER_TYPE)
11613 || !validate_arg (s2, POINTER_TYPE))
11617 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11619 /* If both arguments are constants, evaluate at compile-time. */
11622 const size_t r = strcspn (p1, p2);
11623 return size_int (r);
11626 /* If the first argument is "", return NULL_TREE. */
11627 if (p1 && *p1 == '\0')
11629 /* Evaluate and ignore argument s2 in case it has
11631 return omit_one_operand_loc (loc, size_type_node,
11632 size_zero_node, s2);
11635 /* If the second argument is "", return __builtin_strlen(s1). */
11636 if (p2 && *p2 == '\0')
11638 tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11640 /* If the replacement _DECL isn't initialized, don't do the
11645 return build_call_expr_loc (loc, fn, 1, s1);
11651 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
11652 to the call. IGNORE is true if the value returned
11653 by the builtin will be ignored. UNLOCKED is true is true if this
11654 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
11655 the known length of the string. Return NULL_TREE if no simplification
11659 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11660 bool ignore, bool unlocked, tree len)
11662 /* If we're using an unlocked function, assume the other unlocked
11663 functions exist explicitly. */
11664 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11665 : implicit_built_in_decls[BUILT_IN_FPUTC];
11666 tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11667 : implicit_built_in_decls[BUILT_IN_FWRITE];
11669 /* If the return value is used, don't do the transformation. */
11673 /* Verify the arguments in the original call. */
11674 if (!validate_arg (arg0, POINTER_TYPE)
11675 || !validate_arg (arg1, POINTER_TYPE))
11679 len = c_strlen (arg0, 0);
11681 /* Get the length of the string passed to fputs. If the length
11682 can't be determined, punt. */
11684 || TREE_CODE (len) != INTEGER_CST)
11687 switch (compare_tree_int (len, 1))
11689 case -1: /* length is 0, delete the call entirely . */
11690 return omit_one_operand_loc (loc, integer_type_node,
11691 integer_zero_node, arg1);;
11693 case 0: /* length is 1, call fputc. */
11695 const char *p = c_getstr (arg0);
11700 return build_call_expr_loc (loc, fn_fputc, 2,
11701 build_int_cst (NULL_TREE, p[0]), arg1);
11707 case 1: /* length is greater than 1, call fwrite. */
11709 /* If optimizing for size keep fputs. */
11710 if (optimize_function_for_size_p (cfun))
11712 /* New argument list transforming fputs(string, stream) to
11713 fwrite(string, 1, len, stream). */
11715 return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11716 size_one_node, len, arg1);
11721 gcc_unreachable ();
11726 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11727 produced. False otherwise. This is done so that we don't output the error
11728 or warning twice or three times. */
11731 fold_builtin_next_arg (tree exp, bool va_start_p)
11733 tree fntype = TREE_TYPE (current_function_decl);
11734 int nargs = call_expr_nargs (exp);
11737 if (TYPE_ARG_TYPES (fntype) == 0
11738 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
11739 == void_type_node))
11741 error ("%<va_start%> used in function with fixed args");
11747 if (va_start_p && (nargs != 2))
11749 error ("wrong number of arguments to function %<va_start%>");
11752 arg = CALL_EXPR_ARG (exp, 1);
11754 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11755 when we checked the arguments and if needed issued a warning. */
11760 /* Evidently an out of date version of <stdarg.h>; can't validate
11761 va_start's second argument, but can still work as intended. */
11762 warning (0, "%<__builtin_next_arg%> called without an argument");
11765 else if (nargs > 1)
11767 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11770 arg = CALL_EXPR_ARG (exp, 0);
11773 if (TREE_CODE (arg) == SSA_NAME)
11774 arg = SSA_NAME_VAR (arg);
11776 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11777 or __builtin_next_arg (0) the first time we see it, after checking
11778 the arguments and if needed issuing a warning. */
11779 if (!integer_zerop (arg))
11781 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11783 /* Strip off all nops for the sake of the comparison. This
11784 is not quite the same as STRIP_NOPS. It does more.
11785 We must also strip off INDIRECT_EXPR for C++ reference
11787 while (CONVERT_EXPR_P (arg)
11788 || TREE_CODE (arg) == INDIRECT_REF)
11789 arg = TREE_OPERAND (arg, 0);
11790 if (arg != last_parm)
11792 /* FIXME: Sometimes with the tree optimizers we can get the
11793 not the last argument even though the user used the last
11794 argument. We just warn and set the arg to be the last
11795 argument so that we will get wrong-code because of
11797 warning (0, "second parameter of %<va_start%> not last named argument");
11800 /* Undefined by C99 7.15.1.4p4 (va_start):
11801 "If the parameter parmN is declared with the register storage
11802 class, with a function or array type, or with a type that is
11803 not compatible with the type that results after application of
11804 the default argument promotions, the behavior is undefined."
11806 else if (DECL_REGISTER (arg))
11807 warning (0, "undefined behaviour when second parameter of "
11808 "%<va_start%> is declared with %<register%> storage");
11810 /* We want to verify the second parameter just once before the tree
11811 optimizers are run and then avoid keeping it in the tree,
11812 as otherwise we could warn even for correct code like:
11813 void foo (int i, ...)
11814 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11816 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11818 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11824 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11825 ORIG may be null if this is a 2-argument call. We don't attempt to
11826 simplify calls with more than 3 arguments.
11828 Return NULL_TREE if no simplification was possible, otherwise return the
11829 simplified form of the call as a tree. If IGNORED is true, it means that
11830 the caller does not use the returned value of the function. */
11833 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11834 tree orig, int ignored)
11837 const char *fmt_str = NULL;
11839 /* Verify the required arguments in the original call. We deal with two
11840 types of sprintf() calls: 'sprintf (str, fmt)' and
11841 'sprintf (dest, "%s", orig)'. */
11842 if (!validate_arg (dest, POINTER_TYPE)
11843 || !validate_arg (fmt, POINTER_TYPE))
11845 if (orig && !validate_arg (orig, POINTER_TYPE))
11848 /* Check whether the format is a literal string constant. */
11849 fmt_str = c_getstr (fmt);
11850 if (fmt_str == NULL)
11854 retval = NULL_TREE;
11856 if (!init_target_chars ())
11859 /* If the format doesn't contain % args or %%, use strcpy. */
11860 if (strchr (fmt_str, target_percent) == NULL)
11862 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11867 /* Don't optimize sprintf (buf, "abc", ptr++). */
11871 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11872 'format' is known to contain no % formats. */
11873 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11875 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11878 /* If the format is "%s", use strcpy if the result isn't used. */
11879 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11882 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11887 /* Don't crash on sprintf (str1, "%s"). */
11891 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
11894 retval = c_strlen (orig, 1);
11895 if (!retval || TREE_CODE (retval) != INTEGER_CST)
11898 call = build_call_expr_loc (loc, fn, 2, dest, orig);
11901 if (call && retval)
11903 retval = fold_convert_loc
11904 (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11906 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11912 /* Expand a call EXP to __builtin_object_size. */
11915 expand_builtin_object_size (tree exp)
11918 int object_size_type;
11919 tree fndecl = get_callee_fndecl (exp);
11921 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11923 error ("%Kfirst argument of %D must be a pointer, second integer constant",
11925 expand_builtin_trap ();
11929 ost = CALL_EXPR_ARG (exp, 1);
11932 if (TREE_CODE (ost) != INTEGER_CST
11933 || tree_int_cst_sgn (ost) < 0
11934 || compare_tree_int (ost, 3) > 0)
11936 error ("%Klast argument of %D is not integer constant between 0 and 3",
11938 expand_builtin_trap ();
11942 object_size_type = tree_low_cst (ost, 0);
11944 return object_size_type < 2 ? constm1_rtx : const0_rtx;
11947 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11948 FCODE is the BUILT_IN_* to use.
11949 Return NULL_RTX if we failed; the caller should emit a normal call,
11950 otherwise try to get the result in TARGET, if convenient (and in
11951 mode MODE if that's convenient). */
11954 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11955 enum built_in_function fcode)
11957 tree dest, src, len, size;
11959 if (!validate_arglist (exp,
11961 fcode == BUILT_IN_MEMSET_CHK
11962 ? INTEGER_TYPE : POINTER_TYPE,
11963 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11966 dest = CALL_EXPR_ARG (exp, 0);
11967 src = CALL_EXPR_ARG (exp, 1);
11968 len = CALL_EXPR_ARG (exp, 2);
11969 size = CALL_EXPR_ARG (exp, 3);
11971 if (! host_integerp (size, 1))
11974 if (host_integerp (len, 1) || integer_all_onesp (size))
11978 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11980 warning_at (tree_nonartificial_location (exp),
11981 0, "%Kcall to %D will always overflow destination buffer",
11982 exp, get_callee_fndecl (exp));
11987 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11988 mem{cpy,pcpy,move,set} is available. */
11991 case BUILT_IN_MEMCPY_CHK:
11992 fn = built_in_decls[BUILT_IN_MEMCPY];
11994 case BUILT_IN_MEMPCPY_CHK:
11995 fn = built_in_decls[BUILT_IN_MEMPCPY];
11997 case BUILT_IN_MEMMOVE_CHK:
11998 fn = built_in_decls[BUILT_IN_MEMMOVE];
12000 case BUILT_IN_MEMSET_CHK:
12001 fn = built_in_decls[BUILT_IN_MEMSET];
12010 fn = build_call_nofold (fn, 3, dest, src, len);
12011 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12012 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12013 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12015 else if (fcode == BUILT_IN_MEMSET_CHK)
12019 unsigned int dest_align
12020 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
12022 /* If DEST is not a pointer type, call the normal function. */
12023 if (dest_align == 0)
12026 /* If SRC and DEST are the same (and not volatile), do nothing. */
12027 if (operand_equal_p (src, dest, 0))
12031 if (fcode != BUILT_IN_MEMPCPY_CHK)
12033 /* Evaluate and ignore LEN in case it has side-effects. */
12034 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12035 return expand_expr (dest, target, mode, EXPAND_NORMAL);
12038 expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12039 return expand_expr (expr, target, mode, EXPAND_NORMAL);
12042 /* __memmove_chk special case. */
12043 if (fcode == BUILT_IN_MEMMOVE_CHK)
12045 unsigned int src_align
12046 = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
12048 if (src_align == 0)
12051 /* If src is categorized for a readonly section we can use
12052 normal __memcpy_chk. */
12053 if (readonly_data_expr (src))
12055 tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12058 fn = build_call_nofold (fn, 4, dest, src, len, size);
12059 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12060 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12061 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12068 /* Emit warning if a buffer overflow is detected at compile time. */
12071 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12075 location_t loc = tree_nonartificial_location (exp);
12079 case BUILT_IN_STRCPY_CHK:
12080 case BUILT_IN_STPCPY_CHK:
12081 /* For __strcat_chk the warning will be emitted only if overflowing
12082 by at least strlen (dest) + 1 bytes. */
12083 case BUILT_IN_STRCAT_CHK:
12084 len = CALL_EXPR_ARG (exp, 1);
12085 size = CALL_EXPR_ARG (exp, 2);
12088 case BUILT_IN_STRNCAT_CHK:
12089 case BUILT_IN_STRNCPY_CHK:
12090 len = CALL_EXPR_ARG (exp, 2);
12091 size = CALL_EXPR_ARG (exp, 3);
12093 case BUILT_IN_SNPRINTF_CHK:
12094 case BUILT_IN_VSNPRINTF_CHK:
12095 len = CALL_EXPR_ARG (exp, 1);
12096 size = CALL_EXPR_ARG (exp, 3);
12099 gcc_unreachable ();
12105 if (! host_integerp (size, 1) || integer_all_onesp (size))
12110 len = c_strlen (len, 1);
12111 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12114 else if (fcode == BUILT_IN_STRNCAT_CHK)
12116 tree src = CALL_EXPR_ARG (exp, 1);
12117 if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12119 src = c_strlen (src, 1);
12120 if (! src || ! host_integerp (src, 1))
12122 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12123 exp, get_callee_fndecl (exp));
12126 else if (tree_int_cst_lt (src, size))
12129 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12132 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12133 exp, get_callee_fndecl (exp));
12136 /* Emit warning if a buffer overflow is detected at compile time
12137 in __sprintf_chk/__vsprintf_chk calls. */
12140 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12142 tree dest, size, len, fmt, flag;
12143 const char *fmt_str;
12144 int nargs = call_expr_nargs (exp);
12146 /* Verify the required arguments in the original call. */
12150 dest = CALL_EXPR_ARG (exp, 0);
12151 flag = CALL_EXPR_ARG (exp, 1);
12152 size = CALL_EXPR_ARG (exp, 2);
12153 fmt = CALL_EXPR_ARG (exp, 3);
12155 if (! host_integerp (size, 1) || integer_all_onesp (size))
12158 /* Check whether the format is a literal string constant. */
12159 fmt_str = c_getstr (fmt);
12160 if (fmt_str == NULL)
12163 if (!init_target_chars ())
12166 /* If the format doesn't contain % args or %%, we know its size. */
12167 if (strchr (fmt_str, target_percent) == 0)
12168 len = build_int_cstu (size_type_node, strlen (fmt_str));
12169 /* If the format is "%s" and first ... argument is a string literal,
12171 else if (fcode == BUILT_IN_SPRINTF_CHK
12172 && strcmp (fmt_str, target_percent_s) == 0)
12178 arg = CALL_EXPR_ARG (exp, 4);
12179 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12182 len = c_strlen (arg, 1);
12183 if (!len || ! host_integerp (len, 1))
12189 if (! tree_int_cst_lt (len, size))
12190 warning_at (tree_nonartificial_location (exp),
12191 0, "%Kcall to %D will always overflow destination buffer",
12192 exp, get_callee_fndecl (exp));
12195 /* Emit warning if a free is called with address of a variable. */
12198 maybe_emit_free_warning (tree exp)
12200 tree arg = CALL_EXPR_ARG (exp, 0);
12203 if (TREE_CODE (arg) != ADDR_EXPR)
12206 arg = get_base_address (TREE_OPERAND (arg, 0));
12207 if (arg == NULL || INDIRECT_REF_P (arg))
12210 if (SSA_VAR_P (arg))
12211 warning_at (tree_nonartificial_location (exp),
12212 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12214 warning_at (tree_nonartificial_location (exp),
12215 0, "%Kattempt to free a non-heap object", exp);
12218 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12222 fold_builtin_object_size (tree ptr, tree ost)
12224 tree ret = NULL_TREE;
12225 int object_size_type;
12227 if (!validate_arg (ptr, POINTER_TYPE)
12228 || !validate_arg (ost, INTEGER_TYPE))
12233 if (TREE_CODE (ost) != INTEGER_CST
12234 || tree_int_cst_sgn (ost) < 0
12235 || compare_tree_int (ost, 3) > 0)
12238 object_size_type = tree_low_cst (ost, 0);
12240 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12241 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12242 and (size_t) 0 for types 2 and 3. */
12243 if (TREE_SIDE_EFFECTS (ptr))
12244 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12246 if (TREE_CODE (ptr) == ADDR_EXPR)
12247 ret = build_int_cstu (size_type_node,
12248 compute_builtin_object_size (ptr, object_size_type));
12250 else if (TREE_CODE (ptr) == SSA_NAME)
12252 unsigned HOST_WIDE_INT bytes;
12254 /* If object size is not known yet, delay folding until
12255 later. Maybe subsequent passes will help determining
12257 bytes = compute_builtin_object_size (ptr, object_size_type);
12258 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
12260 ret = build_int_cstu (size_type_node, bytes);
12265 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (ret);
12266 HOST_WIDE_INT high = TREE_INT_CST_HIGH (ret);
12267 if (fit_double_type (low, high, &low, &high, TREE_TYPE (ret)))
12274 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12275 DEST, SRC, LEN, and SIZE are the arguments to the call.
12276 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12277 code of the builtin. If MAXLEN is not NULL, it is maximum length
12278 passed as third argument. */
12281 fold_builtin_memory_chk (location_t loc, tree fndecl,
12282 tree dest, tree src, tree len, tree size,
12283 tree maxlen, bool ignore,
12284 enum built_in_function fcode)
12288 if (!validate_arg (dest, POINTER_TYPE)
12289 || !validate_arg (src,
12290 (fcode == BUILT_IN_MEMSET_CHK
12291 ? INTEGER_TYPE : POINTER_TYPE))
12292 || !validate_arg (len, INTEGER_TYPE)
12293 || !validate_arg (size, INTEGER_TYPE))
12296 /* If SRC and DEST are the same (and not volatile), return DEST
12297 (resp. DEST+LEN for __mempcpy_chk). */
12298 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12300 if (fcode != BUILT_IN_MEMPCPY_CHK)
12301 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12305 tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12307 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12311 if (! host_integerp (size, 1))
12314 if (! integer_all_onesp (size))
12316 if (! host_integerp (len, 1))
12318 /* If LEN is not constant, try MAXLEN too.
12319 For MAXLEN only allow optimizing into non-_ocs function
12320 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12321 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12323 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12325 /* (void) __mempcpy_chk () can be optimized into
12326 (void) __memcpy_chk (). */
12327 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12331 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12339 if (tree_int_cst_lt (size, maxlen))
12344 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12345 mem{cpy,pcpy,move,set} is available. */
12348 case BUILT_IN_MEMCPY_CHK:
12349 fn = built_in_decls[BUILT_IN_MEMCPY];
12351 case BUILT_IN_MEMPCPY_CHK:
12352 fn = built_in_decls[BUILT_IN_MEMPCPY];
12354 case BUILT_IN_MEMMOVE_CHK:
12355 fn = built_in_decls[BUILT_IN_MEMMOVE];
12357 case BUILT_IN_MEMSET_CHK:
12358 fn = built_in_decls[BUILT_IN_MEMSET];
12367 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12370 /* Fold a call to the __st[rp]cpy_chk builtin.
12371 DEST, SRC, and SIZE are the arguments to the call.
12372 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12373 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12374 strings passed as second argument. */
12377 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12378 tree src, tree size,
12379 tree maxlen, bool ignore,
12380 enum built_in_function fcode)
12384 if (!validate_arg (dest, POINTER_TYPE)
12385 || !validate_arg (src, POINTER_TYPE)
12386 || !validate_arg (size, INTEGER_TYPE))
12389 /* If SRC and DEST are the same (and not volatile), return DEST. */
12390 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12391 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12393 if (! host_integerp (size, 1))
12396 if (! integer_all_onesp (size))
12398 len = c_strlen (src, 1);
12399 if (! len || ! host_integerp (len, 1))
12401 /* If LEN is not constant, try MAXLEN too.
12402 For MAXLEN only allow optimizing into non-_ocs function
12403 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12404 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12406 if (fcode == BUILT_IN_STPCPY_CHK)
12411 /* If return value of __stpcpy_chk is ignored,
12412 optimize into __strcpy_chk. */
12413 fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12417 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12420 if (! len || TREE_SIDE_EFFECTS (len))
12423 /* If c_strlen returned something, but not a constant,
12424 transform __strcpy_chk into __memcpy_chk. */
12425 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12429 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12430 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12431 build_call_expr_loc (loc, fn, 4,
12432 dest, src, len, size));
12438 if (! tree_int_cst_lt (maxlen, size))
12442 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12443 fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12444 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12448 return build_call_expr_loc (loc, fn, 2, dest, src);
12451 /* Fold a call to the __strncpy_chk builtin. DEST, SRC, LEN, and SIZE
12452 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12453 length passed as third argument. */
12456 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12457 tree len, tree size, tree maxlen)
12461 if (!validate_arg (dest, POINTER_TYPE)
12462 || !validate_arg (src, POINTER_TYPE)
12463 || !validate_arg (len, INTEGER_TYPE)
12464 || !validate_arg (size, INTEGER_TYPE))
12467 if (! host_integerp (size, 1))
12470 if (! integer_all_onesp (size))
12472 if (! host_integerp (len, 1))
12474 /* If LEN is not constant, try MAXLEN too.
12475 For MAXLEN only allow optimizing into non-_ocs function
12476 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12477 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12483 if (tree_int_cst_lt (size, maxlen))
12487 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
12488 fn = built_in_decls[BUILT_IN_STRNCPY];
12492 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12495 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12496 are the arguments to the call. */
12499 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12500 tree src, tree size)
12505 if (!validate_arg (dest, POINTER_TYPE)
12506 || !validate_arg (src, POINTER_TYPE)
12507 || !validate_arg (size, INTEGER_TYPE))
12510 p = c_getstr (src);
12511 /* If the SRC parameter is "", return DEST. */
12512 if (p && *p == '\0')
12513 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12515 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12518 /* If __builtin_strcat_chk is used, assume strcat is available. */
12519 fn = built_in_decls[BUILT_IN_STRCAT];
12523 return build_call_expr_loc (loc, fn, 2, dest, src);
12526 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12530 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12531 tree dest, tree src, tree len, tree size)
12536 if (!validate_arg (dest, POINTER_TYPE)
12537 || !validate_arg (src, POINTER_TYPE)
12538 || !validate_arg (size, INTEGER_TYPE)
12539 || !validate_arg (size, INTEGER_TYPE))
12542 p = c_getstr (src);
12543 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
12544 if (p && *p == '\0')
12545 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12546 else if (integer_zerop (len))
12547 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12549 if (! host_integerp (size, 1))
12552 if (! integer_all_onesp (size))
12554 tree src_len = c_strlen (src, 1);
12556 && host_integerp (src_len, 1)
12557 && host_integerp (len, 1)
12558 && ! tree_int_cst_lt (len, src_len))
12560 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
12561 fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12565 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12570 /* If __builtin_strncat_chk is used, assume strncat is available. */
12571 fn = built_in_decls[BUILT_IN_STRNCAT];
12575 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12578 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
12579 a normal call should be emitted rather than expanding the function
12580 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
12583 fold_builtin_sprintf_chk (location_t loc, tree exp,
12584 enum built_in_function fcode)
12586 tree dest, size, len, fn, fmt, flag;
12587 const char *fmt_str;
12588 int nargs = call_expr_nargs (exp);
12590 /* Verify the required arguments in the original call. */
12593 dest = CALL_EXPR_ARG (exp, 0);
12594 if (!validate_arg (dest, POINTER_TYPE))
12596 flag = CALL_EXPR_ARG (exp, 1);
12597 if (!validate_arg (flag, INTEGER_TYPE))
12599 size = CALL_EXPR_ARG (exp, 2);
12600 if (!validate_arg (size, INTEGER_TYPE))
12602 fmt = CALL_EXPR_ARG (exp, 3);
12603 if (!validate_arg (fmt, POINTER_TYPE))
12606 if (! host_integerp (size, 1))
12611 if (!init_target_chars ())
12614 /* Check whether the format is a literal string constant. */
12615 fmt_str = c_getstr (fmt);
12616 if (fmt_str != NULL)
12618 /* If the format doesn't contain % args or %%, we know the size. */
12619 if (strchr (fmt_str, target_percent) == 0)
12621 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12622 len = build_int_cstu (size_type_node, strlen (fmt_str));
12624 /* If the format is "%s" and first ... argument is a string literal,
12625 we know the size too. */
12626 else if (fcode == BUILT_IN_SPRINTF_CHK
12627 && strcmp (fmt_str, target_percent_s) == 0)
12633 arg = CALL_EXPR_ARG (exp, 4);
12634 if (validate_arg (arg, POINTER_TYPE))
12636 len = c_strlen (arg, 1);
12637 if (! len || ! host_integerp (len, 1))
12644 if (! integer_all_onesp (size))
12646 if (! len || ! tree_int_cst_lt (len, size))
12650 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12651 or if format doesn't contain % chars or is "%s". */
12652 if (! integer_zerop (flag))
12654 if (fmt_str == NULL)
12656 if (strchr (fmt_str, target_percent) != NULL
12657 && strcmp (fmt_str, target_percent_s))
12661 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
12662 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12663 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12667 return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12670 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
12671 a normal call should be emitted rather than expanding the function
12672 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
12673 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
12674 passed as second argument. */
12677 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12678 enum built_in_function fcode)
12680 tree dest, size, len, fn, fmt, flag;
12681 const char *fmt_str;
12683 /* Verify the required arguments in the original call. */
12684 if (call_expr_nargs (exp) < 5)
12686 dest = CALL_EXPR_ARG (exp, 0);
12687 if (!validate_arg (dest, POINTER_TYPE))
12689 len = CALL_EXPR_ARG (exp, 1);
12690 if (!validate_arg (len, INTEGER_TYPE))
12692 flag = CALL_EXPR_ARG (exp, 2);
12693 if (!validate_arg (flag, INTEGER_TYPE))
12695 size = CALL_EXPR_ARG (exp, 3);
12696 if (!validate_arg (size, INTEGER_TYPE))
12698 fmt = CALL_EXPR_ARG (exp, 4);
12699 if (!validate_arg (fmt, POINTER_TYPE))
12702 if (! host_integerp (size, 1))
12705 if (! integer_all_onesp (size))
12707 if (! host_integerp (len, 1))
12709 /* If LEN is not constant, try MAXLEN too.
12710 For MAXLEN only allow optimizing into non-_ocs function
12711 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12712 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12718 if (tree_int_cst_lt (size, maxlen))
12722 if (!init_target_chars ())
12725 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12726 or if format doesn't contain % chars or is "%s". */
12727 if (! integer_zerop (flag))
12729 fmt_str = c_getstr (fmt);
12730 if (fmt_str == NULL)
12732 if (strchr (fmt_str, target_percent) != NULL
12733 && strcmp (fmt_str, target_percent_s))
12737 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12739 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12740 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12744 return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12747 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12748 FMT and ARG are the arguments to the call; we don't fold cases with
12749 more than 2 arguments, and ARG may be null if this is a 1-argument case.
12751 Return NULL_TREE if no simplification was possible, otherwise return the
12752 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12753 code of the function to be simplified. */
12756 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12757 tree arg, bool ignore,
12758 enum built_in_function fcode)
12760 tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12761 const char *fmt_str = NULL;
12763 /* If the return value is used, don't do the transformation. */
12767 /* Verify the required arguments in the original call. */
12768 if (!validate_arg (fmt, POINTER_TYPE))
12771 /* Check whether the format is a literal string constant. */
12772 fmt_str = c_getstr (fmt);
12773 if (fmt_str == NULL)
12776 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12778 /* If we're using an unlocked function, assume the other
12779 unlocked functions exist explicitly. */
12780 fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12781 fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12785 fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12786 fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12789 if (!init_target_chars ())
12792 if (strcmp (fmt_str, target_percent_s) == 0
12793 || strchr (fmt_str, target_percent) == NULL)
12797 if (strcmp (fmt_str, target_percent_s) == 0)
12799 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12802 if (!arg || !validate_arg (arg, POINTER_TYPE))
12805 str = c_getstr (arg);
12811 /* The format specifier doesn't contain any '%' characters. */
12812 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12818 /* If the string was "", printf does nothing. */
12819 if (str[0] == '\0')
12820 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12822 /* If the string has length of 1, call putchar. */
12823 if (str[1] == '\0')
12825 /* Given printf("c"), (where c is any one character,)
12826 convert "c"[0] to an int and pass that to the replacement
12828 newarg = build_int_cst (NULL_TREE, str[0]);
12830 call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12834 /* If the string was "string\n", call puts("string"). */
12835 size_t len = strlen (str);
12836 if ((unsigned char)str[len - 1] == target_newline)
12838 /* Create a NUL-terminated string that's one char shorter
12839 than the original, stripping off the trailing '\n'. */
12840 char *newstr = XALLOCAVEC (char, len);
12841 memcpy (newstr, str, len - 1);
12842 newstr[len - 1] = 0;
12844 newarg = build_string_literal (len, newstr);
12846 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12849 /* We'd like to arrange to call fputs(string,stdout) here,
12850 but we need stdout and don't have a way to get it yet. */
12855 /* The other optimizations can be done only on the non-va_list variants. */
12856 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12859 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
12860 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12862 if (!arg || !validate_arg (arg, POINTER_TYPE))
12865 call = build_call_expr_loc (loc, fn_puts, 1, arg);
12868 /* If the format specifier was "%c", call __builtin_putchar(arg). */
12869 else if (strcmp (fmt_str, target_percent_c) == 0)
12871 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12874 call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12880 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12883 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12884 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
12885 more than 3 arguments, and ARG may be null in the 2-argument case.
12887 Return NULL_TREE if no simplification was possible, otherwise return the
12888 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12889 code of the function to be simplified. */
12892 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12893 tree fmt, tree arg, bool ignore,
12894 enum built_in_function fcode)
12896 tree fn_fputc, fn_fputs, call = NULL_TREE;
12897 const char *fmt_str = NULL;
12899 /* If the return value is used, don't do the transformation. */
12903 /* Verify the required arguments in the original call. */
12904 if (!validate_arg (fp, POINTER_TYPE))
12906 if (!validate_arg (fmt, POINTER_TYPE))
12909 /* Check whether the format is a literal string constant. */
12910 fmt_str = c_getstr (fmt);
12911 if (fmt_str == NULL)
12914 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12916 /* If we're using an unlocked function, assume the other
12917 unlocked functions exist explicitly. */
12918 fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12919 fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12923 fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12924 fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12927 if (!init_target_chars ())
12930 /* If the format doesn't contain % args or %%, use strcpy. */
12931 if (strchr (fmt_str, target_percent) == NULL)
12933 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12937 /* If the format specifier was "", fprintf does nothing. */
12938 if (fmt_str[0] == '\0')
12940 /* If FP has side-effects, just wait until gimplification is
12942 if (TREE_SIDE_EFFECTS (fp))
12945 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12948 /* When "string" doesn't contain %, replace all cases of
12949 fprintf (fp, string) with fputs (string, fp). The fputs
12950 builtin will take care of special cases like length == 1. */
12952 call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12955 /* The other optimizations can be done only on the non-va_list variants. */
12956 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12959 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
12960 else if (strcmp (fmt_str, target_percent_s) == 0)
12962 if (!arg || !validate_arg (arg, POINTER_TYPE))
12965 call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12968 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
12969 else if (strcmp (fmt_str, target_percent_c) == 0)
12971 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12974 call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12979 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12982 /* Initialize format string characters in the target charset. */
12985 init_target_chars (void)
12990 target_newline = lang_hooks.to_target_charset ('\n');
12991 target_percent = lang_hooks.to_target_charset ('%');
12992 target_c = lang_hooks.to_target_charset ('c');
12993 target_s = lang_hooks.to_target_charset ('s');
12994 if (target_newline == 0 || target_percent == 0 || target_c == 0
12998 target_percent_c[0] = target_percent;
12999 target_percent_c[1] = target_c;
13000 target_percent_c[2] = '\0';
13002 target_percent_s[0] = target_percent;
13003 target_percent_s[1] = target_s;
13004 target_percent_s[2] = '\0';
13006 target_percent_s_newline[0] = target_percent;
13007 target_percent_s_newline[1] = target_s;
13008 target_percent_s_newline[2] = target_newline;
13009 target_percent_s_newline[3] = '\0';
13016 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
13017 and no overflow/underflow occurred. INEXACT is true if M was not
13018 exactly calculated. TYPE is the tree type for the result. This
13019 function assumes that you cleared the MPFR flags and then
13020 calculated M to see if anything subsequently set a flag prior to
13021 entering this function. Return NULL_TREE if any checks fail. */
13024 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13026 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13027 overflow/underflow occurred. If -frounding-math, proceed iff the
13028 result of calling FUNC was exact. */
13029 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13030 && (!flag_rounding_math || !inexact))
13032 REAL_VALUE_TYPE rr;
13034 real_from_mpfr (&rr, m, type, GMP_RNDN);
13035 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13036 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13037 but the mpft_t is not, then we underflowed in the
13039 if (real_isfinite (&rr)
13040 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13042 REAL_VALUE_TYPE rmode;
13044 real_convert (&rmode, TYPE_MODE (type), &rr);
13045 /* Proceed iff the specified mode can hold the value. */
13046 if (real_identical (&rmode, &rr))
13047 return build_real (type, rmode);
13054 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
13055 number and no overflow/underflow occurred. INEXACT is true if M
13056 was not exactly calculated. TYPE is the tree type for the result.
13057 This function assumes that you cleared the MPFR flags and then
13058 calculated M to see if anything subsequently set a flag prior to
13059 entering this function. Return NULL_TREE if any checks fail, if
13060 FORCE_CONVERT is true, then bypass the checks. */
13063 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13065 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13066 overflow/underflow occurred. If -frounding-math, proceed iff the
13067 result of calling FUNC was exact. */
13069 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13070 && !mpfr_overflow_p () && !mpfr_underflow_p ()
13071 && (!flag_rounding_math || !inexact)))
13073 REAL_VALUE_TYPE re, im;
13075 real_from_mpfr (&re, mpc_realref (m), type, GMP_RNDN);
13076 real_from_mpfr (&im, mpc_imagref (m), type, GMP_RNDN);
13077 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13078 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13079 but the mpft_t is not, then we underflowed in the
13082 || (real_isfinite (&re) && real_isfinite (&im)
13083 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13084 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13086 REAL_VALUE_TYPE re_mode, im_mode;
13088 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13089 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13090 /* Proceed iff the specified mode can hold the value. */
13092 || (real_identical (&re_mode, &re)
13093 && real_identical (&im_mode, &im)))
13094 return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13095 build_real (TREE_TYPE (type), im_mode));
13100 #endif /* HAVE_mpc */
13102 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13103 FUNC on it and return the resulting value as a tree with type TYPE.
13104 If MIN and/or MAX are not NULL, then the supplied ARG must be
13105 within those bounds. If INCLUSIVE is true, then MIN/MAX are
13106 acceptable values, otherwise they are not. The mpfr precision is
13107 set to the precision of TYPE. We assume that function FUNC returns
13108 zero if the result could be calculated exactly within the requested
13112 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13113 const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13116 tree result = NULL_TREE;
13120 /* To proceed, MPFR must exactly represent the target floating point
13121 format, which only happens when the target base equals two. */
13122 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13123 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13125 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13127 if (real_isfinite (ra)
13128 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13129 && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13131 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13132 const int prec = fmt->p;
13133 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13137 mpfr_init2 (m, prec);
13138 mpfr_from_real (m, ra, GMP_RNDN);
13139 mpfr_clear_flags ();
13140 inexact = func (m, m, rnd);
13141 result = do_mpfr_ckconv (m, type, inexact);
13149 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13150 FUNC on it and return the resulting value as a tree with type TYPE.
13151 The mpfr precision is set to the precision of TYPE. We assume that
13152 function FUNC returns zero if the result could be calculated
13153 exactly within the requested precision. */
13156 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13157 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13159 tree result = NULL_TREE;
13164 /* To proceed, MPFR must exactly represent the target floating point
13165 format, which only happens when the target base equals two. */
13166 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13167 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13168 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13170 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13171 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13173 if (real_isfinite (ra1) && real_isfinite (ra2))
13175 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13176 const int prec = fmt->p;
13177 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13181 mpfr_inits2 (prec, m1, m2, NULL);
13182 mpfr_from_real (m1, ra1, GMP_RNDN);
13183 mpfr_from_real (m2, ra2, GMP_RNDN);
13184 mpfr_clear_flags ();
13185 inexact = func (m1, m1, m2, rnd);
13186 result = do_mpfr_ckconv (m1, type, inexact);
13187 mpfr_clears (m1, m2, NULL);
13194 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13195 FUNC on it and return the resulting value as a tree with type TYPE.
13196 The mpfr precision is set to the precision of TYPE. We assume that
13197 function FUNC returns zero if the result could be calculated
13198 exactly within the requested precision. */
13201 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13202 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13204 tree result = NULL_TREE;
13210 /* To proceed, MPFR must exactly represent the target floating point
13211 format, which only happens when the target base equals two. */
13212 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13213 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13214 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13215 && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13217 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13218 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13219 const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13221 if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13223 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13224 const int prec = fmt->p;
13225 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13229 mpfr_inits2 (prec, m1, m2, m3, NULL);
13230 mpfr_from_real (m1, ra1, GMP_RNDN);
13231 mpfr_from_real (m2, ra2, GMP_RNDN);
13232 mpfr_from_real (m3, ra3, GMP_RNDN);
13233 mpfr_clear_flags ();
13234 inexact = func (m1, m1, m2, m3, rnd);
13235 result = do_mpfr_ckconv (m1, type, inexact);
13236 mpfr_clears (m1, m2, m3, NULL);
13243 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13244 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13245 If ARG_SINP and ARG_COSP are NULL then the result is returned
13246 as a complex value.
13247 The type is taken from the type of ARG and is used for setting the
13248 precision of the calculation and results. */
13251 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13253 tree const type = TREE_TYPE (arg);
13254 tree result = NULL_TREE;
13258 /* To proceed, MPFR must exactly represent the target floating point
13259 format, which only happens when the target base equals two. */
13260 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13261 && TREE_CODE (arg) == REAL_CST
13262 && !TREE_OVERFLOW (arg))
13264 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13266 if (real_isfinite (ra))
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;
13271 tree result_s, result_c;
13275 mpfr_inits2 (prec, m, ms, mc, NULL);
13276 mpfr_from_real (m, ra, GMP_RNDN);
13277 mpfr_clear_flags ();
13278 inexact = mpfr_sin_cos (ms, mc, m, rnd);
13279 result_s = do_mpfr_ckconv (ms, type, inexact);
13280 result_c = do_mpfr_ckconv (mc, type, inexact);
13281 mpfr_clears (m, ms, mc, NULL);
13282 if (result_s && result_c)
13284 /* If we are to return in a complex value do so. */
13285 if (!arg_sinp && !arg_cosp)
13286 return build_complex (build_complex_type (type),
13287 result_c, result_s);
13289 /* Dereference the sin/cos pointer arguments. */
13290 arg_sinp = build_fold_indirect_ref (arg_sinp);
13291 arg_cosp = build_fold_indirect_ref (arg_cosp);
13292 /* Proceed if valid pointer type were passed in. */
13293 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13294 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13296 /* Set the values. */
13297 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13299 TREE_SIDE_EFFECTS (result_s) = 1;
13300 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13302 TREE_SIDE_EFFECTS (result_c) = 1;
13303 /* Combine the assignments into a compound expr. */
13304 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13305 result_s, result_c));
13313 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13314 two-argument mpfr order N Bessel function FUNC on them and return
13315 the resulting value as a tree with type TYPE. The mpfr precision
13316 is set to the precision of TYPE. We assume that function FUNC
13317 returns zero if the result could be calculated exactly within the
13318 requested precision. */
13320 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13321 int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13322 const REAL_VALUE_TYPE *min, bool inclusive)
13324 tree result = NULL_TREE;
13329 /* To proceed, MPFR must exactly represent the target floating point
13330 format, which only happens when the target base equals two. */
13331 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13332 && host_integerp (arg1, 0)
13333 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13335 const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13336 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13339 && real_isfinite (ra)
13340 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13342 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13343 const int prec = fmt->p;
13344 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13348 mpfr_init2 (m, prec);
13349 mpfr_from_real (m, ra, GMP_RNDN);
13350 mpfr_clear_flags ();
13351 inexact = func (m, n, m, rnd);
13352 result = do_mpfr_ckconv (m, type, inexact);
13360 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13361 the pointer *(ARG_QUO) and return the result. The type is taken
13362 from the type of ARG0 and is used for setting the precision of the
13363 calculation and results. */
13366 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13368 tree const type = TREE_TYPE (arg0);
13369 tree result = NULL_TREE;
13374 /* To proceed, MPFR must exactly represent the target floating point
13375 format, which only happens when the target base equals two. */
13376 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13377 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13378 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13380 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13381 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13383 if (real_isfinite (ra0) && real_isfinite (ra1))
13385 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13386 const int prec = fmt->p;
13387 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13392 mpfr_inits2 (prec, m0, m1, NULL);
13393 mpfr_from_real (m0, ra0, GMP_RNDN);
13394 mpfr_from_real (m1, ra1, GMP_RNDN);
13395 mpfr_clear_flags ();
13396 mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13397 /* Remquo is independent of the rounding mode, so pass
13398 inexact=0 to do_mpfr_ckconv(). */
13399 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13400 mpfr_clears (m0, m1, NULL);
13403 /* MPFR calculates quo in the host's long so it may
13404 return more bits in quo than the target int can hold
13405 if sizeof(host long) > sizeof(target int). This can
13406 happen even for native compilers in LP64 mode. In
13407 these cases, modulo the quo value with the largest
13408 number that the target int can hold while leaving one
13409 bit for the sign. */
13410 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13411 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13413 /* Dereference the quo pointer argument. */
13414 arg_quo = build_fold_indirect_ref (arg_quo);
13415 /* Proceed iff a valid pointer type was passed in. */
13416 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13418 /* Set the value. */
13419 tree result_quo = fold_build2 (MODIFY_EXPR,
13420 TREE_TYPE (arg_quo), arg_quo,
13421 build_int_cst (NULL, integer_quo));
13422 TREE_SIDE_EFFECTS (result_quo) = 1;
13423 /* Combine the quo assignment with the rem. */
13424 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13425 result_quo, result_rem));
13433 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13434 resulting value as a tree with type TYPE. The mpfr precision is
13435 set to the precision of TYPE. We assume that this mpfr function
13436 returns zero if the result could be calculated exactly within the
13437 requested precision. In addition, the integer pointer represented
13438 by ARG_SG will be dereferenced and set to the appropriate signgam
13442 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13444 tree result = NULL_TREE;
13448 /* To proceed, MPFR must exactly represent the target floating point
13449 format, which only happens when the target base equals two. Also
13450 verify ARG is a constant and that ARG_SG is an int pointer. */
13451 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13452 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13453 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13454 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13456 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13458 /* In addition to NaN and Inf, the argument cannot be zero or a
13459 negative integer. */
13460 if (real_isfinite (ra)
13461 && ra->cl != rvc_zero
13462 && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13464 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13465 const int prec = fmt->p;
13466 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13471 mpfr_init2 (m, prec);
13472 mpfr_from_real (m, ra, GMP_RNDN);
13473 mpfr_clear_flags ();
13474 inexact = mpfr_lgamma (m, &sg, m, rnd);
13475 result_lg = do_mpfr_ckconv (m, type, inexact);
13481 /* Dereference the arg_sg pointer argument. */
13482 arg_sg = build_fold_indirect_ref (arg_sg);
13483 /* Assign the signgam value into *arg_sg. */
13484 result_sg = fold_build2 (MODIFY_EXPR,
13485 TREE_TYPE (arg_sg), arg_sg,
13486 build_int_cst (NULL, sg));
13487 TREE_SIDE_EFFECTS (result_sg) = 1;
13488 /* Combine the signgam assignment with the lgamma result. */
13489 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13490 result_sg, result_lg));
13499 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13500 function FUNC on it and return the resulting value as a tree with
13501 type TYPE. The mpfr precision is set to the precision of TYPE. We
13502 assume that function FUNC returns zero if the result could be
13503 calculated exactly within the requested precision. */
13506 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13508 tree result = NULL_TREE;
13512 /* To proceed, MPFR must exactly represent the target floating point
13513 format, which only happens when the target base equals two. */
13514 if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13515 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13516 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13518 const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13519 const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13521 if (real_isfinite (re) && real_isfinite (im))
13523 const struct real_format *const fmt =
13524 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13525 const int prec = fmt->p;
13526 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13527 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13531 mpc_init2 (m, prec);
13532 mpfr_from_real (mpc_realref(m), re, rnd);
13533 mpfr_from_real (mpc_imagref(m), im, rnd);
13534 mpfr_clear_flags ();
13535 inexact = func (m, m, crnd);
13536 result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13544 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13545 mpc function FUNC on it and return the resulting value as a tree
13546 with type TYPE. The mpfr precision is set to the precision of
13547 TYPE. We assume that function FUNC returns zero if the result
13548 could be calculated exactly within the requested precision. If
13549 DO_NONFINITE is true, then fold expressions containing Inf or NaN
13550 in the arguments and/or results. */
13554 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13555 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13557 tree result = NULL_TREE;
13562 /* To proceed, MPFR must exactly represent the target floating point
13563 format, which only happens when the target base equals two. */
13564 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13565 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13566 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13567 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13568 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13570 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13571 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13572 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13573 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13576 || (real_isfinite (re0) && real_isfinite (im0)
13577 && real_isfinite (re1) && real_isfinite (im1)))
13579 const struct real_format *const fmt =
13580 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13581 const int prec = fmt->p;
13582 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13583 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13587 mpc_init2 (m0, prec);
13588 mpc_init2 (m1, prec);
13589 mpfr_from_real (mpc_realref(m0), re0, rnd);
13590 mpfr_from_real (mpc_imagref(m0), im0, rnd);
13591 mpfr_from_real (mpc_realref(m1), re1, rnd);
13592 mpfr_from_real (mpc_imagref(m1), im1, rnd);
13593 mpfr_clear_flags ();
13594 inexact = func (m0, m0, m1, crnd);
13595 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13604 #endif /* HAVE_mpc */
13607 The functions below provide an alternate interface for folding
13608 builtin function calls presented as GIMPLE_CALL statements rather
13609 than as CALL_EXPRs. The folded result is still expressed as a
13610 tree. There is too much code duplication in the handling of
13611 varargs functions, and a more intrusive re-factoring would permit
13612 better sharing of code between the tree and statement-based
13613 versions of these functions. */
13615 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13616 along with N new arguments specified as the "..." parameters. SKIP
13617 is the number of arguments in STMT to be omitted. This function is used
13618 to do varargs-to-varargs transformations. */
13621 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13623 int oldnargs = gimple_call_num_args (stmt);
13624 int nargs = oldnargs - skip + n;
13625 tree fntype = TREE_TYPE (fndecl);
13626 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13630 location_t loc = gimple_location (stmt);
13632 buffer = XALLOCAVEC (tree, nargs);
13634 for (i = 0; i < n; i++)
13635 buffer[i] = va_arg (ap, tree);
13637 for (j = skip; j < oldnargs; j++, i++)
13638 buffer[i] = gimple_call_arg (stmt, j);
13640 return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13643 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
13644 a normal call should be emitted rather than expanding the function
13645 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13648 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13650 tree dest, size, len, fn, fmt, flag;
13651 const char *fmt_str;
13652 int nargs = gimple_call_num_args (stmt);
13654 /* Verify the required arguments in the original call. */
13657 dest = gimple_call_arg (stmt, 0);
13658 if (!validate_arg (dest, POINTER_TYPE))
13660 flag = gimple_call_arg (stmt, 1);
13661 if (!validate_arg (flag, INTEGER_TYPE))
13663 size = gimple_call_arg (stmt, 2);
13664 if (!validate_arg (size, INTEGER_TYPE))
13666 fmt = gimple_call_arg (stmt, 3);
13667 if (!validate_arg (fmt, POINTER_TYPE))
13670 if (! host_integerp (size, 1))
13675 if (!init_target_chars ())
13678 /* Check whether the format is a literal string constant. */
13679 fmt_str = c_getstr (fmt);
13680 if (fmt_str != NULL)
13682 /* If the format doesn't contain % args or %%, we know the size. */
13683 if (strchr (fmt_str, target_percent) == 0)
13685 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13686 len = build_int_cstu (size_type_node, strlen (fmt_str));
13688 /* If the format is "%s" and first ... argument is a string literal,
13689 we know the size too. */
13690 else if (fcode == BUILT_IN_SPRINTF_CHK
13691 && strcmp (fmt_str, target_percent_s) == 0)
13697 arg = gimple_call_arg (stmt, 4);
13698 if (validate_arg (arg, POINTER_TYPE))
13700 len = c_strlen (arg, 1);
13701 if (! len || ! host_integerp (len, 1))
13708 if (! integer_all_onesp (size))
13710 if (! len || ! tree_int_cst_lt (len, size))
13714 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13715 or if format doesn't contain % chars or is "%s". */
13716 if (! integer_zerop (flag))
13718 if (fmt_str == NULL)
13720 if (strchr (fmt_str, target_percent) != NULL
13721 && strcmp (fmt_str, target_percent_s))
13725 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
13726 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13727 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13731 return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13734 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
13735 a normal call should be emitted rather than expanding the function
13736 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13737 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13738 passed as second argument. */
13741 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13742 enum built_in_function fcode)
13744 tree dest, size, len, fn, fmt, flag;
13745 const char *fmt_str;
13747 /* Verify the required arguments in the original call. */
13748 if (gimple_call_num_args (stmt) < 5)
13750 dest = gimple_call_arg (stmt, 0);
13751 if (!validate_arg (dest, POINTER_TYPE))
13753 len = gimple_call_arg (stmt, 1);
13754 if (!validate_arg (len, INTEGER_TYPE))
13756 flag = gimple_call_arg (stmt, 2);
13757 if (!validate_arg (flag, INTEGER_TYPE))
13759 size = gimple_call_arg (stmt, 3);
13760 if (!validate_arg (size, INTEGER_TYPE))
13762 fmt = gimple_call_arg (stmt, 4);
13763 if (!validate_arg (fmt, POINTER_TYPE))
13766 if (! host_integerp (size, 1))
13769 if (! integer_all_onesp (size))
13771 if (! host_integerp (len, 1))
13773 /* If LEN is not constant, try MAXLEN too.
13774 For MAXLEN only allow optimizing into non-_ocs function
13775 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
13776 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13782 if (tree_int_cst_lt (size, maxlen))
13786 if (!init_target_chars ())
13789 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13790 or if format doesn't contain % chars or is "%s". */
13791 if (! integer_zerop (flag))
13793 fmt_str = c_getstr (fmt);
13794 if (fmt_str == NULL)
13796 if (strchr (fmt_str, target_percent) != NULL
13797 && strcmp (fmt_str, target_percent_s))
13801 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13803 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13804 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13808 return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13811 /* Builtins with folding operations that operate on "..." arguments
13812 need special handling; we need to store the arguments in a convenient
13813 data structure before attempting any folding. Fortunately there are
13814 only a few builtins that fall into this category. FNDECL is the
13815 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13816 result of the function call is ignored. */
13819 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13820 bool ignore ATTRIBUTE_UNUSED)
13822 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13823 tree ret = NULL_TREE;
13827 case BUILT_IN_SPRINTF_CHK:
13828 case BUILT_IN_VSPRINTF_CHK:
13829 ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13832 case BUILT_IN_SNPRINTF_CHK:
13833 case BUILT_IN_VSNPRINTF_CHK:
13834 ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13841 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13842 TREE_NO_WARNING (ret) = 1;
13848 /* A wrapper function for builtin folding that prevents warnings for
13849 "statement without effect" and the like, caused by removing the
13850 call node earlier than the warning is generated. */
13853 fold_call_stmt (gimple stmt, bool ignore)
13855 tree ret = NULL_TREE;
13856 tree fndecl = gimple_call_fndecl (stmt);
13857 location_t loc = gimple_location (stmt);
13859 && TREE_CODE (fndecl) == FUNCTION_DECL
13860 && DECL_BUILT_IN (fndecl)
13861 && !gimple_call_va_arg_pack_p (stmt))
13863 int nargs = gimple_call_num_args (stmt);
13865 if (avoid_folding_inline_builtin (fndecl))
13867 /* FIXME: Don't use a list in this interface. */
13868 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13870 tree arglist = NULL_TREE;
13872 for (i = nargs - 1; i >= 0; i--)
13873 arglist = tree_cons (NULL_TREE, gimple_call_arg (stmt, i), arglist);
13874 return targetm.fold_builtin (fndecl, arglist, ignore);
13878 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13880 tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13882 for (i = 0; i < nargs; i++)
13883 args[i] = gimple_call_arg (stmt, i);
13884 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13887 ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13890 /* Propagate location information from original call to
13891 expansion of builtin. Otherwise things like
13892 maybe_emit_chk_warning, that operate on the expansion
13893 of a builtin, will use the wrong location information. */
13894 if (gimple_has_location (stmt))
13896 tree realret = ret;
13897 if (TREE_CODE (ret) == NOP_EXPR)
13898 realret = TREE_OPERAND (ret, 0);
13899 if (CAN_HAVE_LOCATION_P (realret)
13900 && !EXPR_HAS_LOCATION (realret))
13901 SET_EXPR_LOCATION (realret, loc);
13911 /* Look up the function in built_in_decls that corresponds to DECL
13912 and set ASMSPEC as its user assembler name. DECL must be a
13913 function decl that declares a builtin. */
13916 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13919 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13920 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13923 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13924 set_user_assembler_name (builtin, asmspec);
13925 switch (DECL_FUNCTION_CODE (decl))
13927 case BUILT_IN_MEMCPY:
13928 init_block_move_fn (asmspec);
13929 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13931 case BUILT_IN_MEMSET:
13932 init_block_clear_fn (asmspec);
13933 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13935 case BUILT_IN_MEMMOVE:
13936 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13938 case BUILT_IN_MEMCMP:
13939 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13941 case BUILT_IN_ABORT:
13942 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);