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 /* Return the size required for the block returned by __builtin_apply_args,
1263 and initialize apply_args_mode. */
1266 apply_args_size (void)
1268 static int size = -1;
1271 enum machine_mode mode;
1273 /* The values computed by this function never change. */
1276 /* The first value is the incoming arg-pointer. */
1277 size = GET_MODE_SIZE (Pmode);
1279 /* The second value is the structure value address unless this is
1280 passed as an "invisible" first argument. */
1281 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1282 size += GET_MODE_SIZE (Pmode);
1284 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1285 if (FUNCTION_ARG_REGNO_P (regno))
1287 mode = reg_raw_mode[regno];
1289 gcc_assert (mode != VOIDmode);
1291 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1292 if (size % align != 0)
1293 size = CEIL (size, align) * align;
1294 size += GET_MODE_SIZE (mode);
1295 apply_args_mode[regno] = mode;
1299 apply_args_mode[regno] = VOIDmode;
1305 /* Return the size required for the block returned by __builtin_apply,
1306 and initialize apply_result_mode. */
1309 apply_result_size (void)
1311 static int size = -1;
1313 enum machine_mode mode;
1315 /* The values computed by this function never change. */
1320 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1321 if (FUNCTION_VALUE_REGNO_P (regno))
1323 mode = reg_raw_mode[regno];
1325 gcc_assert (mode != VOIDmode);
1327 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1328 if (size % align != 0)
1329 size = CEIL (size, align) * align;
1330 size += GET_MODE_SIZE (mode);
1331 apply_result_mode[regno] = mode;
1334 apply_result_mode[regno] = VOIDmode;
1336 /* Allow targets that use untyped_call and untyped_return to override
1337 the size so that machine-specific information can be stored here. */
1338 #ifdef APPLY_RESULT_SIZE
1339 size = APPLY_RESULT_SIZE;
1345 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1346 /* Create a vector describing the result block RESULT. If SAVEP is true,
1347 the result block is used to save the values; otherwise it is used to
1348 restore the values. */
1351 result_vector (int savep, rtx result)
1353 int regno, size, align, nelts;
1354 enum machine_mode mode;
1356 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1359 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1360 if ((mode = apply_result_mode[regno]) != VOIDmode)
1362 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1363 if (size % align != 0)
1364 size = CEIL (size, align) * align;
1365 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1366 mem = adjust_address (result, mode, size);
1367 savevec[nelts++] = (savep
1368 ? gen_rtx_SET (VOIDmode, mem, reg)
1369 : gen_rtx_SET (VOIDmode, reg, mem));
1370 size += GET_MODE_SIZE (mode);
1372 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1374 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1376 /* Save the state required to perform an untyped call with the same
1377 arguments as were passed to the current function. */
1380 expand_builtin_apply_args_1 (void)
1383 int size, align, regno;
1384 enum machine_mode mode;
1385 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1387 /* Create a block where the arg-pointer, structure value address,
1388 and argument registers can be saved. */
1389 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1391 /* Walk past the arg-pointer and structure value address. */
1392 size = GET_MODE_SIZE (Pmode);
1393 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1394 size += GET_MODE_SIZE (Pmode);
1396 /* Save each register used in calling a function to the block. */
1397 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1398 if ((mode = apply_args_mode[regno]) != VOIDmode)
1400 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1401 if (size % align != 0)
1402 size = CEIL (size, align) * align;
1404 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1406 emit_move_insn (adjust_address (registers, mode, size), tem);
1407 size += GET_MODE_SIZE (mode);
1410 /* Save the arg pointer to the block. */
1411 tem = copy_to_reg (crtl->args.internal_arg_pointer);
1412 #ifdef STACK_GROWS_DOWNWARD
1413 /* We need the pointer as the caller actually passed them to us, not
1414 as we might have pretended they were passed. Make sure it's a valid
1415 operand, as emit_move_insn isn't expected to handle a PLUS. */
1417 = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1420 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1422 size = GET_MODE_SIZE (Pmode);
1424 /* Save the structure value address unless this is passed as an
1425 "invisible" first argument. */
1426 if (struct_incoming_value)
1428 emit_move_insn (adjust_address (registers, Pmode, size),
1429 copy_to_reg (struct_incoming_value));
1430 size += GET_MODE_SIZE (Pmode);
1433 /* Return the address of the block. */
1434 return copy_addr_to_reg (XEXP (registers, 0));
1437 /* __builtin_apply_args returns block of memory allocated on
1438 the stack into which is stored the arg pointer, structure
1439 value address, static chain, and all the registers that might
1440 possibly be used in performing a function call. The code is
1441 moved to the start of the function so the incoming values are
1445 expand_builtin_apply_args (void)
1447 /* Don't do __builtin_apply_args more than once in a function.
1448 Save the result of the first call and reuse it. */
1449 if (apply_args_value != 0)
1450 return apply_args_value;
1452 /* When this function is called, it means that registers must be
1453 saved on entry to this function. So we migrate the
1454 call to the first insn of this function. */
1459 temp = expand_builtin_apply_args_1 ();
1463 apply_args_value = temp;
1465 /* Put the insns after the NOTE that starts the function.
1466 If this is inside a start_sequence, make the outer-level insn
1467 chain current, so the code is placed at the start of the
1468 function. If internal_arg_pointer is a non-virtual pseudo,
1469 it needs to be placed after the function that initializes
1471 push_topmost_sequence ();
1472 if (REG_P (crtl->args.internal_arg_pointer)
1473 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1474 emit_insn_before (seq, parm_birth_insn);
1476 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1477 pop_topmost_sequence ();
1482 /* Perform an untyped call and save the state required to perform an
1483 untyped return of whatever value was returned by the given function. */
1486 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1488 int size, align, regno;
1489 enum machine_mode mode;
1490 rtx incoming_args, result, reg, dest, src, call_insn;
1491 rtx old_stack_level = 0;
1492 rtx call_fusage = 0;
1493 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1495 arguments = convert_memory_address (Pmode, arguments);
1497 /* Create a block where the return registers can be saved. */
1498 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1500 /* Fetch the arg pointer from the ARGUMENTS block. */
1501 incoming_args = gen_reg_rtx (Pmode);
1502 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1503 #ifndef STACK_GROWS_DOWNWARD
1504 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1505 incoming_args, 0, OPTAB_LIB_WIDEN);
1508 /* Push a new argument block and copy the arguments. Do not allow
1509 the (potential) memcpy call below to interfere with our stack
1511 do_pending_stack_adjust ();
1514 /* Save the stack with nonlocal if available. */
1515 #ifdef HAVE_save_stack_nonlocal
1516 if (HAVE_save_stack_nonlocal)
1517 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1520 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1522 /* Allocate a block of memory onto the stack and copy the memory
1523 arguments to the outgoing arguments address. */
1524 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1526 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1527 may have already set current_function_calls_alloca to true.
1528 current_function_calls_alloca won't be set if argsize is zero,
1529 so we have to guarantee need_drap is true here. */
1530 if (SUPPORTS_STACK_ALIGNMENT)
1531 crtl->need_drap = true;
1533 dest = virtual_outgoing_args_rtx;
1534 #ifndef STACK_GROWS_DOWNWARD
1535 if (CONST_INT_P (argsize))
1536 dest = plus_constant (dest, -INTVAL (argsize));
1538 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1540 dest = gen_rtx_MEM (BLKmode, dest);
1541 set_mem_align (dest, PARM_BOUNDARY);
1542 src = gen_rtx_MEM (BLKmode, incoming_args);
1543 set_mem_align (src, PARM_BOUNDARY);
1544 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1546 /* Refer to the argument block. */
1548 arguments = gen_rtx_MEM (BLKmode, arguments);
1549 set_mem_align (arguments, PARM_BOUNDARY);
1551 /* Walk past the arg-pointer and structure value address. */
1552 size = GET_MODE_SIZE (Pmode);
1554 size += GET_MODE_SIZE (Pmode);
1556 /* Restore each of the registers previously saved. Make USE insns
1557 for each of these registers for use in making the call. */
1558 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1559 if ((mode = apply_args_mode[regno]) != VOIDmode)
1561 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1562 if (size % align != 0)
1563 size = CEIL (size, align) * align;
1564 reg = gen_rtx_REG (mode, regno);
1565 emit_move_insn (reg, adjust_address (arguments, mode, size));
1566 use_reg (&call_fusage, reg);
1567 size += GET_MODE_SIZE (mode);
1570 /* Restore the structure value address unless this is passed as an
1571 "invisible" first argument. */
1572 size = GET_MODE_SIZE (Pmode);
1575 rtx value = gen_reg_rtx (Pmode);
1576 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1577 emit_move_insn (struct_value, value);
1578 if (REG_P (struct_value))
1579 use_reg (&call_fusage, struct_value);
1580 size += GET_MODE_SIZE (Pmode);
1583 /* All arguments and registers used for the call are set up by now! */
1584 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1586 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1587 and we don't want to load it into a register as an optimization,
1588 because prepare_call_address already did it if it should be done. */
1589 if (GET_CODE (function) != SYMBOL_REF)
1590 function = memory_address (FUNCTION_MODE, function);
1592 /* Generate the actual call instruction and save the return value. */
1593 #ifdef HAVE_untyped_call
1594 if (HAVE_untyped_call)
1595 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1596 result, result_vector (1, result)));
1599 #ifdef HAVE_call_value
1600 if (HAVE_call_value)
1604 /* Locate the unique return register. It is not possible to
1605 express a call that sets more than one return register using
1606 call_value; use untyped_call for that. In fact, untyped_call
1607 only needs to save the return registers in the given block. */
1608 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1609 if ((mode = apply_result_mode[regno]) != VOIDmode)
1611 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1613 valreg = gen_rtx_REG (mode, regno);
1616 emit_call_insn (GEN_CALL_VALUE (valreg,
1617 gen_rtx_MEM (FUNCTION_MODE, function),
1618 const0_rtx, NULL_RTX, const0_rtx));
1620 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1626 /* Find the CALL insn we just emitted, and attach the register usage
1628 call_insn = last_call_insn ();
1629 add_function_usage_to (call_insn, call_fusage);
1631 /* Restore the stack. */
1632 #ifdef HAVE_save_stack_nonlocal
1633 if (HAVE_save_stack_nonlocal)
1634 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1637 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1641 /* Return the address of the result block. */
1642 result = copy_addr_to_reg (XEXP (result, 0));
1643 return convert_memory_address (ptr_mode, result);
1646 /* Perform an untyped return. */
1649 expand_builtin_return (rtx result)
1651 int size, align, regno;
1652 enum machine_mode mode;
1654 rtx call_fusage = 0;
1656 result = convert_memory_address (Pmode, result);
1658 apply_result_size ();
1659 result = gen_rtx_MEM (BLKmode, result);
1661 #ifdef HAVE_untyped_return
1662 if (HAVE_untyped_return)
1664 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1670 /* Restore the return value and note that each value is used. */
1672 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1673 if ((mode = apply_result_mode[regno]) != VOIDmode)
1675 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1676 if (size % align != 0)
1677 size = CEIL (size, align) * align;
1678 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1679 emit_move_insn (reg, adjust_address (result, mode, size));
1681 push_to_sequence (call_fusage);
1683 call_fusage = get_insns ();
1685 size += GET_MODE_SIZE (mode);
1688 /* Put the USE insns before the return. */
1689 emit_insn (call_fusage);
1691 /* Return whatever values was restored by jumping directly to the end
1693 expand_naked_return ();
1696 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1698 static enum type_class
1699 type_to_class (tree type)
1701 switch (TREE_CODE (type))
1703 case VOID_TYPE: return void_type_class;
1704 case INTEGER_TYPE: return integer_type_class;
1705 case ENUMERAL_TYPE: return enumeral_type_class;
1706 case BOOLEAN_TYPE: return boolean_type_class;
1707 case POINTER_TYPE: return pointer_type_class;
1708 case REFERENCE_TYPE: return reference_type_class;
1709 case OFFSET_TYPE: return offset_type_class;
1710 case REAL_TYPE: return real_type_class;
1711 case COMPLEX_TYPE: return complex_type_class;
1712 case FUNCTION_TYPE: return function_type_class;
1713 case METHOD_TYPE: return method_type_class;
1714 case RECORD_TYPE: return record_type_class;
1716 case QUAL_UNION_TYPE: return union_type_class;
1717 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1718 ? string_type_class : array_type_class);
1719 case LANG_TYPE: return lang_type_class;
1720 default: return no_type_class;
1724 /* Expand a call EXP to __builtin_classify_type. */
1727 expand_builtin_classify_type (tree exp)
1729 if (call_expr_nargs (exp))
1730 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1731 return GEN_INT (no_type_class);
1734 /* This helper macro, meant to be used in mathfn_built_in below,
1735 determines which among a set of three builtin math functions is
1736 appropriate for a given type mode. The `F' and `L' cases are
1737 automatically generated from the `double' case. */
1738 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1739 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1740 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1741 fcodel = BUILT_IN_MATHFN##L ; break;
1742 /* Similar to above, but appends _R after any F/L suffix. */
1743 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1744 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1745 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1746 fcodel = BUILT_IN_MATHFN##L_R ; break;
1748 /* Return mathematic function equivalent to FN but operating directly
1749 on TYPE, if available. If IMPLICIT is true find the function in
1750 implicit_built_in_decls[], otherwise use built_in_decls[]. If we
1751 can't do the conversion, return zero. */
1754 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1756 tree const *const fn_arr
1757 = implicit ? implicit_built_in_decls : built_in_decls;
1758 enum built_in_function fcode, fcodef, fcodel;
1762 CASE_MATHFN (BUILT_IN_ACOS)
1763 CASE_MATHFN (BUILT_IN_ACOSH)
1764 CASE_MATHFN (BUILT_IN_ASIN)
1765 CASE_MATHFN (BUILT_IN_ASINH)
1766 CASE_MATHFN (BUILT_IN_ATAN)
1767 CASE_MATHFN (BUILT_IN_ATAN2)
1768 CASE_MATHFN (BUILT_IN_ATANH)
1769 CASE_MATHFN (BUILT_IN_CBRT)
1770 CASE_MATHFN (BUILT_IN_CEIL)
1771 CASE_MATHFN (BUILT_IN_CEXPI)
1772 CASE_MATHFN (BUILT_IN_COPYSIGN)
1773 CASE_MATHFN (BUILT_IN_COS)
1774 CASE_MATHFN (BUILT_IN_COSH)
1775 CASE_MATHFN (BUILT_IN_DREM)
1776 CASE_MATHFN (BUILT_IN_ERF)
1777 CASE_MATHFN (BUILT_IN_ERFC)
1778 CASE_MATHFN (BUILT_IN_EXP)
1779 CASE_MATHFN (BUILT_IN_EXP10)
1780 CASE_MATHFN (BUILT_IN_EXP2)
1781 CASE_MATHFN (BUILT_IN_EXPM1)
1782 CASE_MATHFN (BUILT_IN_FABS)
1783 CASE_MATHFN (BUILT_IN_FDIM)
1784 CASE_MATHFN (BUILT_IN_FLOOR)
1785 CASE_MATHFN (BUILT_IN_FMA)
1786 CASE_MATHFN (BUILT_IN_FMAX)
1787 CASE_MATHFN (BUILT_IN_FMIN)
1788 CASE_MATHFN (BUILT_IN_FMOD)
1789 CASE_MATHFN (BUILT_IN_FREXP)
1790 CASE_MATHFN (BUILT_IN_GAMMA)
1791 CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1792 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1793 CASE_MATHFN (BUILT_IN_HYPOT)
1794 CASE_MATHFN (BUILT_IN_ILOGB)
1795 CASE_MATHFN (BUILT_IN_INF)
1796 CASE_MATHFN (BUILT_IN_ISINF)
1797 CASE_MATHFN (BUILT_IN_J0)
1798 CASE_MATHFN (BUILT_IN_J1)
1799 CASE_MATHFN (BUILT_IN_JN)
1800 CASE_MATHFN (BUILT_IN_LCEIL)
1801 CASE_MATHFN (BUILT_IN_LDEXP)
1802 CASE_MATHFN (BUILT_IN_LFLOOR)
1803 CASE_MATHFN (BUILT_IN_LGAMMA)
1804 CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1805 CASE_MATHFN (BUILT_IN_LLCEIL)
1806 CASE_MATHFN (BUILT_IN_LLFLOOR)
1807 CASE_MATHFN (BUILT_IN_LLRINT)
1808 CASE_MATHFN (BUILT_IN_LLROUND)
1809 CASE_MATHFN (BUILT_IN_LOG)
1810 CASE_MATHFN (BUILT_IN_LOG10)
1811 CASE_MATHFN (BUILT_IN_LOG1P)
1812 CASE_MATHFN (BUILT_IN_LOG2)
1813 CASE_MATHFN (BUILT_IN_LOGB)
1814 CASE_MATHFN (BUILT_IN_LRINT)
1815 CASE_MATHFN (BUILT_IN_LROUND)
1816 CASE_MATHFN (BUILT_IN_MODF)
1817 CASE_MATHFN (BUILT_IN_NAN)
1818 CASE_MATHFN (BUILT_IN_NANS)
1819 CASE_MATHFN (BUILT_IN_NEARBYINT)
1820 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1821 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1822 CASE_MATHFN (BUILT_IN_POW)
1823 CASE_MATHFN (BUILT_IN_POWI)
1824 CASE_MATHFN (BUILT_IN_POW10)
1825 CASE_MATHFN (BUILT_IN_REMAINDER)
1826 CASE_MATHFN (BUILT_IN_REMQUO)
1827 CASE_MATHFN (BUILT_IN_RINT)
1828 CASE_MATHFN (BUILT_IN_ROUND)
1829 CASE_MATHFN (BUILT_IN_SCALB)
1830 CASE_MATHFN (BUILT_IN_SCALBLN)
1831 CASE_MATHFN (BUILT_IN_SCALBN)
1832 CASE_MATHFN (BUILT_IN_SIGNBIT)
1833 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1834 CASE_MATHFN (BUILT_IN_SIN)
1835 CASE_MATHFN (BUILT_IN_SINCOS)
1836 CASE_MATHFN (BUILT_IN_SINH)
1837 CASE_MATHFN (BUILT_IN_SQRT)
1838 CASE_MATHFN (BUILT_IN_TAN)
1839 CASE_MATHFN (BUILT_IN_TANH)
1840 CASE_MATHFN (BUILT_IN_TGAMMA)
1841 CASE_MATHFN (BUILT_IN_TRUNC)
1842 CASE_MATHFN (BUILT_IN_Y0)
1843 CASE_MATHFN (BUILT_IN_Y1)
1844 CASE_MATHFN (BUILT_IN_YN)
1850 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1851 return fn_arr[fcode];
1852 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1853 return fn_arr[fcodef];
1854 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1855 return fn_arr[fcodel];
1860 /* Like mathfn_built_in_1(), but always use the implicit array. */
1863 mathfn_built_in (tree type, enum built_in_function fn)
1865 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1868 /* If errno must be maintained, expand the RTL to check if the result,
1869 TARGET, of a built-in function call, EXP, is NaN, and if so set
1873 expand_errno_check (tree exp, rtx target)
1875 rtx lab = gen_label_rtx ();
1877 /* Test the result; if it is NaN, set errno=EDOM because
1878 the argument was not in the domain. */
1879 do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1880 NULL_RTX, NULL_RTX, lab);
1883 /* If this built-in doesn't throw an exception, set errno directly. */
1884 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1886 #ifdef GEN_ERRNO_RTX
1887 rtx errno_rtx = GEN_ERRNO_RTX;
1890 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1892 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1898 /* Make sure the library call isn't expanded as a tail call. */
1899 CALL_EXPR_TAILCALL (exp) = 0;
1901 /* We can't set errno=EDOM directly; let the library call do it.
1902 Pop the arguments right away in case the call gets deleted. */
1904 expand_call (exp, target, 0);
1909 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1910 Return NULL_RTX if a normal call should be emitted rather than expanding
1911 the function in-line. EXP is the expression that is a call to the builtin
1912 function; if convenient, the result should be placed in TARGET.
1913 SUBTARGET may be used as the target for computing one of EXP's operands. */
1916 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1918 optab builtin_optab;
1920 tree fndecl = get_callee_fndecl (exp);
1921 enum machine_mode mode;
1922 bool errno_set = false;
1925 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1928 arg = CALL_EXPR_ARG (exp, 0);
1930 switch (DECL_FUNCTION_CODE (fndecl))
1932 CASE_FLT_FN (BUILT_IN_SQRT):
1933 errno_set = ! tree_expr_nonnegative_p (arg);
1934 builtin_optab = sqrt_optab;
1936 CASE_FLT_FN (BUILT_IN_EXP):
1937 errno_set = true; builtin_optab = exp_optab; break;
1938 CASE_FLT_FN (BUILT_IN_EXP10):
1939 CASE_FLT_FN (BUILT_IN_POW10):
1940 errno_set = true; builtin_optab = exp10_optab; break;
1941 CASE_FLT_FN (BUILT_IN_EXP2):
1942 errno_set = true; builtin_optab = exp2_optab; break;
1943 CASE_FLT_FN (BUILT_IN_EXPM1):
1944 errno_set = true; builtin_optab = expm1_optab; break;
1945 CASE_FLT_FN (BUILT_IN_LOGB):
1946 errno_set = true; builtin_optab = logb_optab; break;
1947 CASE_FLT_FN (BUILT_IN_LOG):
1948 errno_set = true; builtin_optab = log_optab; break;
1949 CASE_FLT_FN (BUILT_IN_LOG10):
1950 errno_set = true; builtin_optab = log10_optab; break;
1951 CASE_FLT_FN (BUILT_IN_LOG2):
1952 errno_set = true; builtin_optab = log2_optab; break;
1953 CASE_FLT_FN (BUILT_IN_LOG1P):
1954 errno_set = true; builtin_optab = log1p_optab; break;
1955 CASE_FLT_FN (BUILT_IN_ASIN):
1956 builtin_optab = asin_optab; break;
1957 CASE_FLT_FN (BUILT_IN_ACOS):
1958 builtin_optab = acos_optab; break;
1959 CASE_FLT_FN (BUILT_IN_TAN):
1960 builtin_optab = tan_optab; break;
1961 CASE_FLT_FN (BUILT_IN_ATAN):
1962 builtin_optab = atan_optab; break;
1963 CASE_FLT_FN (BUILT_IN_FLOOR):
1964 builtin_optab = floor_optab; break;
1965 CASE_FLT_FN (BUILT_IN_CEIL):
1966 builtin_optab = ceil_optab; break;
1967 CASE_FLT_FN (BUILT_IN_TRUNC):
1968 builtin_optab = btrunc_optab; break;
1969 CASE_FLT_FN (BUILT_IN_ROUND):
1970 builtin_optab = round_optab; break;
1971 CASE_FLT_FN (BUILT_IN_NEARBYINT):
1972 builtin_optab = nearbyint_optab;
1973 if (flag_trapping_math)
1975 /* Else fallthrough and expand as rint. */
1976 CASE_FLT_FN (BUILT_IN_RINT):
1977 builtin_optab = rint_optab; break;
1978 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
1979 builtin_optab = significand_optab; break;
1984 /* Make a suitable register to place result in. */
1985 mode = TYPE_MODE (TREE_TYPE (exp));
1987 if (! flag_errno_math || ! HONOR_NANS (mode))
1990 /* Before working hard, check whether the instruction is available. */
1991 if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
1993 target = gen_reg_rtx (mode);
1995 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1996 need to expand the argument again. This way, we will not perform
1997 side-effects more the once. */
1998 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2000 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2004 /* Compute into TARGET.
2005 Set TARGET to wherever the result comes back. */
2006 target = expand_unop (mode, builtin_optab, op0, target, 0);
2011 expand_errno_check (exp, target);
2013 /* Output the entire sequence. */
2014 insns = get_insns ();
2020 /* If we were unable to expand via the builtin, stop the sequence
2021 (without outputting the insns) and call to the library function
2022 with the stabilized argument list. */
2026 return expand_call (exp, target, target == const0_rtx);
2029 /* Expand a call to the builtin binary math functions (pow and atan2).
2030 Return NULL_RTX if a normal call should be emitted rather than expanding the
2031 function in-line. EXP is the expression that is a call to the builtin
2032 function; if convenient, the result should be placed in TARGET.
2033 SUBTARGET may be used as the target for computing one of EXP's
2037 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2039 optab builtin_optab;
2040 rtx op0, op1, insns;
2041 int op1_type = REAL_TYPE;
2042 tree fndecl = get_callee_fndecl (exp);
2044 enum machine_mode mode;
2045 bool errno_set = true;
2047 switch (DECL_FUNCTION_CODE (fndecl))
2049 CASE_FLT_FN (BUILT_IN_SCALBN):
2050 CASE_FLT_FN (BUILT_IN_SCALBLN):
2051 CASE_FLT_FN (BUILT_IN_LDEXP):
2052 op1_type = INTEGER_TYPE;
2057 if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2060 arg0 = CALL_EXPR_ARG (exp, 0);
2061 arg1 = CALL_EXPR_ARG (exp, 1);
2063 switch (DECL_FUNCTION_CODE (fndecl))
2065 CASE_FLT_FN (BUILT_IN_POW):
2066 builtin_optab = pow_optab; break;
2067 CASE_FLT_FN (BUILT_IN_ATAN2):
2068 builtin_optab = atan2_optab; break;
2069 CASE_FLT_FN (BUILT_IN_SCALB):
2070 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2072 builtin_optab = scalb_optab; break;
2073 CASE_FLT_FN (BUILT_IN_SCALBN):
2074 CASE_FLT_FN (BUILT_IN_SCALBLN):
2075 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2077 /* Fall through... */
2078 CASE_FLT_FN (BUILT_IN_LDEXP):
2079 builtin_optab = ldexp_optab; break;
2080 CASE_FLT_FN (BUILT_IN_FMOD):
2081 builtin_optab = fmod_optab; break;
2082 CASE_FLT_FN (BUILT_IN_REMAINDER):
2083 CASE_FLT_FN (BUILT_IN_DREM):
2084 builtin_optab = remainder_optab; break;
2089 /* Make a suitable register to place result in. */
2090 mode = TYPE_MODE (TREE_TYPE (exp));
2092 /* Before working hard, check whether the instruction is available. */
2093 if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2096 target = gen_reg_rtx (mode);
2098 if (! flag_errno_math || ! HONOR_NANS (mode))
2101 /* Always stabilize the argument list. */
2102 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2103 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2105 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2106 op1 = expand_normal (arg1);
2110 /* Compute into TARGET.
2111 Set TARGET to wherever the result comes back. */
2112 target = expand_binop (mode, builtin_optab, op0, op1,
2113 target, 0, OPTAB_DIRECT);
2115 /* If we were unable to expand via the builtin, stop the sequence
2116 (without outputting the insns) and call to the library function
2117 with the stabilized argument list. */
2121 return expand_call (exp, target, target == const0_rtx);
2125 expand_errno_check (exp, target);
2127 /* Output the entire sequence. */
2128 insns = get_insns ();
2135 /* Expand a call to the builtin sin and cos math functions.
2136 Return NULL_RTX if a normal call should be emitted rather than expanding the
2137 function in-line. EXP is the expression that is a call to the builtin
2138 function; if convenient, the result should be placed in TARGET.
2139 SUBTARGET may be used as the target for computing one of EXP's
2143 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2145 optab builtin_optab;
2147 tree fndecl = get_callee_fndecl (exp);
2148 enum machine_mode mode;
2151 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2154 arg = CALL_EXPR_ARG (exp, 0);
2156 switch (DECL_FUNCTION_CODE (fndecl))
2158 CASE_FLT_FN (BUILT_IN_SIN):
2159 CASE_FLT_FN (BUILT_IN_COS):
2160 builtin_optab = sincos_optab; break;
2165 /* Make a suitable register to place result in. */
2166 mode = TYPE_MODE (TREE_TYPE (exp));
2168 /* Check if sincos insn is available, otherwise fallback
2169 to sin or cos insn. */
2170 if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2171 switch (DECL_FUNCTION_CODE (fndecl))
2173 CASE_FLT_FN (BUILT_IN_SIN):
2174 builtin_optab = sin_optab; break;
2175 CASE_FLT_FN (BUILT_IN_COS):
2176 builtin_optab = cos_optab; break;
2181 /* Before working hard, check whether the instruction is available. */
2182 if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2184 target = gen_reg_rtx (mode);
2186 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2187 need to expand the argument again. This way, we will not perform
2188 side-effects more the once. */
2189 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2191 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2195 /* Compute into TARGET.
2196 Set TARGET to wherever the result comes back. */
2197 if (builtin_optab == sincos_optab)
2201 switch (DECL_FUNCTION_CODE (fndecl))
2203 CASE_FLT_FN (BUILT_IN_SIN):
2204 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2206 CASE_FLT_FN (BUILT_IN_COS):
2207 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2212 gcc_assert (result);
2216 target = expand_unop (mode, builtin_optab, op0, target, 0);
2221 /* Output the entire sequence. */
2222 insns = get_insns ();
2228 /* If we were unable to expand via the builtin, stop the sequence
2229 (without outputting the insns) and call to the library function
2230 with the stabilized argument list. */
2234 target = expand_call (exp, target, target == const0_rtx);
2239 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2240 return an RTL instruction code that implements the functionality.
2241 If that isn't possible or available return CODE_FOR_nothing. */
2243 static enum insn_code
2244 interclass_mathfn_icode (tree arg, tree fndecl)
2246 bool errno_set = false;
2247 optab builtin_optab = 0;
2248 enum machine_mode mode;
2250 switch (DECL_FUNCTION_CODE (fndecl))
2252 CASE_FLT_FN (BUILT_IN_ILOGB):
2253 errno_set = true; builtin_optab = ilogb_optab; break;
2254 CASE_FLT_FN (BUILT_IN_ISINF):
2255 builtin_optab = isinf_optab; break;
2256 case BUILT_IN_ISNORMAL:
2257 case BUILT_IN_ISFINITE:
2258 CASE_FLT_FN (BUILT_IN_FINITE):
2259 case BUILT_IN_FINITED32:
2260 case BUILT_IN_FINITED64:
2261 case BUILT_IN_FINITED128:
2262 case BUILT_IN_ISINFD32:
2263 case BUILT_IN_ISINFD64:
2264 case BUILT_IN_ISINFD128:
2265 /* These builtins have no optabs (yet). */
2271 /* There's no easy way to detect the case we need to set EDOM. */
2272 if (flag_errno_math && errno_set)
2273 return CODE_FOR_nothing;
2275 /* Optab mode depends on the mode of the input argument. */
2276 mode = TYPE_MODE (TREE_TYPE (arg));
2279 return optab_handler (builtin_optab, mode)->insn_code;
2280 return CODE_FOR_nothing;
2283 /* Expand a call to one of the builtin math functions that operate on
2284 floating point argument and output an integer result (ilogb, isinf,
2286 Return 0 if a normal call should be emitted rather than expanding the
2287 function in-line. EXP is the expression that is a call to the builtin
2288 function; if convenient, the result should be placed in TARGET.
2289 SUBTARGET may be used as the target for computing one of EXP's operands. */
2292 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2294 enum insn_code icode = CODE_FOR_nothing;
2296 tree fndecl = get_callee_fndecl (exp);
2297 enum machine_mode mode;
2300 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2303 arg = CALL_EXPR_ARG (exp, 0);
2304 icode = interclass_mathfn_icode (arg, fndecl);
2305 mode = TYPE_MODE (TREE_TYPE (arg));
2307 if (icode != CODE_FOR_nothing)
2309 /* Make a suitable register to place result in. */
2311 || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2312 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2314 gcc_assert (insn_data[icode].operand[0].predicate
2315 (target, GET_MODE (target)));
2317 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2318 need to expand the argument again. This way, we will not perform
2319 side-effects more the once. */
2320 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2322 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2324 if (mode != GET_MODE (op0))
2325 op0 = convert_to_mode (mode, op0, 0);
2327 /* Compute into TARGET.
2328 Set TARGET to wherever the result comes back. */
2329 emit_unop_insn (icode, target, op0, UNKNOWN);
2336 /* Expand a call to the builtin sincos math function.
2337 Return NULL_RTX if a normal call should be emitted rather than expanding the
2338 function in-line. EXP is the expression that is a call to the builtin
2342 expand_builtin_sincos (tree exp)
2344 rtx op0, op1, op2, target1, target2;
2345 enum machine_mode mode;
2346 tree arg, sinp, cosp;
2348 location_t loc = EXPR_LOCATION (exp);
2350 if (!validate_arglist (exp, REAL_TYPE,
2351 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2354 arg = CALL_EXPR_ARG (exp, 0);
2355 sinp = CALL_EXPR_ARG (exp, 1);
2356 cosp = CALL_EXPR_ARG (exp, 2);
2358 /* Make a suitable register to place result in. */
2359 mode = TYPE_MODE (TREE_TYPE (arg));
2361 /* Check if sincos insn is available, otherwise emit the call. */
2362 if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2365 target1 = gen_reg_rtx (mode);
2366 target2 = gen_reg_rtx (mode);
2368 op0 = expand_normal (arg);
2369 op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2370 op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2372 /* Compute into target1 and target2.
2373 Set TARGET to wherever the result comes back. */
2374 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2375 gcc_assert (result);
2377 /* Move target1 and target2 to the memory locations indicated
2379 emit_move_insn (op1, target1);
2380 emit_move_insn (op2, target2);
2385 /* Expand a call to the internal cexpi builtin to the sincos math function.
2386 EXP is the expression that is a call to the builtin function; if convenient,
2387 the result should be placed in TARGET. SUBTARGET may be used as the target
2388 for computing one of EXP's operands. */
2391 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2393 tree fndecl = get_callee_fndecl (exp);
2395 enum machine_mode mode;
2397 location_t loc = EXPR_LOCATION (exp);
2399 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2402 arg = CALL_EXPR_ARG (exp, 0);
2403 type = TREE_TYPE (arg);
2404 mode = TYPE_MODE (TREE_TYPE (arg));
2406 /* Try expanding via a sincos optab, fall back to emitting a libcall
2407 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2408 is only generated from sincos, cexp or if we have either of them. */
2409 if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2411 op1 = gen_reg_rtx (mode);
2412 op2 = gen_reg_rtx (mode);
2414 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2416 /* Compute into op1 and op2. */
2417 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2419 else if (TARGET_HAS_SINCOS)
2421 tree call, fn = NULL_TREE;
2425 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2426 fn = built_in_decls[BUILT_IN_SINCOSF];
2427 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2428 fn = built_in_decls[BUILT_IN_SINCOS];
2429 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2430 fn = built_in_decls[BUILT_IN_SINCOSL];
2434 op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2435 op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2436 op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2437 op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2438 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2439 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2441 /* Make sure not to fold the sincos call again. */
2442 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2443 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2444 call, 3, arg, top1, top2));
2448 tree call, fn = NULL_TREE, narg;
2449 tree ctype = build_complex_type (type);
2451 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2452 fn = built_in_decls[BUILT_IN_CEXPF];
2453 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2454 fn = built_in_decls[BUILT_IN_CEXP];
2455 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2456 fn = built_in_decls[BUILT_IN_CEXPL];
2460 /* If we don't have a decl for cexp create one. This is the
2461 friendliest fallback if the user calls __builtin_cexpi
2462 without full target C99 function support. */
2463 if (fn == NULL_TREE)
2466 const char *name = NULL;
2468 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2470 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2472 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2475 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2476 fn = build_fn_decl (name, fntype);
2479 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2480 build_real (type, dconst0), arg);
2482 /* Make sure not to fold the cexp call again. */
2483 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2484 return expand_expr (build_call_nary (ctype, call, 1, narg),
2485 target, VOIDmode, EXPAND_NORMAL);
2488 /* Now build the proper return type. */
2489 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2490 make_tree (TREE_TYPE (arg), op2),
2491 make_tree (TREE_TYPE (arg), op1)),
2492 target, VOIDmode, EXPAND_NORMAL);
2495 /* Conveniently construct a function call expression. FNDECL names the
2496 function to be called, N is the number of arguments, and the "..."
2497 parameters are the argument expressions. Unlike build_call_exr
2498 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2501 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2504 tree fntype = TREE_TYPE (fndecl);
2505 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2508 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2510 SET_EXPR_LOCATION (fn, loc);
2513 #define build_call_nofold(...) \
2514 build_call_nofold_loc (UNKNOWN_LOCATION, __VA_ARGS__)
2516 /* Expand a call to one of the builtin rounding functions gcc defines
2517 as an extension (lfloor and lceil). As these are gcc extensions we
2518 do not need to worry about setting errno to EDOM.
2519 If expanding via optab fails, lower expression to (int)(floor(x)).
2520 EXP is the expression that is a call to the builtin function;
2521 if convenient, the result should be placed in TARGET. */
2524 expand_builtin_int_roundingfn (tree exp, rtx target)
2526 convert_optab builtin_optab;
2527 rtx op0, insns, tmp;
2528 tree fndecl = get_callee_fndecl (exp);
2529 enum built_in_function fallback_fn;
2530 tree fallback_fndecl;
2531 enum machine_mode mode;
2534 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2537 arg = CALL_EXPR_ARG (exp, 0);
2539 switch (DECL_FUNCTION_CODE (fndecl))
2541 CASE_FLT_FN (BUILT_IN_LCEIL):
2542 CASE_FLT_FN (BUILT_IN_LLCEIL):
2543 builtin_optab = lceil_optab;
2544 fallback_fn = BUILT_IN_CEIL;
2547 CASE_FLT_FN (BUILT_IN_LFLOOR):
2548 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2549 builtin_optab = lfloor_optab;
2550 fallback_fn = BUILT_IN_FLOOR;
2557 /* Make a suitable register to place result in. */
2558 mode = TYPE_MODE (TREE_TYPE (exp));
2560 target = gen_reg_rtx (mode);
2562 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2563 need to expand the argument again. This way, we will not perform
2564 side-effects more the once. */
2565 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2567 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2571 /* Compute into TARGET. */
2572 if (expand_sfix_optab (target, op0, builtin_optab))
2574 /* Output the entire sequence. */
2575 insns = get_insns ();
2581 /* If we were unable to expand via the builtin, stop the sequence
2582 (without outputting the insns). */
2585 /* Fall back to floating point rounding optab. */
2586 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2588 /* For non-C99 targets we may end up without a fallback fndecl here
2589 if the user called __builtin_lfloor directly. In this case emit
2590 a call to the floor/ceil variants nevertheless. This should result
2591 in the best user experience for not full C99 targets. */
2592 if (fallback_fndecl == NULL_TREE)
2595 const char *name = NULL;
2597 switch (DECL_FUNCTION_CODE (fndecl))
2599 case BUILT_IN_LCEIL:
2600 case BUILT_IN_LLCEIL:
2603 case BUILT_IN_LCEILF:
2604 case BUILT_IN_LLCEILF:
2607 case BUILT_IN_LCEILL:
2608 case BUILT_IN_LLCEILL:
2611 case BUILT_IN_LFLOOR:
2612 case BUILT_IN_LLFLOOR:
2615 case BUILT_IN_LFLOORF:
2616 case BUILT_IN_LLFLOORF:
2619 case BUILT_IN_LFLOORL:
2620 case BUILT_IN_LLFLOORL:
2627 fntype = build_function_type_list (TREE_TYPE (arg),
2628 TREE_TYPE (arg), NULL_TREE);
2629 fallback_fndecl = build_fn_decl (name, fntype);
2632 exp = build_call_nofold (fallback_fndecl, 1, arg);
2634 tmp = expand_normal (exp);
2636 /* Truncate the result of floating point optab to integer
2637 via expand_fix (). */
2638 target = gen_reg_rtx (mode);
2639 expand_fix (target, tmp, 0);
2644 /* Expand a call to one of the builtin math functions doing integer
2646 Return 0 if a normal call should be emitted rather than expanding the
2647 function in-line. EXP is the expression that is a call to the builtin
2648 function; if convenient, the result should be placed in TARGET. */
2651 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2653 convert_optab builtin_optab;
2655 tree fndecl = get_callee_fndecl (exp);
2657 enum machine_mode mode;
2659 /* There's no easy way to detect the case we need to set EDOM. */
2660 if (flag_errno_math)
2663 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2666 arg = CALL_EXPR_ARG (exp, 0);
2668 switch (DECL_FUNCTION_CODE (fndecl))
2670 CASE_FLT_FN (BUILT_IN_LRINT):
2671 CASE_FLT_FN (BUILT_IN_LLRINT):
2672 builtin_optab = lrint_optab; break;
2673 CASE_FLT_FN (BUILT_IN_LROUND):
2674 CASE_FLT_FN (BUILT_IN_LLROUND):
2675 builtin_optab = lround_optab; break;
2680 /* Make a suitable register to place result in. */
2681 mode = TYPE_MODE (TREE_TYPE (exp));
2683 target = gen_reg_rtx (mode);
2685 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2686 need to expand the argument again. This way, we will not perform
2687 side-effects more the once. */
2688 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2690 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2694 if (expand_sfix_optab (target, op0, builtin_optab))
2696 /* Output the entire sequence. */
2697 insns = get_insns ();
2703 /* If we were unable to expand via the builtin, stop the sequence
2704 (without outputting the insns) and call to the library function
2705 with the stabilized argument list. */
2708 target = expand_call (exp, target, target == const0_rtx);
2713 /* To evaluate powi(x,n), the floating point value x raised to the
2714 constant integer exponent n, we use a hybrid algorithm that
2715 combines the "window method" with look-up tables. For an
2716 introduction to exponentiation algorithms and "addition chains",
2717 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2718 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2719 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2720 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2722 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2723 multiplications to inline before calling the system library's pow
2724 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2725 so this default never requires calling pow, powf or powl. */
2727 #ifndef POWI_MAX_MULTS
2728 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2731 /* The size of the "optimal power tree" lookup table. All
2732 exponents less than this value are simply looked up in the
2733 powi_table below. This threshold is also used to size the
2734 cache of pseudo registers that hold intermediate results. */
2735 #define POWI_TABLE_SIZE 256
2737 /* The size, in bits of the window, used in the "window method"
2738 exponentiation algorithm. This is equivalent to a radix of
2739 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2740 #define POWI_WINDOW_SIZE 3
2742 /* The following table is an efficient representation of an
2743 "optimal power tree". For each value, i, the corresponding
2744 value, j, in the table states than an optimal evaluation
2745 sequence for calculating pow(x,i) can be found by evaluating
2746 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2747 100 integers is given in Knuth's "Seminumerical algorithms". */
2749 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2751 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2752 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2753 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2754 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2755 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2756 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2757 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2758 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2759 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2760 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2761 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2762 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2763 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2764 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2765 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2766 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2767 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2768 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2769 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2770 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2771 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2772 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2773 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2774 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2775 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2776 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2777 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2778 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2779 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2780 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2781 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2782 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2786 /* Return the number of multiplications required to calculate
2787 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2788 subroutine of powi_cost. CACHE is an array indicating
2789 which exponents have already been calculated. */
2792 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2794 /* If we've already calculated this exponent, then this evaluation
2795 doesn't require any additional multiplications. */
2800 return powi_lookup_cost (n - powi_table[n], cache)
2801 + powi_lookup_cost (powi_table[n], cache) + 1;
2804 /* Return the number of multiplications required to calculate
2805 powi(x,n) for an arbitrary x, given the exponent N. This
2806 function needs to be kept in sync with expand_powi below. */
2809 powi_cost (HOST_WIDE_INT n)
2811 bool cache[POWI_TABLE_SIZE];
2812 unsigned HOST_WIDE_INT digit;
2813 unsigned HOST_WIDE_INT val;
2819 /* Ignore the reciprocal when calculating the cost. */
2820 val = (n < 0) ? -n : n;
2822 /* Initialize the exponent cache. */
2823 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2828 while (val >= POWI_TABLE_SIZE)
2832 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2833 result += powi_lookup_cost (digit, cache)
2834 + POWI_WINDOW_SIZE + 1;
2835 val >>= POWI_WINDOW_SIZE;
2844 return result + powi_lookup_cost (val, cache);
2847 /* Recursive subroutine of expand_powi. This function takes the array,
2848 CACHE, of already calculated exponents and an exponent N and returns
2849 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2852 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2854 unsigned HOST_WIDE_INT digit;
2858 if (n < POWI_TABLE_SIZE)
2863 target = gen_reg_rtx (mode);
2866 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2867 op1 = expand_powi_1 (mode, powi_table[n], cache);
2871 target = gen_reg_rtx (mode);
2872 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2873 op0 = expand_powi_1 (mode, n - digit, cache);
2874 op1 = expand_powi_1 (mode, digit, cache);
2878 target = gen_reg_rtx (mode);
2879 op0 = expand_powi_1 (mode, n >> 1, cache);
2883 result = expand_mult (mode, op0, op1, target, 0);
2884 if (result != target)
2885 emit_move_insn (target, result);
2889 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2890 floating point operand in mode MODE, and N is the exponent. This
2891 function needs to be kept in sync with powi_cost above. */
2894 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2896 rtx cache[POWI_TABLE_SIZE];
2900 return CONST1_RTX (mode);
2902 memset (cache, 0, sizeof (cache));
2905 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2907 /* If the original exponent was negative, reciprocate the result. */
2909 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2910 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2915 /* Expand a call to the pow built-in mathematical function. Return NULL_RTX if
2916 a normal call should be emitted rather than expanding the function
2917 in-line. EXP is the expression that is a call to the builtin
2918 function; if convenient, the result should be placed in TARGET. */
2921 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2925 tree type = TREE_TYPE (exp);
2926 REAL_VALUE_TYPE cint, c, c2;
2929 enum machine_mode mode = TYPE_MODE (type);
2931 if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2934 arg0 = CALL_EXPR_ARG (exp, 0);
2935 arg1 = CALL_EXPR_ARG (exp, 1);
2937 if (TREE_CODE (arg1) != REAL_CST
2938 || TREE_OVERFLOW (arg1))
2939 return expand_builtin_mathfn_2 (exp, target, subtarget);
2941 /* Handle constant exponents. */
2943 /* For integer valued exponents we can expand to an optimal multiplication
2944 sequence using expand_powi. */
2945 c = TREE_REAL_CST (arg1);
2946 n = real_to_integer (&c);
2947 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2948 if (real_identical (&c, &cint)
2949 && ((n >= -1 && n <= 2)
2950 || (flag_unsafe_math_optimizations
2951 && optimize_insn_for_speed_p ()
2952 && powi_cost (n) <= POWI_MAX_MULTS)))
2954 op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2957 op = force_reg (mode, op);
2958 op = expand_powi (op, mode, n);
2963 narg0 = builtin_save_expr (arg0);
2965 /* If the exponent is not integer valued, check if it is half of an integer.
2966 In this case we can expand to sqrt (x) * x**(n/2). */
2967 fn = mathfn_built_in (type, BUILT_IN_SQRT);
2968 if (fn != NULL_TREE)
2970 real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2971 n = real_to_integer (&c2);
2972 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2973 if (real_identical (&c2, &cint)
2974 && ((flag_unsafe_math_optimizations
2975 && optimize_insn_for_speed_p ()
2976 && powi_cost (n/2) <= POWI_MAX_MULTS)
2979 tree call_expr = build_call_nofold (fn, 1, narg0);
2980 /* Use expand_expr in case the newly built call expression
2981 was folded to a non-call. */
2982 op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
2985 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
2986 op2 = force_reg (mode, op2);
2987 op2 = expand_powi (op2, mode, abs (n / 2));
2988 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
2989 0, OPTAB_LIB_WIDEN);
2990 /* If the original exponent was negative, reciprocate the
2993 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2994 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3000 /* Try if the exponent is a third of an integer. In this case
3001 we can expand to x**(n/3) * cbrt(x)**(n%3). As cbrt (x) is
3002 different from pow (x, 1./3.) due to rounding and behavior
3003 with negative x we need to constrain this transformation to
3004 unsafe math and positive x or finite math. */
3005 fn = mathfn_built_in (type, BUILT_IN_CBRT);
3007 && flag_unsafe_math_optimizations
3008 && (tree_expr_nonnegative_p (arg0)
3009 || !HONOR_NANS (mode)))
3011 REAL_VALUE_TYPE dconst3;
3012 real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3013 real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3014 real_round (&c2, mode, &c2);
3015 n = real_to_integer (&c2);
3016 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3017 real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3018 real_convert (&c2, mode, &c2);
3019 if (real_identical (&c2, &c)
3020 && ((optimize_insn_for_speed_p ()
3021 && powi_cost (n/3) <= POWI_MAX_MULTS)
3024 tree call_expr = build_call_nofold (fn, 1,narg0);
3025 op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3026 if (abs (n) % 3 == 2)
3027 op = expand_simple_binop (mode, MULT, op, op, op,
3028 0, OPTAB_LIB_WIDEN);
3031 op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3032 op2 = force_reg (mode, op2);
3033 op2 = expand_powi (op2, mode, abs (n / 3));
3034 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3035 0, OPTAB_LIB_WIDEN);
3036 /* If the original exponent was negative, reciprocate the
3039 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3040 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3046 /* Fall back to optab expansion. */
3047 return expand_builtin_mathfn_2 (exp, target, subtarget);
3050 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
3051 a normal call should be emitted rather than expanding the function
3052 in-line. EXP is the expression that is a call to the builtin
3053 function; if convenient, the result should be placed in TARGET. */
3056 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3060 enum machine_mode mode;
3061 enum machine_mode mode2;
3063 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3066 arg0 = CALL_EXPR_ARG (exp, 0);
3067 arg1 = CALL_EXPR_ARG (exp, 1);
3068 mode = TYPE_MODE (TREE_TYPE (exp));
3070 /* Handle constant power. */
3072 if (TREE_CODE (arg1) == INTEGER_CST
3073 && !TREE_OVERFLOW (arg1))
3075 HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3077 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3078 Otherwise, check the number of multiplications required. */
3079 if ((TREE_INT_CST_HIGH (arg1) == 0
3080 || TREE_INT_CST_HIGH (arg1) == -1)
3081 && ((n >= -1 && n <= 2)
3082 || (optimize_insn_for_speed_p ()
3083 && powi_cost (n) <= POWI_MAX_MULTS)))
3085 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3086 op0 = force_reg (mode, op0);
3087 return expand_powi (op0, mode, n);
3091 /* Emit a libcall to libgcc. */
3093 /* Mode of the 2nd argument must match that of an int. */
3094 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3096 if (target == NULL_RTX)
3097 target = gen_reg_rtx (mode);
3099 op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3100 if (GET_MODE (op0) != mode)
3101 op0 = convert_to_mode (mode, op0, 0);
3102 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3103 if (GET_MODE (op1) != mode2)
3104 op1 = convert_to_mode (mode2, op1, 0);
3106 target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3107 target, LCT_CONST, mode, 2,
3108 op0, mode, op1, mode2);
3113 /* Expand expression EXP which is a call to the strlen builtin. Return
3114 NULL_RTX if we failed the caller should emit a normal call, otherwise
3115 try to get the result in TARGET, if convenient. */
3118 expand_builtin_strlen (tree exp, rtx target,
3119 enum machine_mode target_mode)
3121 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3127 tree src = CALL_EXPR_ARG (exp, 0);
3128 rtx result, src_reg, char_rtx, before_strlen;
3129 enum machine_mode insn_mode = target_mode, char_mode;
3130 enum insn_code icode = CODE_FOR_nothing;
3133 /* If the length can be computed at compile-time, return it. */
3134 len = c_strlen (src, 0);
3136 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3138 /* If the length can be computed at compile-time and is constant
3139 integer, but there are side-effects in src, evaluate
3140 src for side-effects, then return len.
3141 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3142 can be optimized into: i++; x = 3; */
3143 len = c_strlen (src, 1);
3144 if (len && TREE_CODE (len) == INTEGER_CST)
3146 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3147 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3150 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3152 /* If SRC is not a pointer type, don't do this operation inline. */
3156 /* Bail out if we can't compute strlen in the right mode. */
3157 while (insn_mode != VOIDmode)
3159 icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3160 if (icode != CODE_FOR_nothing)
3163 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3165 if (insn_mode == VOIDmode)
3168 /* Make a place to write the result of the instruction. */
3172 && GET_MODE (result) == insn_mode
3173 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3174 result = gen_reg_rtx (insn_mode);
3176 /* Make a place to hold the source address. We will not expand
3177 the actual source until we are sure that the expansion will
3178 not fail -- there are trees that cannot be expanded twice. */
3179 src_reg = gen_reg_rtx (Pmode);
3181 /* Mark the beginning of the strlen sequence so we can emit the
3182 source operand later. */
3183 before_strlen = get_last_insn ();
3185 char_rtx = const0_rtx;
3186 char_mode = insn_data[(int) icode].operand[2].mode;
3187 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3189 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3191 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3192 char_rtx, GEN_INT (align));
3197 /* Now that we are assured of success, expand the source. */
3199 pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3201 emit_move_insn (src_reg, pat);
3206 emit_insn_after (pat, before_strlen);
3208 emit_insn_before (pat, get_insns ());
3210 /* Return the value in the proper mode for this function. */
3211 if (GET_MODE (result) == target_mode)
3213 else if (target != 0)
3214 convert_move (target, result, 0);
3216 target = convert_to_mode (target_mode, result, 0);
3222 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3223 bytes from constant string DATA + OFFSET and return it as target
3227 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3228 enum machine_mode mode)
3230 const char *str = (const char *) data;
3232 gcc_assert (offset >= 0
3233 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3234 <= strlen (str) + 1));
3236 return c_readstr (str + offset, mode);
3239 /* Expand a call EXP to the memcpy builtin.
3240 Return NULL_RTX if we failed, the caller should emit a normal call,
3241 otherwise try to get the result in TARGET, if convenient (and in
3242 mode MODE if that's convenient). */
3245 expand_builtin_memcpy (tree exp, rtx target)
3247 if (!validate_arglist (exp,
3248 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3252 tree dest = CALL_EXPR_ARG (exp, 0);
3253 tree src = CALL_EXPR_ARG (exp, 1);
3254 tree len = CALL_EXPR_ARG (exp, 2);
3255 const char *src_str;
3256 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3257 unsigned int dest_align
3258 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3259 rtx dest_mem, src_mem, dest_addr, len_rtx;
3260 HOST_WIDE_INT expected_size = -1;
3261 unsigned int expected_align = 0;
3263 /* If DEST is not a pointer type, call the normal function. */
3264 if (dest_align == 0)
3267 /* If either SRC is not a pointer type, don't do this
3268 operation in-line. */
3272 if (currently_expanding_gimple_stmt)
3273 stringop_block_profile (currently_expanding_gimple_stmt,
3274 &expected_align, &expected_size);
3276 if (expected_align < dest_align)
3277 expected_align = dest_align;
3278 dest_mem = get_memory_rtx (dest, len);
3279 set_mem_align (dest_mem, dest_align);
3280 len_rtx = expand_normal (len);
3281 src_str = c_getstr (src);
3283 /* If SRC is a string constant and block move would be done
3284 by pieces, we can avoid loading the string from memory
3285 and only stored the computed constants. */
3287 && CONST_INT_P (len_rtx)
3288 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3289 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3290 CONST_CAST (char *, src_str),
3293 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3294 builtin_memcpy_read_str,
3295 CONST_CAST (char *, src_str),
3296 dest_align, false, 0);
3297 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3298 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3302 src_mem = get_memory_rtx (src, len);
3303 set_mem_align (src_mem, src_align);
3305 /* Copy word part most expediently. */
3306 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3307 CALL_EXPR_TAILCALL (exp)
3308 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3309 expected_align, expected_size);
3313 dest_addr = force_operand (XEXP (dest_mem, 0), target);
3314 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3320 /* Expand a call EXP to the mempcpy builtin.
3321 Return NULL_RTX if we failed; the caller should emit a normal call,
3322 otherwise try to get the result in TARGET, if convenient (and in
3323 mode MODE if that's convenient). If ENDP is 0 return the
3324 destination pointer, if ENDP is 1 return the end pointer ala
3325 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3329 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3331 if (!validate_arglist (exp,
3332 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3336 tree dest = CALL_EXPR_ARG (exp, 0);
3337 tree src = CALL_EXPR_ARG (exp, 1);
3338 tree len = CALL_EXPR_ARG (exp, 2);
3339 return expand_builtin_mempcpy_args (dest, src, len,
3340 target, mode, /*endp=*/ 1);
3344 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3345 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3346 so that this can also be called without constructing an actual CALL_EXPR.
3347 The other arguments and return value are the same as for
3348 expand_builtin_mempcpy. */
3351 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3352 rtx target, enum machine_mode mode, int endp)
3354 /* If return value is ignored, transform mempcpy into memcpy. */
3355 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3357 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3358 tree result = build_call_nofold (fn, 3, dest, src, len);
3359 return expand_expr (result, target, mode, EXPAND_NORMAL);
3363 const char *src_str;
3364 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3365 unsigned int dest_align
3366 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3367 rtx dest_mem, src_mem, len_rtx;
3369 /* If either SRC or DEST is not a pointer type, don't do this
3370 operation in-line. */
3371 if (dest_align == 0 || src_align == 0)
3374 /* If LEN is not constant, call the normal function. */
3375 if (! host_integerp (len, 1))
3378 len_rtx = expand_normal (len);
3379 src_str = c_getstr (src);
3381 /* If SRC is a string constant and block move would be done
3382 by pieces, we can avoid loading the string from memory
3383 and only stored the computed constants. */
3385 && CONST_INT_P (len_rtx)
3386 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3387 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3388 CONST_CAST (char *, src_str),
3391 dest_mem = get_memory_rtx (dest, len);
3392 set_mem_align (dest_mem, dest_align);
3393 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3394 builtin_memcpy_read_str,
3395 CONST_CAST (char *, src_str),
3396 dest_align, false, endp);
3397 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3398 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3402 if (CONST_INT_P (len_rtx)
3403 && can_move_by_pieces (INTVAL (len_rtx),
3404 MIN (dest_align, src_align)))
3406 dest_mem = get_memory_rtx (dest, len);
3407 set_mem_align (dest_mem, dest_align);
3408 src_mem = get_memory_rtx (src, len);
3409 set_mem_align (src_mem, src_align);
3410 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3411 MIN (dest_align, src_align), endp);
3412 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3413 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3422 # define HAVE_movstr 0
3423 # define CODE_FOR_movstr CODE_FOR_nothing
3426 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3427 we failed, the caller should emit a normal call, otherwise try to
3428 get the result in TARGET, if convenient. If ENDP is 0 return the
3429 destination pointer, if ENDP is 1 return the end pointer ala
3430 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3434 expand_movstr (tree dest, tree src, rtx target, int endp)
3440 const struct insn_data * data;
3445 dest_mem = get_memory_rtx (dest, NULL);
3446 src_mem = get_memory_rtx (src, NULL);
3449 target = force_reg (Pmode, XEXP (dest_mem, 0));
3450 dest_mem = replace_equiv_address (dest_mem, target);
3451 end = gen_reg_rtx (Pmode);
3455 if (target == 0 || target == const0_rtx)
3457 end = gen_reg_rtx (Pmode);
3465 data = insn_data + CODE_FOR_movstr;
3467 if (data->operand[0].mode != VOIDmode)
3468 end = gen_lowpart (data->operand[0].mode, end);
3470 insn = data->genfun (end, dest_mem, src_mem);
3476 /* movstr is supposed to set end to the address of the NUL
3477 terminator. If the caller requested a mempcpy-like return value,
3479 if (endp == 1 && target != const0_rtx)
3481 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3482 emit_move_insn (target, force_operand (tem, NULL_RTX));
3488 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3489 NULL_RTX if we failed the caller should emit a normal call, otherwise
3490 try to get the result in TARGET, if convenient (and in mode MODE if that's
3494 expand_builtin_strcpy (tree exp, rtx target)
3496 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3498 tree dest = CALL_EXPR_ARG (exp, 0);
3499 tree src = CALL_EXPR_ARG (exp, 1);
3500 return expand_builtin_strcpy_args (dest, src, target);
3505 /* Helper function to do the actual work for expand_builtin_strcpy. The
3506 arguments to the builtin_strcpy call DEST and SRC are broken out
3507 so that this can also be called without constructing an actual CALL_EXPR.
3508 The other arguments and return value are the same as for
3509 expand_builtin_strcpy. */
3512 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3514 return expand_movstr (dest, src, target, /*endp=*/0);
3517 /* Expand a call EXP to the stpcpy builtin.
3518 Return NULL_RTX if we failed the caller should emit a normal call,
3519 otherwise try to get the result in TARGET, if convenient (and in
3520 mode MODE if that's convenient). */
3523 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3526 location_t loc = EXPR_LOCATION (exp);
3528 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3531 dst = CALL_EXPR_ARG (exp, 0);
3532 src = CALL_EXPR_ARG (exp, 1);
3534 /* If return value is ignored, transform stpcpy into strcpy. */
3535 if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3537 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3538 tree result = build_call_nofold (fn, 2, dst, src);
3539 return expand_expr (result, target, mode, EXPAND_NORMAL);
3546 /* Ensure we get an actual string whose length can be evaluated at
3547 compile-time, not an expression containing a string. This is
3548 because the latter will potentially produce pessimized code
3549 when used to produce the return value. */
3550 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3551 return expand_movstr (dst, src, target, /*endp=*/2);
3553 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3554 ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3555 target, mode, /*endp=*/2);
3560 if (TREE_CODE (len) == INTEGER_CST)
3562 rtx len_rtx = expand_normal (len);
3564 if (CONST_INT_P (len_rtx))
3566 ret = expand_builtin_strcpy_args (dst, src, target);
3572 if (mode != VOIDmode)
3573 target = gen_reg_rtx (mode);
3575 target = gen_reg_rtx (GET_MODE (ret));
3577 if (GET_MODE (target) != GET_MODE (ret))
3578 ret = gen_lowpart (GET_MODE (target), ret);
3580 ret = plus_constant (ret, INTVAL (len_rtx));
3581 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3589 return expand_movstr (dst, src, target, /*endp=*/2);
3593 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3594 bytes from constant string DATA + OFFSET and return it as target
3598 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3599 enum machine_mode mode)
3601 const char *str = (const char *) data;
3603 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3606 return c_readstr (str + offset, mode);
3609 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3610 NULL_RTX if we failed the caller should emit a normal call. */
3613 expand_builtin_strncpy (tree exp, rtx target)
3615 location_t loc = EXPR_LOCATION (exp);
3617 if (validate_arglist (exp,
3618 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3620 tree dest = CALL_EXPR_ARG (exp, 0);
3621 tree src = CALL_EXPR_ARG (exp, 1);
3622 tree len = CALL_EXPR_ARG (exp, 2);
3623 tree slen = c_strlen (src, 1);
3625 /* We must be passed a constant len and src parameter. */
3626 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3629 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3631 /* We're required to pad with trailing zeros if the requested
3632 len is greater than strlen(s2)+1. In that case try to
3633 use store_by_pieces, if it fails, punt. */
3634 if (tree_int_cst_lt (slen, len))
3636 unsigned int dest_align
3637 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3638 const char *p = c_getstr (src);
3641 if (!p || dest_align == 0 || !host_integerp (len, 1)
3642 || !can_store_by_pieces (tree_low_cst (len, 1),
3643 builtin_strncpy_read_str,
3644 CONST_CAST (char *, p),
3648 dest_mem = get_memory_rtx (dest, len);
3649 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3650 builtin_strncpy_read_str,
3651 CONST_CAST (char *, p), dest_align, false, 0);
3652 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3653 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3660 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3661 bytes from constant string DATA + OFFSET and return it as target
3665 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3666 enum machine_mode mode)
3668 const char *c = (const char *) data;
3669 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3671 memset (p, *c, GET_MODE_SIZE (mode));
3673 return c_readstr (p, mode);
3676 /* Callback routine for store_by_pieces. Return the RTL of a register
3677 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3678 char value given in the RTL register data. For example, if mode is
3679 4 bytes wide, return the RTL for 0x01010101*data. */
3682 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3683 enum machine_mode mode)
3689 size = GET_MODE_SIZE (mode);
3693 p = XALLOCAVEC (char, size);
3694 memset (p, 1, size);
3695 coeff = c_readstr (p, mode);
3697 target = convert_to_mode (mode, (rtx) data, 1);
3698 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3699 return force_reg (mode, target);
3702 /* Expand expression EXP, which is a call to the memset builtin. Return
3703 NULL_RTX if we failed the caller should emit a normal call, otherwise
3704 try to get the result in TARGET, if convenient (and in mode MODE if that's
3708 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3710 if (!validate_arglist (exp,
3711 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3715 tree dest = CALL_EXPR_ARG (exp, 0);
3716 tree val = CALL_EXPR_ARG (exp, 1);
3717 tree len = CALL_EXPR_ARG (exp, 2);
3718 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3722 /* Helper function to do the actual work for expand_builtin_memset. The
3723 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3724 so that this can also be called without constructing an actual CALL_EXPR.
3725 The other arguments and return value are the same as for
3726 expand_builtin_memset. */
3729 expand_builtin_memset_args (tree dest, tree val, tree len,
3730 rtx target, enum machine_mode mode, tree orig_exp)
3733 enum built_in_function fcode;
3735 unsigned int dest_align;
3736 rtx dest_mem, dest_addr, len_rtx;
3737 HOST_WIDE_INT expected_size = -1;
3738 unsigned int expected_align = 0;
3740 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3742 /* If DEST is not a pointer type, don't do this operation in-line. */
3743 if (dest_align == 0)
3746 if (currently_expanding_gimple_stmt)
3747 stringop_block_profile (currently_expanding_gimple_stmt,
3748 &expected_align, &expected_size);
3750 if (expected_align < dest_align)
3751 expected_align = dest_align;
3753 /* If the LEN parameter is zero, return DEST. */
3754 if (integer_zerop (len))
3756 /* Evaluate and ignore VAL in case it has side-effects. */
3757 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3758 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3761 /* Stabilize the arguments in case we fail. */
3762 dest = builtin_save_expr (dest);
3763 val = builtin_save_expr (val);
3764 len = builtin_save_expr (len);
3766 len_rtx = expand_normal (len);
3767 dest_mem = get_memory_rtx (dest, len);
3769 if (TREE_CODE (val) != INTEGER_CST)
3773 val_rtx = expand_normal (val);
3774 val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3777 /* Assume that we can memset by pieces if we can store
3778 * the coefficients by pieces (in the required modes).
3779 * We can't pass builtin_memset_gen_str as that emits RTL. */
3781 if (host_integerp (len, 1)
3782 && can_store_by_pieces (tree_low_cst (len, 1),
3783 builtin_memset_read_str, &c, dest_align,
3786 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3788 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3789 builtin_memset_gen_str, val_rtx, dest_align,
3792 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3793 dest_align, expected_align,
3797 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3798 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3802 if (target_char_cast (val, &c))
3807 if (host_integerp (len, 1)
3808 && can_store_by_pieces (tree_low_cst (len, 1),
3809 builtin_memset_read_str, &c, dest_align,
3811 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3812 builtin_memset_read_str, &c, dest_align, true, 0);
3813 else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3814 dest_align, expected_align,
3818 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3819 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3823 set_mem_align (dest_mem, dest_align);
3824 dest_addr = clear_storage_hints (dest_mem, len_rtx,
3825 CALL_EXPR_TAILCALL (orig_exp)
3826 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3827 expected_align, expected_size);
3831 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3832 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3838 fndecl = get_callee_fndecl (orig_exp);
3839 fcode = DECL_FUNCTION_CODE (fndecl);
3840 if (fcode == BUILT_IN_MEMSET)
3841 fn = build_call_nofold (fndecl, 3, dest, val, len);
3842 else if (fcode == BUILT_IN_BZERO)
3843 fn = build_call_nofold (fndecl, 2, dest, len);
3846 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3847 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3848 return expand_call (fn, target, target == const0_rtx);
3851 /* Expand expression EXP, which is a call to the bzero builtin. Return
3852 NULL_RTX if we failed the caller should emit a normal call. */
3855 expand_builtin_bzero (tree exp)
3858 location_t loc = EXPR_LOCATION (exp);
3860 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3863 dest = CALL_EXPR_ARG (exp, 0);
3864 size = CALL_EXPR_ARG (exp, 1);
3866 /* New argument list transforming bzero(ptr x, int y) to
3867 memset(ptr x, int 0, size_t y). This is done this way
3868 so that if it isn't expanded inline, we fallback to
3869 calling bzero instead of memset. */
3871 return expand_builtin_memset_args (dest, integer_zero_node,
3872 fold_convert_loc (loc, sizetype, size),
3873 const0_rtx, VOIDmode, exp);
3876 /* Expand expression EXP, which is a call to the memcmp built-in function.
3877 Return NULL_RTX if we failed and the
3878 caller should emit a normal call, otherwise try to get the result in
3879 TARGET, if convenient (and in mode MODE, if that's convenient). */
3882 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3883 ATTRIBUTE_UNUSED enum machine_mode mode)
3885 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3887 if (!validate_arglist (exp,
3888 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3891 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3893 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3896 tree arg1 = CALL_EXPR_ARG (exp, 0);
3897 tree arg2 = CALL_EXPR_ARG (exp, 1);
3898 tree len = CALL_EXPR_ARG (exp, 2);
3901 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3903 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3904 enum machine_mode insn_mode;
3906 #ifdef HAVE_cmpmemsi
3908 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3911 #ifdef HAVE_cmpstrnsi
3913 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3918 /* If we don't have POINTER_TYPE, call the function. */
3919 if (arg1_align == 0 || arg2_align == 0)
3922 /* Make a place to write the result of the instruction. */
3925 && REG_P (result) && GET_MODE (result) == insn_mode
3926 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3927 result = gen_reg_rtx (insn_mode);
3929 arg1_rtx = get_memory_rtx (arg1, len);
3930 arg2_rtx = get_memory_rtx (arg2, len);
3931 arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3933 /* Set MEM_SIZE as appropriate. */
3934 if (CONST_INT_P (arg3_rtx))
3936 set_mem_size (arg1_rtx, arg3_rtx);
3937 set_mem_size (arg2_rtx, arg3_rtx);
3940 #ifdef HAVE_cmpmemsi
3942 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3943 GEN_INT (MIN (arg1_align, arg2_align)));
3946 #ifdef HAVE_cmpstrnsi
3948 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3949 GEN_INT (MIN (arg1_align, arg2_align)));
3957 emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3958 TYPE_MODE (integer_type_node), 3,
3959 XEXP (arg1_rtx, 0), Pmode,
3960 XEXP (arg2_rtx, 0), Pmode,
3961 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3962 TYPE_UNSIGNED (sizetype)),
3963 TYPE_MODE (sizetype));
3965 /* Return the value in the proper mode for this function. */
3966 mode = TYPE_MODE (TREE_TYPE (exp));
3967 if (GET_MODE (result) == mode)
3969 else if (target != 0)
3971 convert_move (target, result, 0);
3975 return convert_to_mode (mode, result, 0);
3982 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
3983 if we failed the caller should emit a normal call, otherwise try to get
3984 the result in TARGET, if convenient. */
3987 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
3989 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3992 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3993 if (cmpstr_optab[SImode] != CODE_FOR_nothing
3994 || cmpstrn_optab[SImode] != CODE_FOR_nothing)
3996 rtx arg1_rtx, arg2_rtx;
3997 rtx result, insn = NULL_RTX;
3999 tree arg1 = CALL_EXPR_ARG (exp, 0);
4000 tree arg2 = CALL_EXPR_ARG (exp, 1);
4003 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4005 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4007 /* If we don't have POINTER_TYPE, call the function. */
4008 if (arg1_align == 0 || arg2_align == 0)
4011 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4012 arg1 = builtin_save_expr (arg1);
4013 arg2 = builtin_save_expr (arg2);
4015 arg1_rtx = get_memory_rtx (arg1, NULL);
4016 arg2_rtx = get_memory_rtx (arg2, NULL);
4018 #ifdef HAVE_cmpstrsi
4019 /* Try to call cmpstrsi. */
4022 enum machine_mode insn_mode
4023 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4025 /* Make a place to write the result of the instruction. */
4028 && REG_P (result) && GET_MODE (result) == insn_mode
4029 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4030 result = gen_reg_rtx (insn_mode);
4032 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4033 GEN_INT (MIN (arg1_align, arg2_align)));
4036 #ifdef HAVE_cmpstrnsi
4037 /* Try to determine at least one length and call cmpstrnsi. */
4038 if (!insn && HAVE_cmpstrnsi)
4043 enum machine_mode insn_mode
4044 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4045 tree len1 = c_strlen (arg1, 1);
4046 tree len2 = c_strlen (arg2, 1);
4049 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4051 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4053 /* If we don't have a constant length for the first, use the length
4054 of the second, if we know it. We don't require a constant for
4055 this case; some cost analysis could be done if both are available
4056 but neither is constant. For now, assume they're equally cheap,
4057 unless one has side effects. If both strings have constant lengths,
4064 else if (TREE_SIDE_EFFECTS (len1))
4066 else if (TREE_SIDE_EFFECTS (len2))
4068 else if (TREE_CODE (len1) != INTEGER_CST)
4070 else if (TREE_CODE (len2) != INTEGER_CST)
4072 else if (tree_int_cst_lt (len1, len2))
4077 /* If both arguments have side effects, we cannot optimize. */
4078 if (!len || TREE_SIDE_EFFECTS (len))
4081 arg3_rtx = expand_normal (len);
4083 /* Make a place to write the result of the instruction. */
4086 && REG_P (result) && GET_MODE (result) == insn_mode
4087 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4088 result = gen_reg_rtx (insn_mode);
4090 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4091 GEN_INT (MIN (arg1_align, arg2_align)));
4097 enum machine_mode mode;
4100 /* Return the value in the proper mode for this function. */
4101 mode = TYPE_MODE (TREE_TYPE (exp));
4102 if (GET_MODE (result) == mode)
4105 return convert_to_mode (mode, result, 0);
4106 convert_move (target, result, 0);
4110 /* Expand the library call ourselves using a stabilized argument
4111 list to avoid re-evaluating the function's arguments twice. */
4112 #ifdef HAVE_cmpstrnsi
4115 fndecl = get_callee_fndecl (exp);
4116 fn = build_call_nofold (fndecl, 2, arg1, arg2);
4117 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4118 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4119 return expand_call (fn, target, target == const0_rtx);
4125 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4126 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4127 the result in TARGET, if convenient. */
4130 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4131 ATTRIBUTE_UNUSED enum machine_mode mode)
4133 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4135 if (!validate_arglist (exp,
4136 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4139 /* If c_strlen can determine an expression for one of the string
4140 lengths, and it doesn't have side effects, then emit cmpstrnsi
4141 using length MIN(strlen(string)+1, arg3). */
4142 #ifdef HAVE_cmpstrnsi
4145 tree len, len1, len2;
4146 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4149 tree arg1 = CALL_EXPR_ARG (exp, 0);
4150 tree arg2 = CALL_EXPR_ARG (exp, 1);
4151 tree arg3 = CALL_EXPR_ARG (exp, 2);
4154 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4156 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4157 enum machine_mode insn_mode
4158 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4160 len1 = c_strlen (arg1, 1);
4161 len2 = c_strlen (arg2, 1);
4164 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4166 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4168 /* If we don't have a constant length for the first, use the length
4169 of the second, if we know it. We don't require a constant for
4170 this case; some cost analysis could be done if both are available
4171 but neither is constant. For now, assume they're equally cheap,
4172 unless one has side effects. If both strings have constant lengths,
4179 else if (TREE_SIDE_EFFECTS (len1))
4181 else if (TREE_SIDE_EFFECTS (len2))
4183 else if (TREE_CODE (len1) != INTEGER_CST)
4185 else if (TREE_CODE (len2) != INTEGER_CST)
4187 else if (tree_int_cst_lt (len1, len2))
4192 /* If both arguments have side effects, we cannot optimize. */
4193 if (!len || TREE_SIDE_EFFECTS (len))
4196 /* The actual new length parameter is MIN(len,arg3). */
4197 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4198 fold_convert_loc (loc, TREE_TYPE (len), arg3));
4200 /* If we don't have POINTER_TYPE, call the function. */
4201 if (arg1_align == 0 || arg2_align == 0)
4204 /* Make a place to write the result of the instruction. */
4207 && REG_P (result) && GET_MODE (result) == insn_mode
4208 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4209 result = gen_reg_rtx (insn_mode);
4211 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4212 arg1 = builtin_save_expr (arg1);
4213 arg2 = builtin_save_expr (arg2);
4214 len = builtin_save_expr (len);
4216 arg1_rtx = get_memory_rtx (arg1, len);
4217 arg2_rtx = get_memory_rtx (arg2, len);
4218 arg3_rtx = expand_normal (len);
4219 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4220 GEN_INT (MIN (arg1_align, arg2_align)));
4225 /* Return the value in the proper mode for this function. */
4226 mode = TYPE_MODE (TREE_TYPE (exp));
4227 if (GET_MODE (result) == mode)
4230 return convert_to_mode (mode, result, 0);
4231 convert_move (target, result, 0);
4235 /* Expand the library call ourselves using a stabilized argument
4236 list to avoid re-evaluating the function's arguments twice. */
4237 fndecl = get_callee_fndecl (exp);
4238 fn = build_call_nofold (fndecl, 3, arg1, arg2, len);
4239 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4240 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4241 return expand_call (fn, target, target == const0_rtx);
4247 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4248 if that's convenient. */
4251 expand_builtin_saveregs (void)
4255 /* Don't do __builtin_saveregs more than once in a function.
4256 Save the result of the first call and reuse it. */
4257 if (saveregs_value != 0)
4258 return saveregs_value;
4260 /* When this function is called, it means that registers must be
4261 saved on entry to this function. So we migrate the call to the
4262 first insn of this function. */
4266 /* Do whatever the machine needs done in this case. */
4267 val = targetm.calls.expand_builtin_saveregs ();
4272 saveregs_value = val;
4274 /* Put the insns after the NOTE that starts the function. If this
4275 is inside a start_sequence, make the outer-level insn chain current, so
4276 the code is placed at the start of the function. */
4277 push_topmost_sequence ();
4278 emit_insn_after (seq, entry_of_function ());
4279 pop_topmost_sequence ();
4284 /* __builtin_args_info (N) returns word N of the arg space info
4285 for the current function. The number and meanings of words
4286 is controlled by the definition of CUMULATIVE_ARGS. */
4289 expand_builtin_args_info (tree exp)
4291 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4292 int *word_ptr = (int *) &crtl->args.info;
4294 gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4296 if (call_expr_nargs (exp) != 0)
4298 if (!host_integerp (CALL_EXPR_ARG (exp, 0), 0))
4299 error ("argument of %<__builtin_args_info%> must be constant");
4302 HOST_WIDE_INT wordnum = tree_low_cst (CALL_EXPR_ARG (exp, 0), 0);
4304 if (wordnum < 0 || wordnum >= nwords)
4305 error ("argument of %<__builtin_args_info%> out of range");
4307 return GEN_INT (word_ptr[wordnum]);
4311 error ("missing argument in %<__builtin_args_info%>");
4316 /* Expand a call to __builtin_next_arg. */
4319 expand_builtin_next_arg (void)
4321 /* Checking arguments is already done in fold_builtin_next_arg
4322 that must be called before this function. */
4323 return expand_binop (ptr_mode, add_optab,
4324 crtl->args.internal_arg_pointer,
4325 crtl->args.arg_offset_rtx,
4326 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4329 /* Make it easier for the backends by protecting the valist argument
4330 from multiple evaluations. */
4333 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4335 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4337 gcc_assert (vatype != NULL_TREE);
4339 if (TREE_CODE (vatype) == ARRAY_TYPE)
4341 if (TREE_SIDE_EFFECTS (valist))
4342 valist = save_expr (valist);
4344 /* For this case, the backends will be expecting a pointer to
4345 vatype, but it's possible we've actually been given an array
4346 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4348 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4350 tree p1 = build_pointer_type (TREE_TYPE (vatype));
4351 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4360 if (! TREE_SIDE_EFFECTS (valist))
4363 pt = build_pointer_type (vatype);
4364 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4365 TREE_SIDE_EFFECTS (valist) = 1;
4368 if (TREE_SIDE_EFFECTS (valist))
4369 valist = save_expr (valist);
4370 valist = build_fold_indirect_ref_loc (loc, valist);
4376 /* The "standard" definition of va_list is void*. */
4379 std_build_builtin_va_list (void)
4381 return ptr_type_node;
4384 /* The "standard" abi va_list is va_list_type_node. */
4387 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4389 return va_list_type_node;
4392 /* The "standard" type of va_list is va_list_type_node. */
4395 std_canonical_va_list_type (tree type)
4399 if (INDIRECT_REF_P (type))
4400 type = TREE_TYPE (type);
4401 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4402 type = TREE_TYPE (type);
4403 wtype = va_list_type_node;
4405 /* Treat structure va_list types. */
4406 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4407 htype = TREE_TYPE (htype);
4408 else if (TREE_CODE (wtype) == ARRAY_TYPE)
4410 /* If va_list is an array type, the argument may have decayed
4411 to a pointer type, e.g. by being passed to another function.
4412 In that case, unwrap both types so that we can compare the
4413 underlying records. */
4414 if (TREE_CODE (htype) == ARRAY_TYPE
4415 || POINTER_TYPE_P (htype))
4417 wtype = TREE_TYPE (wtype);
4418 htype = TREE_TYPE (htype);
4421 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4422 return va_list_type_node;
4427 /* The "standard" implementation of va_start: just assign `nextarg' to
4431 std_expand_builtin_va_start (tree valist, rtx nextarg)
4433 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4434 convert_move (va_r, nextarg, 0);
4437 /* Expand EXP, a call to __builtin_va_start. */
4440 expand_builtin_va_start (tree exp)
4444 location_t loc = EXPR_LOCATION (exp);
4446 if (call_expr_nargs (exp) < 2)
4448 error_at (loc, "too few arguments to function %<va_start%>");
4452 if (fold_builtin_next_arg (exp, true))
4455 nextarg = expand_builtin_next_arg ();
4456 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4458 if (targetm.expand_builtin_va_start)
4459 targetm.expand_builtin_va_start (valist, nextarg);
4461 std_expand_builtin_va_start (valist, nextarg);
4466 /* The "standard" implementation of va_arg: read the value from the
4467 current (padded) address and increment by the (padded) size. */
4470 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4473 tree addr, t, type_size, rounded_size, valist_tmp;
4474 unsigned HOST_WIDE_INT align, boundary;
4477 #ifdef ARGS_GROW_DOWNWARD
4478 /* All of the alignment and movement below is for args-grow-up machines.
4479 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4480 implement their own specialized gimplify_va_arg_expr routines. */
4484 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4486 type = build_pointer_type (type);
4488 align = PARM_BOUNDARY / BITS_PER_UNIT;
4489 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4491 /* When we align parameter on stack for caller, if the parameter
4492 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4493 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
4494 here with caller. */
4495 if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4496 boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4498 boundary /= BITS_PER_UNIT;
4500 /* Hoist the valist value into a temporary for the moment. */
4501 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4503 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4504 requires greater alignment, we must perform dynamic alignment. */
4505 if (boundary > align
4506 && !integer_zerop (TYPE_SIZE (type)))
4508 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4509 fold_build2 (POINTER_PLUS_EXPR,
4511 valist_tmp, size_int (boundary - 1)));
4512 gimplify_and_add (t, pre_p);
4514 t = fold_convert (sizetype, valist_tmp);
4515 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4516 fold_convert (TREE_TYPE (valist),
4517 fold_build2 (BIT_AND_EXPR, sizetype, t,
4518 size_int (-boundary))));
4519 gimplify_and_add (t, pre_p);
4524 /* If the actual alignment is less than the alignment of the type,
4525 adjust the type accordingly so that we don't assume strict alignment
4526 when dereferencing the pointer. */
4527 boundary *= BITS_PER_UNIT;
4528 if (boundary < TYPE_ALIGN (type))
4530 type = build_variant_type_copy (type);
4531 TYPE_ALIGN (type) = boundary;
4534 /* Compute the rounded size of the type. */
4535 type_size = size_in_bytes (type);
4536 rounded_size = round_up (type_size, align);
4538 /* Reduce rounded_size so it's sharable with the postqueue. */
4539 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4543 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4545 /* Small args are padded downward. */
4546 t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4547 rounded_size, size_int (align));
4548 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4549 size_binop (MINUS_EXPR, rounded_size, type_size));
4550 addr = fold_build2 (POINTER_PLUS_EXPR,
4551 TREE_TYPE (addr), addr, t);
4554 /* Compute new value for AP. */
4555 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4556 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4557 gimplify_and_add (t, pre_p);
4559 addr = fold_convert (build_pointer_type (type), addr);
4562 addr = build_va_arg_indirect_ref (addr);
4564 return build_va_arg_indirect_ref (addr);
4567 /* Build an indirect-ref expression over the given TREE, which represents a
4568 piece of a va_arg() expansion. */
4570 build_va_arg_indirect_ref (tree addr)
4572 addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4574 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4580 /* Return a dummy expression of type TYPE in order to keep going after an
4584 dummy_object (tree type)
4586 tree t = build_int_cst (build_pointer_type (type), 0);
4587 return build1 (INDIRECT_REF, type, t);
4590 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4591 builtin function, but a very special sort of operator. */
4593 enum gimplify_status
4594 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4596 tree promoted_type, have_va_type;
4597 tree valist = TREE_OPERAND (*expr_p, 0);
4598 tree type = TREE_TYPE (*expr_p);
4600 location_t loc = EXPR_LOCATION (*expr_p);
4602 /* Verify that valist is of the proper type. */
4603 have_va_type = TREE_TYPE (valist);
4604 if (have_va_type == error_mark_node)
4606 have_va_type = targetm.canonical_va_list_type (have_va_type);
4608 if (have_va_type == NULL_TREE)
4610 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4614 /* Generate a diagnostic for requesting data of a type that cannot
4615 be passed through `...' due to type promotion at the call site. */
4616 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4619 static bool gave_help;
4622 /* Unfortunately, this is merely undefined, rather than a constraint
4623 violation, so we cannot make this an error. If this call is never
4624 executed, the program is still strictly conforming. */
4625 warned = warning_at (loc, 0,
4626 "%qT is promoted to %qT when passed through %<...%>",
4627 type, promoted_type);
4628 if (!gave_help && warned)
4631 inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4632 promoted_type, type);
4635 /* We can, however, treat "undefined" any way we please.
4636 Call abort to encourage the user to fix the program. */
4638 inform (loc, "if this code is reached, the program will abort");
4639 /* Before the abort, allow the evaluation of the va_list
4640 expression to exit or longjmp. */
4641 gimplify_and_add (valist, pre_p);
4642 t = build_call_expr_loc (loc,
4643 implicit_built_in_decls[BUILT_IN_TRAP], 0);
4644 gimplify_and_add (t, pre_p);
4646 /* This is dead code, but go ahead and finish so that the
4647 mode of the result comes out right. */
4648 *expr_p = dummy_object (type);
4653 /* Make it easier for the backends by protecting the valist argument
4654 from multiple evaluations. */
4655 if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4657 /* For this case, the backends will be expecting a pointer to
4658 TREE_TYPE (abi), but it's possible we've
4659 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4661 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4663 tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4664 valist = fold_convert_loc (loc, p1,
4665 build_fold_addr_expr_loc (loc, valist));
4668 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4671 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4673 if (!targetm.gimplify_va_arg_expr)
4674 /* FIXME: Once most targets are converted we should merely
4675 assert this is non-null. */
4678 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4683 /* Expand EXP, a call to __builtin_va_end. */
4686 expand_builtin_va_end (tree exp)
4688 tree valist = CALL_EXPR_ARG (exp, 0);
4690 /* Evaluate for side effects, if needed. I hate macros that don't
4692 if (TREE_SIDE_EFFECTS (valist))
4693 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4698 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4699 builtin rather than just as an assignment in stdarg.h because of the
4700 nastiness of array-type va_list types. */
4703 expand_builtin_va_copy (tree exp)
4706 location_t loc = EXPR_LOCATION (exp);
4708 dst = CALL_EXPR_ARG (exp, 0);
4709 src = CALL_EXPR_ARG (exp, 1);
4711 dst = stabilize_va_list_loc (loc, dst, 1);
4712 src = stabilize_va_list_loc (loc, src, 0);
4714 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4716 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4718 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4719 TREE_SIDE_EFFECTS (t) = 1;
4720 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4724 rtx dstb, srcb, size;
4726 /* Evaluate to pointers. */
4727 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4728 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4729 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4730 NULL_RTX, VOIDmode, EXPAND_NORMAL);
4732 dstb = convert_memory_address (Pmode, dstb);
4733 srcb = convert_memory_address (Pmode, srcb);
4735 /* "Dereference" to BLKmode memories. */
4736 dstb = gen_rtx_MEM (BLKmode, dstb);
4737 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4738 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4739 srcb = gen_rtx_MEM (BLKmode, srcb);
4740 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4741 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4744 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4750 /* Expand a call to one of the builtin functions __builtin_frame_address or
4751 __builtin_return_address. */
4754 expand_builtin_frame_address (tree fndecl, tree exp)
4756 /* The argument must be a nonnegative integer constant.
4757 It counts the number of frames to scan up the stack.
4758 The value is the return address saved in that frame. */
4759 if (call_expr_nargs (exp) == 0)
4760 /* Warning about missing arg was already issued. */
4762 else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4764 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4765 error ("invalid argument to %<__builtin_frame_address%>");
4767 error ("invalid argument to %<__builtin_return_address%>");
4773 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4774 tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4776 /* Some ports cannot access arbitrary stack frames. */
4779 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4780 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4782 warning (0, "unsupported argument to %<__builtin_return_address%>");
4786 /* For __builtin_frame_address, return what we've got. */
4787 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4791 && ! CONSTANT_P (tem))
4792 tem = copy_to_mode_reg (Pmode, tem);
4797 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if
4798 we failed and the caller should emit a normal call, otherwise try to get
4799 the result in TARGET, if convenient. */
4802 expand_builtin_alloca (tree exp, rtx target)
4807 /* Emit normal call if marked not-inlineable. */
4808 if (CALL_CANNOT_INLINE_P (exp))
4811 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4814 /* Compute the argument. */
4815 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4817 /* Allocate the desired space. */
4818 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4819 result = convert_memory_address (ptr_mode, result);
4824 /* Expand a call to a bswap builtin with argument ARG0. MODE
4825 is the mode to expand with. */
4828 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4830 enum machine_mode mode;
4834 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4837 arg = CALL_EXPR_ARG (exp, 0);
4838 mode = TYPE_MODE (TREE_TYPE (arg));
4839 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4841 target = expand_unop (mode, bswap_optab, op0, target, 1);
4843 gcc_assert (target);
4845 return convert_to_mode (mode, target, 0);
4848 /* Expand a call to a unary builtin in EXP.
4849 Return NULL_RTX if a normal call should be emitted rather than expanding the
4850 function in-line. If convenient, the result should be placed in TARGET.
4851 SUBTARGET may be used as the target for computing one of EXP's operands. */
4854 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4855 rtx subtarget, optab op_optab)
4859 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4862 /* Compute the argument. */
4863 op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
4864 VOIDmode, EXPAND_NORMAL);
4865 /* Compute op, into TARGET if possible.
4866 Set TARGET to wherever the result comes back. */
4867 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4868 op_optab, op0, target, 1);
4869 gcc_assert (target);
4871 return convert_to_mode (target_mode, target, 0);
4874 /* Expand a call to __builtin_expect. We just return our argument
4875 as the builtin_expect semantic should've been already executed by
4876 tree branch prediction pass. */
4879 expand_builtin_expect (tree exp, rtx target)
4883 if (call_expr_nargs (exp) < 2)
4885 arg = CALL_EXPR_ARG (exp, 0);
4887 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4888 /* When guessing was done, the hints should be already stripped away. */
4889 gcc_assert (!flag_guess_branch_prob
4890 || optimize == 0 || errorcount || sorrycount);
4895 expand_builtin_trap (void)
4899 emit_insn (gen_trap ());
4902 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4906 /* Expand a call to __builtin_unreachable. We do nothing except emit
4907 a barrier saying that control flow will not pass here.
4909 It is the responsibility of the program being compiled to ensure
4910 that control flow does never reach __builtin_unreachable. */
4912 expand_builtin_unreachable (void)
4917 /* Expand EXP, a call to fabs, fabsf or fabsl.
4918 Return NULL_RTX if a normal call should be emitted rather than expanding
4919 the function inline. If convenient, the result should be placed
4920 in TARGET. SUBTARGET may be used as the target for computing
4924 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4926 enum machine_mode mode;
4930 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4933 arg = CALL_EXPR_ARG (exp, 0);
4934 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4935 mode = TYPE_MODE (TREE_TYPE (arg));
4936 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4937 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4940 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4941 Return NULL is a normal call should be emitted rather than expanding the
4942 function inline. If convenient, the result should be placed in TARGET.
4943 SUBTARGET may be used as the target for computing the operand. */
4946 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4951 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4954 arg = CALL_EXPR_ARG (exp, 0);
4955 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4957 arg = CALL_EXPR_ARG (exp, 1);
4958 op1 = expand_normal (arg);
4960 return expand_copysign (op0, op1, target);
4963 /* Create a new constant string literal and return a char* pointer to it.
4964 The STRING_CST value is the LEN characters at STR. */
4966 build_string_literal (int len, const char *str)
4968 tree t, elem, index, type;
4970 t = build_string (len, str);
4971 elem = build_type_variant (char_type_node, 1, 0);
4972 index = build_index_type (size_int (len - 1));
4973 type = build_array_type (elem, index);
4974 TREE_TYPE (t) = type;
4975 TREE_CONSTANT (t) = 1;
4976 TREE_READONLY (t) = 1;
4977 TREE_STATIC (t) = 1;
4979 type = build_pointer_type (elem);
4980 t = build1 (ADDR_EXPR, type,
4981 build4 (ARRAY_REF, elem,
4982 t, integer_zero_node, NULL_TREE, NULL_TREE));
4986 /* Expand EXP, a call to printf or printf_unlocked.
4987 Return NULL_RTX if a normal call should be emitted rather than transforming
4988 the function inline. If convenient, the result should be placed in
4989 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4992 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
4995 /* If we're using an unlocked function, assume the other unlocked
4996 functions exist explicitly. */
4997 tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
4998 : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4999 tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
5000 : implicit_built_in_decls[BUILT_IN_PUTS];
5001 const char *fmt_str;
5004 int nargs = call_expr_nargs (exp);
5006 /* If the return value is used, don't do the transformation. */
5007 if (target != const0_rtx)
5010 /* Verify the required arguments in the original call. */
5013 fmt = CALL_EXPR_ARG (exp, 0);
5014 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5017 /* Check whether the format is a literal string constant. */
5018 fmt_str = c_getstr (fmt);
5019 if (fmt_str == NULL)
5022 if (!init_target_chars ())
5025 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
5026 if (strcmp (fmt_str, target_percent_s_newline) == 0)
5029 || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 1))))
5032 fn = build_call_nofold (fn_puts, 1, CALL_EXPR_ARG (exp, 1));
5034 /* If the format specifier was "%c", call __builtin_putchar(arg). */
5035 else if (strcmp (fmt_str, target_percent_c) == 0)
5038 || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))) != INTEGER_TYPE)
5041 fn = build_call_nofold (fn_putchar, 1, CALL_EXPR_ARG (exp, 1));
5045 /* We can't handle anything else with % args or %% ... yet. */
5046 if (strchr (fmt_str, target_percent))
5052 /* If the format specifier was "", printf does nothing. */
5053 if (fmt_str[0] == '\0')
5055 /* If the format specifier has length of 1, call putchar. */
5056 if (fmt_str[1] == '\0')
5058 /* Given printf("c"), (where c is any one character,)
5059 convert "c"[0] to an int and pass that to the replacement
5061 arg = build_int_cst (NULL_TREE, fmt_str[0]);
5063 fn = build_call_nofold (fn_putchar, 1, arg);
5067 /* If the format specifier was "string\n", call puts("string"). */
5068 size_t len = strlen (fmt_str);
5069 if ((unsigned char)fmt_str[len - 1] == target_newline)
5071 /* Create a NUL-terminated string that's one char shorter
5072 than the original, stripping off the trailing '\n'. */
5073 char *newstr = XALLOCAVEC (char, len);
5074 memcpy (newstr, fmt_str, len - 1);
5075 newstr[len - 1] = 0;
5076 arg = build_string_literal (len, newstr);
5078 fn = build_call_nofold (fn_puts, 1, arg);
5081 /* We'd like to arrange to call fputs(string,stdout) here,
5082 but we need stdout and don't have a way to get it yet. */
5089 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
5090 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5091 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5094 /* Expand EXP, a call to fprintf or fprintf_unlocked.
5095 Return NULL_RTX if a normal call should be emitted rather than transforming
5096 the function inline. If convenient, the result should be placed in
5097 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
5100 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
5103 /* If we're using an unlocked function, assume the other unlocked
5104 functions exist explicitly. */
5105 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
5106 : implicit_built_in_decls[BUILT_IN_FPUTC];
5107 tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
5108 : implicit_built_in_decls[BUILT_IN_FPUTS];
5109 const char *fmt_str;
5112 int nargs = call_expr_nargs (exp);
5114 /* If the return value is used, don't do the transformation. */
5115 if (target != const0_rtx)
5118 /* Verify the required arguments in the original call. */
5121 fp = CALL_EXPR_ARG (exp, 0);
5122 if (! POINTER_TYPE_P (TREE_TYPE (fp)))
5124 fmt = CALL_EXPR_ARG (exp, 1);
5125 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5128 /* Check whether the format is a literal string constant. */
5129 fmt_str = c_getstr (fmt);
5130 if (fmt_str == NULL)
5133 if (!init_target_chars ())
5136 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
5137 if (strcmp (fmt_str, target_percent_s) == 0)
5140 || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 2))))
5142 arg = CALL_EXPR_ARG (exp, 2);
5144 fn = build_call_nofold (fn_fputs, 2, arg, fp);
5146 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
5147 else if (strcmp (fmt_str, target_percent_c) == 0)
5150 || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2))) != INTEGER_TYPE)
5152 arg = CALL_EXPR_ARG (exp, 2);
5154 fn = build_call_nofold (fn_fputc, 2, arg, fp);
5158 /* We can't handle anything else with % args or %% ... yet. */
5159 if (strchr (fmt_str, target_percent))
5165 /* If the format specifier was "", fprintf does nothing. */
5166 if (fmt_str[0] == '\0')
5168 /* Evaluate and ignore FILE* argument for side-effects. */
5169 expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5173 /* When "string" doesn't contain %, replace all cases of
5174 fprintf(stream,string) with fputs(string,stream). The fputs
5175 builtin will take care of special cases like length == 1. */
5177 fn = build_call_nofold (fn_fputs, 2, fmt, fp);
5182 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
5183 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5184 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5187 /* Expand a call EXP to sprintf. Return NULL_RTX if
5188 a normal call should be emitted rather than expanding the function
5189 inline. If convenient, the result should be placed in TARGET with
5193 expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
5196 const char *fmt_str;
5197 int nargs = call_expr_nargs (exp);
5199 /* Verify the required arguments in the original call. */
5202 dest = CALL_EXPR_ARG (exp, 0);
5203 if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5205 fmt = CALL_EXPR_ARG (exp, 0);
5206 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5209 /* Check whether the format is a literal string constant. */
5210 fmt_str = c_getstr (fmt);
5211 if (fmt_str == NULL)
5214 if (!init_target_chars ())
5217 /* If the format doesn't contain % args or %%, use strcpy. */
5218 if (strchr (fmt_str, target_percent) == 0)
5220 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5223 if ((nargs > 2) || ! fn)
5225 expand_expr (build_call_nofold (fn, 2, dest, fmt),
5226 const0_rtx, VOIDmode, EXPAND_NORMAL);
5227 if (target == const0_rtx)
5229 exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5230 return expand_expr (exp, target, mode, EXPAND_NORMAL);
5232 /* If the format is "%s", use strcpy if the result isn't used. */
5233 else if (strcmp (fmt_str, target_percent_s) == 0)
5236 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5242 arg = CALL_EXPR_ARG (exp, 2);
5243 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5246 if (target != const0_rtx)
5248 len = c_strlen (arg, 1);
5249 if (! len || TREE_CODE (len) != INTEGER_CST)
5255 expand_expr (build_call_nofold (fn, 2, dest, arg),
5256 const0_rtx, VOIDmode, EXPAND_NORMAL);
5258 if (target == const0_rtx)
5260 return expand_expr (len, target, mode, EXPAND_NORMAL);
5266 /* Expand a call to either the entry or exit function profiler. */
5269 expand_builtin_profile_func (bool exitp)
5271 rtx this_rtx, which;
5273 this_rtx = DECL_RTL (current_function_decl);
5274 gcc_assert (MEM_P (this_rtx));
5275 this_rtx = XEXP (this_rtx, 0);
5278 which = profile_function_exit_libfunc;
5280 which = profile_function_entry_libfunc;
5282 emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5283 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5290 /* Expand a call to __builtin___clear_cache. */
5293 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5295 #ifndef HAVE_clear_cache
5296 #ifdef CLEAR_INSN_CACHE
5297 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5298 does something. Just do the default expansion to a call to
5302 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5303 does nothing. There is no need to call it. Do nothing. */
5305 #endif /* CLEAR_INSN_CACHE */
5307 /* We have a "clear_cache" insn, and it will handle everything. */
5309 rtx begin_rtx, end_rtx;
5310 enum insn_code icode;
5312 /* We must not expand to a library call. If we did, any
5313 fallback library function in libgcc that might contain a call to
5314 __builtin___clear_cache() would recurse infinitely. */
5315 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5317 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5321 if (HAVE_clear_cache)
5323 icode = CODE_FOR_clear_cache;
5325 begin = CALL_EXPR_ARG (exp, 0);
5326 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5327 begin_rtx = convert_memory_address (Pmode, begin_rtx);
5328 if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5329 begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5331 end = CALL_EXPR_ARG (exp, 1);
5332 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5333 end_rtx = convert_memory_address (Pmode, end_rtx);
5334 if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5335 end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5337 emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5340 #endif /* HAVE_clear_cache */
5343 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5346 round_trampoline_addr (rtx tramp)
5348 rtx temp, addend, mask;
5350 /* If we don't need too much alignment, we'll have been guaranteed
5351 proper alignment by get_trampoline_type. */
5352 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5355 /* Round address up to desired boundary. */
5356 temp = gen_reg_rtx (Pmode);
5357 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5358 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5360 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
5361 temp, 0, OPTAB_LIB_WIDEN);
5362 tramp = expand_simple_binop (Pmode, AND, temp, mask,
5363 temp, 0, OPTAB_LIB_WIDEN);
5369 expand_builtin_init_trampoline (tree exp)
5371 tree t_tramp, t_func, t_chain;
5372 rtx m_tramp, r_tramp, r_chain, tmp;
5374 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5375 POINTER_TYPE, VOID_TYPE))
5378 t_tramp = CALL_EXPR_ARG (exp, 0);
5379 t_func = CALL_EXPR_ARG (exp, 1);
5380 t_chain = CALL_EXPR_ARG (exp, 2);
5382 r_tramp = expand_normal (t_tramp);
5383 m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5384 MEM_NOTRAP_P (m_tramp) = 1;
5386 /* The TRAMP argument should be the address of a field within the
5387 local function's FRAME decl. Let's see if we can fill in the
5388 to fill in the MEM_ATTRs for this memory. */
5389 if (TREE_CODE (t_tramp) == ADDR_EXPR)
5390 set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5393 tmp = round_trampoline_addr (r_tramp);
5396 m_tramp = change_address (m_tramp, BLKmode, tmp);
5397 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5398 set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5401 /* The FUNC argument should be the address of the nested function.
5402 Extract the actual function decl to pass to the hook. */
5403 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5404 t_func = TREE_OPERAND (t_func, 0);
5405 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5407 r_chain = expand_normal (t_chain);
5409 /* Generate insns to initialize the trampoline. */
5410 targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5412 trampolines_created = 1;
5417 expand_builtin_adjust_trampoline (tree exp)
5421 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5424 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5425 tramp = round_trampoline_addr (tramp);
5426 if (targetm.calls.trampoline_adjust_address)
5427 tramp = targetm.calls.trampoline_adjust_address (tramp);
5432 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5433 function. The function first checks whether the back end provides
5434 an insn to implement signbit for the respective mode. If not, it
5435 checks whether the floating point format of the value is such that
5436 the sign bit can be extracted. If that is not the case, the
5437 function returns NULL_RTX to indicate that a normal call should be
5438 emitted rather than expanding the function in-line. EXP is the
5439 expression that is a call to the builtin function; if convenient,
5440 the result should be placed in TARGET. */
5442 expand_builtin_signbit (tree exp, rtx target)
5444 const struct real_format *fmt;
5445 enum machine_mode fmode, imode, rmode;
5446 HOST_WIDE_INT hi, lo;
5449 enum insn_code icode;
5451 location_t loc = EXPR_LOCATION (exp);
5453 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5456 arg = CALL_EXPR_ARG (exp, 0);
5457 fmode = TYPE_MODE (TREE_TYPE (arg));
5458 rmode = TYPE_MODE (TREE_TYPE (exp));
5459 fmt = REAL_MODE_FORMAT (fmode);
5461 arg = builtin_save_expr (arg);
5463 /* Expand the argument yielding a RTX expression. */
5464 temp = expand_normal (arg);
5466 /* Check if the back end provides an insn that handles signbit for the
5468 icode = signbit_optab->handlers [(int) fmode].insn_code;
5469 if (icode != CODE_FOR_nothing)
5471 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5472 emit_unop_insn (icode, target, temp, UNKNOWN);
5476 /* For floating point formats without a sign bit, implement signbit
5478 bitpos = fmt->signbit_ro;
5481 /* But we can't do this if the format supports signed zero. */
5482 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5485 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5486 build_real (TREE_TYPE (arg), dconst0));
5487 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5490 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5492 imode = int_mode_for_mode (fmode);
5493 if (imode == BLKmode)
5495 temp = gen_lowpart (imode, temp);
5500 /* Handle targets with different FP word orders. */
5501 if (FLOAT_WORDS_BIG_ENDIAN)
5502 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5504 word = bitpos / BITS_PER_WORD;
5505 temp = operand_subword_force (temp, word, fmode);
5506 bitpos = bitpos % BITS_PER_WORD;
5509 /* Force the intermediate word_mode (or narrower) result into a
5510 register. This avoids attempting to create paradoxical SUBREGs
5511 of floating point modes below. */
5512 temp = force_reg (imode, temp);
5514 /* If the bitpos is within the "result mode" lowpart, the operation
5515 can be implement with a single bitwise AND. Otherwise, we need
5516 a right shift and an AND. */
5518 if (bitpos < GET_MODE_BITSIZE (rmode))
5520 if (bitpos < HOST_BITS_PER_WIDE_INT)
5523 lo = (HOST_WIDE_INT) 1 << bitpos;
5527 hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5531 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5532 temp = gen_lowpart (rmode, temp);
5533 temp = expand_binop (rmode, and_optab, temp,
5534 immed_double_const (lo, hi, rmode),
5535 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5539 /* Perform a logical right shift to place the signbit in the least
5540 significant bit, then truncate the result to the desired mode
5541 and mask just this bit. */
5542 temp = expand_shift (RSHIFT_EXPR, imode, temp,
5543 build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5544 temp = gen_lowpart (rmode, temp);
5545 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5546 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5552 /* Expand fork or exec calls. TARGET is the desired target of the
5553 call. EXP is the call. FN is the
5554 identificator of the actual function. IGNORE is nonzero if the
5555 value is to be ignored. */
5558 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5563 /* If we are not profiling, just call the function. */
5564 if (!profile_arc_flag)
5567 /* Otherwise call the wrapper. This should be equivalent for the rest of
5568 compiler, so the code does not diverge, and the wrapper may run the
5569 code necessary for keeping the profiling sane. */
5571 switch (DECL_FUNCTION_CODE (fn))
5574 id = get_identifier ("__gcov_fork");
5577 case BUILT_IN_EXECL:
5578 id = get_identifier ("__gcov_execl");
5581 case BUILT_IN_EXECV:
5582 id = get_identifier ("__gcov_execv");
5585 case BUILT_IN_EXECLP:
5586 id = get_identifier ("__gcov_execlp");
5589 case BUILT_IN_EXECLE:
5590 id = get_identifier ("__gcov_execle");
5593 case BUILT_IN_EXECVP:
5594 id = get_identifier ("__gcov_execvp");
5597 case BUILT_IN_EXECVE:
5598 id = get_identifier ("__gcov_execve");
5605 decl = build_decl (DECL_SOURCE_LOCATION (fn),
5606 FUNCTION_DECL, id, TREE_TYPE (fn));
5607 DECL_EXTERNAL (decl) = 1;
5608 TREE_PUBLIC (decl) = 1;
5609 DECL_ARTIFICIAL (decl) = 1;
5610 TREE_NOTHROW (decl) = 1;
5611 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5612 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5613 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5614 return expand_call (call, target, ignore);
5619 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5620 the pointer in these functions is void*, the tree optimizers may remove
5621 casts. The mode computed in expand_builtin isn't reliable either, due
5622 to __sync_bool_compare_and_swap.
5624 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5625 group of builtins. This gives us log2 of the mode size. */
5627 static inline enum machine_mode
5628 get_builtin_sync_mode (int fcode_diff)
5630 /* The size is not negotiable, so ask not to get BLKmode in return
5631 if the target indicates that a smaller size would be better. */
5632 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5635 /* Expand the memory expression LOC and return the appropriate memory operand
5636 for the builtin_sync operations. */
5639 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5643 addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5644 addr = convert_memory_address (Pmode, addr);
5646 /* Note that we explicitly do not want any alias information for this
5647 memory, so that we kill all other live memories. Otherwise we don't
5648 satisfy the full barrier semantics of the intrinsic. */
5649 mem = validize_mem (gen_rtx_MEM (mode, addr));
5651 set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
5652 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5653 MEM_VOLATILE_P (mem) = 1;
5658 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5659 EXP is the CALL_EXPR. CODE is the rtx code
5660 that corresponds to the arithmetic or logical operation from the name;
5661 an exception here is that NOT actually means NAND. TARGET is an optional
5662 place for us to store the results; AFTER is true if this is the
5663 fetch_and_xxx form. IGNORE is true if we don't actually care about
5664 the result of the operation at all. */
5667 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5668 enum rtx_code code, bool after,
5669 rtx target, bool ignore)
5672 enum machine_mode old_mode;
5673 location_t loc = EXPR_LOCATION (exp);
5675 if (code == NOT && warn_sync_nand)
5677 tree fndecl = get_callee_fndecl (exp);
5678 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5680 static bool warned_f_a_n, warned_n_a_f;
5684 case BUILT_IN_FETCH_AND_NAND_1:
5685 case BUILT_IN_FETCH_AND_NAND_2:
5686 case BUILT_IN_FETCH_AND_NAND_4:
5687 case BUILT_IN_FETCH_AND_NAND_8:
5688 case BUILT_IN_FETCH_AND_NAND_16:
5693 fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5694 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5695 warned_f_a_n = true;
5698 case BUILT_IN_NAND_AND_FETCH_1:
5699 case BUILT_IN_NAND_AND_FETCH_2:
5700 case BUILT_IN_NAND_AND_FETCH_4:
5701 case BUILT_IN_NAND_AND_FETCH_8:
5702 case BUILT_IN_NAND_AND_FETCH_16:
5707 fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5708 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5709 warned_n_a_f = true;
5717 /* Expand the operands. */
5718 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5720 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5721 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5722 of CONST_INTs, where we know the old_mode only from the call argument. */
5723 old_mode = GET_MODE (val);
5724 if (old_mode == VOIDmode)
5725 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5726 val = convert_modes (mode, old_mode, val, 1);
5729 return expand_sync_operation (mem, val, code);
5731 return expand_sync_fetch_operation (mem, val, code, after, target);
5734 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5735 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5736 true if this is the boolean form. TARGET is a place for us to store the
5737 results; this is NOT optional if IS_BOOL is true. */
5740 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5741 bool is_bool, rtx target)
5743 rtx old_val, new_val, mem;
5744 enum machine_mode old_mode;
5746 /* Expand the operands. */
5747 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5750 old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5751 mode, EXPAND_NORMAL);
5752 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5753 of CONST_INTs, where we know the old_mode only from the call argument. */
5754 old_mode = GET_MODE (old_val);
5755 if (old_mode == VOIDmode)
5756 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5757 old_val = convert_modes (mode, old_mode, old_val, 1);
5759 new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5760 mode, EXPAND_NORMAL);
5761 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5762 of CONST_INTs, where we know the old_mode only from the call argument. */
5763 old_mode = GET_MODE (new_val);
5764 if (old_mode == VOIDmode)
5765 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5766 new_val = convert_modes (mode, old_mode, new_val, 1);
5769 return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5771 return expand_val_compare_and_swap (mem, old_val, new_val, target);
5774 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5775 general form is actually an atomic exchange, and some targets only
5776 support a reduced form with the second argument being a constant 1.
5777 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5781 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5785 enum machine_mode old_mode;
5787 /* Expand the operands. */
5788 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5789 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5790 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5791 of CONST_INTs, where we know the old_mode only from the call argument. */
5792 old_mode = GET_MODE (val);
5793 if (old_mode == VOIDmode)
5794 old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5795 val = convert_modes (mode, old_mode, val, 1);
5797 return expand_sync_lock_test_and_set (mem, val, target);
5800 /* Expand the __sync_synchronize intrinsic. */
5803 expand_builtin_synchronize (void)
5806 VEC (tree, gc) *v_clobbers;
5808 #ifdef HAVE_memory_barrier
5809 if (HAVE_memory_barrier)
5811 emit_insn (gen_memory_barrier ());
5816 if (synchronize_libfunc != NULL_RTX)
5818 emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5822 /* If no explicit memory barrier instruction is available, create an
5823 empty asm stmt with a memory clobber. */
5824 v_clobbers = VEC_alloc (tree, gc, 1);
5825 VEC_quick_push (tree, v_clobbers,
5826 tree_cons (NULL, build_string (6, "memory"), NULL));
5827 x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5828 gimple_asm_set_volatile (x, true);
5829 expand_asm_stmt (x);
5832 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5835 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5837 enum insn_code icode;
5839 rtx val = const0_rtx;
5841 /* Expand the operands. */
5842 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5844 /* If there is an explicit operation in the md file, use it. */
5845 icode = sync_lock_release[mode];
5846 if (icode != CODE_FOR_nothing)
5848 if (!insn_data[icode].operand[1].predicate (val, mode))
5849 val = force_reg (mode, val);
5851 insn = GEN_FCN (icode) (mem, val);
5859 /* Otherwise we can implement this operation by emitting a barrier
5860 followed by a store of zero. */
5861 expand_builtin_synchronize ();
5862 emit_move_insn (mem, val);
5865 /* Expand an expression EXP that calls a built-in function,
5866 with result going to TARGET if that's convenient
5867 (and in mode MODE if that's convenient).
5868 SUBTARGET may be used as the target for computing one of EXP's operands.
5869 IGNORE is nonzero if the value is to be ignored. */
5872 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5875 tree fndecl = get_callee_fndecl (exp);
5876 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5877 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5879 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5880 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5882 /* When not optimizing, generate calls to library functions for a certain
5885 && !called_as_built_in (fndecl)
5886 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5887 && fcode != BUILT_IN_ALLOCA
5888 && fcode != BUILT_IN_FREE)
5889 return expand_call (exp, target, ignore);
5891 /* The built-in function expanders test for target == const0_rtx
5892 to determine whether the function's result will be ignored. */
5894 target = const0_rtx;
5896 /* If the result of a pure or const built-in function is ignored, and
5897 none of its arguments are volatile, we can avoid expanding the
5898 built-in call and just evaluate the arguments for side-effects. */
5899 if (target == const0_rtx
5900 && (DECL_PURE_P (fndecl) || TREE_READONLY (fndecl)))
5902 bool volatilep = false;
5904 call_expr_arg_iterator iter;
5906 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5907 if (TREE_THIS_VOLATILE (arg))
5915 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5916 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5923 CASE_FLT_FN (BUILT_IN_FABS):
5924 target = expand_builtin_fabs (exp, target, subtarget);
5929 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5930 target = expand_builtin_copysign (exp, target, subtarget);
5935 /* Just do a normal library call if we were unable to fold
5937 CASE_FLT_FN (BUILT_IN_CABS):
5940 CASE_FLT_FN (BUILT_IN_EXP):
5941 CASE_FLT_FN (BUILT_IN_EXP10):
5942 CASE_FLT_FN (BUILT_IN_POW10):
5943 CASE_FLT_FN (BUILT_IN_EXP2):
5944 CASE_FLT_FN (BUILT_IN_EXPM1):
5945 CASE_FLT_FN (BUILT_IN_LOGB):
5946 CASE_FLT_FN (BUILT_IN_LOG):
5947 CASE_FLT_FN (BUILT_IN_LOG10):
5948 CASE_FLT_FN (BUILT_IN_LOG2):
5949 CASE_FLT_FN (BUILT_IN_LOG1P):
5950 CASE_FLT_FN (BUILT_IN_TAN):
5951 CASE_FLT_FN (BUILT_IN_ASIN):
5952 CASE_FLT_FN (BUILT_IN_ACOS):
5953 CASE_FLT_FN (BUILT_IN_ATAN):
5954 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5955 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5956 because of possible accuracy problems. */
5957 if (! flag_unsafe_math_optimizations)
5959 CASE_FLT_FN (BUILT_IN_SQRT):
5960 CASE_FLT_FN (BUILT_IN_FLOOR):
5961 CASE_FLT_FN (BUILT_IN_CEIL):
5962 CASE_FLT_FN (BUILT_IN_TRUNC):
5963 CASE_FLT_FN (BUILT_IN_ROUND):
5964 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5965 CASE_FLT_FN (BUILT_IN_RINT):
5966 target = expand_builtin_mathfn (exp, target, subtarget);
5971 CASE_FLT_FN (BUILT_IN_ILOGB):
5972 if (! flag_unsafe_math_optimizations)
5974 CASE_FLT_FN (BUILT_IN_ISINF):
5975 CASE_FLT_FN (BUILT_IN_FINITE):
5976 case BUILT_IN_ISFINITE:
5977 case BUILT_IN_ISNORMAL:
5978 target = expand_builtin_interclass_mathfn (exp, target, subtarget);
5983 CASE_FLT_FN (BUILT_IN_LCEIL):
5984 CASE_FLT_FN (BUILT_IN_LLCEIL):
5985 CASE_FLT_FN (BUILT_IN_LFLOOR):
5986 CASE_FLT_FN (BUILT_IN_LLFLOOR):
5987 target = expand_builtin_int_roundingfn (exp, target);
5992 CASE_FLT_FN (BUILT_IN_LRINT):
5993 CASE_FLT_FN (BUILT_IN_LLRINT):
5994 CASE_FLT_FN (BUILT_IN_LROUND):
5995 CASE_FLT_FN (BUILT_IN_LLROUND):
5996 target = expand_builtin_int_roundingfn_2 (exp, target);
6001 CASE_FLT_FN (BUILT_IN_POW):
6002 target = expand_builtin_pow (exp, target, subtarget);
6007 CASE_FLT_FN (BUILT_IN_POWI):
6008 target = expand_builtin_powi (exp, target, subtarget);
6013 CASE_FLT_FN (BUILT_IN_ATAN2):
6014 CASE_FLT_FN (BUILT_IN_LDEXP):
6015 CASE_FLT_FN (BUILT_IN_SCALB):
6016 CASE_FLT_FN (BUILT_IN_SCALBN):
6017 CASE_FLT_FN (BUILT_IN_SCALBLN):
6018 if (! flag_unsafe_math_optimizations)
6021 CASE_FLT_FN (BUILT_IN_FMOD):
6022 CASE_FLT_FN (BUILT_IN_REMAINDER):
6023 CASE_FLT_FN (BUILT_IN_DREM):
6024 target = expand_builtin_mathfn_2 (exp, target, subtarget);
6029 CASE_FLT_FN (BUILT_IN_CEXPI):
6030 target = expand_builtin_cexpi (exp, target, subtarget);
6031 gcc_assert (target);
6034 CASE_FLT_FN (BUILT_IN_SIN):
6035 CASE_FLT_FN (BUILT_IN_COS):
6036 if (! flag_unsafe_math_optimizations)
6038 target = expand_builtin_mathfn_3 (exp, target, subtarget);
6043 CASE_FLT_FN (BUILT_IN_SINCOS):
6044 if (! flag_unsafe_math_optimizations)
6046 target = expand_builtin_sincos (exp);
6051 case BUILT_IN_APPLY_ARGS:
6052 return expand_builtin_apply_args ();
6054 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6055 FUNCTION with a copy of the parameters described by
6056 ARGUMENTS, and ARGSIZE. It returns a block of memory
6057 allocated on the stack into which is stored all the registers
6058 that might possibly be used for returning the result of a
6059 function. ARGUMENTS is the value returned by
6060 __builtin_apply_args. ARGSIZE is the number of bytes of
6061 arguments that must be copied. ??? How should this value be
6062 computed? We'll also need a safe worst case value for varargs
6064 case BUILT_IN_APPLY:
6065 if (!validate_arglist (exp, POINTER_TYPE,
6066 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
6067 && !validate_arglist (exp, REFERENCE_TYPE,
6068 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6074 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6075 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6076 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6078 return expand_builtin_apply (ops[0], ops[1], ops[2]);
6081 /* __builtin_return (RESULT) causes the function to return the
6082 value described by RESULT. RESULT is address of the block of
6083 memory returned by __builtin_apply. */
6084 case BUILT_IN_RETURN:
6085 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6086 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6089 case BUILT_IN_SAVEREGS:
6090 return expand_builtin_saveregs ();
6092 case BUILT_IN_ARGS_INFO:
6093 return expand_builtin_args_info (exp);
6095 case BUILT_IN_VA_ARG_PACK:
6096 /* All valid uses of __builtin_va_arg_pack () are removed during
6098 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
6101 case BUILT_IN_VA_ARG_PACK_LEN:
6102 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6104 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
6107 /* Return the address of the first anonymous stack arg. */
6108 case BUILT_IN_NEXT_ARG:
6109 if (fold_builtin_next_arg (exp, false))
6111 return expand_builtin_next_arg ();
6113 case BUILT_IN_CLEAR_CACHE:
6114 target = expand_builtin___clear_cache (exp);
6119 case BUILT_IN_CLASSIFY_TYPE:
6120 return expand_builtin_classify_type (exp);
6122 case BUILT_IN_CONSTANT_P:
6125 case BUILT_IN_FRAME_ADDRESS:
6126 case BUILT_IN_RETURN_ADDRESS:
6127 return expand_builtin_frame_address (fndecl, exp);
6129 /* Returns the address of the area where the structure is returned.
6131 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6132 if (call_expr_nargs (exp) != 0
6133 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6134 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6137 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6139 case BUILT_IN_ALLOCA:
6140 target = expand_builtin_alloca (exp, target);
6145 case BUILT_IN_STACK_SAVE:
6146 return expand_stack_save ();
6148 case BUILT_IN_STACK_RESTORE:
6149 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6152 case BUILT_IN_BSWAP32:
6153 case BUILT_IN_BSWAP64:
6154 target = expand_builtin_bswap (exp, target, subtarget);
6160 CASE_INT_FN (BUILT_IN_FFS):
6161 case BUILT_IN_FFSIMAX:
6162 target = expand_builtin_unop (target_mode, exp, target,
6163 subtarget, ffs_optab);
6168 CASE_INT_FN (BUILT_IN_CLZ):
6169 case BUILT_IN_CLZIMAX:
6170 target = expand_builtin_unop (target_mode, exp, target,
6171 subtarget, clz_optab);
6176 CASE_INT_FN (BUILT_IN_CTZ):
6177 case BUILT_IN_CTZIMAX:
6178 target = expand_builtin_unop (target_mode, exp, target,
6179 subtarget, ctz_optab);
6184 CASE_INT_FN (BUILT_IN_POPCOUNT):
6185 case BUILT_IN_POPCOUNTIMAX:
6186 target = expand_builtin_unop (target_mode, exp, target,
6187 subtarget, popcount_optab);
6192 CASE_INT_FN (BUILT_IN_PARITY):
6193 case BUILT_IN_PARITYIMAX:
6194 target = expand_builtin_unop (target_mode, exp, target,
6195 subtarget, parity_optab);
6200 case BUILT_IN_STRLEN:
6201 target = expand_builtin_strlen (exp, target, target_mode);
6206 case BUILT_IN_STRCPY:
6207 target = expand_builtin_strcpy (exp, target);
6212 case BUILT_IN_STRNCPY:
6213 target = expand_builtin_strncpy (exp, target);
6218 case BUILT_IN_STPCPY:
6219 target = expand_builtin_stpcpy (exp, target, mode);
6224 case BUILT_IN_MEMCPY:
6225 target = expand_builtin_memcpy (exp, target);
6230 case BUILT_IN_MEMPCPY:
6231 target = expand_builtin_mempcpy (exp, target, mode);
6236 case BUILT_IN_MEMSET:
6237 target = expand_builtin_memset (exp, target, mode);
6242 case BUILT_IN_BZERO:
6243 target = expand_builtin_bzero (exp);
6248 case BUILT_IN_STRCMP:
6249 target = expand_builtin_strcmp (exp, target);
6254 case BUILT_IN_STRNCMP:
6255 target = expand_builtin_strncmp (exp, target, mode);
6261 case BUILT_IN_MEMCMP:
6262 target = expand_builtin_memcmp (exp, target, mode);
6267 case BUILT_IN_SETJMP:
6268 /* This should have been lowered to the builtins below. */
6271 case BUILT_IN_SETJMP_SETUP:
6272 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6273 and the receiver label. */
6274 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6276 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6277 VOIDmode, EXPAND_NORMAL);
6278 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6279 rtx label_r = label_rtx (label);
6281 /* This is copied from the handling of non-local gotos. */
6282 expand_builtin_setjmp_setup (buf_addr, label_r);
6283 nonlocal_goto_handler_labels
6284 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6285 nonlocal_goto_handler_labels);
6286 /* ??? Do not let expand_label treat us as such since we would
6287 not want to be both on the list of non-local labels and on
6288 the list of forced labels. */
6289 FORCED_LABEL (label) = 0;
6294 case BUILT_IN_SETJMP_DISPATCHER:
6295 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6296 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6298 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6299 rtx label_r = label_rtx (label);
6301 /* Remove the dispatcher label from the list of non-local labels
6302 since the receiver labels have been added to it above. */
6303 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6308 case BUILT_IN_SETJMP_RECEIVER:
6309 /* __builtin_setjmp_receiver is passed the receiver label. */
6310 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6312 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6313 rtx label_r = label_rtx (label);
6315 expand_builtin_setjmp_receiver (label_r);
6320 /* __builtin_longjmp is passed a pointer to an array of five words.
6321 It's similar to the C library longjmp function but works with
6322 __builtin_setjmp above. */
6323 case BUILT_IN_LONGJMP:
6324 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6326 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6327 VOIDmode, EXPAND_NORMAL);
6328 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6330 if (value != const1_rtx)
6332 error ("%<__builtin_longjmp%> second argument must be 1");
6336 expand_builtin_longjmp (buf_addr, value);
6341 case BUILT_IN_NONLOCAL_GOTO:
6342 target = expand_builtin_nonlocal_goto (exp);
6347 /* This updates the setjmp buffer that is its argument with the value
6348 of the current stack pointer. */
6349 case BUILT_IN_UPDATE_SETJMP_BUF:
6350 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6353 = expand_normal (CALL_EXPR_ARG (exp, 0));
6355 expand_builtin_update_setjmp_buf (buf_addr);
6361 expand_builtin_trap ();
6364 case BUILT_IN_UNREACHABLE:
6365 expand_builtin_unreachable ();
6368 case BUILT_IN_PRINTF:
6369 target = expand_builtin_printf (exp, target, mode, false);
6374 case BUILT_IN_PRINTF_UNLOCKED:
6375 target = expand_builtin_printf (exp, target, mode, true);
6380 case BUILT_IN_FPRINTF:
6381 target = expand_builtin_fprintf (exp, target, mode, false);
6386 case BUILT_IN_FPRINTF_UNLOCKED:
6387 target = expand_builtin_fprintf (exp, target, mode, true);
6392 case BUILT_IN_SPRINTF:
6393 target = expand_builtin_sprintf (exp, target, mode);
6398 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6399 case BUILT_IN_SIGNBITD32:
6400 case BUILT_IN_SIGNBITD64:
6401 case BUILT_IN_SIGNBITD128:
6402 target = expand_builtin_signbit (exp, target);
6407 /* Various hooks for the DWARF 2 __throw routine. */
6408 case BUILT_IN_UNWIND_INIT:
6409 expand_builtin_unwind_init ();
6411 case BUILT_IN_DWARF_CFA:
6412 return virtual_cfa_rtx;
6413 #ifdef DWARF2_UNWIND_INFO
6414 case BUILT_IN_DWARF_SP_COLUMN:
6415 return expand_builtin_dwarf_sp_column ();
6416 case BUILT_IN_INIT_DWARF_REG_SIZES:
6417 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6420 case BUILT_IN_FROB_RETURN_ADDR:
6421 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6422 case BUILT_IN_EXTRACT_RETURN_ADDR:
6423 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6424 case BUILT_IN_EH_RETURN:
6425 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6426 CALL_EXPR_ARG (exp, 1));
6428 #ifdef EH_RETURN_DATA_REGNO
6429 case BUILT_IN_EH_RETURN_DATA_REGNO:
6430 return expand_builtin_eh_return_data_regno (exp);
6432 case BUILT_IN_EXTEND_POINTER:
6433 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6434 case BUILT_IN_EH_POINTER:
6435 return expand_builtin_eh_pointer (exp);
6436 case BUILT_IN_EH_FILTER:
6437 return expand_builtin_eh_filter (exp);
6438 case BUILT_IN_EH_COPY_VALUES:
6439 return expand_builtin_eh_copy_values (exp);
6441 case BUILT_IN_VA_START:
6442 return expand_builtin_va_start (exp);
6443 case BUILT_IN_VA_END:
6444 return expand_builtin_va_end (exp);
6445 case BUILT_IN_VA_COPY:
6446 return expand_builtin_va_copy (exp);
6447 case BUILT_IN_EXPECT:
6448 return expand_builtin_expect (exp, target);
6449 case BUILT_IN_PREFETCH:
6450 expand_builtin_prefetch (exp);
6453 case BUILT_IN_PROFILE_FUNC_ENTER:
6454 return expand_builtin_profile_func (false);
6455 case BUILT_IN_PROFILE_FUNC_EXIT:
6456 return expand_builtin_profile_func (true);
6458 case BUILT_IN_INIT_TRAMPOLINE:
6459 return expand_builtin_init_trampoline (exp);
6460 case BUILT_IN_ADJUST_TRAMPOLINE:
6461 return expand_builtin_adjust_trampoline (exp);
6464 case BUILT_IN_EXECL:
6465 case BUILT_IN_EXECV:
6466 case BUILT_IN_EXECLP:
6467 case BUILT_IN_EXECLE:
6468 case BUILT_IN_EXECVP:
6469 case BUILT_IN_EXECVE:
6470 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6475 case BUILT_IN_FETCH_AND_ADD_1:
6476 case BUILT_IN_FETCH_AND_ADD_2:
6477 case BUILT_IN_FETCH_AND_ADD_4:
6478 case BUILT_IN_FETCH_AND_ADD_8:
6479 case BUILT_IN_FETCH_AND_ADD_16:
6480 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6481 target = expand_builtin_sync_operation (mode, exp, PLUS,
6482 false, target, ignore);
6487 case BUILT_IN_FETCH_AND_SUB_1:
6488 case BUILT_IN_FETCH_AND_SUB_2:
6489 case BUILT_IN_FETCH_AND_SUB_4:
6490 case BUILT_IN_FETCH_AND_SUB_8:
6491 case BUILT_IN_FETCH_AND_SUB_16:
6492 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6493 target = expand_builtin_sync_operation (mode, exp, MINUS,
6494 false, target, ignore);
6499 case BUILT_IN_FETCH_AND_OR_1:
6500 case BUILT_IN_FETCH_AND_OR_2:
6501 case BUILT_IN_FETCH_AND_OR_4:
6502 case BUILT_IN_FETCH_AND_OR_8:
6503 case BUILT_IN_FETCH_AND_OR_16:
6504 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6505 target = expand_builtin_sync_operation (mode, exp, IOR,
6506 false, target, ignore);
6511 case BUILT_IN_FETCH_AND_AND_1:
6512 case BUILT_IN_FETCH_AND_AND_2:
6513 case BUILT_IN_FETCH_AND_AND_4:
6514 case BUILT_IN_FETCH_AND_AND_8:
6515 case BUILT_IN_FETCH_AND_AND_16:
6516 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6517 target = expand_builtin_sync_operation (mode, exp, AND,
6518 false, target, ignore);
6523 case BUILT_IN_FETCH_AND_XOR_1:
6524 case BUILT_IN_FETCH_AND_XOR_2:
6525 case BUILT_IN_FETCH_AND_XOR_4:
6526 case BUILT_IN_FETCH_AND_XOR_8:
6527 case BUILT_IN_FETCH_AND_XOR_16:
6528 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6529 target = expand_builtin_sync_operation (mode, exp, XOR,
6530 false, target, ignore);
6535 case BUILT_IN_FETCH_AND_NAND_1:
6536 case BUILT_IN_FETCH_AND_NAND_2:
6537 case BUILT_IN_FETCH_AND_NAND_4:
6538 case BUILT_IN_FETCH_AND_NAND_8:
6539 case BUILT_IN_FETCH_AND_NAND_16:
6540 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6541 target = expand_builtin_sync_operation (mode, exp, NOT,
6542 false, target, ignore);
6547 case BUILT_IN_ADD_AND_FETCH_1:
6548 case BUILT_IN_ADD_AND_FETCH_2:
6549 case BUILT_IN_ADD_AND_FETCH_4:
6550 case BUILT_IN_ADD_AND_FETCH_8:
6551 case BUILT_IN_ADD_AND_FETCH_16:
6552 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6553 target = expand_builtin_sync_operation (mode, exp, PLUS,
6554 true, target, ignore);
6559 case BUILT_IN_SUB_AND_FETCH_1:
6560 case BUILT_IN_SUB_AND_FETCH_2:
6561 case BUILT_IN_SUB_AND_FETCH_4:
6562 case BUILT_IN_SUB_AND_FETCH_8:
6563 case BUILT_IN_SUB_AND_FETCH_16:
6564 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6565 target = expand_builtin_sync_operation (mode, exp, MINUS,
6566 true, target, ignore);
6571 case BUILT_IN_OR_AND_FETCH_1:
6572 case BUILT_IN_OR_AND_FETCH_2:
6573 case BUILT_IN_OR_AND_FETCH_4:
6574 case BUILT_IN_OR_AND_FETCH_8:
6575 case BUILT_IN_OR_AND_FETCH_16:
6576 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6577 target = expand_builtin_sync_operation (mode, exp, IOR,
6578 true, target, ignore);
6583 case BUILT_IN_AND_AND_FETCH_1:
6584 case BUILT_IN_AND_AND_FETCH_2:
6585 case BUILT_IN_AND_AND_FETCH_4:
6586 case BUILT_IN_AND_AND_FETCH_8:
6587 case BUILT_IN_AND_AND_FETCH_16:
6588 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6589 target = expand_builtin_sync_operation (mode, exp, AND,
6590 true, target, ignore);
6595 case BUILT_IN_XOR_AND_FETCH_1:
6596 case BUILT_IN_XOR_AND_FETCH_2:
6597 case BUILT_IN_XOR_AND_FETCH_4:
6598 case BUILT_IN_XOR_AND_FETCH_8:
6599 case BUILT_IN_XOR_AND_FETCH_16:
6600 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6601 target = expand_builtin_sync_operation (mode, exp, XOR,
6602 true, target, ignore);
6607 case BUILT_IN_NAND_AND_FETCH_1:
6608 case BUILT_IN_NAND_AND_FETCH_2:
6609 case BUILT_IN_NAND_AND_FETCH_4:
6610 case BUILT_IN_NAND_AND_FETCH_8:
6611 case BUILT_IN_NAND_AND_FETCH_16:
6612 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6613 target = expand_builtin_sync_operation (mode, exp, NOT,
6614 true, target, ignore);
6619 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6620 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6621 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6622 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6623 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6624 if (mode == VOIDmode)
6625 mode = TYPE_MODE (boolean_type_node);
6626 if (!target || !register_operand (target, mode))
6627 target = gen_reg_rtx (mode);
6629 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6630 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6635 case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6636 case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6637 case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6638 case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6639 case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6640 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6641 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6646 case BUILT_IN_LOCK_TEST_AND_SET_1:
6647 case BUILT_IN_LOCK_TEST_AND_SET_2:
6648 case BUILT_IN_LOCK_TEST_AND_SET_4:
6649 case BUILT_IN_LOCK_TEST_AND_SET_8:
6650 case BUILT_IN_LOCK_TEST_AND_SET_16:
6651 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6652 target = expand_builtin_lock_test_and_set (mode, exp, target);
6657 case BUILT_IN_LOCK_RELEASE_1:
6658 case BUILT_IN_LOCK_RELEASE_2:
6659 case BUILT_IN_LOCK_RELEASE_4:
6660 case BUILT_IN_LOCK_RELEASE_8:
6661 case BUILT_IN_LOCK_RELEASE_16:
6662 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6663 expand_builtin_lock_release (mode, exp);
6666 case BUILT_IN_SYNCHRONIZE:
6667 expand_builtin_synchronize ();
6670 case BUILT_IN_OBJECT_SIZE:
6671 return expand_builtin_object_size (exp);
6673 case BUILT_IN_MEMCPY_CHK:
6674 case BUILT_IN_MEMPCPY_CHK:
6675 case BUILT_IN_MEMMOVE_CHK:
6676 case BUILT_IN_MEMSET_CHK:
6677 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6682 case BUILT_IN_STRCPY_CHK:
6683 case BUILT_IN_STPCPY_CHK:
6684 case BUILT_IN_STRNCPY_CHK:
6685 case BUILT_IN_STRCAT_CHK:
6686 case BUILT_IN_STRNCAT_CHK:
6687 case BUILT_IN_SNPRINTF_CHK:
6688 case BUILT_IN_VSNPRINTF_CHK:
6689 maybe_emit_chk_warning (exp, fcode);
6692 case BUILT_IN_SPRINTF_CHK:
6693 case BUILT_IN_VSPRINTF_CHK:
6694 maybe_emit_sprintf_chk_warning (exp, fcode);
6698 maybe_emit_free_warning (exp);
6701 default: /* just do library call, if unknown builtin */
6705 /* The switch statement above can drop through to cause the function
6706 to be called normally. */
6707 return expand_call (exp, target, ignore);
6710 /* Determine whether a tree node represents a call to a built-in
6711 function. If the tree T is a call to a built-in function with
6712 the right number of arguments of the appropriate types, return
6713 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6714 Otherwise the return value is END_BUILTINS. */
6716 enum built_in_function
6717 builtin_mathfn_code (const_tree t)
6719 const_tree fndecl, arg, parmlist;
6720 const_tree argtype, parmtype;
6721 const_call_expr_arg_iterator iter;
6723 if (TREE_CODE (t) != CALL_EXPR
6724 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6725 return END_BUILTINS;
6727 fndecl = get_callee_fndecl (t);
6728 if (fndecl == NULL_TREE
6729 || TREE_CODE (fndecl) != FUNCTION_DECL
6730 || ! DECL_BUILT_IN (fndecl)
6731 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6732 return END_BUILTINS;
6734 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6735 init_const_call_expr_arg_iterator (t, &iter);
6736 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6738 /* If a function doesn't take a variable number of arguments,
6739 the last element in the list will have type `void'. */
6740 parmtype = TREE_VALUE (parmlist);
6741 if (VOID_TYPE_P (parmtype))
6743 if (more_const_call_expr_args_p (&iter))
6744 return END_BUILTINS;
6745 return DECL_FUNCTION_CODE (fndecl);
6748 if (! more_const_call_expr_args_p (&iter))
6749 return END_BUILTINS;
6751 arg = next_const_call_expr_arg (&iter);
6752 argtype = TREE_TYPE (arg);
6754 if (SCALAR_FLOAT_TYPE_P (parmtype))
6756 if (! SCALAR_FLOAT_TYPE_P (argtype))
6757 return END_BUILTINS;
6759 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6761 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6762 return END_BUILTINS;
6764 else if (POINTER_TYPE_P (parmtype))
6766 if (! POINTER_TYPE_P (argtype))
6767 return END_BUILTINS;
6769 else if (INTEGRAL_TYPE_P (parmtype))
6771 if (! INTEGRAL_TYPE_P (argtype))
6772 return END_BUILTINS;
6775 return END_BUILTINS;
6778 /* Variable-length argument list. */
6779 return DECL_FUNCTION_CODE (fndecl);
6782 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6783 evaluate to a constant. */
6786 fold_builtin_constant_p (tree arg)
6788 /* We return 1 for a numeric type that's known to be a constant
6789 value at compile-time or for an aggregate type that's a
6790 literal constant. */
6793 /* If we know this is a constant, emit the constant of one. */
6794 if (CONSTANT_CLASS_P (arg)
6795 || (TREE_CODE (arg) == CONSTRUCTOR
6796 && TREE_CONSTANT (arg)))
6797 return integer_one_node;
6798 if (TREE_CODE (arg) == ADDR_EXPR)
6800 tree op = TREE_OPERAND (arg, 0);
6801 if (TREE_CODE (op) == STRING_CST
6802 || (TREE_CODE (op) == ARRAY_REF
6803 && integer_zerop (TREE_OPERAND (op, 1))
6804 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6805 return integer_one_node;
6808 /* If this expression has side effects, show we don't know it to be a
6809 constant. Likewise if it's a pointer or aggregate type since in
6810 those case we only want literals, since those are only optimized
6811 when generating RTL, not later.
6812 And finally, if we are compiling an initializer, not code, we
6813 need to return a definite result now; there's not going to be any
6814 more optimization done. */
6815 if (TREE_SIDE_EFFECTS (arg)
6816 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6817 || POINTER_TYPE_P (TREE_TYPE (arg))
6819 || folding_initializer)
6820 return integer_zero_node;
6825 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6826 return it as a truthvalue. */
6829 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6831 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6833 fn = built_in_decls[BUILT_IN_EXPECT];
6834 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6835 ret_type = TREE_TYPE (TREE_TYPE (fn));
6836 pred_type = TREE_VALUE (arg_types);
6837 expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6839 pred = fold_convert_loc (loc, pred_type, pred);
6840 expected = fold_convert_loc (loc, expected_type, expected);
6841 call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6843 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6844 build_int_cst (ret_type, 0));
6847 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6848 NULL_TREE if no simplification is possible. */
6851 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6854 enum tree_code code;
6856 /* If this is a builtin_expect within a builtin_expect keep the
6857 inner one. See through a comparison against a constant. It
6858 might have been added to create a thruthvalue. */
6860 if (COMPARISON_CLASS_P (inner)
6861 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6862 inner = TREE_OPERAND (inner, 0);
6864 if (TREE_CODE (inner) == CALL_EXPR
6865 && (fndecl = get_callee_fndecl (inner))
6866 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6867 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6870 /* Distribute the expected value over short-circuiting operators.
6871 See through the cast from truthvalue_type_node to long. */
6873 while (TREE_CODE (inner) == NOP_EXPR
6874 && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6875 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6876 inner = TREE_OPERAND (inner, 0);
6878 code = TREE_CODE (inner);
6879 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6881 tree op0 = TREE_OPERAND (inner, 0);
6882 tree op1 = TREE_OPERAND (inner, 1);
6884 op0 = build_builtin_expect_predicate (loc, op0, arg1);
6885 op1 = build_builtin_expect_predicate (loc, op1, arg1);
6886 inner = build2 (code, TREE_TYPE (inner), op0, op1);
6888 return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6891 /* If the argument isn't invariant then there's nothing else we can do. */
6892 if (!TREE_CONSTANT (arg0))
6895 /* If we expect that a comparison against the argument will fold to
6896 a constant return the constant. In practice, this means a true
6897 constant or the address of a non-weak symbol. */
6900 if (TREE_CODE (inner) == ADDR_EXPR)
6904 inner = TREE_OPERAND (inner, 0);
6906 while (TREE_CODE (inner) == COMPONENT_REF
6907 || TREE_CODE (inner) == ARRAY_REF);
6908 if ((TREE_CODE (inner) == VAR_DECL
6909 || TREE_CODE (inner) == FUNCTION_DECL)
6910 && DECL_WEAK (inner))
6914 /* Otherwise, ARG0 already has the proper type for the return value. */
6918 /* Fold a call to __builtin_classify_type with argument ARG. */
6921 fold_builtin_classify_type (tree arg)
6924 return build_int_cst (NULL_TREE, no_type_class);
6926 return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6929 /* Fold a call to __builtin_strlen with argument ARG. */
6932 fold_builtin_strlen (location_t loc, tree arg)
6934 if (!validate_arg (arg, POINTER_TYPE))
6938 tree len = c_strlen (arg, 0);
6942 /* Convert from the internal "sizetype" type to "size_t". */
6944 len = fold_convert_loc (loc, size_type_node, len);
6952 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6955 fold_builtin_inf (location_t loc, tree type, int warn)
6957 REAL_VALUE_TYPE real;
6959 /* __builtin_inff is intended to be usable to define INFINITY on all
6960 targets. If an infinity is not available, INFINITY expands "to a
6961 positive constant of type float that overflows at translation
6962 time", footnote "In this case, using INFINITY will violate the
6963 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6964 Thus we pedwarn to ensure this constraint violation is
6966 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6967 pedwarn (loc, 0, "target format does not support infinity");
6970 return build_real (type, real);
6973 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
6976 fold_builtin_nan (tree arg, tree type, int quiet)
6978 REAL_VALUE_TYPE real;
6981 if (!validate_arg (arg, POINTER_TYPE))
6983 str = c_getstr (arg);
6987 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6990 return build_real (type, real);
6993 /* Return true if the floating point expression T has an integer value.
6994 We also allow +Inf, -Inf and NaN to be considered integer values. */
6997 integer_valued_real_p (tree t)
6999 switch (TREE_CODE (t))
7006 return integer_valued_real_p (TREE_OPERAND (t, 0));
7011 return integer_valued_real_p (TREE_OPERAND (t, 1));
7018 return integer_valued_real_p (TREE_OPERAND (t, 0))
7019 && integer_valued_real_p (TREE_OPERAND (t, 1));
7022 return integer_valued_real_p (TREE_OPERAND (t, 1))
7023 && integer_valued_real_p (TREE_OPERAND (t, 2));
7026 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7030 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7031 if (TREE_CODE (type) == INTEGER_TYPE)
7033 if (TREE_CODE (type) == REAL_TYPE)
7034 return integer_valued_real_p (TREE_OPERAND (t, 0));
7039 switch (builtin_mathfn_code (t))
7041 CASE_FLT_FN (BUILT_IN_CEIL):
7042 CASE_FLT_FN (BUILT_IN_FLOOR):
7043 CASE_FLT_FN (BUILT_IN_NEARBYINT):
7044 CASE_FLT_FN (BUILT_IN_RINT):
7045 CASE_FLT_FN (BUILT_IN_ROUND):
7046 CASE_FLT_FN (BUILT_IN_TRUNC):
7049 CASE_FLT_FN (BUILT_IN_FMIN):
7050 CASE_FLT_FN (BUILT_IN_FMAX):
7051 return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7052 && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7065 /* FNDECL is assumed to be a builtin where truncation can be propagated
7066 across (for instance floor((double)f) == (double)floorf (f).
7067 Do the transformation for a call with argument ARG. */
7070 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
7072 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7074 if (!validate_arg (arg, REAL_TYPE))
7077 /* Integer rounding functions are idempotent. */
7078 if (fcode == builtin_mathfn_code (arg))
7081 /* If argument is already integer valued, and we don't need to worry
7082 about setting errno, there's no need to perform rounding. */
7083 if (! flag_errno_math && integer_valued_real_p (arg))
7088 tree arg0 = strip_float_extensions (arg);
7089 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7090 tree newtype = TREE_TYPE (arg0);
7093 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7094 && (decl = mathfn_built_in (newtype, fcode)))
7095 return fold_convert_loc (loc, ftype,
7096 build_call_expr_loc (loc, decl, 1,
7097 fold_convert_loc (loc,
7104 /* FNDECL is assumed to be builtin which can narrow the FP type of
7105 the argument, for instance lround((double)f) -> lroundf (f).
7106 Do the transformation for a call with argument ARG. */
7109 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
7111 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7113 if (!validate_arg (arg, REAL_TYPE))
7116 /* If argument is already integer valued, and we don't need to worry
7117 about setting errno, there's no need to perform rounding. */
7118 if (! flag_errno_math && integer_valued_real_p (arg))
7119 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7120 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7124 tree ftype = TREE_TYPE (arg);
7125 tree arg0 = strip_float_extensions (arg);
7126 tree newtype = TREE_TYPE (arg0);
7129 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7130 && (decl = mathfn_built_in (newtype, fcode)))
7131 return build_call_expr_loc (loc, decl, 1,
7132 fold_convert_loc (loc, newtype, arg0));
7135 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7136 sizeof (long long) == sizeof (long). */
7137 if (TYPE_PRECISION (long_long_integer_type_node)
7138 == TYPE_PRECISION (long_integer_type_node))
7140 tree newfn = NULL_TREE;
7143 CASE_FLT_FN (BUILT_IN_LLCEIL):
7144 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7147 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7148 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7151 CASE_FLT_FN (BUILT_IN_LLROUND):
7152 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7155 CASE_FLT_FN (BUILT_IN_LLRINT):
7156 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7165 tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7166 return fold_convert_loc (loc,
7167 TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7174 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7175 return type. Return NULL_TREE if no simplification can be made. */
7178 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7182 if (!validate_arg (arg, COMPLEX_TYPE)
7183 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7186 /* Calculate the result when the argument is a constant. */
7187 if (TREE_CODE (arg) == COMPLEX_CST
7188 && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7192 if (TREE_CODE (arg) == COMPLEX_EXPR)
7194 tree real = TREE_OPERAND (arg, 0);
7195 tree imag = TREE_OPERAND (arg, 1);
7197 /* If either part is zero, cabs is fabs of the other. */
7198 if (real_zerop (real))
7199 return fold_build1_loc (loc, ABS_EXPR, type, imag);
7200 if (real_zerop (imag))
7201 return fold_build1_loc (loc, ABS_EXPR, type, real);
7203 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7204 if (flag_unsafe_math_optimizations
7205 && operand_equal_p (real, imag, OEP_PURE_SAME))
7207 const REAL_VALUE_TYPE sqrt2_trunc
7208 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7210 return fold_build2_loc (loc, MULT_EXPR, type,
7211 fold_build1_loc (loc, ABS_EXPR, type, real),
7212 build_real (type, sqrt2_trunc));
7216 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7217 if (TREE_CODE (arg) == NEGATE_EXPR
7218 || TREE_CODE (arg) == CONJ_EXPR)
7219 return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7221 /* Don't do this when optimizing for size. */
7222 if (flag_unsafe_math_optimizations
7223 && optimize && optimize_function_for_speed_p (cfun))
7225 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7227 if (sqrtfn != NULL_TREE)
7229 tree rpart, ipart, result;
7231 arg = builtin_save_expr (arg);
7233 rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7234 ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7236 rpart = builtin_save_expr (rpart);
7237 ipart = builtin_save_expr (ipart);
7239 result = fold_build2_loc (loc, PLUS_EXPR, type,
7240 fold_build2_loc (loc, MULT_EXPR, type,
7242 fold_build2_loc (loc, MULT_EXPR, type,
7245 return build_call_expr_loc (loc, sqrtfn, 1, result);
7252 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7253 Return NULL_TREE if no simplification can be made. */
7256 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7259 enum built_in_function fcode;
7262 if (!validate_arg (arg, REAL_TYPE))
7265 /* Calculate the result when the argument is a constant. */
7266 if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7269 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7270 fcode = builtin_mathfn_code (arg);
7271 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7273 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7274 arg = fold_build2_loc (loc, MULT_EXPR, type,
7275 CALL_EXPR_ARG (arg, 0),
7276 build_real (type, dconsthalf));
7277 return build_call_expr_loc (loc, expfn, 1, arg);
7280 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7281 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7283 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7287 tree arg0 = CALL_EXPR_ARG (arg, 0);
7289 /* The inner root was either sqrt or cbrt. */
7290 /* This was a conditional expression but it triggered a bug
7292 REAL_VALUE_TYPE dconstroot;
7293 if (BUILTIN_SQRT_P (fcode))
7294 dconstroot = dconsthalf;
7296 dconstroot = dconst_third ();
7298 /* Adjust for the outer root. */
7299 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7300 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7301 tree_root = build_real (type, dconstroot);
7302 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7306 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7307 if (flag_unsafe_math_optimizations
7308 && (fcode == BUILT_IN_POW
7309 || fcode == BUILT_IN_POWF
7310 || fcode == BUILT_IN_POWL))
7312 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7313 tree arg0 = CALL_EXPR_ARG (arg, 0);
7314 tree arg1 = CALL_EXPR_ARG (arg, 1);
7316 if (!tree_expr_nonnegative_p (arg0))
7317 arg0 = build1 (ABS_EXPR, type, arg0);
7318 narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7319 build_real (type, dconsthalf));
7320 return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7326 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7327 Return NULL_TREE if no simplification can be made. */
7330 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7332 const enum built_in_function fcode = builtin_mathfn_code (arg);
7335 if (!validate_arg (arg, REAL_TYPE))
7338 /* Calculate the result when the argument is a constant. */
7339 if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7342 if (flag_unsafe_math_optimizations)
7344 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7345 if (BUILTIN_EXPONENT_P (fcode))
7347 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7348 const REAL_VALUE_TYPE third_trunc =
7349 real_value_truncate (TYPE_MODE (type), dconst_third ());
7350 arg = fold_build2_loc (loc, MULT_EXPR, type,
7351 CALL_EXPR_ARG (arg, 0),
7352 build_real (type, third_trunc));
7353 return build_call_expr_loc (loc, expfn, 1, arg);
7356 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7357 if (BUILTIN_SQRT_P (fcode))
7359 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7363 tree arg0 = CALL_EXPR_ARG (arg, 0);
7365 REAL_VALUE_TYPE dconstroot = dconst_third ();
7367 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7368 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7369 tree_root = build_real (type, dconstroot);
7370 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7374 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7375 if (BUILTIN_CBRT_P (fcode))
7377 tree arg0 = CALL_EXPR_ARG (arg, 0);
7378 if (tree_expr_nonnegative_p (arg0))
7380 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7385 REAL_VALUE_TYPE dconstroot;
7387 real_arithmetic (&dconstroot, MULT_EXPR,
7388 dconst_third_ptr (), dconst_third_ptr ());
7389 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7390 tree_root = build_real (type, dconstroot);
7391 return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7396 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7397 if (fcode == BUILT_IN_POW
7398 || fcode == BUILT_IN_POWF
7399 || fcode == BUILT_IN_POWL)
7401 tree arg00 = CALL_EXPR_ARG (arg, 0);
7402 tree arg01 = CALL_EXPR_ARG (arg, 1);
7403 if (tree_expr_nonnegative_p (arg00))
7405 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7406 const REAL_VALUE_TYPE dconstroot
7407 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7408 tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7409 build_real (type, dconstroot));
7410 return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7417 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7418 TYPE is the type of the return value. Return NULL_TREE if no
7419 simplification can be made. */
7422 fold_builtin_cos (location_t loc,
7423 tree arg, tree type, tree fndecl)
7427 if (!validate_arg (arg, REAL_TYPE))
7430 /* Calculate the result when the argument is a constant. */
7431 if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7434 /* Optimize cos(-x) into cos (x). */
7435 if ((narg = fold_strip_sign_ops (arg)))
7436 return build_call_expr_loc (loc, fndecl, 1, narg);
7441 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7442 Return NULL_TREE if no simplification can be made. */
7445 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7447 if (validate_arg (arg, REAL_TYPE))
7451 /* Calculate the result when the argument is a constant. */
7452 if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7455 /* Optimize cosh(-x) into cosh (x). */
7456 if ((narg = fold_strip_sign_ops (arg)))
7457 return build_call_expr_loc (loc, fndecl, 1, narg);
7463 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7464 argument ARG. TYPE is the type of the return value. Return
7465 NULL_TREE if no simplification can be made. */
7468 fold_builtin_ccos (location_t loc,
7469 tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
7470 bool hyper ATTRIBUTE_UNUSED)
7472 if (validate_arg (arg, COMPLEX_TYPE)
7473 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7478 /* Calculate the result when the argument is a constant. */
7479 if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7483 /* Optimize fn(-x) into fn(x). */
7484 if ((tmp = fold_strip_sign_ops (arg)))
7485 return build_call_expr_loc (loc, fndecl, 1, tmp);
7491 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7492 Return NULL_TREE if no simplification can be made. */
7495 fold_builtin_tan (tree arg, tree type)
7497 enum built_in_function fcode;
7500 if (!validate_arg (arg, REAL_TYPE))
7503 /* Calculate the result when the argument is a constant. */
7504 if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7507 /* Optimize tan(atan(x)) = x. */
7508 fcode = builtin_mathfn_code (arg);
7509 if (flag_unsafe_math_optimizations
7510 && (fcode == BUILT_IN_ATAN
7511 || fcode == BUILT_IN_ATANF
7512 || fcode == BUILT_IN_ATANL))
7513 return CALL_EXPR_ARG (arg, 0);
7518 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7519 NULL_TREE if no simplification can be made. */
7522 fold_builtin_sincos (location_t loc,
7523 tree arg0, tree arg1, tree arg2)
7528 if (!validate_arg (arg0, REAL_TYPE)
7529 || !validate_arg (arg1, POINTER_TYPE)
7530 || !validate_arg (arg2, POINTER_TYPE))
7533 type = TREE_TYPE (arg0);
7535 /* Calculate the result when the argument is a constant. */
7536 if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7539 /* Canonicalize sincos to cexpi. */
7540 if (!TARGET_C99_FUNCTIONS)
7542 fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7546 call = build_call_expr_loc (loc, fn, 1, arg0);
7547 call = builtin_save_expr (call);
7549 return build2 (COMPOUND_EXPR, void_type_node,
7550 build2 (MODIFY_EXPR, void_type_node,
7551 build_fold_indirect_ref_loc (loc, arg1),
7552 build1 (IMAGPART_EXPR, type, call)),
7553 build2 (MODIFY_EXPR, void_type_node,
7554 build_fold_indirect_ref_loc (loc, arg2),
7555 build1 (REALPART_EXPR, type, call)));
7558 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7559 NULL_TREE if no simplification can be made. */
7562 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7565 tree realp, imagp, ifn;
7570 if (!validate_arg (arg0, COMPLEX_TYPE)
7571 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7575 /* Calculate the result when the argument is a constant. */
7576 if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7580 rtype = TREE_TYPE (TREE_TYPE (arg0));
7582 /* In case we can figure out the real part of arg0 and it is constant zero
7584 if (!TARGET_C99_FUNCTIONS)
7586 ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7590 if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7591 && real_zerop (realp))
7593 tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7594 return build_call_expr_loc (loc, ifn, 1, narg);
7597 /* In case we can easily decompose real and imaginary parts split cexp
7598 to exp (r) * cexpi (i). */
7599 if (flag_unsafe_math_optimizations
7602 tree rfn, rcall, icall;
7604 rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7608 imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7612 icall = build_call_expr_loc (loc, ifn, 1, imagp);
7613 icall = builtin_save_expr (icall);
7614 rcall = build_call_expr_loc (loc, rfn, 1, realp);
7615 rcall = builtin_save_expr (rcall);
7616 return fold_build2_loc (loc, COMPLEX_EXPR, type,
7617 fold_build2_loc (loc, MULT_EXPR, rtype,
7619 fold_build1_loc (loc, REALPART_EXPR,
7621 fold_build2_loc (loc, MULT_EXPR, rtype,
7623 fold_build1_loc (loc, IMAGPART_EXPR,
7630 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7631 Return NULL_TREE if no simplification can be made. */
7634 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7636 if (!validate_arg (arg, REAL_TYPE))
7639 /* Optimize trunc of constant value. */
7640 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7642 REAL_VALUE_TYPE r, x;
7643 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7645 x = TREE_REAL_CST (arg);
7646 real_trunc (&r, TYPE_MODE (type), &x);
7647 return build_real (type, r);
7650 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7653 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7654 Return NULL_TREE if no simplification can be made. */
7657 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7659 if (!validate_arg (arg, REAL_TYPE))
7662 /* Optimize floor of constant value. */
7663 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7667 x = TREE_REAL_CST (arg);
7668 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7670 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7673 real_floor (&r, TYPE_MODE (type), &x);
7674 return build_real (type, r);
7678 /* Fold floor (x) where x is nonnegative to trunc (x). */
7679 if (tree_expr_nonnegative_p (arg))
7681 tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7683 return build_call_expr_loc (loc, truncfn, 1, arg);
7686 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7689 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7690 Return NULL_TREE if no simplification can be made. */
7693 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7695 if (!validate_arg (arg, REAL_TYPE))
7698 /* Optimize ceil of constant value. */
7699 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7703 x = TREE_REAL_CST (arg);
7704 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7706 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7709 real_ceil (&r, TYPE_MODE (type), &x);
7710 return build_real (type, r);
7714 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7717 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7718 Return NULL_TREE if no simplification can be made. */
7721 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7723 if (!validate_arg (arg, REAL_TYPE))
7726 /* Optimize round of constant value. */
7727 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7731 x = TREE_REAL_CST (arg);
7732 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7734 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7737 real_round (&r, TYPE_MODE (type), &x);
7738 return build_real (type, r);
7742 return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7745 /* Fold function call to builtin lround, lroundf or lroundl (or the
7746 corresponding long long versions) and other rounding functions. ARG
7747 is the argument to the call. Return NULL_TREE if no simplification
7751 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7753 if (!validate_arg (arg, REAL_TYPE))
7756 /* Optimize lround of constant value. */
7757 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7759 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7761 if (real_isfinite (&x))
7763 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7764 tree ftype = TREE_TYPE (arg);
7765 unsigned HOST_WIDE_INT lo2;
7766 HOST_WIDE_INT hi, lo;
7769 switch (DECL_FUNCTION_CODE (fndecl))
7771 CASE_FLT_FN (BUILT_IN_LFLOOR):
7772 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7773 real_floor (&r, TYPE_MODE (ftype), &x);
7776 CASE_FLT_FN (BUILT_IN_LCEIL):
7777 CASE_FLT_FN (BUILT_IN_LLCEIL):
7778 real_ceil (&r, TYPE_MODE (ftype), &x);
7781 CASE_FLT_FN (BUILT_IN_LROUND):
7782 CASE_FLT_FN (BUILT_IN_LLROUND):
7783 real_round (&r, TYPE_MODE (ftype), &x);
7790 REAL_VALUE_TO_INT (&lo, &hi, r);
7791 if (!fit_double_type (lo, hi, &lo2, &hi, itype))
7792 return build_int_cst_wide (itype, lo2, hi);
7796 switch (DECL_FUNCTION_CODE (fndecl))
7798 CASE_FLT_FN (BUILT_IN_LFLOOR):
7799 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7800 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
7801 if (tree_expr_nonnegative_p (arg))
7802 return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7803 TREE_TYPE (TREE_TYPE (fndecl)), arg);
7808 return fold_fixed_mathfn (loc, fndecl, arg);
7811 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7812 and their long and long long variants (i.e. ffsl and ffsll). ARG is
7813 the argument to the call. Return NULL_TREE if no simplification can
7817 fold_builtin_bitop (tree fndecl, tree arg)
7819 if (!validate_arg (arg, INTEGER_TYPE))
7822 /* Optimize for constant argument. */
7823 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7825 HOST_WIDE_INT hi, width, result;
7826 unsigned HOST_WIDE_INT lo;
7829 type = TREE_TYPE (arg);
7830 width = TYPE_PRECISION (type);
7831 lo = TREE_INT_CST_LOW (arg);
7833 /* Clear all the bits that are beyond the type's precision. */
7834 if (width > HOST_BITS_PER_WIDE_INT)
7836 hi = TREE_INT_CST_HIGH (arg);
7837 if (width < 2 * HOST_BITS_PER_WIDE_INT)
7838 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7843 if (width < HOST_BITS_PER_WIDE_INT)
7844 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7847 switch (DECL_FUNCTION_CODE (fndecl))
7849 CASE_INT_FN (BUILT_IN_FFS):
7851 result = exact_log2 (lo & -lo) + 1;
7853 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
7858 CASE_INT_FN (BUILT_IN_CLZ):
7860 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7862 result = width - floor_log2 (lo) - 1;
7863 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7867 CASE_INT_FN (BUILT_IN_CTZ):
7869 result = exact_log2 (lo & -lo);
7871 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
7872 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7876 CASE_INT_FN (BUILT_IN_POPCOUNT):
7879 result++, lo &= lo - 1;
7881 result++, hi &= hi - 1;
7884 CASE_INT_FN (BUILT_IN_PARITY):
7887 result++, lo &= lo - 1;
7889 result++, hi &= hi - 1;
7897 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7903 /* Fold function call to builtin_bswap and the long and long long
7904 variants. Return NULL_TREE if no simplification can be made. */
7906 fold_builtin_bswap (tree fndecl, tree arg)
7908 if (! validate_arg (arg, INTEGER_TYPE))
7911 /* Optimize constant value. */
7912 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7914 HOST_WIDE_INT hi, width, r_hi = 0;
7915 unsigned HOST_WIDE_INT lo, r_lo = 0;
7918 type = TREE_TYPE (arg);
7919 width = TYPE_PRECISION (type);
7920 lo = TREE_INT_CST_LOW (arg);
7921 hi = TREE_INT_CST_HIGH (arg);
7923 switch (DECL_FUNCTION_CODE (fndecl))
7925 case BUILT_IN_BSWAP32:
7926 case BUILT_IN_BSWAP64:
7930 for (s = 0; s < width; s += 8)
7932 int d = width - s - 8;
7933 unsigned HOST_WIDE_INT byte;
7935 if (s < HOST_BITS_PER_WIDE_INT)
7936 byte = (lo >> s) & 0xff;
7938 byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7940 if (d < HOST_BITS_PER_WIDE_INT)
7943 r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7953 if (width < HOST_BITS_PER_WIDE_INT)
7954 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7956 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7962 /* A subroutine of fold_builtin to fold the various logarithmic
7963 functions. Return NULL_TREE if no simplification can me made.
7964 FUNC is the corresponding MPFR logarithm function. */
7967 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7968 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7970 if (validate_arg (arg, REAL_TYPE))
7972 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7974 const enum built_in_function fcode = builtin_mathfn_code (arg);
7976 /* Calculate the result when the argument is a constant. */
7977 if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7980 /* Special case, optimize logN(expN(x)) = x. */
7981 if (flag_unsafe_math_optimizations
7982 && ((func == mpfr_log
7983 && (fcode == BUILT_IN_EXP
7984 || fcode == BUILT_IN_EXPF
7985 || fcode == BUILT_IN_EXPL))
7986 || (func == mpfr_log2
7987 && (fcode == BUILT_IN_EXP2
7988 || fcode == BUILT_IN_EXP2F
7989 || fcode == BUILT_IN_EXP2L))
7990 || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7991 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7993 /* Optimize logN(func()) for various exponential functions. We
7994 want to determine the value "x" and the power "exponent" in
7995 order to transform logN(x**exponent) into exponent*logN(x). */
7996 if (flag_unsafe_math_optimizations)
7998 tree exponent = 0, x = 0;
8002 CASE_FLT_FN (BUILT_IN_EXP):
8003 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
8004 x = build_real (type, real_value_truncate (TYPE_MODE (type),
8006 exponent = CALL_EXPR_ARG (arg, 0);
8008 CASE_FLT_FN (BUILT_IN_EXP2):
8009 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
8010 x = build_real (type, dconst2);
8011 exponent = CALL_EXPR_ARG (arg, 0);
8013 CASE_FLT_FN (BUILT_IN_EXP10):
8014 CASE_FLT_FN (BUILT_IN_POW10):
8015 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
8017 REAL_VALUE_TYPE dconst10;
8018 real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8019 x = build_real (type, dconst10);
8021 exponent = CALL_EXPR_ARG (arg, 0);
8023 CASE_FLT_FN (BUILT_IN_SQRT):
8024 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
8025 x = CALL_EXPR_ARG (arg, 0);
8026 exponent = build_real (type, dconsthalf);
8028 CASE_FLT_FN (BUILT_IN_CBRT):
8029 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
8030 x = CALL_EXPR_ARG (arg, 0);
8031 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8034 CASE_FLT_FN (BUILT_IN_POW):
8035 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
8036 x = CALL_EXPR_ARG (arg, 0);
8037 exponent = CALL_EXPR_ARG (arg, 1);
8043 /* Now perform the optimization. */
8046 tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
8047 return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
8055 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8056 NULL_TREE if no simplification can be made. */
8059 fold_builtin_hypot (location_t loc, tree fndecl,
8060 tree arg0, tree arg1, tree type)
8062 tree res, narg0, narg1;
8064 if (!validate_arg (arg0, REAL_TYPE)
8065 || !validate_arg (arg1, REAL_TYPE))
8068 /* Calculate the result when the argument is a constant. */
8069 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8072 /* If either argument to hypot has a negate or abs, strip that off.
8073 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8074 narg0 = fold_strip_sign_ops (arg0);
8075 narg1 = fold_strip_sign_ops (arg1);
8078 return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
8079 narg1 ? narg1 : arg1);
8082 /* If either argument is zero, hypot is fabs of the other. */
8083 if (real_zerop (arg0))
8084 return fold_build1_loc (loc, ABS_EXPR, type, arg1);
8085 else if (real_zerop (arg1))
8086 return fold_build1_loc (loc, ABS_EXPR, type, arg0);
8088 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8089 if (flag_unsafe_math_optimizations
8090 && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8092 const REAL_VALUE_TYPE sqrt2_trunc
8093 = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8094 return fold_build2_loc (loc, MULT_EXPR, type,
8095 fold_build1_loc (loc, ABS_EXPR, type, arg0),
8096 build_real (type, sqrt2_trunc));
8103 /* Fold a builtin function call to pow, powf, or powl. Return
8104 NULL_TREE if no simplification can be made. */
8106 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8110 if (!validate_arg (arg0, REAL_TYPE)
8111 || !validate_arg (arg1, REAL_TYPE))
8114 /* Calculate the result when the argument is a constant. */
8115 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8118 /* Optimize pow(1.0,y) = 1.0. */
8119 if (real_onep (arg0))
8120 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8122 if (TREE_CODE (arg1) == REAL_CST
8123 && !TREE_OVERFLOW (arg1))
8125 REAL_VALUE_TYPE cint;
8129 c = TREE_REAL_CST (arg1);
8131 /* Optimize pow(x,0.0) = 1.0. */
8132 if (REAL_VALUES_EQUAL (c, dconst0))
8133 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8136 /* Optimize pow(x,1.0) = x. */
8137 if (REAL_VALUES_EQUAL (c, dconst1))
8140 /* Optimize pow(x,-1.0) = 1.0/x. */
8141 if (REAL_VALUES_EQUAL (c, dconstm1))
8142 return fold_build2_loc (loc, RDIV_EXPR, type,
8143 build_real (type, dconst1), arg0);
8145 /* Optimize pow(x,0.5) = sqrt(x). */
8146 if (flag_unsafe_math_optimizations
8147 && REAL_VALUES_EQUAL (c, dconsthalf))
8149 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8151 if (sqrtfn != NULL_TREE)
8152 return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8155 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8156 if (flag_unsafe_math_optimizations)
8158 const REAL_VALUE_TYPE dconstroot
8159 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8161 if (REAL_VALUES_EQUAL (c, dconstroot))
8163 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8164 if (cbrtfn != NULL_TREE)
8165 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8169 /* Check for an integer exponent. */
8170 n = real_to_integer (&c);
8171 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8172 if (real_identical (&c, &cint))
8174 /* Attempt to evaluate pow at compile-time, unless this should
8175 raise an exception. */
8176 if (TREE_CODE (arg0) == REAL_CST
8177 && !TREE_OVERFLOW (arg0)
8179 || (!flag_trapping_math && !flag_errno_math)
8180 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8185 x = TREE_REAL_CST (arg0);
8186 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8187 if (flag_unsafe_math_optimizations || !inexact)
8188 return build_real (type, x);
8191 /* Strip sign ops from even integer powers. */
8192 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8194 tree narg0 = fold_strip_sign_ops (arg0);
8196 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8201 if (flag_unsafe_math_optimizations)
8203 const enum built_in_function fcode = builtin_mathfn_code (arg0);
8205 /* Optimize pow(expN(x),y) = expN(x*y). */
8206 if (BUILTIN_EXPONENT_P (fcode))
8208 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8209 tree arg = CALL_EXPR_ARG (arg0, 0);
8210 arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8211 return build_call_expr_loc (loc, expfn, 1, arg);
8214 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8215 if (BUILTIN_SQRT_P (fcode))
8217 tree narg0 = CALL_EXPR_ARG (arg0, 0);
8218 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8219 build_real (type, dconsthalf));
8220 return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8223 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8224 if (BUILTIN_CBRT_P (fcode))
8226 tree arg = CALL_EXPR_ARG (arg0, 0);
8227 if (tree_expr_nonnegative_p (arg))
8229 const REAL_VALUE_TYPE dconstroot
8230 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8231 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8232 build_real (type, dconstroot));
8233 return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8237 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8238 if (fcode == BUILT_IN_POW
8239 || fcode == BUILT_IN_POWF
8240 || fcode == BUILT_IN_POWL)
8242 tree arg00 = CALL_EXPR_ARG (arg0, 0);
8243 if (tree_expr_nonnegative_p (arg00))
8245 tree arg01 = CALL_EXPR_ARG (arg0, 1);
8246 tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8247 return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8255 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8256 Return NULL_TREE if no simplification can be made. */
8258 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8259 tree arg0, tree arg1, tree type)
8261 if (!validate_arg (arg0, REAL_TYPE)
8262 || !validate_arg (arg1, INTEGER_TYPE))
8265 /* Optimize pow(1.0,y) = 1.0. */
8266 if (real_onep (arg0))
8267 return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8269 if (host_integerp (arg1, 0))
8271 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8273 /* Evaluate powi at compile-time. */
8274 if (TREE_CODE (arg0) == REAL_CST
8275 && !TREE_OVERFLOW (arg0))
8278 x = TREE_REAL_CST (arg0);
8279 real_powi (&x, TYPE_MODE (type), &x, c);
8280 return build_real (type, x);
8283 /* Optimize pow(x,0) = 1.0. */
8285 return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8288 /* Optimize pow(x,1) = x. */
8292 /* Optimize pow(x,-1) = 1.0/x. */
8294 return fold_build2_loc (loc, RDIV_EXPR, type,
8295 build_real (type, dconst1), arg0);
8301 /* A subroutine of fold_builtin to fold the various exponent
8302 functions. Return NULL_TREE if no simplification can be made.
8303 FUNC is the corresponding MPFR exponent function. */
8306 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8307 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8309 if (validate_arg (arg, REAL_TYPE))
8311 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8314 /* Calculate the result when the argument is a constant. */
8315 if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8318 /* Optimize expN(logN(x)) = x. */
8319 if (flag_unsafe_math_optimizations)
8321 const enum built_in_function fcode = builtin_mathfn_code (arg);
8323 if ((func == mpfr_exp
8324 && (fcode == BUILT_IN_LOG
8325 || fcode == BUILT_IN_LOGF
8326 || fcode == BUILT_IN_LOGL))
8327 || (func == mpfr_exp2
8328 && (fcode == BUILT_IN_LOG2
8329 || fcode == BUILT_IN_LOG2F
8330 || fcode == BUILT_IN_LOG2L))
8331 || (func == mpfr_exp10
8332 && (fcode == BUILT_IN_LOG10
8333 || fcode == BUILT_IN_LOG10F
8334 || fcode == BUILT_IN_LOG10L)))
8335 return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8342 /* Return true if VAR is a VAR_DECL or a component thereof. */
8345 var_decl_component_p (tree var)
8348 while (handled_component_p (inner))
8349 inner = TREE_OPERAND (inner, 0);
8350 return SSA_VAR_P (inner);
8353 /* Fold function call to builtin memset. Return
8354 NULL_TREE if no simplification can be made. */
8357 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8358 tree type, bool ignore)
8360 tree var, ret, etype;
8361 unsigned HOST_WIDE_INT length, cval;
8363 if (! validate_arg (dest, POINTER_TYPE)
8364 || ! validate_arg (c, INTEGER_TYPE)
8365 || ! validate_arg (len, INTEGER_TYPE))
8368 if (! host_integerp (len, 1))
8371 /* If the LEN parameter is zero, return DEST. */
8372 if (integer_zerop (len))
8373 return omit_one_operand_loc (loc, type, dest, c);
8375 if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8380 if (TREE_CODE (var) != ADDR_EXPR)
8383 var = TREE_OPERAND (var, 0);
8384 if (TREE_THIS_VOLATILE (var))
8387 etype = TREE_TYPE (var);
8388 if (TREE_CODE (etype) == ARRAY_TYPE)
8389 etype = TREE_TYPE (etype);
8391 if (!INTEGRAL_TYPE_P (etype)
8392 && !POINTER_TYPE_P (etype))
8395 if (! var_decl_component_p (var))
8398 length = tree_low_cst (len, 1);
8399 if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8400 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8404 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8407 if (integer_zerop (c))
8411 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8414 cval = tree_low_cst (c, 1);
8418 cval |= (cval << 31) << 1;
8421 ret = build_int_cst_type (etype, cval);
8422 var = build_fold_indirect_ref_loc (loc,
8423 fold_convert_loc (loc,
8424 build_pointer_type (etype),
8426 ret = build2 (MODIFY_EXPR, etype, var, ret);
8430 return omit_one_operand_loc (loc, type, dest, ret);
8433 /* Fold function call to builtin memset. Return
8434 NULL_TREE if no simplification can be made. */
8437 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8439 if (! validate_arg (dest, POINTER_TYPE)
8440 || ! validate_arg (size, INTEGER_TYPE))
8446 /* New argument list transforming bzero(ptr x, int y) to
8447 memset(ptr x, int 0, size_t y). This is done this way
8448 so that if it isn't expanded inline, we fallback to
8449 calling bzero instead of memset. */
8451 return fold_builtin_memset (loc, dest, integer_zero_node,
8452 fold_convert_loc (loc, sizetype, size),
8453 void_type_node, ignore);
8456 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8457 NULL_TREE if no simplification can be made.
8458 If ENDP is 0, return DEST (like memcpy).
8459 If ENDP is 1, return DEST+LEN (like mempcpy).
8460 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8461 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8465 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8466 tree len, tree type, bool ignore, int endp)
8468 tree destvar, srcvar, expr;
8470 if (! validate_arg (dest, POINTER_TYPE)
8471 || ! validate_arg (src, POINTER_TYPE)
8472 || ! validate_arg (len, INTEGER_TYPE))
8475 /* If the LEN parameter is zero, return DEST. */
8476 if (integer_zerop (len))
8477 return omit_one_operand_loc (loc, type, dest, src);
8479 /* If SRC and DEST are the same (and not volatile), return
8480 DEST{,+LEN,+LEN-1}. */
8481 if (operand_equal_p (src, dest, 0))
8485 tree srctype, desttype;
8486 int src_align, dest_align;
8490 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8491 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8493 /* Both DEST and SRC must be pointer types.
8494 ??? This is what old code did. Is the testing for pointer types
8497 If either SRC is readonly or length is 1, we can use memcpy. */
8498 if (!dest_align || !src_align)
8500 if (readonly_data_expr (src)
8501 || (host_integerp (len, 1)
8502 && (MIN (src_align, dest_align) / BITS_PER_UNIT
8503 >= tree_low_cst (len, 1))))
8505 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8508 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8511 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8512 srcvar = build_fold_indirect_ref_loc (loc, src);
8513 destvar = build_fold_indirect_ref_loc (loc, dest);
8515 && !TREE_THIS_VOLATILE (srcvar)
8517 && !TREE_THIS_VOLATILE (destvar))
8519 tree src_base, dest_base, fn;
8520 HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8521 HOST_WIDE_INT size = -1;
8522 HOST_WIDE_INT maxsize = -1;
8525 if (handled_component_p (src_base))
8526 src_base = get_ref_base_and_extent (src_base, &src_offset,
8528 dest_base = destvar;
8529 if (handled_component_p (dest_base))
8530 dest_base = get_ref_base_and_extent (dest_base, &dest_offset,
8532 if (host_integerp (len, 1))
8534 maxsize = tree_low_cst (len, 1);
8536 > INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT)
8539 maxsize *= BITS_PER_UNIT;
8543 if (SSA_VAR_P (src_base)
8544 && SSA_VAR_P (dest_base))
8546 if (operand_equal_p (src_base, dest_base, 0)
8547 && ranges_overlap_p (src_offset, maxsize,
8548 dest_offset, maxsize))
8551 else if (TREE_CODE (src_base) == INDIRECT_REF
8552 && TREE_CODE (dest_base) == INDIRECT_REF)
8554 if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8555 TREE_OPERAND (dest_base, 0), 0)
8556 || ranges_overlap_p (src_offset, maxsize,
8557 dest_offset, maxsize))
8563 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8566 return build_call_expr_loc (loc, fn, 3, dest, src, len);
8571 if (!host_integerp (len, 0))
8574 This logic lose for arguments like (type *)malloc (sizeof (type)),
8575 since we strip the casts of up to VOID return value from malloc.
8576 Perhaps we ought to inherit type from non-VOID argument here? */
8579 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8580 if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8582 tree tem = TREE_OPERAND (src, 0);
8584 if (tem != TREE_OPERAND (src, 0))
8585 src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8587 if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8589 tree tem = TREE_OPERAND (dest, 0);
8591 if (tem != TREE_OPERAND (dest, 0))
8592 dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8594 srctype = TREE_TYPE (TREE_TYPE (src));
8596 && TREE_CODE (srctype) == ARRAY_TYPE
8597 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8599 srctype = TREE_TYPE (srctype);
8601 src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8603 desttype = TREE_TYPE (TREE_TYPE (dest));
8605 && TREE_CODE (desttype) == ARRAY_TYPE
8606 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8608 desttype = TREE_TYPE (desttype);
8610 dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8612 if (!srctype || !desttype
8613 || !TYPE_SIZE_UNIT (srctype)
8614 || !TYPE_SIZE_UNIT (desttype)
8615 || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8616 || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST
8617 || TYPE_VOLATILE (srctype)
8618 || TYPE_VOLATILE (desttype))
8621 src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8622 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8623 if (dest_align < (int) TYPE_ALIGN (desttype)
8624 || src_align < (int) TYPE_ALIGN (srctype))
8628 dest = builtin_save_expr (dest);
8631 if (tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8633 srcvar = build_fold_indirect_ref_loc (loc, src);
8634 if (TREE_THIS_VOLATILE (srcvar))
8636 else if (!tree_int_cst_equal (tree_expr_size (srcvar), len))
8638 /* With memcpy, it is possible to bypass aliasing rules, so without
8639 this check i.e. execute/20060930-2.c would be misoptimized,
8640 because it use conflicting alias set to hold argument for the
8641 memcpy call. This check is probably unnecessary with
8642 -fno-strict-aliasing. Similarly for destvar. See also
8644 else if (!var_decl_component_p (srcvar))
8648 destvar = NULL_TREE;
8649 if (tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8651 destvar = build_fold_indirect_ref_loc (loc, dest);
8652 if (TREE_THIS_VOLATILE (destvar))
8654 else if (!tree_int_cst_equal (tree_expr_size (destvar), len))
8655 destvar = NULL_TREE;
8656 else if (!var_decl_component_p (destvar))
8657 destvar = NULL_TREE;
8660 if (srcvar == NULL_TREE && destvar == NULL_TREE)
8663 if (srcvar == NULL_TREE)
8666 if (TREE_ADDRESSABLE (TREE_TYPE (destvar)))
8669 srctype = build_qualified_type (desttype, 0);
8670 if (src_align < (int) TYPE_ALIGN (srctype))
8672 if (AGGREGATE_TYPE_P (srctype)
8673 || SLOW_UNALIGNED_ACCESS (TYPE_MODE (srctype), src_align))
8676 srctype = build_variant_type_copy (srctype);
8677 TYPE_ALIGN (srctype) = src_align;
8678 TYPE_USER_ALIGN (srctype) = 1;
8679 TYPE_PACKED (srctype) = 1;
8681 srcptype = build_pointer_type_for_mode (srctype, ptr_mode, true);
8682 src = fold_convert_loc (loc, srcptype, src);
8683 srcvar = build_fold_indirect_ref_loc (loc, src);
8685 else if (destvar == NULL_TREE)
8688 if (TREE_ADDRESSABLE (TREE_TYPE (srcvar)))
8691 desttype = build_qualified_type (srctype, 0);
8692 if (dest_align < (int) TYPE_ALIGN (desttype))
8694 if (AGGREGATE_TYPE_P (desttype)
8695 || SLOW_UNALIGNED_ACCESS (TYPE_MODE (desttype), dest_align))
8698 desttype = build_variant_type_copy (desttype);
8699 TYPE_ALIGN (desttype) = dest_align;
8700 TYPE_USER_ALIGN (desttype) = 1;
8701 TYPE_PACKED (desttype) = 1;
8703 destptype = build_pointer_type_for_mode (desttype, ptr_mode, true);
8704 dest = fold_convert_loc (loc, destptype, dest);
8705 destvar = build_fold_indirect_ref_loc (loc, dest);
8708 if (srctype == desttype
8709 || (gimple_in_ssa_p (cfun)
8710 && useless_type_conversion_p (desttype, srctype)))
8712 else if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
8713 || POINTER_TYPE_P (TREE_TYPE (srcvar)))
8714 && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
8715 || POINTER_TYPE_P (TREE_TYPE (destvar))))
8716 expr = fold_convert_loc (loc, TREE_TYPE (destvar), srcvar);
8718 expr = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8719 TREE_TYPE (destvar), srcvar);
8720 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
8726 if (endp == 0 || endp == 3)
8727 return omit_one_operand_loc (loc, type, dest, expr);
8733 len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8736 len = fold_convert_loc (loc, sizetype, len);
8737 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8738 dest = fold_convert_loc (loc, type, dest);
8740 dest = omit_one_operand_loc (loc, type, dest, expr);
8744 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8745 If LEN is not NULL, it represents the length of the string to be
8746 copied. Return NULL_TREE if no simplification can be made. */
8749 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8753 if (!validate_arg (dest, POINTER_TYPE)
8754 || !validate_arg (src, POINTER_TYPE))
8757 /* If SRC and DEST are the same (and not volatile), return DEST. */
8758 if (operand_equal_p (src, dest, 0))
8759 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8761 if (optimize_function_for_size_p (cfun))
8764 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8770 len = c_strlen (src, 1);
8771 if (! len || TREE_SIDE_EFFECTS (len))
8775 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8776 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8777 build_call_expr_loc (loc, fn, 3, dest, src, len));
8780 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8781 Return NULL_TREE if no simplification can be made. */
8784 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8786 tree fn, len, lenp1, call, type;
8788 if (!validate_arg (dest, POINTER_TYPE)
8789 || !validate_arg (src, POINTER_TYPE))
8792 len = c_strlen (src, 1);
8794 || TREE_CODE (len) != INTEGER_CST)
8797 if (optimize_function_for_size_p (cfun)
8798 /* If length is zero it's small enough. */
8799 && !integer_zerop (len))
8802 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8806 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8807 /* We use dest twice in building our expression. Save it from
8808 multiple expansions. */
8809 dest = builtin_save_expr (dest);
8810 call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8812 type = TREE_TYPE (TREE_TYPE (fndecl));
8813 len = fold_convert_loc (loc, sizetype, len);
8814 dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8815 dest = fold_convert_loc (loc, type, dest);
8816 dest = omit_one_operand_loc (loc, type, dest, call);
8820 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8821 If SLEN is not NULL, it represents the length of the source string.
8822 Return NULL_TREE if no simplification can be made. */
8825 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8826 tree src, tree len, tree slen)
8830 if (!validate_arg (dest, POINTER_TYPE)
8831 || !validate_arg (src, POINTER_TYPE)
8832 || !validate_arg (len, INTEGER_TYPE))
8835 /* If the LEN parameter is zero, return DEST. */
8836 if (integer_zerop (len))
8837 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8839 /* We can't compare slen with len as constants below if len is not a
8841 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8845 slen = c_strlen (src, 1);
8847 /* Now, we must be passed a constant src ptr parameter. */
8848 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8851 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8853 /* We do not support simplification of this case, though we do
8854 support it when expanding trees into RTL. */
8855 /* FIXME: generate a call to __builtin_memset. */
8856 if (tree_int_cst_lt (slen, len))
8859 /* OK transform into builtin memcpy. */
8860 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8863 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8864 build_call_expr_loc (loc, fn, 3, dest, src, len));
8867 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8868 arguments to the call, and TYPE is its return type.
8869 Return NULL_TREE if no simplification can be made. */
8872 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8874 if (!validate_arg (arg1, POINTER_TYPE)
8875 || !validate_arg (arg2, INTEGER_TYPE)
8876 || !validate_arg (len, INTEGER_TYPE))
8882 if (TREE_CODE (arg2) != INTEGER_CST
8883 || !host_integerp (len, 1))
8886 p1 = c_getstr (arg1);
8887 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8893 if (target_char_cast (arg2, &c))
8896 r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8899 return build_int_cst (TREE_TYPE (arg1), 0);
8901 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8903 return fold_convert_loc (loc, type, tem);
8909 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8910 Return NULL_TREE if no simplification can be made. */
8913 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8915 const char *p1, *p2;
8917 if (!validate_arg (arg1, POINTER_TYPE)
8918 || !validate_arg (arg2, POINTER_TYPE)
8919 || !validate_arg (len, INTEGER_TYPE))
8922 /* If the LEN parameter is zero, return zero. */
8923 if (integer_zerop (len))
8924 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8927 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8928 if (operand_equal_p (arg1, arg2, 0))
8929 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8931 p1 = c_getstr (arg1);
8932 p2 = c_getstr (arg2);
8934 /* If all arguments are constant, and the value of len is not greater
8935 than the lengths of arg1 and arg2, evaluate at compile-time. */
8936 if (host_integerp (len, 1) && p1 && p2
8937 && compare_tree_int (len, strlen (p1) + 1) <= 0
8938 && compare_tree_int (len, strlen (p2) + 1) <= 0)
8940 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8943 return integer_one_node;
8945 return integer_minus_one_node;
8947 return integer_zero_node;
8950 /* If len parameter is one, return an expression corresponding to
8951 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8952 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8954 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8955 tree cst_uchar_ptr_node
8956 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8959 = fold_convert_loc (loc, integer_type_node,
8960 build1 (INDIRECT_REF, cst_uchar_node,
8961 fold_convert_loc (loc,
8965 = fold_convert_loc (loc, integer_type_node,
8966 build1 (INDIRECT_REF, cst_uchar_node,
8967 fold_convert_loc (loc,
8970 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8976 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8977 Return NULL_TREE if no simplification can be made. */
8980 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8982 const char *p1, *p2;
8984 if (!validate_arg (arg1, POINTER_TYPE)
8985 || !validate_arg (arg2, POINTER_TYPE))
8988 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8989 if (operand_equal_p (arg1, arg2, 0))
8990 return integer_zero_node;
8992 p1 = c_getstr (arg1);
8993 p2 = c_getstr (arg2);
8997 const int i = strcmp (p1, p2);
8999 return integer_minus_one_node;
9001 return integer_one_node;
9003 return integer_zero_node;
9006 /* If the second arg is "", return *(const unsigned char*)arg1. */
9007 if (p2 && *p2 == '\0')
9009 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9010 tree cst_uchar_ptr_node
9011 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9013 return fold_convert_loc (loc, integer_type_node,
9014 build1 (INDIRECT_REF, cst_uchar_node,
9015 fold_convert_loc (loc,
9020 /* If the first arg is "", return -*(const unsigned char*)arg2. */
9021 if (p1 && *p1 == '\0')
9023 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9024 tree cst_uchar_ptr_node
9025 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9028 = fold_convert_loc (loc, integer_type_node,
9029 build1 (INDIRECT_REF, cst_uchar_node,
9030 fold_convert_loc (loc,
9033 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9039 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9040 Return NULL_TREE if no simplification can be made. */
9043 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
9045 const char *p1, *p2;
9047 if (!validate_arg (arg1, POINTER_TYPE)
9048 || !validate_arg (arg2, POINTER_TYPE)
9049 || !validate_arg (len, INTEGER_TYPE))
9052 /* If the LEN parameter is zero, return zero. */
9053 if (integer_zerop (len))
9054 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9057 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9058 if (operand_equal_p (arg1, arg2, 0))
9059 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9061 p1 = c_getstr (arg1);
9062 p2 = c_getstr (arg2);
9064 if (host_integerp (len, 1) && p1 && p2)
9066 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9068 return integer_one_node;
9070 return integer_minus_one_node;
9072 return integer_zero_node;
9075 /* If the second arg is "", and the length is greater than zero,
9076 return *(const unsigned char*)arg1. */
9077 if (p2 && *p2 == '\0'
9078 && TREE_CODE (len) == INTEGER_CST
9079 && tree_int_cst_sgn (len) == 1)
9081 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9082 tree cst_uchar_ptr_node
9083 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9085 return fold_convert_loc (loc, integer_type_node,
9086 build1 (INDIRECT_REF, cst_uchar_node,
9087 fold_convert_loc (loc,
9092 /* If the first arg is "", and the length is greater than zero,
9093 return -*(const unsigned char*)arg2. */
9094 if (p1 && *p1 == '\0'
9095 && TREE_CODE (len) == INTEGER_CST
9096 && tree_int_cst_sgn (len) == 1)
9098 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9099 tree cst_uchar_ptr_node
9100 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9102 tree temp = fold_convert_loc (loc, integer_type_node,
9103 build1 (INDIRECT_REF, cst_uchar_node,
9104 fold_convert_loc (loc,
9107 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9110 /* If len parameter is one, return an expression corresponding to
9111 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9112 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9114 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9115 tree cst_uchar_ptr_node
9116 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9118 tree ind1 = fold_convert_loc (loc, integer_type_node,
9119 build1 (INDIRECT_REF, cst_uchar_node,
9120 fold_convert_loc (loc,
9123 tree ind2 = fold_convert_loc (loc, integer_type_node,
9124 build1 (INDIRECT_REF, cst_uchar_node,
9125 fold_convert_loc (loc,
9128 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9134 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9135 ARG. Return NULL_TREE if no simplification can be made. */
9138 fold_builtin_signbit (location_t loc, tree arg, tree type)
9142 if (!validate_arg (arg, REAL_TYPE))
9145 /* If ARG is a compile-time constant, determine the result. */
9146 if (TREE_CODE (arg) == REAL_CST
9147 && !TREE_OVERFLOW (arg))
9151 c = TREE_REAL_CST (arg);
9152 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9153 return fold_convert_loc (loc, type, temp);
9156 /* If ARG is non-negative, the result is always zero. */
9157 if (tree_expr_nonnegative_p (arg))
9158 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9160 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9161 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9162 return fold_build2_loc (loc, LT_EXPR, type, arg,
9163 build_real (TREE_TYPE (arg), dconst0));
9168 /* Fold function call to builtin copysign, copysignf or copysignl with
9169 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9173 fold_builtin_copysign (location_t loc, tree fndecl,
9174 tree arg1, tree arg2, tree type)
9178 if (!validate_arg (arg1, REAL_TYPE)
9179 || !validate_arg (arg2, REAL_TYPE))
9182 /* copysign(X,X) is X. */
9183 if (operand_equal_p (arg1, arg2, 0))
9184 return fold_convert_loc (loc, type, arg1);
9186 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9187 if (TREE_CODE (arg1) == REAL_CST
9188 && TREE_CODE (arg2) == REAL_CST
9189 && !TREE_OVERFLOW (arg1)
9190 && !TREE_OVERFLOW (arg2))
9192 REAL_VALUE_TYPE c1, c2;
9194 c1 = TREE_REAL_CST (arg1);
9195 c2 = TREE_REAL_CST (arg2);
9196 /* c1.sign := c2.sign. */
9197 real_copysign (&c1, &c2);
9198 return build_real (type, c1);
9201 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9202 Remember to evaluate Y for side-effects. */
9203 if (tree_expr_nonnegative_p (arg2))
9204 return omit_one_operand_loc (loc, type,
9205 fold_build1_loc (loc, ABS_EXPR, type, arg1),
9208 /* Strip sign changing operations for the first argument. */
9209 tem = fold_strip_sign_ops (arg1);
9211 return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9216 /* Fold a call to builtin isascii with argument ARG. */
9219 fold_builtin_isascii (location_t loc, tree arg)
9221 if (!validate_arg (arg, INTEGER_TYPE))
9225 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9226 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9227 build_int_cst (NULL_TREE,
9228 ~ (unsigned HOST_WIDE_INT) 0x7f));
9229 return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9230 arg, integer_zero_node);
9234 /* Fold a call to builtin toascii with argument ARG. */
9237 fold_builtin_toascii (location_t loc, tree arg)
9239 if (!validate_arg (arg, INTEGER_TYPE))
9242 /* Transform toascii(c) -> (c & 0x7f). */
9243 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9244 build_int_cst (NULL_TREE, 0x7f));
9247 /* Fold a call to builtin isdigit with argument ARG. */
9250 fold_builtin_isdigit (location_t loc, tree arg)
9252 if (!validate_arg (arg, INTEGER_TYPE))
9256 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9257 /* According to the C standard, isdigit is unaffected by locale.
9258 However, it definitely is affected by the target character set. */
9259 unsigned HOST_WIDE_INT target_digit0
9260 = lang_hooks.to_target_charset ('0');
9262 if (target_digit0 == 0)
9265 arg = fold_convert_loc (loc, unsigned_type_node, arg);
9266 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9267 build_int_cst (unsigned_type_node, target_digit0));
9268 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9269 build_int_cst (unsigned_type_node, 9));
9273 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9276 fold_builtin_fabs (location_t loc, tree arg, tree type)
9278 if (!validate_arg (arg, REAL_TYPE))
9281 arg = fold_convert_loc (loc, type, arg);
9282 if (TREE_CODE (arg) == REAL_CST)
9283 return fold_abs_const (arg, type);
9284 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9287 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9290 fold_builtin_abs (location_t loc, tree arg, tree type)
9292 if (!validate_arg (arg, INTEGER_TYPE))
9295 arg = fold_convert_loc (loc, type, arg);
9296 if (TREE_CODE (arg) == INTEGER_CST)
9297 return fold_abs_const (arg, type);
9298 return fold_build1_loc (loc, ABS_EXPR, type, arg);
9301 /* Fold a call to builtin fmin or fmax. */
9304 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9305 tree type, bool max)
9307 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9309 /* Calculate the result when the argument is a constant. */
9310 tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9315 /* If either argument is NaN, return the other one. Avoid the
9316 transformation if we get (and honor) a signalling NaN. Using
9317 omit_one_operand() ensures we create a non-lvalue. */
9318 if (TREE_CODE (arg0) == REAL_CST
9319 && real_isnan (&TREE_REAL_CST (arg0))
9320 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9321 || ! TREE_REAL_CST (arg0).signalling))
9322 return omit_one_operand_loc (loc, type, arg1, arg0);
9323 if (TREE_CODE (arg1) == REAL_CST
9324 && real_isnan (&TREE_REAL_CST (arg1))
9325 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9326 || ! TREE_REAL_CST (arg1).signalling))
9327 return omit_one_operand_loc (loc, type, arg0, arg1);
9329 /* Transform fmin/fmax(x,x) -> x. */
9330 if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9331 return omit_one_operand_loc (loc, type, arg0, arg1);
9333 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9334 functions to return the numeric arg if the other one is NaN.
9335 These tree codes don't honor that, so only transform if
9336 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9337 handled, so we don't have to worry about it either. */
9338 if (flag_finite_math_only)
9339 return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9340 fold_convert_loc (loc, type, arg0),
9341 fold_convert_loc (loc, type, arg1));
9346 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9349 fold_builtin_carg (location_t loc, tree arg, tree type)
9351 if (validate_arg (arg, COMPLEX_TYPE)
9352 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9354 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9358 tree new_arg = builtin_save_expr (arg);
9359 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9360 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9361 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9368 /* Fold a call to builtin logb/ilogb. */
9371 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9373 if (! validate_arg (arg, REAL_TYPE))
9378 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9380 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9386 /* If arg is Inf or NaN and we're logb, return it. */
9387 if (TREE_CODE (rettype) == REAL_TYPE)
9388 return fold_convert_loc (loc, rettype, arg);
9389 /* Fall through... */
9391 /* Zero may set errno and/or raise an exception for logb, also
9392 for ilogb we don't know FP_ILOGB0. */
9395 /* For normal numbers, proceed iff radix == 2. In GCC,
9396 normalized significands are in the range [0.5, 1.0). We
9397 want the exponent as if they were [1.0, 2.0) so get the
9398 exponent and subtract 1. */
9399 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9400 return fold_convert_loc (loc, rettype,
9401 build_int_cst (NULL_TREE,
9402 REAL_EXP (value)-1));
9410 /* Fold a call to builtin significand, if radix == 2. */
9413 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9415 if (! validate_arg (arg, REAL_TYPE))
9420 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9422 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9429 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9430 return fold_convert_loc (loc, rettype, arg);
9432 /* For normal numbers, proceed iff radix == 2. */
9433 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9435 REAL_VALUE_TYPE result = *value;
9436 /* In GCC, normalized significands are in the range [0.5,
9437 1.0). We want them to be [1.0, 2.0) so set the
9439 SET_REAL_EXP (&result, 1);
9440 return build_real (rettype, result);
9449 /* Fold a call to builtin frexp, we can assume the base is 2. */
9452 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9454 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9459 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9462 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9464 /* Proceed if a valid pointer type was passed in. */
9465 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9467 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9473 /* For +-0, return (*exp = 0, +-0). */
9474 exp = integer_zero_node;
9479 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9480 return omit_one_operand_loc (loc, rettype, arg0, arg1);
9483 /* Since the frexp function always expects base 2, and in
9484 GCC normalized significands are already in the range
9485 [0.5, 1.0), we have exactly what frexp wants. */
9486 REAL_VALUE_TYPE frac_rvt = *value;
9487 SET_REAL_EXP (&frac_rvt, 0);
9488 frac = build_real (rettype, frac_rvt);
9489 exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9496 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9497 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9498 TREE_SIDE_EFFECTS (arg1) = 1;
9499 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9505 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9506 then we can assume the base is two. If it's false, then we have to
9507 check the mode of the TYPE parameter in certain cases. */
9510 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9511 tree type, bool ldexp)
9513 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9518 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9519 if (real_zerop (arg0) || integer_zerop (arg1)
9520 || (TREE_CODE (arg0) == REAL_CST
9521 && !real_isfinite (&TREE_REAL_CST (arg0))))
9522 return omit_one_operand_loc (loc, type, arg0, arg1);
9524 /* If both arguments are constant, then try to evaluate it. */
9525 if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9526 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9527 && host_integerp (arg1, 0))
9529 /* Bound the maximum adjustment to twice the range of the
9530 mode's valid exponents. Use abs to ensure the range is
9531 positive as a sanity check. */
9532 const long max_exp_adj = 2 *
9533 labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9534 - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9536 /* Get the user-requested adjustment. */
9537 const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9539 /* The requested adjustment must be inside this range. This
9540 is a preliminary cap to avoid things like overflow, we
9541 may still fail to compute the result for other reasons. */
9542 if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9544 REAL_VALUE_TYPE initial_result;
9546 real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9548 /* Ensure we didn't overflow. */
9549 if (! real_isinf (&initial_result))
9551 const REAL_VALUE_TYPE trunc_result
9552 = real_value_truncate (TYPE_MODE (type), initial_result);
9554 /* Only proceed if the target mode can hold the
9556 if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9557 return build_real (type, trunc_result);
9566 /* Fold a call to builtin modf. */
9569 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9571 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9576 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9579 arg1 = build_fold_indirect_ref_loc (loc, arg1);
9581 /* Proceed if a valid pointer type was passed in. */
9582 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9584 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9585 REAL_VALUE_TYPE trunc, frac;
9591 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9592 trunc = frac = *value;
9595 /* For +-Inf, return (*arg1 = arg0, +-0). */
9597 frac.sign = value->sign;
9601 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9602 real_trunc (&trunc, VOIDmode, value);
9603 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9604 /* If the original number was negative and already
9605 integral, then the fractional part is -0.0. */
9606 if (value->sign && frac.cl == rvc_zero)
9607 frac.sign = value->sign;
9611 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9612 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9613 build_real (rettype, trunc));
9614 TREE_SIDE_EFFECTS (arg1) = 1;
9615 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9616 build_real (rettype, frac));
9622 /* Given a location LOC, an interclass builtin function decl FNDECL
9623 and its single argument ARG, return an folded expression computing
9624 the same, or NULL_TREE if we either couldn't or didn't want to fold
9625 (the latter happen if there's an RTL instruction available). */
9628 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9630 enum machine_mode mode;
9632 if (!validate_arg (arg, REAL_TYPE))
9635 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9638 mode = TYPE_MODE (TREE_TYPE (arg));
9640 /* If there is no optab, try generic code. */
9641 switch (DECL_FUNCTION_CODE (fndecl))
9645 CASE_FLT_FN (BUILT_IN_ISINF):
9647 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9648 tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9649 tree const type = TREE_TYPE (arg);
9653 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9654 real_from_string (&r, buf);
9655 result = build_call_expr (isgr_fn, 2,
9656 fold_build1_loc (loc, ABS_EXPR, type, arg),
9657 build_real (type, r));
9660 CASE_FLT_FN (BUILT_IN_FINITE):
9661 case BUILT_IN_ISFINITE:
9663 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9664 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9665 tree const type = TREE_TYPE (arg);
9669 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9670 real_from_string (&r, buf);
9671 result = build_call_expr (isle_fn, 2,
9672 fold_build1_loc (loc, ABS_EXPR, type, arg),
9673 build_real (type, r));
9674 /*result = fold_build2_loc (loc, UNGT_EXPR,
9675 TREE_TYPE (TREE_TYPE (fndecl)),
9676 fold_build1_loc (loc, ABS_EXPR, type, arg),
9677 build_real (type, r));
9678 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9679 TREE_TYPE (TREE_TYPE (fndecl)),
9683 case BUILT_IN_ISNORMAL:
9685 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9686 islessequal(fabs(x),DBL_MAX). */
9687 tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9688 tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9689 tree const type = TREE_TYPE (arg);
9690 REAL_VALUE_TYPE rmax, rmin;
9693 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9694 real_from_string (&rmax, buf);
9695 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9696 real_from_string (&rmin, buf);
9697 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9698 result = build_call_expr (isle_fn, 2, arg,
9699 build_real (type, rmax));
9700 result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9701 build_call_expr (isge_fn, 2, arg,
9702 build_real (type, rmin)));
9712 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9713 ARG is the argument for the call. */
9716 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9718 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9721 if (!validate_arg (arg, REAL_TYPE))
9724 switch (builtin_index)
9726 case BUILT_IN_ISINF:
9727 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9728 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9730 if (TREE_CODE (arg) == REAL_CST)
9732 r = TREE_REAL_CST (arg);
9733 if (real_isinf (&r))
9734 return real_compare (GT_EXPR, &r, &dconst0)
9735 ? integer_one_node : integer_minus_one_node;
9737 return integer_zero_node;
9742 case BUILT_IN_ISINF_SIGN:
9744 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9745 /* In a boolean context, GCC will fold the inner COND_EXPR to
9746 1. So e.g. "if (isinf_sign(x))" would be folded to just
9747 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9748 tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9749 tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9750 tree tmp = NULL_TREE;
9752 arg = builtin_save_expr (arg);
9754 if (signbit_fn && isinf_fn)
9756 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9757 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9759 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9760 signbit_call, integer_zero_node);
9761 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9762 isinf_call, integer_zero_node);
9764 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9765 integer_minus_one_node, integer_one_node);
9766 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9774 case BUILT_IN_ISFINITE:
9775 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9776 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9777 return omit_one_operand_loc (loc, type, integer_one_node, arg);
9779 if (TREE_CODE (arg) == REAL_CST)
9781 r = TREE_REAL_CST (arg);
9782 return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9787 case BUILT_IN_ISNAN:
9788 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9789 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9791 if (TREE_CODE (arg) == REAL_CST)
9793 r = TREE_REAL_CST (arg);
9794 return real_isnan (&r) ? integer_one_node : integer_zero_node;
9797 arg = builtin_save_expr (arg);
9798 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9805 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9806 This builtin will generate code to return the appropriate floating
9807 point classification depending on the value of the floating point
9808 number passed in. The possible return values must be supplied as
9809 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9810 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9811 one floating point argument which is "type generic". */
9814 fold_builtin_fpclassify (location_t loc, tree exp)
9816 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9817 arg, type, res, tmp;
9818 enum machine_mode mode;
9822 /* Verify the required arguments in the original call. */
9823 if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9824 INTEGER_TYPE, INTEGER_TYPE,
9825 INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9828 fp_nan = CALL_EXPR_ARG (exp, 0);
9829 fp_infinite = CALL_EXPR_ARG (exp, 1);
9830 fp_normal = CALL_EXPR_ARG (exp, 2);
9831 fp_subnormal = CALL_EXPR_ARG (exp, 3);
9832 fp_zero = CALL_EXPR_ARG (exp, 4);
9833 arg = CALL_EXPR_ARG (exp, 5);
9834 type = TREE_TYPE (arg);
9835 mode = TYPE_MODE (type);
9836 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9840 (fabs(x) == Inf ? FP_INFINITE :
9841 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9842 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9844 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9845 build_real (type, dconst0));
9846 res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9847 tmp, fp_zero, fp_subnormal);
9849 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9850 real_from_string (&r, buf);
9851 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9852 arg, build_real (type, r));
9853 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9855 if (HONOR_INFINITIES (mode))
9858 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9859 build_real (type, r));
9860 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9864 if (HONOR_NANS (mode))
9866 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9867 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9873 /* Fold a call to an unordered comparison function such as
9874 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9875 being called and ARG0 and ARG1 are the arguments for the call.
9876 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9877 the opposite of the desired result. UNORDERED_CODE is used
9878 for modes that can hold NaNs and ORDERED_CODE is used for
9882 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9883 enum tree_code unordered_code,
9884 enum tree_code ordered_code)
9886 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9887 enum tree_code code;
9889 enum tree_code code0, code1;
9890 tree cmp_type = NULL_TREE;
9892 type0 = TREE_TYPE (arg0);
9893 type1 = TREE_TYPE (arg1);
9895 code0 = TREE_CODE (type0);
9896 code1 = TREE_CODE (type1);
9898 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9899 /* Choose the wider of two real types. */
9900 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9902 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9904 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9907 arg0 = fold_convert_loc (loc, cmp_type, arg0);
9908 arg1 = fold_convert_loc (loc, cmp_type, arg1);
9910 if (unordered_code == UNORDERED_EXPR)
9912 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9913 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9914 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9917 code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9919 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9920 fold_build2_loc (loc, code, type, arg0, arg1));
9923 /* Fold a call to built-in function FNDECL with 0 arguments.
9924 IGNORE is true if the result of the function call is ignored. This
9925 function returns NULL_TREE if no simplification was possible. */
9928 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9930 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9931 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9934 CASE_FLT_FN (BUILT_IN_INF):
9935 case BUILT_IN_INFD32:
9936 case BUILT_IN_INFD64:
9937 case BUILT_IN_INFD128:
9938 return fold_builtin_inf (loc, type, true);
9940 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9941 return fold_builtin_inf (loc, type, false);
9943 case BUILT_IN_CLASSIFY_TYPE:
9944 return fold_builtin_classify_type (NULL_TREE);
9952 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9953 IGNORE is true if the result of the function call is ignored. This
9954 function returns NULL_TREE if no simplification was possible. */
9957 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9959 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9960 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9964 case BUILT_IN_CONSTANT_P:
9966 tree val = fold_builtin_constant_p (arg0);
9968 /* Gimplification will pull the CALL_EXPR for the builtin out of
9969 an if condition. When not optimizing, we'll not CSE it back.
9970 To avoid link error types of regressions, return false now. */
9971 if (!val && !optimize)
9972 val = integer_zero_node;
9977 case BUILT_IN_CLASSIFY_TYPE:
9978 return fold_builtin_classify_type (arg0);
9980 case BUILT_IN_STRLEN:
9981 return fold_builtin_strlen (loc, arg0);
9983 CASE_FLT_FN (BUILT_IN_FABS):
9984 return fold_builtin_fabs (loc, arg0, type);
9988 case BUILT_IN_LLABS:
9989 case BUILT_IN_IMAXABS:
9990 return fold_builtin_abs (loc, arg0, type);
9992 CASE_FLT_FN (BUILT_IN_CONJ):
9993 if (validate_arg (arg0, COMPLEX_TYPE)
9994 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9995 return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9998 CASE_FLT_FN (BUILT_IN_CREAL):
9999 if (validate_arg (arg0, COMPLEX_TYPE)
10000 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10001 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
10004 CASE_FLT_FN (BUILT_IN_CIMAG):
10005 if (validate_arg (arg0, COMPLEX_TYPE)
10006 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10007 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
10010 CASE_FLT_FN (BUILT_IN_CCOS):
10011 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
10013 CASE_FLT_FN (BUILT_IN_CCOSH):
10014 return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
10017 CASE_FLT_FN (BUILT_IN_CSIN):
10018 if (validate_arg (arg0, COMPLEX_TYPE)
10019 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10020 return do_mpc_arg1 (arg0, type, mpc_sin);
10023 CASE_FLT_FN (BUILT_IN_CSINH):
10024 if (validate_arg (arg0, COMPLEX_TYPE)
10025 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10026 return do_mpc_arg1 (arg0, type, mpc_sinh);
10029 CASE_FLT_FN (BUILT_IN_CTAN):
10030 if (validate_arg (arg0, COMPLEX_TYPE)
10031 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10032 return do_mpc_arg1 (arg0, type, mpc_tan);
10035 CASE_FLT_FN (BUILT_IN_CTANH):
10036 if (validate_arg (arg0, COMPLEX_TYPE)
10037 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10038 return do_mpc_arg1 (arg0, type, mpc_tanh);
10041 CASE_FLT_FN (BUILT_IN_CLOG):
10042 if (validate_arg (arg0, COMPLEX_TYPE)
10043 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10044 return do_mpc_arg1 (arg0, type, mpc_log);
10047 CASE_FLT_FN (BUILT_IN_CSQRT):
10048 if (validate_arg (arg0, COMPLEX_TYPE)
10049 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10050 return do_mpc_arg1 (arg0, type, mpc_sqrt);
10053 #ifdef HAVE_mpc_arc
10054 CASE_FLT_FN (BUILT_IN_CASIN):
10055 if (validate_arg (arg0, COMPLEX_TYPE)
10056 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10057 return do_mpc_arg1 (arg0, type, mpc_asin);
10060 CASE_FLT_FN (BUILT_IN_CACOS):
10061 if (validate_arg (arg0, COMPLEX_TYPE)
10062 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10063 return do_mpc_arg1 (arg0, type, mpc_acos);
10066 CASE_FLT_FN (BUILT_IN_CATAN):
10067 if (validate_arg (arg0, COMPLEX_TYPE)
10068 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10069 return do_mpc_arg1 (arg0, type, mpc_atan);
10072 CASE_FLT_FN (BUILT_IN_CASINH):
10073 if (validate_arg (arg0, COMPLEX_TYPE)
10074 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10075 return do_mpc_arg1 (arg0, type, mpc_asinh);
10078 CASE_FLT_FN (BUILT_IN_CACOSH):
10079 if (validate_arg (arg0, COMPLEX_TYPE)
10080 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10081 return do_mpc_arg1 (arg0, type, mpc_acosh);
10084 CASE_FLT_FN (BUILT_IN_CATANH):
10085 if (validate_arg (arg0, COMPLEX_TYPE)
10086 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10087 return do_mpc_arg1 (arg0, type, mpc_atanh);
10089 #endif /* HAVE_mpc_arc */
10090 #endif /* HAVE_mpc */
10092 CASE_FLT_FN (BUILT_IN_CABS):
10093 return fold_builtin_cabs (loc, arg0, type, fndecl);
10095 CASE_FLT_FN (BUILT_IN_CARG):
10096 return fold_builtin_carg (loc, arg0, type);
10098 CASE_FLT_FN (BUILT_IN_SQRT):
10099 return fold_builtin_sqrt (loc, arg0, type);
10101 CASE_FLT_FN (BUILT_IN_CBRT):
10102 return fold_builtin_cbrt (loc, arg0, type);
10104 CASE_FLT_FN (BUILT_IN_ASIN):
10105 if (validate_arg (arg0, REAL_TYPE))
10106 return do_mpfr_arg1 (arg0, type, mpfr_asin,
10107 &dconstm1, &dconst1, true);
10110 CASE_FLT_FN (BUILT_IN_ACOS):
10111 if (validate_arg (arg0, REAL_TYPE))
10112 return do_mpfr_arg1 (arg0, type, mpfr_acos,
10113 &dconstm1, &dconst1, true);
10116 CASE_FLT_FN (BUILT_IN_ATAN):
10117 if (validate_arg (arg0, REAL_TYPE))
10118 return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10121 CASE_FLT_FN (BUILT_IN_ASINH):
10122 if (validate_arg (arg0, REAL_TYPE))
10123 return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10126 CASE_FLT_FN (BUILT_IN_ACOSH):
10127 if (validate_arg (arg0, REAL_TYPE))
10128 return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10129 &dconst1, NULL, true);
10132 CASE_FLT_FN (BUILT_IN_ATANH):
10133 if (validate_arg (arg0, REAL_TYPE))
10134 return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10135 &dconstm1, &dconst1, false);
10138 CASE_FLT_FN (BUILT_IN_SIN):
10139 if (validate_arg (arg0, REAL_TYPE))
10140 return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10143 CASE_FLT_FN (BUILT_IN_COS):
10144 return fold_builtin_cos (loc, arg0, type, fndecl);
10146 CASE_FLT_FN (BUILT_IN_TAN):
10147 return fold_builtin_tan (arg0, type);
10149 CASE_FLT_FN (BUILT_IN_CEXP):
10150 return fold_builtin_cexp (loc, arg0, type);
10152 CASE_FLT_FN (BUILT_IN_CEXPI):
10153 if (validate_arg (arg0, REAL_TYPE))
10154 return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10157 CASE_FLT_FN (BUILT_IN_SINH):
10158 if (validate_arg (arg0, REAL_TYPE))
10159 return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10162 CASE_FLT_FN (BUILT_IN_COSH):
10163 return fold_builtin_cosh (loc, arg0, type, fndecl);
10165 CASE_FLT_FN (BUILT_IN_TANH):
10166 if (validate_arg (arg0, REAL_TYPE))
10167 return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10170 CASE_FLT_FN (BUILT_IN_ERF):
10171 if (validate_arg (arg0, REAL_TYPE))
10172 return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10175 CASE_FLT_FN (BUILT_IN_ERFC):
10176 if (validate_arg (arg0, REAL_TYPE))
10177 return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10180 CASE_FLT_FN (BUILT_IN_TGAMMA):
10181 if (validate_arg (arg0, REAL_TYPE))
10182 return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10185 CASE_FLT_FN (BUILT_IN_EXP):
10186 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10188 CASE_FLT_FN (BUILT_IN_EXP2):
10189 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10191 CASE_FLT_FN (BUILT_IN_EXP10):
10192 CASE_FLT_FN (BUILT_IN_POW10):
10193 return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10195 CASE_FLT_FN (BUILT_IN_EXPM1):
10196 if (validate_arg (arg0, REAL_TYPE))
10197 return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10200 CASE_FLT_FN (BUILT_IN_LOG):
10201 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10203 CASE_FLT_FN (BUILT_IN_LOG2):
10204 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10206 CASE_FLT_FN (BUILT_IN_LOG10):
10207 return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10209 CASE_FLT_FN (BUILT_IN_LOG1P):
10210 if (validate_arg (arg0, REAL_TYPE))
10211 return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10212 &dconstm1, NULL, false);
10215 CASE_FLT_FN (BUILT_IN_J0):
10216 if (validate_arg (arg0, REAL_TYPE))
10217 return do_mpfr_arg1 (arg0, type, mpfr_j0,
10221 CASE_FLT_FN (BUILT_IN_J1):
10222 if (validate_arg (arg0, REAL_TYPE))
10223 return do_mpfr_arg1 (arg0, type, mpfr_j1,
10227 CASE_FLT_FN (BUILT_IN_Y0):
10228 if (validate_arg (arg0, REAL_TYPE))
10229 return do_mpfr_arg1 (arg0, type, mpfr_y0,
10230 &dconst0, NULL, false);
10233 CASE_FLT_FN (BUILT_IN_Y1):
10234 if (validate_arg (arg0, REAL_TYPE))
10235 return do_mpfr_arg1 (arg0, type, mpfr_y1,
10236 &dconst0, NULL, false);
10239 CASE_FLT_FN (BUILT_IN_NAN):
10240 case BUILT_IN_NAND32:
10241 case BUILT_IN_NAND64:
10242 case BUILT_IN_NAND128:
10243 return fold_builtin_nan (arg0, type, true);
10245 CASE_FLT_FN (BUILT_IN_NANS):
10246 return fold_builtin_nan (arg0, type, false);
10248 CASE_FLT_FN (BUILT_IN_FLOOR):
10249 return fold_builtin_floor (loc, fndecl, arg0);
10251 CASE_FLT_FN (BUILT_IN_CEIL):
10252 return fold_builtin_ceil (loc, fndecl, arg0);
10254 CASE_FLT_FN (BUILT_IN_TRUNC):
10255 return fold_builtin_trunc (loc, fndecl, arg0);
10257 CASE_FLT_FN (BUILT_IN_ROUND):
10258 return fold_builtin_round (loc, fndecl, arg0);
10260 CASE_FLT_FN (BUILT_IN_NEARBYINT):
10261 CASE_FLT_FN (BUILT_IN_RINT):
10262 return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10264 CASE_FLT_FN (BUILT_IN_LCEIL):
10265 CASE_FLT_FN (BUILT_IN_LLCEIL):
10266 CASE_FLT_FN (BUILT_IN_LFLOOR):
10267 CASE_FLT_FN (BUILT_IN_LLFLOOR):
10268 CASE_FLT_FN (BUILT_IN_LROUND):
10269 CASE_FLT_FN (BUILT_IN_LLROUND):
10270 return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10272 CASE_FLT_FN (BUILT_IN_LRINT):
10273 CASE_FLT_FN (BUILT_IN_LLRINT):
10274 return fold_fixed_mathfn (loc, fndecl, arg0);
10276 case BUILT_IN_BSWAP32:
10277 case BUILT_IN_BSWAP64:
10278 return fold_builtin_bswap (fndecl, arg0);
10280 CASE_INT_FN (BUILT_IN_FFS):
10281 CASE_INT_FN (BUILT_IN_CLZ):
10282 CASE_INT_FN (BUILT_IN_CTZ):
10283 CASE_INT_FN (BUILT_IN_POPCOUNT):
10284 CASE_INT_FN (BUILT_IN_PARITY):
10285 return fold_builtin_bitop (fndecl, arg0);
10287 CASE_FLT_FN (BUILT_IN_SIGNBIT):
10288 return fold_builtin_signbit (loc, arg0, type);
10290 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10291 return fold_builtin_significand (loc, arg0, type);
10293 CASE_FLT_FN (BUILT_IN_ILOGB):
10294 CASE_FLT_FN (BUILT_IN_LOGB):
10295 return fold_builtin_logb (loc, arg0, type);
10297 case BUILT_IN_ISASCII:
10298 return fold_builtin_isascii (loc, arg0);
10300 case BUILT_IN_TOASCII:
10301 return fold_builtin_toascii (loc, arg0);
10303 case BUILT_IN_ISDIGIT:
10304 return fold_builtin_isdigit (loc, arg0);
10306 CASE_FLT_FN (BUILT_IN_FINITE):
10307 case BUILT_IN_FINITED32:
10308 case BUILT_IN_FINITED64:
10309 case BUILT_IN_FINITED128:
10310 case BUILT_IN_ISFINITE:
10312 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10315 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10318 CASE_FLT_FN (BUILT_IN_ISINF):
10319 case BUILT_IN_ISINFD32:
10320 case BUILT_IN_ISINFD64:
10321 case BUILT_IN_ISINFD128:
10323 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10326 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10329 case BUILT_IN_ISNORMAL:
10330 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10332 case BUILT_IN_ISINF_SIGN:
10333 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10335 CASE_FLT_FN (BUILT_IN_ISNAN):
10336 case BUILT_IN_ISNAND32:
10337 case BUILT_IN_ISNAND64:
10338 case BUILT_IN_ISNAND128:
10339 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10341 case BUILT_IN_PRINTF:
10342 case BUILT_IN_PRINTF_UNLOCKED:
10343 case BUILT_IN_VPRINTF:
10344 return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10354 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10355 IGNORE is true if the result of the function call is ignored. This
10356 function returns NULL_TREE if no simplification was possible. */
10359 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10361 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10362 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10366 CASE_FLT_FN (BUILT_IN_JN):
10367 if (validate_arg (arg0, INTEGER_TYPE)
10368 && validate_arg (arg1, REAL_TYPE))
10369 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10372 CASE_FLT_FN (BUILT_IN_YN):
10373 if (validate_arg (arg0, INTEGER_TYPE)
10374 && validate_arg (arg1, REAL_TYPE))
10375 return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10379 CASE_FLT_FN (BUILT_IN_DREM):
10380 CASE_FLT_FN (BUILT_IN_REMAINDER):
10381 if (validate_arg (arg0, REAL_TYPE)
10382 && validate_arg(arg1, REAL_TYPE))
10383 return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10386 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10387 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10388 if (validate_arg (arg0, REAL_TYPE)
10389 && validate_arg(arg1, POINTER_TYPE))
10390 return do_mpfr_lgamma_r (arg0, arg1, type);
10393 CASE_FLT_FN (BUILT_IN_ATAN2):
10394 if (validate_arg (arg0, REAL_TYPE)
10395 && validate_arg(arg1, REAL_TYPE))
10396 return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10399 CASE_FLT_FN (BUILT_IN_FDIM):
10400 if (validate_arg (arg0, REAL_TYPE)
10401 && validate_arg(arg1, REAL_TYPE))
10402 return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10405 CASE_FLT_FN (BUILT_IN_HYPOT):
10406 return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10408 #ifdef HAVE_mpc_pow
10409 CASE_FLT_FN (BUILT_IN_CPOW):
10410 if (validate_arg (arg0, COMPLEX_TYPE)
10411 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10412 && validate_arg (arg1, COMPLEX_TYPE)
10413 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10414 return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10418 CASE_FLT_FN (BUILT_IN_LDEXP):
10419 return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10420 CASE_FLT_FN (BUILT_IN_SCALBN):
10421 CASE_FLT_FN (BUILT_IN_SCALBLN):
10422 return fold_builtin_load_exponent (loc, arg0, arg1,
10423 type, /*ldexp=*/false);
10425 CASE_FLT_FN (BUILT_IN_FREXP):
10426 return fold_builtin_frexp (loc, arg0, arg1, type);
10428 CASE_FLT_FN (BUILT_IN_MODF):
10429 return fold_builtin_modf (loc, arg0, arg1, type);
10431 case BUILT_IN_BZERO:
10432 return fold_builtin_bzero (loc, arg0, arg1, ignore);
10434 case BUILT_IN_FPUTS:
10435 return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10437 case BUILT_IN_FPUTS_UNLOCKED:
10438 return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10440 case BUILT_IN_STRSTR:
10441 return fold_builtin_strstr (loc, arg0, arg1, type);
10443 case BUILT_IN_STRCAT:
10444 return fold_builtin_strcat (loc, arg0, arg1);
10446 case BUILT_IN_STRSPN:
10447 return fold_builtin_strspn (loc, arg0, arg1);
10449 case BUILT_IN_STRCSPN:
10450 return fold_builtin_strcspn (loc, arg0, arg1);
10452 case BUILT_IN_STRCHR:
10453 case BUILT_IN_INDEX:
10454 return fold_builtin_strchr (loc, arg0, arg1, type);
10456 case BUILT_IN_STRRCHR:
10457 case BUILT_IN_RINDEX:
10458 return fold_builtin_strrchr (loc, arg0, arg1, type);
10460 case BUILT_IN_STRCPY:
10461 return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10463 case BUILT_IN_STPCPY:
10466 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10470 return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10473 return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10476 case BUILT_IN_STRCMP:
10477 return fold_builtin_strcmp (loc, arg0, arg1);
10479 case BUILT_IN_STRPBRK:
10480 return fold_builtin_strpbrk (loc, arg0, arg1, type);
10482 case BUILT_IN_EXPECT:
10483 return fold_builtin_expect (loc, arg0, arg1);
10485 CASE_FLT_FN (BUILT_IN_POW):
10486 return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10488 CASE_FLT_FN (BUILT_IN_POWI):
10489 return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10491 CASE_FLT_FN (BUILT_IN_COPYSIGN):
10492 return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10494 CASE_FLT_FN (BUILT_IN_FMIN):
10495 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10497 CASE_FLT_FN (BUILT_IN_FMAX):
10498 return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10500 case BUILT_IN_ISGREATER:
10501 return fold_builtin_unordered_cmp (loc, fndecl,
10502 arg0, arg1, UNLE_EXPR, LE_EXPR);
10503 case BUILT_IN_ISGREATEREQUAL:
10504 return fold_builtin_unordered_cmp (loc, fndecl,
10505 arg0, arg1, UNLT_EXPR, LT_EXPR);
10506 case BUILT_IN_ISLESS:
10507 return fold_builtin_unordered_cmp (loc, fndecl,
10508 arg0, arg1, UNGE_EXPR, GE_EXPR);
10509 case BUILT_IN_ISLESSEQUAL:
10510 return fold_builtin_unordered_cmp (loc, fndecl,
10511 arg0, arg1, UNGT_EXPR, GT_EXPR);
10512 case BUILT_IN_ISLESSGREATER:
10513 return fold_builtin_unordered_cmp (loc, fndecl,
10514 arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10515 case BUILT_IN_ISUNORDERED:
10516 return fold_builtin_unordered_cmp (loc, fndecl,
10517 arg0, arg1, UNORDERED_EXPR,
10520 /* We do the folding for va_start in the expander. */
10521 case BUILT_IN_VA_START:
10524 case BUILT_IN_SPRINTF:
10525 return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10527 case BUILT_IN_OBJECT_SIZE:
10528 return fold_builtin_object_size (arg0, arg1);
10530 case BUILT_IN_PRINTF:
10531 case BUILT_IN_PRINTF_UNLOCKED:
10532 case BUILT_IN_VPRINTF:
10533 return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10535 case BUILT_IN_PRINTF_CHK:
10536 case BUILT_IN_VPRINTF_CHK:
10537 if (!validate_arg (arg0, INTEGER_TYPE)
10538 || TREE_SIDE_EFFECTS (arg0))
10541 return fold_builtin_printf (loc, fndecl,
10542 arg1, NULL_TREE, ignore, fcode);
10545 case BUILT_IN_FPRINTF:
10546 case BUILT_IN_FPRINTF_UNLOCKED:
10547 case BUILT_IN_VFPRINTF:
10548 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10557 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10558 and ARG2. IGNORE is true if the result of the function call is ignored.
10559 This function returns NULL_TREE if no simplification was possible. */
10562 fold_builtin_3 (location_t loc, tree fndecl,
10563 tree arg0, tree arg1, tree arg2, bool ignore)
10565 tree type = TREE_TYPE (TREE_TYPE (fndecl));
10566 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10570 CASE_FLT_FN (BUILT_IN_SINCOS):
10571 return fold_builtin_sincos (loc, arg0, arg1, arg2);
10573 CASE_FLT_FN (BUILT_IN_FMA):
10574 if (validate_arg (arg0, REAL_TYPE)
10575 && validate_arg(arg1, REAL_TYPE)
10576 && validate_arg(arg2, REAL_TYPE))
10577 return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10580 CASE_FLT_FN (BUILT_IN_REMQUO):
10581 if (validate_arg (arg0, REAL_TYPE)
10582 && validate_arg(arg1, REAL_TYPE)
10583 && validate_arg(arg2, POINTER_TYPE))
10584 return do_mpfr_remquo (arg0, arg1, arg2);
10587 case BUILT_IN_MEMSET:
10588 return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10590 case BUILT_IN_BCOPY:
10591 return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10592 void_type_node, true, /*endp=*/3);
10594 case BUILT_IN_MEMCPY:
10595 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10596 type, ignore, /*endp=*/0);
10598 case BUILT_IN_MEMPCPY:
10599 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10600 type, ignore, /*endp=*/1);
10602 case BUILT_IN_MEMMOVE:
10603 return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10604 type, ignore, /*endp=*/3);
10606 case BUILT_IN_STRNCAT:
10607 return fold_builtin_strncat (loc, arg0, arg1, arg2);
10609 case BUILT_IN_STRNCPY:
10610 return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10612 case BUILT_IN_STRNCMP:
10613 return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10615 case BUILT_IN_MEMCHR:
10616 return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10618 case BUILT_IN_BCMP:
10619 case BUILT_IN_MEMCMP:
10620 return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10622 case BUILT_IN_SPRINTF:
10623 return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10625 case BUILT_IN_STRCPY_CHK:
10626 case BUILT_IN_STPCPY_CHK:
10627 return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10630 case BUILT_IN_STRCAT_CHK:
10631 return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10633 case BUILT_IN_PRINTF_CHK:
10634 case BUILT_IN_VPRINTF_CHK:
10635 if (!validate_arg (arg0, INTEGER_TYPE)
10636 || TREE_SIDE_EFFECTS (arg0))
10639 return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10642 case BUILT_IN_FPRINTF:
10643 case BUILT_IN_FPRINTF_UNLOCKED:
10644 case BUILT_IN_VFPRINTF:
10645 return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10648 case BUILT_IN_FPRINTF_CHK:
10649 case BUILT_IN_VFPRINTF_CHK:
10650 if (!validate_arg (arg1, INTEGER_TYPE)
10651 || TREE_SIDE_EFFECTS (arg1))
10654 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10663 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10664 ARG2, and ARG3. IGNORE is true if the result of the function call is
10665 ignored. This function returns NULL_TREE if no simplification was
10669 fold_builtin_4 (location_t loc, tree fndecl,
10670 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10672 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10676 case BUILT_IN_MEMCPY_CHK:
10677 case BUILT_IN_MEMPCPY_CHK:
10678 case BUILT_IN_MEMMOVE_CHK:
10679 case BUILT_IN_MEMSET_CHK:
10680 return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10682 DECL_FUNCTION_CODE (fndecl));
10684 case BUILT_IN_STRNCPY_CHK:
10685 return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10687 case BUILT_IN_STRNCAT_CHK:
10688 return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10690 case BUILT_IN_FPRINTF_CHK:
10691 case BUILT_IN_VFPRINTF_CHK:
10692 if (!validate_arg (arg1, INTEGER_TYPE)
10693 || TREE_SIDE_EFFECTS (arg1))
10696 return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10706 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10707 arguments, where NARGS <= 4. IGNORE is true if the result of the
10708 function call is ignored. This function returns NULL_TREE if no
10709 simplification was possible. Note that this only folds builtins with
10710 fixed argument patterns. Foldings that do varargs-to-varargs
10711 transformations, or that match calls with more than 4 arguments,
10712 need to be handled with fold_builtin_varargs instead. */
10714 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10717 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10719 tree ret = NULL_TREE;
10724 ret = fold_builtin_0 (loc, fndecl, ignore);
10727 ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10730 ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10733 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10736 ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10744 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10745 SET_EXPR_LOCATION (ret, loc);
10746 TREE_NO_WARNING (ret) = 1;
10752 /* Builtins with folding operations that operate on "..." arguments
10753 need special handling; we need to store the arguments in a convenient
10754 data structure before attempting any folding. Fortunately there are
10755 only a few builtins that fall into this category. FNDECL is the
10756 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10757 result of the function call is ignored. */
10760 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10761 bool ignore ATTRIBUTE_UNUSED)
10763 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10764 tree ret = NULL_TREE;
10768 case BUILT_IN_SPRINTF_CHK:
10769 case BUILT_IN_VSPRINTF_CHK:
10770 ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10773 case BUILT_IN_SNPRINTF_CHK:
10774 case BUILT_IN_VSNPRINTF_CHK:
10775 ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10778 case BUILT_IN_FPCLASSIFY:
10779 ret = fold_builtin_fpclassify (loc, exp);
10787 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10788 SET_EXPR_LOCATION (ret, loc);
10789 TREE_NO_WARNING (ret) = 1;
10795 /* Return true if FNDECL shouldn't be folded right now.
10796 If a built-in function has an inline attribute always_inline
10797 wrapper, defer folding it after always_inline functions have
10798 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10799 might not be performed. */
10802 avoid_folding_inline_builtin (tree fndecl)
10804 return (DECL_DECLARED_INLINE_P (fndecl)
10805 && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10807 && !cfun->always_inline_functions_inlined
10808 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10811 /* A wrapper function for builtin folding that prevents warnings for
10812 "statement without effect" and the like, caused by removing the
10813 call node earlier than the warning is generated. */
10816 fold_call_expr (location_t loc, tree exp, bool ignore)
10818 tree ret = NULL_TREE;
10819 tree fndecl = get_callee_fndecl (exp);
10821 && TREE_CODE (fndecl) == FUNCTION_DECL
10822 && DECL_BUILT_IN (fndecl)
10823 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10824 yet. Defer folding until we see all the arguments
10825 (after inlining). */
10826 && !CALL_EXPR_VA_ARG_PACK (exp))
10828 int nargs = call_expr_nargs (exp);
10830 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10831 instead last argument is __builtin_va_arg_pack (). Defer folding
10832 even in that case, until arguments are finalized. */
10833 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10835 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10837 && TREE_CODE (fndecl2) == FUNCTION_DECL
10838 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10839 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10843 if (avoid_folding_inline_builtin (fndecl))
10846 /* FIXME: Don't use a list in this interface. */
10847 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10848 return targetm.fold_builtin (fndecl, CALL_EXPR_ARGS (exp), ignore);
10851 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10853 tree *args = CALL_EXPR_ARGP (exp);
10854 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10857 ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10865 /* Conveniently construct a function call expression. FNDECL names the
10866 function to be called and ARGLIST is a TREE_LIST of arguments. */
10869 build_function_call_expr (location_t loc, tree fndecl, tree arglist)
10871 tree fntype = TREE_TYPE (fndecl);
10872 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10873 int n = list_length (arglist);
10874 tree *argarray = (tree *) alloca (n * sizeof (tree));
10877 for (i = 0; i < n; i++, arglist = TREE_CHAIN (arglist))
10878 argarray[i] = TREE_VALUE (arglist);
10879 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10882 /* Conveniently construct a function call expression. FNDECL names the
10883 function to be called, N is the number of arguments, and the "..."
10884 parameters are the argument expressions. */
10887 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10890 tree fntype = TREE_TYPE (fndecl);
10891 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10892 tree *argarray = (tree *) alloca (n * sizeof (tree));
10896 for (i = 0; i < n; i++)
10897 argarray[i] = va_arg (ap, tree);
10899 return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10902 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10903 N arguments are passed in the array ARGARRAY. */
10906 fold_builtin_call_array (location_t loc, tree type,
10911 tree ret = NULL_TREE;
10915 if (TREE_CODE (fn) == ADDR_EXPR)
10917 tree fndecl = TREE_OPERAND (fn, 0);
10918 if (TREE_CODE (fndecl) == FUNCTION_DECL
10919 && DECL_BUILT_IN (fndecl))
10921 /* If last argument is __builtin_va_arg_pack (), arguments to this
10922 function are not finalized yet. Defer folding until they are. */
10923 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10925 tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10927 && TREE_CODE (fndecl2) == FUNCTION_DECL
10928 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10929 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10930 return build_call_array_loc (loc, type, fn, n, argarray);
10932 if (avoid_folding_inline_builtin (fndecl))
10933 return build_call_array_loc (loc, type, fn, n, argarray);
10934 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10936 tree arglist = NULL_TREE;
10937 for (i = n - 1; i >= 0; i--)
10938 arglist = tree_cons (NULL_TREE, argarray[i], arglist);
10939 ret = targetm.fold_builtin (fndecl, arglist, false);
10942 return build_call_array_loc (loc, type, fn, n, argarray);
10944 else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10946 /* First try the transformations that don't require consing up
10948 ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10953 /* If we got this far, we need to build an exp. */
10954 exp = build_call_array_loc (loc, type, fn, n, argarray);
10955 ret = fold_builtin_varargs (loc, fndecl, exp, false);
10956 return ret ? ret : exp;
10960 return build_call_array_loc (loc, type, fn, n, argarray);
10963 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10964 along with N new arguments specified as the "..." parameters. SKIP
10965 is the number of arguments in EXP to be omitted. This function is used
10966 to do varargs-to-varargs transformations. */
10969 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10971 int oldnargs = call_expr_nargs (exp);
10972 int nargs = oldnargs - skip + n;
10973 tree fntype = TREE_TYPE (fndecl);
10974 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10982 buffer = XALLOCAVEC (tree, nargs);
10984 for (i = 0; i < n; i++)
10985 buffer[i] = va_arg (ap, tree);
10987 for (j = skip; j < oldnargs; j++, i++)
10988 buffer[i] = CALL_EXPR_ARG (exp, j);
10991 buffer = CALL_EXPR_ARGP (exp) + skip;
10993 return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
10996 /* Validate a single argument ARG against a tree code CODE representing
11000 validate_arg (const_tree arg, enum tree_code code)
11004 else if (code == POINTER_TYPE)
11005 return POINTER_TYPE_P (TREE_TYPE (arg));
11006 else if (code == INTEGER_TYPE)
11007 return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11008 return code == TREE_CODE (TREE_TYPE (arg));
11011 /* This function validates the types of a function call argument list
11012 against a specified list of tree_codes. If the last specifier is a 0,
11013 that represents an ellipses, otherwise the last specifier must be a
11016 This is the GIMPLE version of validate_arglist. Eventually we want to
11017 completely convert builtins.c to work from GIMPLEs and the tree based
11018 validate_arglist will then be removed. */
11021 validate_gimple_arglist (const_gimple call, ...)
11023 enum tree_code code;
11029 va_start (ap, call);
11034 code = (enum tree_code) va_arg (ap, int);
11038 /* This signifies an ellipses, any further arguments are all ok. */
11042 /* This signifies an endlink, if no arguments remain, return
11043 true, otherwise return false. */
11044 res = (i == gimple_call_num_args (call));
11047 /* If no parameters remain or the parameter's code does not
11048 match the specified code, return false. Otherwise continue
11049 checking any remaining arguments. */
11050 arg = gimple_call_arg (call, i++);
11051 if (!validate_arg (arg, code))
11058 /* We need gotos here since we can only have one VA_CLOSE in a
11066 /* This function validates the types of a function call argument list
11067 against a specified list of tree_codes. If the last specifier is a 0,
11068 that represents an ellipses, otherwise the last specifier must be a
11072 validate_arglist (const_tree callexpr, ...)
11074 enum tree_code code;
11077 const_call_expr_arg_iterator iter;
11080 va_start (ap, callexpr);
11081 init_const_call_expr_arg_iterator (callexpr, &iter);
11085 code = (enum tree_code) va_arg (ap, int);
11089 /* This signifies an ellipses, any further arguments are all ok. */
11093 /* This signifies an endlink, if no arguments remain, return
11094 true, otherwise return false. */
11095 res = !more_const_call_expr_args_p (&iter);
11098 /* If no parameters remain or the parameter's code does not
11099 match the specified code, return false. Otherwise continue
11100 checking any remaining arguments. */
11101 arg = next_const_call_expr_arg (&iter);
11102 if (!validate_arg (arg, code))
11109 /* We need gotos here since we can only have one VA_CLOSE in a
11117 /* Default target-specific builtin expander that does nothing. */
11120 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11121 rtx target ATTRIBUTE_UNUSED,
11122 rtx subtarget ATTRIBUTE_UNUSED,
11123 enum machine_mode mode ATTRIBUTE_UNUSED,
11124 int ignore ATTRIBUTE_UNUSED)
11129 /* Returns true is EXP represents data that would potentially reside
11130 in a readonly section. */
11133 readonly_data_expr (tree exp)
11137 if (TREE_CODE (exp) != ADDR_EXPR)
11140 exp = get_base_address (TREE_OPERAND (exp, 0));
11144 /* Make sure we call decl_readonly_section only for trees it
11145 can handle (since it returns true for everything it doesn't
11147 if (TREE_CODE (exp) == STRING_CST
11148 || TREE_CODE (exp) == CONSTRUCTOR
11149 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11150 return decl_readonly_section (exp, 0);
11155 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11156 to the call, and TYPE is its return type.
11158 Return NULL_TREE if no simplification was possible, otherwise return the
11159 simplified form of the call as a tree.
11161 The simplified form may be a constant or other expression which
11162 computes the same value, but in a more efficient manner (including
11163 calls to other builtin functions).
11165 The call may contain arguments which need to be evaluated, but
11166 which are not useful to determine the result of the call. In
11167 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11168 COMPOUND_EXPR will be an argument which must be evaluated.
11169 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11170 COMPOUND_EXPR in the chain will contain the tree for the simplified
11171 form of the builtin function call. */
11174 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11176 if (!validate_arg (s1, POINTER_TYPE)
11177 || !validate_arg (s2, POINTER_TYPE))
11182 const char *p1, *p2;
11184 p2 = c_getstr (s2);
11188 p1 = c_getstr (s1);
11191 const char *r = strstr (p1, p2);
11195 return build_int_cst (TREE_TYPE (s1), 0);
11197 /* Return an offset into the constant string argument. */
11198 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11199 s1, size_int (r - p1));
11200 return fold_convert_loc (loc, type, tem);
11203 /* The argument is const char *, and the result is char *, so we need
11204 a type conversion here to avoid a warning. */
11206 return fold_convert_loc (loc, type, s1);
11211 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11215 /* New argument list transforming strstr(s1, s2) to
11216 strchr(s1, s2[0]). */
11217 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11221 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11222 the call, and TYPE is its return type.
11224 Return NULL_TREE if no simplification was possible, otherwise return the
11225 simplified form of the call as a tree.
11227 The simplified form may be a constant or other expression which
11228 computes the same value, but in a more efficient manner (including
11229 calls to other builtin functions).
11231 The call may contain arguments which need to be evaluated, but
11232 which are not useful to determine the result of the call. In
11233 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11234 COMPOUND_EXPR will be an argument which must be evaluated.
11235 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11236 COMPOUND_EXPR in the chain will contain the tree for the simplified
11237 form of the builtin function call. */
11240 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11242 if (!validate_arg (s1, POINTER_TYPE)
11243 || !validate_arg (s2, INTEGER_TYPE))
11249 if (TREE_CODE (s2) != INTEGER_CST)
11252 p1 = c_getstr (s1);
11259 if (target_char_cast (s2, &c))
11262 r = strchr (p1, c);
11265 return build_int_cst (TREE_TYPE (s1), 0);
11267 /* Return an offset into the constant string argument. */
11268 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11269 s1, size_int (r - p1));
11270 return fold_convert_loc (loc, type, tem);
11276 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11277 the call, and TYPE is its return type.
11279 Return NULL_TREE if no simplification was possible, otherwise return the
11280 simplified form of the call as a tree.
11282 The simplified form may be a constant or other expression which
11283 computes the same value, but in a more efficient manner (including
11284 calls to other builtin functions).
11286 The call may contain arguments which need to be evaluated, but
11287 which are not useful to determine the result of the call. In
11288 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11289 COMPOUND_EXPR will be an argument which must be evaluated.
11290 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11291 COMPOUND_EXPR in the chain will contain the tree for the simplified
11292 form of the builtin function call. */
11295 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11297 if (!validate_arg (s1, POINTER_TYPE)
11298 || !validate_arg (s2, INTEGER_TYPE))
11305 if (TREE_CODE (s2) != INTEGER_CST)
11308 p1 = c_getstr (s1);
11315 if (target_char_cast (s2, &c))
11318 r = strrchr (p1, c);
11321 return build_int_cst (TREE_TYPE (s1), 0);
11323 /* Return an offset into the constant string argument. */
11324 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11325 s1, size_int (r - p1));
11326 return fold_convert_loc (loc, type, tem);
11329 if (! integer_zerop (s2))
11332 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11336 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11337 return build_call_expr_loc (loc, fn, 2, s1, s2);
11341 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11342 to the call, and TYPE is its return type.
11344 Return NULL_TREE if no simplification was possible, otherwise return the
11345 simplified form of the call as a tree.
11347 The simplified form may be a constant or other expression which
11348 computes the same value, but in a more efficient manner (including
11349 calls to other builtin functions).
11351 The call may contain arguments which need to be evaluated, but
11352 which are not useful to determine the result of the call. In
11353 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11354 COMPOUND_EXPR will be an argument which must be evaluated.
11355 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11356 COMPOUND_EXPR in the chain will contain the tree for the simplified
11357 form of the builtin function call. */
11360 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11362 if (!validate_arg (s1, POINTER_TYPE)
11363 || !validate_arg (s2, POINTER_TYPE))
11368 const char *p1, *p2;
11370 p2 = c_getstr (s2);
11374 p1 = c_getstr (s1);
11377 const char *r = strpbrk (p1, p2);
11381 return build_int_cst (TREE_TYPE (s1), 0);
11383 /* Return an offset into the constant string argument. */
11384 tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11385 s1, size_int (r - p1));
11386 return fold_convert_loc (loc, type, tem);
11390 /* strpbrk(x, "") == NULL.
11391 Evaluate and ignore s1 in case it had side-effects. */
11392 return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11395 return NULL_TREE; /* Really call strpbrk. */
11397 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11401 /* New argument list transforming strpbrk(s1, s2) to
11402 strchr(s1, s2[0]). */
11403 return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11407 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11410 Return NULL_TREE if no simplification was possible, otherwise return the
11411 simplified form of the call as a tree.
11413 The simplified form may be a constant or other expression which
11414 computes the same value, but in a more efficient manner (including
11415 calls to other builtin functions).
11417 The call may contain arguments which need to be evaluated, but
11418 which are not useful to determine the result of the call. In
11419 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11420 COMPOUND_EXPR will be an argument which must be evaluated.
11421 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11422 COMPOUND_EXPR in the chain will contain the tree for the simplified
11423 form of the builtin function call. */
11426 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11428 if (!validate_arg (dst, POINTER_TYPE)
11429 || !validate_arg (src, POINTER_TYPE))
11433 const char *p = c_getstr (src);
11435 /* If the string length is zero, return the dst parameter. */
11436 if (p && *p == '\0')
11439 if (optimize_insn_for_speed_p ())
11441 /* See if we can store by pieces into (dst + strlen(dst)). */
11443 tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11444 tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11446 if (!strlen_fn || !strcpy_fn)
11449 /* If we don't have a movstr we don't want to emit an strcpy
11450 call. We have to do that if the length of the source string
11451 isn't computable (in that case we can use memcpy probably
11452 later expanding to a sequence of mov instructions). If we
11453 have movstr instructions we can emit strcpy calls. */
11456 tree len = c_strlen (src, 1);
11457 if (! len || TREE_SIDE_EFFECTS (len))
11461 /* Stabilize the argument list. */
11462 dst = builtin_save_expr (dst);
11464 /* Create strlen (dst). */
11465 newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11466 /* Create (dst p+ strlen (dst)). */
11468 newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11469 TREE_TYPE (dst), dst, newdst);
11470 newdst = builtin_save_expr (newdst);
11472 call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11473 return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11479 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11480 arguments to the call.
11482 Return NULL_TREE if no simplification was possible, otherwise return the
11483 simplified form of the call as a tree.
11485 The simplified form may be a constant or other expression which
11486 computes the same value, but in a more efficient manner (including
11487 calls to other builtin functions).
11489 The call may contain arguments which need to be evaluated, but
11490 which are not useful to determine the result of the call. In
11491 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11492 COMPOUND_EXPR will be an argument which must be evaluated.
11493 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11494 COMPOUND_EXPR in the chain will contain the tree for the simplified
11495 form of the builtin function call. */
11498 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11500 if (!validate_arg (dst, POINTER_TYPE)
11501 || !validate_arg (src, POINTER_TYPE)
11502 || !validate_arg (len, INTEGER_TYPE))
11506 const char *p = c_getstr (src);
11508 /* If the requested length is zero, or the src parameter string
11509 length is zero, return the dst parameter. */
11510 if (integer_zerop (len) || (p && *p == '\0'))
11511 return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11513 /* If the requested len is greater than or equal to the string
11514 length, call strcat. */
11515 if (TREE_CODE (len) == INTEGER_CST && p
11516 && compare_tree_int (len, strlen (p)) >= 0)
11518 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11520 /* If the replacement _DECL isn't initialized, don't do the
11525 return build_call_expr_loc (loc, fn, 2, dst, src);
11531 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11534 Return NULL_TREE if no simplification was possible, otherwise return the
11535 simplified form of the call as a tree.
11537 The simplified form may be a constant or other expression which
11538 computes the same value, but in a more efficient manner (including
11539 calls to other builtin functions).
11541 The call may contain arguments which need to be evaluated, but
11542 which are not useful to determine the result of the call. In
11543 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11544 COMPOUND_EXPR will be an argument which must be evaluated.
11545 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11546 COMPOUND_EXPR in the chain will contain the tree for the simplified
11547 form of the builtin function call. */
11550 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11552 if (!validate_arg (s1, POINTER_TYPE)
11553 || !validate_arg (s2, POINTER_TYPE))
11557 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11559 /* If both arguments are constants, evaluate at compile-time. */
11562 const size_t r = strspn (p1, p2);
11563 return size_int (r);
11566 /* If either argument is "", return NULL_TREE. */
11567 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11568 /* Evaluate and ignore both arguments in case either one has
11570 return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11576 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11579 Return NULL_TREE if no simplification was possible, otherwise return the
11580 simplified form of the call as a tree.
11582 The simplified form may be a constant or other expression which
11583 computes the same value, but in a more efficient manner (including
11584 calls to other builtin functions).
11586 The call may contain arguments which need to be evaluated, but
11587 which are not useful to determine the result of the call. In
11588 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11589 COMPOUND_EXPR will be an argument which must be evaluated.
11590 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11591 COMPOUND_EXPR in the chain will contain the tree for the simplified
11592 form of the builtin function call. */
11595 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11597 if (!validate_arg (s1, POINTER_TYPE)
11598 || !validate_arg (s2, POINTER_TYPE))
11602 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11604 /* If both arguments are constants, evaluate at compile-time. */
11607 const size_t r = strcspn (p1, p2);
11608 return size_int (r);
11611 /* If the first argument is "", return NULL_TREE. */
11612 if (p1 && *p1 == '\0')
11614 /* Evaluate and ignore argument s2 in case it has
11616 return omit_one_operand_loc (loc, size_type_node,
11617 size_zero_node, s2);
11620 /* If the second argument is "", return __builtin_strlen(s1). */
11621 if (p2 && *p2 == '\0')
11623 tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11625 /* If the replacement _DECL isn't initialized, don't do the
11630 return build_call_expr_loc (loc, fn, 1, s1);
11636 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
11637 to the call. IGNORE is true if the value returned
11638 by the builtin will be ignored. UNLOCKED is true is true if this
11639 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
11640 the known length of the string. Return NULL_TREE if no simplification
11644 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11645 bool ignore, bool unlocked, tree len)
11647 /* If we're using an unlocked function, assume the other unlocked
11648 functions exist explicitly. */
11649 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11650 : implicit_built_in_decls[BUILT_IN_FPUTC];
11651 tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11652 : implicit_built_in_decls[BUILT_IN_FWRITE];
11654 /* If the return value is used, don't do the transformation. */
11658 /* Verify the arguments in the original call. */
11659 if (!validate_arg (arg0, POINTER_TYPE)
11660 || !validate_arg (arg1, POINTER_TYPE))
11664 len = c_strlen (arg0, 0);
11666 /* Get the length of the string passed to fputs. If the length
11667 can't be determined, punt. */
11669 || TREE_CODE (len) != INTEGER_CST)
11672 switch (compare_tree_int (len, 1))
11674 case -1: /* length is 0, delete the call entirely . */
11675 return omit_one_operand_loc (loc, integer_type_node,
11676 integer_zero_node, arg1);;
11678 case 0: /* length is 1, call fputc. */
11680 const char *p = c_getstr (arg0);
11685 return build_call_expr_loc (loc, fn_fputc, 2,
11686 build_int_cst (NULL_TREE, p[0]), arg1);
11692 case 1: /* length is greater than 1, call fwrite. */
11694 /* If optimizing for size keep fputs. */
11695 if (optimize_function_for_size_p (cfun))
11697 /* New argument list transforming fputs(string, stream) to
11698 fwrite(string, 1, len, stream). */
11700 return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11701 size_one_node, len, arg1);
11706 gcc_unreachable ();
11711 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11712 produced. False otherwise. This is done so that we don't output the error
11713 or warning twice or three times. */
11716 fold_builtin_next_arg (tree exp, bool va_start_p)
11718 tree fntype = TREE_TYPE (current_function_decl);
11719 int nargs = call_expr_nargs (exp);
11722 if (TYPE_ARG_TYPES (fntype) == 0
11723 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
11724 == void_type_node))
11726 error ("%<va_start%> used in function with fixed args");
11732 if (va_start_p && (nargs != 2))
11734 error ("wrong number of arguments to function %<va_start%>");
11737 arg = CALL_EXPR_ARG (exp, 1);
11739 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11740 when we checked the arguments and if needed issued a warning. */
11745 /* Evidently an out of date version of <stdarg.h>; can't validate
11746 va_start's second argument, but can still work as intended. */
11747 warning (0, "%<__builtin_next_arg%> called without an argument");
11750 else if (nargs > 1)
11752 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11755 arg = CALL_EXPR_ARG (exp, 0);
11758 if (TREE_CODE (arg) == SSA_NAME)
11759 arg = SSA_NAME_VAR (arg);
11761 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11762 or __builtin_next_arg (0) the first time we see it, after checking
11763 the arguments and if needed issuing a warning. */
11764 if (!integer_zerop (arg))
11766 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11768 /* Strip off all nops for the sake of the comparison. This
11769 is not quite the same as STRIP_NOPS. It does more.
11770 We must also strip off INDIRECT_EXPR for C++ reference
11772 while (CONVERT_EXPR_P (arg)
11773 || TREE_CODE (arg) == INDIRECT_REF)
11774 arg = TREE_OPERAND (arg, 0);
11775 if (arg != last_parm)
11777 /* FIXME: Sometimes with the tree optimizers we can get the
11778 not the last argument even though the user used the last
11779 argument. We just warn and set the arg to be the last
11780 argument so that we will get wrong-code because of
11782 warning (0, "second parameter of %<va_start%> not last named argument");
11785 /* Undefined by C99 7.15.1.4p4 (va_start):
11786 "If the parameter parmN is declared with the register storage
11787 class, with a function or array type, or with a type that is
11788 not compatible with the type that results after application of
11789 the default argument promotions, the behavior is undefined."
11791 else if (DECL_REGISTER (arg))
11792 warning (0, "undefined behaviour when second parameter of "
11793 "%<va_start%> is declared with %<register%> storage");
11795 /* We want to verify the second parameter just once before the tree
11796 optimizers are run and then avoid keeping it in the tree,
11797 as otherwise we could warn even for correct code like:
11798 void foo (int i, ...)
11799 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11801 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11803 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11809 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11810 ORIG may be null if this is a 2-argument call. We don't attempt to
11811 simplify calls with more than 3 arguments.
11813 Return NULL_TREE if no simplification was possible, otherwise return the
11814 simplified form of the call as a tree. If IGNORED is true, it means that
11815 the caller does not use the returned value of the function. */
11818 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11819 tree orig, int ignored)
11822 const char *fmt_str = NULL;
11824 /* Verify the required arguments in the original call. We deal with two
11825 types of sprintf() calls: 'sprintf (str, fmt)' and
11826 'sprintf (dest, "%s", orig)'. */
11827 if (!validate_arg (dest, POINTER_TYPE)
11828 || !validate_arg (fmt, POINTER_TYPE))
11830 if (orig && !validate_arg (orig, POINTER_TYPE))
11833 /* Check whether the format is a literal string constant. */
11834 fmt_str = c_getstr (fmt);
11835 if (fmt_str == NULL)
11839 retval = NULL_TREE;
11841 if (!init_target_chars ())
11844 /* If the format doesn't contain % args or %%, use strcpy. */
11845 if (strchr (fmt_str, target_percent) == NULL)
11847 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11852 /* Don't optimize sprintf (buf, "abc", ptr++). */
11856 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11857 'format' is known to contain no % formats. */
11858 call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11860 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11863 /* If the format is "%s", use strcpy if the result isn't used. */
11864 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11867 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11872 /* Don't crash on sprintf (str1, "%s"). */
11876 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
11879 retval = c_strlen (orig, 1);
11880 if (!retval || TREE_CODE (retval) != INTEGER_CST)
11883 call = build_call_expr_loc (loc, fn, 2, dest, orig);
11886 if (call && retval)
11888 retval = fold_convert_loc
11889 (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11891 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11897 /* Expand a call EXP to __builtin_object_size. */
11900 expand_builtin_object_size (tree exp)
11903 int object_size_type;
11904 tree fndecl = get_callee_fndecl (exp);
11906 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11908 error ("%Kfirst argument of %D must be a pointer, second integer constant",
11910 expand_builtin_trap ();
11914 ost = CALL_EXPR_ARG (exp, 1);
11917 if (TREE_CODE (ost) != INTEGER_CST
11918 || tree_int_cst_sgn (ost) < 0
11919 || compare_tree_int (ost, 3) > 0)
11921 error ("%Klast argument of %D is not integer constant between 0 and 3",
11923 expand_builtin_trap ();
11927 object_size_type = tree_low_cst (ost, 0);
11929 return object_size_type < 2 ? constm1_rtx : const0_rtx;
11932 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11933 FCODE is the BUILT_IN_* to use.
11934 Return NULL_RTX if we failed; the caller should emit a normal call,
11935 otherwise try to get the result in TARGET, if convenient (and in
11936 mode MODE if that's convenient). */
11939 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11940 enum built_in_function fcode)
11942 tree dest, src, len, size;
11944 if (!validate_arglist (exp,
11946 fcode == BUILT_IN_MEMSET_CHK
11947 ? INTEGER_TYPE : POINTER_TYPE,
11948 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11951 dest = CALL_EXPR_ARG (exp, 0);
11952 src = CALL_EXPR_ARG (exp, 1);
11953 len = CALL_EXPR_ARG (exp, 2);
11954 size = CALL_EXPR_ARG (exp, 3);
11956 if (! host_integerp (size, 1))
11959 if (host_integerp (len, 1) || integer_all_onesp (size))
11963 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11965 warning_at (tree_nonartificial_location (exp),
11966 0, "%Kcall to %D will always overflow destination buffer",
11967 exp, get_callee_fndecl (exp));
11972 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11973 mem{cpy,pcpy,move,set} is available. */
11976 case BUILT_IN_MEMCPY_CHK:
11977 fn = built_in_decls[BUILT_IN_MEMCPY];
11979 case BUILT_IN_MEMPCPY_CHK:
11980 fn = built_in_decls[BUILT_IN_MEMPCPY];
11982 case BUILT_IN_MEMMOVE_CHK:
11983 fn = built_in_decls[BUILT_IN_MEMMOVE];
11985 case BUILT_IN_MEMSET_CHK:
11986 fn = built_in_decls[BUILT_IN_MEMSET];
11995 fn = build_call_nofold (fn, 3, dest, src, len);
11996 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11997 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11998 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12000 else if (fcode == BUILT_IN_MEMSET_CHK)
12004 unsigned int dest_align
12005 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
12007 /* If DEST is not a pointer type, call the normal function. */
12008 if (dest_align == 0)
12011 /* If SRC and DEST are the same (and not volatile), do nothing. */
12012 if (operand_equal_p (src, dest, 0))
12016 if (fcode != BUILT_IN_MEMPCPY_CHK)
12018 /* Evaluate and ignore LEN in case it has side-effects. */
12019 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12020 return expand_expr (dest, target, mode, EXPAND_NORMAL);
12023 expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12024 return expand_expr (expr, target, mode, EXPAND_NORMAL);
12027 /* __memmove_chk special case. */
12028 if (fcode == BUILT_IN_MEMMOVE_CHK)
12030 unsigned int src_align
12031 = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
12033 if (src_align == 0)
12036 /* If src is categorized for a readonly section we can use
12037 normal __memcpy_chk. */
12038 if (readonly_data_expr (src))
12040 tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12043 fn = build_call_nofold (fn, 4, dest, src, len, size);
12044 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12045 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12046 return expand_expr (fn, target, mode, EXPAND_NORMAL);
12053 /* Emit warning if a buffer overflow is detected at compile time. */
12056 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12060 location_t loc = tree_nonartificial_location (exp);
12064 case BUILT_IN_STRCPY_CHK:
12065 case BUILT_IN_STPCPY_CHK:
12066 /* For __strcat_chk the warning will be emitted only if overflowing
12067 by at least strlen (dest) + 1 bytes. */
12068 case BUILT_IN_STRCAT_CHK:
12069 len = CALL_EXPR_ARG (exp, 1);
12070 size = CALL_EXPR_ARG (exp, 2);
12073 case BUILT_IN_STRNCAT_CHK:
12074 case BUILT_IN_STRNCPY_CHK:
12075 len = CALL_EXPR_ARG (exp, 2);
12076 size = CALL_EXPR_ARG (exp, 3);
12078 case BUILT_IN_SNPRINTF_CHK:
12079 case BUILT_IN_VSNPRINTF_CHK:
12080 len = CALL_EXPR_ARG (exp, 1);
12081 size = CALL_EXPR_ARG (exp, 3);
12084 gcc_unreachable ();
12090 if (! host_integerp (size, 1) || integer_all_onesp (size))
12095 len = c_strlen (len, 1);
12096 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12099 else if (fcode == BUILT_IN_STRNCAT_CHK)
12101 tree src = CALL_EXPR_ARG (exp, 1);
12102 if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12104 src = c_strlen (src, 1);
12105 if (! src || ! host_integerp (src, 1))
12107 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12108 exp, get_callee_fndecl (exp));
12111 else if (tree_int_cst_lt (src, size))
12114 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12117 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12118 exp, get_callee_fndecl (exp));
12121 /* Emit warning if a buffer overflow is detected at compile time
12122 in __sprintf_chk/__vsprintf_chk calls. */
12125 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12127 tree size, len, fmt;
12128 const char *fmt_str;
12129 int nargs = call_expr_nargs (exp);
12131 /* Verify the required arguments in the original call. */
12135 size = CALL_EXPR_ARG (exp, 2);
12136 fmt = CALL_EXPR_ARG (exp, 3);
12138 if (! host_integerp (size, 1) || integer_all_onesp (size))
12141 /* Check whether the format is a literal string constant. */
12142 fmt_str = c_getstr (fmt);
12143 if (fmt_str == NULL)
12146 if (!init_target_chars ())
12149 /* If the format doesn't contain % args or %%, we know its size. */
12150 if (strchr (fmt_str, target_percent) == 0)
12151 len = build_int_cstu (size_type_node, strlen (fmt_str));
12152 /* If the format is "%s" and first ... argument is a string literal,
12154 else if (fcode == BUILT_IN_SPRINTF_CHK
12155 && strcmp (fmt_str, target_percent_s) == 0)
12161 arg = CALL_EXPR_ARG (exp, 4);
12162 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12165 len = c_strlen (arg, 1);
12166 if (!len || ! host_integerp (len, 1))
12172 if (! tree_int_cst_lt (len, size))
12173 warning_at (tree_nonartificial_location (exp),
12174 0, "%Kcall to %D will always overflow destination buffer",
12175 exp, get_callee_fndecl (exp));
12178 /* Emit warning if a free is called with address of a variable. */
12181 maybe_emit_free_warning (tree exp)
12183 tree arg = CALL_EXPR_ARG (exp, 0);
12186 if (TREE_CODE (arg) != ADDR_EXPR)
12189 arg = get_base_address (TREE_OPERAND (arg, 0));
12190 if (arg == NULL || INDIRECT_REF_P (arg))
12193 if (SSA_VAR_P (arg))
12194 warning_at (tree_nonartificial_location (exp),
12195 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12197 warning_at (tree_nonartificial_location (exp),
12198 0, "%Kattempt to free a non-heap object", exp);
12201 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12205 fold_builtin_object_size (tree ptr, tree ost)
12207 tree ret = NULL_TREE;
12208 int object_size_type;
12210 if (!validate_arg (ptr, POINTER_TYPE)
12211 || !validate_arg (ost, INTEGER_TYPE))
12216 if (TREE_CODE (ost) != INTEGER_CST
12217 || tree_int_cst_sgn (ost) < 0
12218 || compare_tree_int (ost, 3) > 0)
12221 object_size_type = tree_low_cst (ost, 0);
12223 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12224 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12225 and (size_t) 0 for types 2 and 3. */
12226 if (TREE_SIDE_EFFECTS (ptr))
12227 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12229 if (TREE_CODE (ptr) == ADDR_EXPR)
12230 ret = build_int_cstu (size_type_node,
12231 compute_builtin_object_size (ptr, object_size_type));
12233 else if (TREE_CODE (ptr) == SSA_NAME)
12235 unsigned HOST_WIDE_INT bytes;
12237 /* If object size is not known yet, delay folding until
12238 later. Maybe subsequent passes will help determining
12240 bytes = compute_builtin_object_size (ptr, object_size_type);
12241 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
12243 ret = build_int_cstu (size_type_node, bytes);
12248 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (ret);
12249 HOST_WIDE_INT high = TREE_INT_CST_HIGH (ret);
12250 if (fit_double_type (low, high, &low, &high, TREE_TYPE (ret)))
12257 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12258 DEST, SRC, LEN, and SIZE are the arguments to the call.
12259 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12260 code of the builtin. If MAXLEN is not NULL, it is maximum length
12261 passed as third argument. */
12264 fold_builtin_memory_chk (location_t loc, tree fndecl,
12265 tree dest, tree src, tree len, tree size,
12266 tree maxlen, bool ignore,
12267 enum built_in_function fcode)
12271 if (!validate_arg (dest, POINTER_TYPE)
12272 || !validate_arg (src,
12273 (fcode == BUILT_IN_MEMSET_CHK
12274 ? INTEGER_TYPE : POINTER_TYPE))
12275 || !validate_arg (len, INTEGER_TYPE)
12276 || !validate_arg (size, INTEGER_TYPE))
12279 /* If SRC and DEST are the same (and not volatile), return DEST
12280 (resp. DEST+LEN for __mempcpy_chk). */
12281 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12283 if (fcode != BUILT_IN_MEMPCPY_CHK)
12284 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12288 tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12290 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12294 if (! host_integerp (size, 1))
12297 if (! integer_all_onesp (size))
12299 if (! host_integerp (len, 1))
12301 /* If LEN is not constant, try MAXLEN too.
12302 For MAXLEN only allow optimizing into non-_ocs function
12303 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12304 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12306 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12308 /* (void) __mempcpy_chk () can be optimized into
12309 (void) __memcpy_chk (). */
12310 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12314 return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12322 if (tree_int_cst_lt (size, maxlen))
12327 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12328 mem{cpy,pcpy,move,set} is available. */
12331 case BUILT_IN_MEMCPY_CHK:
12332 fn = built_in_decls[BUILT_IN_MEMCPY];
12334 case BUILT_IN_MEMPCPY_CHK:
12335 fn = built_in_decls[BUILT_IN_MEMPCPY];
12337 case BUILT_IN_MEMMOVE_CHK:
12338 fn = built_in_decls[BUILT_IN_MEMMOVE];
12340 case BUILT_IN_MEMSET_CHK:
12341 fn = built_in_decls[BUILT_IN_MEMSET];
12350 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12353 /* Fold a call to the __st[rp]cpy_chk builtin.
12354 DEST, SRC, and SIZE are the arguments to the call.
12355 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12356 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12357 strings passed as second argument. */
12360 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12361 tree src, tree size,
12362 tree maxlen, bool ignore,
12363 enum built_in_function fcode)
12367 if (!validate_arg (dest, POINTER_TYPE)
12368 || !validate_arg (src, POINTER_TYPE)
12369 || !validate_arg (size, INTEGER_TYPE))
12372 /* If SRC and DEST are the same (and not volatile), return DEST. */
12373 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12374 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12376 if (! host_integerp (size, 1))
12379 if (! integer_all_onesp (size))
12381 len = c_strlen (src, 1);
12382 if (! len || ! host_integerp (len, 1))
12384 /* If LEN is not constant, try MAXLEN too.
12385 For MAXLEN only allow optimizing into non-_ocs function
12386 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12387 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12389 if (fcode == BUILT_IN_STPCPY_CHK)
12394 /* If return value of __stpcpy_chk is ignored,
12395 optimize into __strcpy_chk. */
12396 fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12400 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12403 if (! len || TREE_SIDE_EFFECTS (len))
12406 /* If c_strlen returned something, but not a constant,
12407 transform __strcpy_chk into __memcpy_chk. */
12408 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12412 len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12413 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12414 build_call_expr_loc (loc, fn, 4,
12415 dest, src, len, size));
12421 if (! tree_int_cst_lt (maxlen, size))
12425 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12426 fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12427 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12431 return build_call_expr_loc (loc, fn, 2, dest, src);
12434 /* Fold a call to the __strncpy_chk builtin. DEST, SRC, LEN, and SIZE
12435 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12436 length passed as third argument. */
12439 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12440 tree len, tree size, tree maxlen)
12444 if (!validate_arg (dest, POINTER_TYPE)
12445 || !validate_arg (src, POINTER_TYPE)
12446 || !validate_arg (len, INTEGER_TYPE)
12447 || !validate_arg (size, INTEGER_TYPE))
12450 if (! host_integerp (size, 1))
12453 if (! integer_all_onesp (size))
12455 if (! host_integerp (len, 1))
12457 /* If LEN is not constant, try MAXLEN too.
12458 For MAXLEN only allow optimizing into non-_ocs function
12459 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12460 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12466 if (tree_int_cst_lt (size, maxlen))
12470 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
12471 fn = built_in_decls[BUILT_IN_STRNCPY];
12475 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12478 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12479 are the arguments to the call. */
12482 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12483 tree src, tree size)
12488 if (!validate_arg (dest, POINTER_TYPE)
12489 || !validate_arg (src, POINTER_TYPE)
12490 || !validate_arg (size, INTEGER_TYPE))
12493 p = c_getstr (src);
12494 /* If the SRC parameter is "", return DEST. */
12495 if (p && *p == '\0')
12496 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12498 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12501 /* If __builtin_strcat_chk is used, assume strcat is available. */
12502 fn = built_in_decls[BUILT_IN_STRCAT];
12506 return build_call_expr_loc (loc, fn, 2, dest, src);
12509 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12513 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12514 tree dest, tree src, tree len, tree size)
12519 if (!validate_arg (dest, POINTER_TYPE)
12520 || !validate_arg (src, POINTER_TYPE)
12521 || !validate_arg (size, INTEGER_TYPE)
12522 || !validate_arg (size, INTEGER_TYPE))
12525 p = c_getstr (src);
12526 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
12527 if (p && *p == '\0')
12528 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12529 else if (integer_zerop (len))
12530 return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12532 if (! host_integerp (size, 1))
12535 if (! integer_all_onesp (size))
12537 tree src_len = c_strlen (src, 1);
12539 && host_integerp (src_len, 1)
12540 && host_integerp (len, 1)
12541 && ! tree_int_cst_lt (len, src_len))
12543 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
12544 fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12548 return build_call_expr_loc (loc, fn, 3, dest, src, size);
12553 /* If __builtin_strncat_chk is used, assume strncat is available. */
12554 fn = built_in_decls[BUILT_IN_STRNCAT];
12558 return build_call_expr_loc (loc, fn, 3, dest, src, len);
12561 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
12562 a normal call should be emitted rather than expanding the function
12563 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
12566 fold_builtin_sprintf_chk (location_t loc, tree exp,
12567 enum built_in_function fcode)
12569 tree dest, size, len, fn, fmt, flag;
12570 const char *fmt_str;
12571 int nargs = call_expr_nargs (exp);
12573 /* Verify the required arguments in the original call. */
12576 dest = CALL_EXPR_ARG (exp, 0);
12577 if (!validate_arg (dest, POINTER_TYPE))
12579 flag = CALL_EXPR_ARG (exp, 1);
12580 if (!validate_arg (flag, INTEGER_TYPE))
12582 size = CALL_EXPR_ARG (exp, 2);
12583 if (!validate_arg (size, INTEGER_TYPE))
12585 fmt = CALL_EXPR_ARG (exp, 3);
12586 if (!validate_arg (fmt, POINTER_TYPE))
12589 if (! host_integerp (size, 1))
12594 if (!init_target_chars ())
12597 /* Check whether the format is a literal string constant. */
12598 fmt_str = c_getstr (fmt);
12599 if (fmt_str != NULL)
12601 /* If the format doesn't contain % args or %%, we know the size. */
12602 if (strchr (fmt_str, target_percent) == 0)
12604 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12605 len = build_int_cstu (size_type_node, strlen (fmt_str));
12607 /* If the format is "%s" and first ... argument is a string literal,
12608 we know the size too. */
12609 else if (fcode == BUILT_IN_SPRINTF_CHK
12610 && strcmp (fmt_str, target_percent_s) == 0)
12616 arg = CALL_EXPR_ARG (exp, 4);
12617 if (validate_arg (arg, POINTER_TYPE))
12619 len = c_strlen (arg, 1);
12620 if (! len || ! host_integerp (len, 1))
12627 if (! integer_all_onesp (size))
12629 if (! len || ! tree_int_cst_lt (len, size))
12633 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12634 or if format doesn't contain % chars or is "%s". */
12635 if (! integer_zerop (flag))
12637 if (fmt_str == NULL)
12639 if (strchr (fmt_str, target_percent) != NULL
12640 && strcmp (fmt_str, target_percent_s))
12644 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
12645 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12646 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12650 return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12653 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
12654 a normal call should be emitted rather than expanding the function
12655 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
12656 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
12657 passed as second argument. */
12660 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12661 enum built_in_function fcode)
12663 tree dest, size, len, fn, fmt, flag;
12664 const char *fmt_str;
12666 /* Verify the required arguments in the original call. */
12667 if (call_expr_nargs (exp) < 5)
12669 dest = CALL_EXPR_ARG (exp, 0);
12670 if (!validate_arg (dest, POINTER_TYPE))
12672 len = CALL_EXPR_ARG (exp, 1);
12673 if (!validate_arg (len, INTEGER_TYPE))
12675 flag = CALL_EXPR_ARG (exp, 2);
12676 if (!validate_arg (flag, INTEGER_TYPE))
12678 size = CALL_EXPR_ARG (exp, 3);
12679 if (!validate_arg (size, INTEGER_TYPE))
12681 fmt = CALL_EXPR_ARG (exp, 4);
12682 if (!validate_arg (fmt, POINTER_TYPE))
12685 if (! host_integerp (size, 1))
12688 if (! integer_all_onesp (size))
12690 if (! host_integerp (len, 1))
12692 /* If LEN is not constant, try MAXLEN too.
12693 For MAXLEN only allow optimizing into non-_ocs function
12694 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12695 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12701 if (tree_int_cst_lt (size, maxlen))
12705 if (!init_target_chars ())
12708 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12709 or if format doesn't contain % chars or is "%s". */
12710 if (! integer_zerop (flag))
12712 fmt_str = c_getstr (fmt);
12713 if (fmt_str == NULL)
12715 if (strchr (fmt_str, target_percent) != NULL
12716 && strcmp (fmt_str, target_percent_s))
12720 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12722 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12723 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12727 return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12730 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12731 FMT and ARG are the arguments to the call; we don't fold cases with
12732 more than 2 arguments, and ARG may be null if this is a 1-argument case.
12734 Return NULL_TREE if no simplification was possible, otherwise return the
12735 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12736 code of the function to be simplified. */
12739 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12740 tree arg, bool ignore,
12741 enum built_in_function fcode)
12743 tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12744 const char *fmt_str = NULL;
12746 /* If the return value is used, don't do the transformation. */
12750 /* Verify the required arguments in the original call. */
12751 if (!validate_arg (fmt, POINTER_TYPE))
12754 /* Check whether the format is a literal string constant. */
12755 fmt_str = c_getstr (fmt);
12756 if (fmt_str == NULL)
12759 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12761 /* If we're using an unlocked function, assume the other
12762 unlocked functions exist explicitly. */
12763 fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12764 fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12768 fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12769 fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12772 if (!init_target_chars ())
12775 if (strcmp (fmt_str, target_percent_s) == 0
12776 || strchr (fmt_str, target_percent) == NULL)
12780 if (strcmp (fmt_str, target_percent_s) == 0)
12782 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12785 if (!arg || !validate_arg (arg, POINTER_TYPE))
12788 str = c_getstr (arg);
12794 /* The format specifier doesn't contain any '%' characters. */
12795 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12801 /* If the string was "", printf does nothing. */
12802 if (str[0] == '\0')
12803 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12805 /* If the string has length of 1, call putchar. */
12806 if (str[1] == '\0')
12808 /* Given printf("c"), (where c is any one character,)
12809 convert "c"[0] to an int and pass that to the replacement
12811 newarg = build_int_cst (NULL_TREE, str[0]);
12813 call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12817 /* If the string was "string\n", call puts("string"). */
12818 size_t len = strlen (str);
12819 if ((unsigned char)str[len - 1] == target_newline)
12821 /* Create a NUL-terminated string that's one char shorter
12822 than the original, stripping off the trailing '\n'. */
12823 char *newstr = XALLOCAVEC (char, len);
12824 memcpy (newstr, str, len - 1);
12825 newstr[len - 1] = 0;
12827 newarg = build_string_literal (len, newstr);
12829 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12832 /* We'd like to arrange to call fputs(string,stdout) here,
12833 but we need stdout and don't have a way to get it yet. */
12838 /* The other optimizations can be done only on the non-va_list variants. */
12839 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12842 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
12843 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12845 if (!arg || !validate_arg (arg, POINTER_TYPE))
12848 call = build_call_expr_loc (loc, fn_puts, 1, arg);
12851 /* If the format specifier was "%c", call __builtin_putchar(arg). */
12852 else if (strcmp (fmt_str, target_percent_c) == 0)
12854 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12857 call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12863 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12866 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12867 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
12868 more than 3 arguments, and ARG may be null in the 2-argument case.
12870 Return NULL_TREE if no simplification was possible, otherwise return the
12871 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12872 code of the function to be simplified. */
12875 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12876 tree fmt, tree arg, bool ignore,
12877 enum built_in_function fcode)
12879 tree fn_fputc, fn_fputs, call = NULL_TREE;
12880 const char *fmt_str = NULL;
12882 /* If the return value is used, don't do the transformation. */
12886 /* Verify the required arguments in the original call. */
12887 if (!validate_arg (fp, POINTER_TYPE))
12889 if (!validate_arg (fmt, POINTER_TYPE))
12892 /* Check whether the format is a literal string constant. */
12893 fmt_str = c_getstr (fmt);
12894 if (fmt_str == NULL)
12897 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12899 /* If we're using an unlocked function, assume the other
12900 unlocked functions exist explicitly. */
12901 fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12902 fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12906 fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12907 fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12910 if (!init_target_chars ())
12913 /* If the format doesn't contain % args or %%, use strcpy. */
12914 if (strchr (fmt_str, target_percent) == NULL)
12916 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12920 /* If the format specifier was "", fprintf does nothing. */
12921 if (fmt_str[0] == '\0')
12923 /* If FP has side-effects, just wait until gimplification is
12925 if (TREE_SIDE_EFFECTS (fp))
12928 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12931 /* When "string" doesn't contain %, replace all cases of
12932 fprintf (fp, string) with fputs (string, fp). The fputs
12933 builtin will take care of special cases like length == 1. */
12935 call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12938 /* The other optimizations can be done only on the non-va_list variants. */
12939 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12942 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
12943 else if (strcmp (fmt_str, target_percent_s) == 0)
12945 if (!arg || !validate_arg (arg, POINTER_TYPE))
12948 call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12951 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
12952 else if (strcmp (fmt_str, target_percent_c) == 0)
12954 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12957 call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12962 return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12965 /* Initialize format string characters in the target charset. */
12968 init_target_chars (void)
12973 target_newline = lang_hooks.to_target_charset ('\n');
12974 target_percent = lang_hooks.to_target_charset ('%');
12975 target_c = lang_hooks.to_target_charset ('c');
12976 target_s = lang_hooks.to_target_charset ('s');
12977 if (target_newline == 0 || target_percent == 0 || target_c == 0
12981 target_percent_c[0] = target_percent;
12982 target_percent_c[1] = target_c;
12983 target_percent_c[2] = '\0';
12985 target_percent_s[0] = target_percent;
12986 target_percent_s[1] = target_s;
12987 target_percent_s[2] = '\0';
12989 target_percent_s_newline[0] = target_percent;
12990 target_percent_s_newline[1] = target_s;
12991 target_percent_s_newline[2] = target_newline;
12992 target_percent_s_newline[3] = '\0';
12999 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
13000 and no overflow/underflow occurred. INEXACT is true if M was not
13001 exactly calculated. TYPE is the tree type for the result. This
13002 function assumes that you cleared the MPFR flags and then
13003 calculated M to see if anything subsequently set a flag prior to
13004 entering this function. Return NULL_TREE if any checks fail. */
13007 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13009 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13010 overflow/underflow occurred. If -frounding-math, proceed iff the
13011 result of calling FUNC was exact. */
13012 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13013 && (!flag_rounding_math || !inexact))
13015 REAL_VALUE_TYPE rr;
13017 real_from_mpfr (&rr, m, type, GMP_RNDN);
13018 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13019 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13020 but the mpft_t is not, then we underflowed in the
13022 if (real_isfinite (&rr)
13023 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13025 REAL_VALUE_TYPE rmode;
13027 real_convert (&rmode, TYPE_MODE (type), &rr);
13028 /* Proceed iff the specified mode can hold the value. */
13029 if (real_identical (&rmode, &rr))
13030 return build_real (type, rmode);
13037 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
13038 number and no overflow/underflow occurred. INEXACT is true if M
13039 was not exactly calculated. TYPE is the tree type for the result.
13040 This function assumes that you cleared the MPFR flags and then
13041 calculated M to see if anything subsequently set a flag prior to
13042 entering this function. Return NULL_TREE if any checks fail, if
13043 FORCE_CONVERT is true, then bypass the checks. */
13046 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13048 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13049 overflow/underflow occurred. If -frounding-math, proceed iff the
13050 result of calling FUNC was exact. */
13052 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13053 && !mpfr_overflow_p () && !mpfr_underflow_p ()
13054 && (!flag_rounding_math || !inexact)))
13056 REAL_VALUE_TYPE re, im;
13058 real_from_mpfr (&re, mpc_realref (m), type, GMP_RNDN);
13059 real_from_mpfr (&im, mpc_imagref (m), type, GMP_RNDN);
13060 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13061 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13062 but the mpft_t is not, then we underflowed in the
13065 || (real_isfinite (&re) && real_isfinite (&im)
13066 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13067 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13069 REAL_VALUE_TYPE re_mode, im_mode;
13071 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13072 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13073 /* Proceed iff the specified mode can hold the value. */
13075 || (real_identical (&re_mode, &re)
13076 && real_identical (&im_mode, &im)))
13077 return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13078 build_real (TREE_TYPE (type), im_mode));
13083 #endif /* HAVE_mpc */
13085 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13086 FUNC on it and return the resulting value as a tree with type TYPE.
13087 If MIN and/or MAX are not NULL, then the supplied ARG must be
13088 within those bounds. If INCLUSIVE is true, then MIN/MAX are
13089 acceptable values, otherwise they are not. The mpfr precision is
13090 set to the precision of TYPE. We assume that function FUNC returns
13091 zero if the result could be calculated exactly within the requested
13095 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13096 const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13099 tree result = NULL_TREE;
13103 /* To proceed, MPFR must exactly represent the target floating point
13104 format, which only happens when the target base equals two. */
13105 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13106 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13108 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13110 if (real_isfinite (ra)
13111 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13112 && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13114 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13115 const int prec = fmt->p;
13116 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13120 mpfr_init2 (m, prec);
13121 mpfr_from_real (m, ra, GMP_RNDN);
13122 mpfr_clear_flags ();
13123 inexact = func (m, m, rnd);
13124 result = do_mpfr_ckconv (m, type, inexact);
13132 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13133 FUNC on it and return the resulting value as a tree with type TYPE.
13134 The mpfr precision is set to the precision of TYPE. We assume that
13135 function FUNC returns zero if the result could be calculated
13136 exactly within the requested precision. */
13139 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13140 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13142 tree result = NULL_TREE;
13147 /* To proceed, MPFR must exactly represent the target floating point
13148 format, which only happens when the target base equals two. */
13149 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13150 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13151 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13153 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13154 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13156 if (real_isfinite (ra1) && real_isfinite (ra2))
13158 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13159 const int prec = fmt->p;
13160 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13164 mpfr_inits2 (prec, m1, m2, NULL);
13165 mpfr_from_real (m1, ra1, GMP_RNDN);
13166 mpfr_from_real (m2, ra2, GMP_RNDN);
13167 mpfr_clear_flags ();
13168 inexact = func (m1, m1, m2, rnd);
13169 result = do_mpfr_ckconv (m1, type, inexact);
13170 mpfr_clears (m1, m2, NULL);
13177 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13178 FUNC on it and return the resulting value as a tree with type TYPE.
13179 The mpfr precision is set to the precision of TYPE. We assume that
13180 function FUNC returns zero if the result could be calculated
13181 exactly within the requested precision. */
13184 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13185 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13187 tree result = NULL_TREE;
13193 /* To proceed, MPFR must exactly represent the target floating point
13194 format, which only happens when the target base equals two. */
13195 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13196 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13197 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13198 && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13200 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13201 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13202 const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13204 if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13206 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13207 const int prec = fmt->p;
13208 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13212 mpfr_inits2 (prec, m1, m2, m3, NULL);
13213 mpfr_from_real (m1, ra1, GMP_RNDN);
13214 mpfr_from_real (m2, ra2, GMP_RNDN);
13215 mpfr_from_real (m3, ra3, GMP_RNDN);
13216 mpfr_clear_flags ();
13217 inexact = func (m1, m1, m2, m3, rnd);
13218 result = do_mpfr_ckconv (m1, type, inexact);
13219 mpfr_clears (m1, m2, m3, NULL);
13226 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13227 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13228 If ARG_SINP and ARG_COSP are NULL then the result is returned
13229 as a complex value.
13230 The type is taken from the type of ARG and is used for setting the
13231 precision of the calculation and results. */
13234 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13236 tree const type = TREE_TYPE (arg);
13237 tree result = NULL_TREE;
13241 /* To proceed, MPFR must exactly represent the target floating point
13242 format, which only happens when the target base equals two. */
13243 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13244 && TREE_CODE (arg) == REAL_CST
13245 && !TREE_OVERFLOW (arg))
13247 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13249 if (real_isfinite (ra))
13251 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13252 const int prec = fmt->p;
13253 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13254 tree result_s, result_c;
13258 mpfr_inits2 (prec, m, ms, mc, NULL);
13259 mpfr_from_real (m, ra, GMP_RNDN);
13260 mpfr_clear_flags ();
13261 inexact = mpfr_sin_cos (ms, mc, m, rnd);
13262 result_s = do_mpfr_ckconv (ms, type, inexact);
13263 result_c = do_mpfr_ckconv (mc, type, inexact);
13264 mpfr_clears (m, ms, mc, NULL);
13265 if (result_s && result_c)
13267 /* If we are to return in a complex value do so. */
13268 if (!arg_sinp && !arg_cosp)
13269 return build_complex (build_complex_type (type),
13270 result_c, result_s);
13272 /* Dereference the sin/cos pointer arguments. */
13273 arg_sinp = build_fold_indirect_ref (arg_sinp);
13274 arg_cosp = build_fold_indirect_ref (arg_cosp);
13275 /* Proceed if valid pointer type were passed in. */
13276 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13277 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13279 /* Set the values. */
13280 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13282 TREE_SIDE_EFFECTS (result_s) = 1;
13283 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13285 TREE_SIDE_EFFECTS (result_c) = 1;
13286 /* Combine the assignments into a compound expr. */
13287 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13288 result_s, result_c));
13296 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13297 two-argument mpfr order N Bessel function FUNC on them and return
13298 the resulting value as a tree with type TYPE. The mpfr precision
13299 is set to the precision of TYPE. We assume that function FUNC
13300 returns zero if the result could be calculated exactly within the
13301 requested precision. */
13303 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13304 int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13305 const REAL_VALUE_TYPE *min, bool inclusive)
13307 tree result = NULL_TREE;
13312 /* To proceed, MPFR must exactly represent the target floating point
13313 format, which only happens when the target base equals two. */
13314 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13315 && host_integerp (arg1, 0)
13316 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13318 const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13319 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13322 && real_isfinite (ra)
13323 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13325 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13326 const int prec = fmt->p;
13327 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13331 mpfr_init2 (m, prec);
13332 mpfr_from_real (m, ra, GMP_RNDN);
13333 mpfr_clear_flags ();
13334 inexact = func (m, n, m, rnd);
13335 result = do_mpfr_ckconv (m, type, inexact);
13343 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13344 the pointer *(ARG_QUO) and return the result. The type is taken
13345 from the type of ARG0 and is used for setting the precision of the
13346 calculation and results. */
13349 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13351 tree const type = TREE_TYPE (arg0);
13352 tree result = NULL_TREE;
13357 /* To proceed, MPFR must exactly represent the target floating point
13358 format, which only happens when the target base equals two. */
13359 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13360 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13361 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13363 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13364 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13366 if (real_isfinite (ra0) && real_isfinite (ra1))
13368 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13369 const int prec = fmt->p;
13370 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13375 mpfr_inits2 (prec, m0, m1, NULL);
13376 mpfr_from_real (m0, ra0, GMP_RNDN);
13377 mpfr_from_real (m1, ra1, GMP_RNDN);
13378 mpfr_clear_flags ();
13379 mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13380 /* Remquo is independent of the rounding mode, so pass
13381 inexact=0 to do_mpfr_ckconv(). */
13382 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13383 mpfr_clears (m0, m1, NULL);
13386 /* MPFR calculates quo in the host's long so it may
13387 return more bits in quo than the target int can hold
13388 if sizeof(host long) > sizeof(target int). This can
13389 happen even for native compilers in LP64 mode. In
13390 these cases, modulo the quo value with the largest
13391 number that the target int can hold while leaving one
13392 bit for the sign. */
13393 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13394 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13396 /* Dereference the quo pointer argument. */
13397 arg_quo = build_fold_indirect_ref (arg_quo);
13398 /* Proceed iff a valid pointer type was passed in. */
13399 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13401 /* Set the value. */
13402 tree result_quo = fold_build2 (MODIFY_EXPR,
13403 TREE_TYPE (arg_quo), arg_quo,
13404 build_int_cst (NULL, integer_quo));
13405 TREE_SIDE_EFFECTS (result_quo) = 1;
13406 /* Combine the quo assignment with the rem. */
13407 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13408 result_quo, result_rem));
13416 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13417 resulting value as a tree with type TYPE. The mpfr precision is
13418 set to the precision of TYPE. We assume that this mpfr function
13419 returns zero if the result could be calculated exactly within the
13420 requested precision. In addition, the integer pointer represented
13421 by ARG_SG will be dereferenced and set to the appropriate signgam
13425 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13427 tree result = NULL_TREE;
13431 /* To proceed, MPFR must exactly represent the target floating point
13432 format, which only happens when the target base equals two. Also
13433 verify ARG is a constant and that ARG_SG is an int pointer. */
13434 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13435 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13436 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13437 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13439 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13441 /* In addition to NaN and Inf, the argument cannot be zero or a
13442 negative integer. */
13443 if (real_isfinite (ra)
13444 && ra->cl != rvc_zero
13445 && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13447 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13448 const int prec = fmt->p;
13449 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13454 mpfr_init2 (m, prec);
13455 mpfr_from_real (m, ra, GMP_RNDN);
13456 mpfr_clear_flags ();
13457 inexact = mpfr_lgamma (m, &sg, m, rnd);
13458 result_lg = do_mpfr_ckconv (m, type, inexact);
13464 /* Dereference the arg_sg pointer argument. */
13465 arg_sg = build_fold_indirect_ref (arg_sg);
13466 /* Assign the signgam value into *arg_sg. */
13467 result_sg = fold_build2 (MODIFY_EXPR,
13468 TREE_TYPE (arg_sg), arg_sg,
13469 build_int_cst (NULL, sg));
13470 TREE_SIDE_EFFECTS (result_sg) = 1;
13471 /* Combine the signgam assignment with the lgamma result. */
13472 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13473 result_sg, result_lg));
13482 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13483 function FUNC on it and return the resulting value as a tree with
13484 type TYPE. The mpfr precision is set to the precision of TYPE. We
13485 assume that function FUNC returns zero if the result could be
13486 calculated exactly within the requested precision. */
13489 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13491 tree result = NULL_TREE;
13495 /* To proceed, MPFR must exactly represent the target floating point
13496 format, which only happens when the target base equals two. */
13497 if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13498 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13499 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13501 const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13502 const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13504 if (real_isfinite (re) && real_isfinite (im))
13506 const struct real_format *const fmt =
13507 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13508 const int prec = fmt->p;
13509 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13510 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13514 mpc_init2 (m, prec);
13515 mpfr_from_real (mpc_realref(m), re, rnd);
13516 mpfr_from_real (mpc_imagref(m), im, rnd);
13517 mpfr_clear_flags ();
13518 inexact = func (m, m, crnd);
13519 result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13527 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13528 mpc function FUNC on it and return the resulting value as a tree
13529 with type TYPE. The mpfr precision is set to the precision of
13530 TYPE. We assume that function FUNC returns zero if the result
13531 could be calculated exactly within the requested precision. If
13532 DO_NONFINITE is true, then fold expressions containing Inf or NaN
13533 in the arguments and/or results. */
13537 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13538 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13540 tree result = NULL_TREE;
13545 /* To proceed, MPFR must exactly represent the target floating point
13546 format, which only happens when the target base equals two. */
13547 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13548 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13549 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13550 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13551 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13553 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13554 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13555 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13556 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13559 || (real_isfinite (re0) && real_isfinite (im0)
13560 && real_isfinite (re1) && real_isfinite (im1)))
13562 const struct real_format *const fmt =
13563 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13564 const int prec = fmt->p;
13565 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13566 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13570 mpc_init2 (m0, prec);
13571 mpc_init2 (m1, prec);
13572 mpfr_from_real (mpc_realref(m0), re0, rnd);
13573 mpfr_from_real (mpc_imagref(m0), im0, rnd);
13574 mpfr_from_real (mpc_realref(m1), re1, rnd);
13575 mpfr_from_real (mpc_imagref(m1), im1, rnd);
13576 mpfr_clear_flags ();
13577 inexact = func (m0, m0, m1, crnd);
13578 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13587 #endif /* HAVE_mpc */
13590 The functions below provide an alternate interface for folding
13591 builtin function calls presented as GIMPLE_CALL statements rather
13592 than as CALL_EXPRs. The folded result is still expressed as a
13593 tree. There is too much code duplication in the handling of
13594 varargs functions, and a more intrusive re-factoring would permit
13595 better sharing of code between the tree and statement-based
13596 versions of these functions. */
13598 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13599 along with N new arguments specified as the "..." parameters. SKIP
13600 is the number of arguments in STMT to be omitted. This function is used
13601 to do varargs-to-varargs transformations. */
13604 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13606 int oldnargs = gimple_call_num_args (stmt);
13607 int nargs = oldnargs - skip + n;
13608 tree fntype = TREE_TYPE (fndecl);
13609 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13613 location_t loc = gimple_location (stmt);
13615 buffer = XALLOCAVEC (tree, nargs);
13617 for (i = 0; i < n; i++)
13618 buffer[i] = va_arg (ap, tree);
13620 for (j = skip; j < oldnargs; j++, i++)
13621 buffer[i] = gimple_call_arg (stmt, j);
13623 return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13626 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
13627 a normal call should be emitted rather than expanding the function
13628 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13631 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13633 tree dest, size, len, fn, fmt, flag;
13634 const char *fmt_str;
13635 int nargs = gimple_call_num_args (stmt);
13637 /* Verify the required arguments in the original call. */
13640 dest = gimple_call_arg (stmt, 0);
13641 if (!validate_arg (dest, POINTER_TYPE))
13643 flag = gimple_call_arg (stmt, 1);
13644 if (!validate_arg (flag, INTEGER_TYPE))
13646 size = gimple_call_arg (stmt, 2);
13647 if (!validate_arg (size, INTEGER_TYPE))
13649 fmt = gimple_call_arg (stmt, 3);
13650 if (!validate_arg (fmt, POINTER_TYPE))
13653 if (! host_integerp (size, 1))
13658 if (!init_target_chars ())
13661 /* Check whether the format is a literal string constant. */
13662 fmt_str = c_getstr (fmt);
13663 if (fmt_str != NULL)
13665 /* If the format doesn't contain % args or %%, we know the size. */
13666 if (strchr (fmt_str, target_percent) == 0)
13668 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13669 len = build_int_cstu (size_type_node, strlen (fmt_str));
13671 /* If the format is "%s" and first ... argument is a string literal,
13672 we know the size too. */
13673 else if (fcode == BUILT_IN_SPRINTF_CHK
13674 && strcmp (fmt_str, target_percent_s) == 0)
13680 arg = gimple_call_arg (stmt, 4);
13681 if (validate_arg (arg, POINTER_TYPE))
13683 len = c_strlen (arg, 1);
13684 if (! len || ! host_integerp (len, 1))
13691 if (! integer_all_onesp (size))
13693 if (! len || ! tree_int_cst_lt (len, size))
13697 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13698 or if format doesn't contain % chars or is "%s". */
13699 if (! integer_zerop (flag))
13701 if (fmt_str == NULL)
13703 if (strchr (fmt_str, target_percent) != NULL
13704 && strcmp (fmt_str, target_percent_s))
13708 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
13709 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13710 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13714 return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13717 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
13718 a normal call should be emitted rather than expanding the function
13719 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13720 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13721 passed as second argument. */
13724 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13725 enum built_in_function fcode)
13727 tree dest, size, len, fn, fmt, flag;
13728 const char *fmt_str;
13730 /* Verify the required arguments in the original call. */
13731 if (gimple_call_num_args (stmt) < 5)
13733 dest = gimple_call_arg (stmt, 0);
13734 if (!validate_arg (dest, POINTER_TYPE))
13736 len = gimple_call_arg (stmt, 1);
13737 if (!validate_arg (len, INTEGER_TYPE))
13739 flag = gimple_call_arg (stmt, 2);
13740 if (!validate_arg (flag, INTEGER_TYPE))
13742 size = gimple_call_arg (stmt, 3);
13743 if (!validate_arg (size, INTEGER_TYPE))
13745 fmt = gimple_call_arg (stmt, 4);
13746 if (!validate_arg (fmt, POINTER_TYPE))
13749 if (! host_integerp (size, 1))
13752 if (! integer_all_onesp (size))
13754 if (! host_integerp (len, 1))
13756 /* If LEN is not constant, try MAXLEN too.
13757 For MAXLEN only allow optimizing into non-_ocs function
13758 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
13759 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13765 if (tree_int_cst_lt (size, maxlen))
13769 if (!init_target_chars ())
13772 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13773 or if format doesn't contain % chars or is "%s". */
13774 if (! integer_zerop (flag))
13776 fmt_str = c_getstr (fmt);
13777 if (fmt_str == NULL)
13779 if (strchr (fmt_str, target_percent) != NULL
13780 && strcmp (fmt_str, target_percent_s))
13784 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13786 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13787 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13791 return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13794 /* Builtins with folding operations that operate on "..." arguments
13795 need special handling; we need to store the arguments in a convenient
13796 data structure before attempting any folding. Fortunately there are
13797 only a few builtins that fall into this category. FNDECL is the
13798 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13799 result of the function call is ignored. */
13802 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13803 bool ignore ATTRIBUTE_UNUSED)
13805 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13806 tree ret = NULL_TREE;
13810 case BUILT_IN_SPRINTF_CHK:
13811 case BUILT_IN_VSPRINTF_CHK:
13812 ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13815 case BUILT_IN_SNPRINTF_CHK:
13816 case BUILT_IN_VSNPRINTF_CHK:
13817 ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13824 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13825 TREE_NO_WARNING (ret) = 1;
13831 /* A wrapper function for builtin folding that prevents warnings for
13832 "statement without effect" and the like, caused by removing the
13833 call node earlier than the warning is generated. */
13836 fold_call_stmt (gimple stmt, bool ignore)
13838 tree ret = NULL_TREE;
13839 tree fndecl = gimple_call_fndecl (stmt);
13840 location_t loc = gimple_location (stmt);
13842 && TREE_CODE (fndecl) == FUNCTION_DECL
13843 && DECL_BUILT_IN (fndecl)
13844 && !gimple_call_va_arg_pack_p (stmt))
13846 int nargs = gimple_call_num_args (stmt);
13848 if (avoid_folding_inline_builtin (fndecl))
13850 /* FIXME: Don't use a list in this interface. */
13851 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13853 tree arglist = NULL_TREE;
13855 for (i = nargs - 1; i >= 0; i--)
13856 arglist = tree_cons (NULL_TREE, gimple_call_arg (stmt, i), arglist);
13857 return targetm.fold_builtin (fndecl, arglist, ignore);
13861 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13863 tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13865 for (i = 0; i < nargs; i++)
13866 args[i] = gimple_call_arg (stmt, i);
13867 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13870 ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13873 /* Propagate location information from original call to
13874 expansion of builtin. Otherwise things like
13875 maybe_emit_chk_warning, that operate on the expansion
13876 of a builtin, will use the wrong location information. */
13877 if (gimple_has_location (stmt))
13879 tree realret = ret;
13880 if (TREE_CODE (ret) == NOP_EXPR)
13881 realret = TREE_OPERAND (ret, 0);
13882 if (CAN_HAVE_LOCATION_P (realret)
13883 && !EXPR_HAS_LOCATION (realret))
13884 SET_EXPR_LOCATION (realret, loc);
13894 /* Look up the function in built_in_decls that corresponds to DECL
13895 and set ASMSPEC as its user assembler name. DECL must be a
13896 function decl that declares a builtin. */
13899 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13902 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13903 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13906 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13907 set_user_assembler_name (builtin, asmspec);
13908 switch (DECL_FUNCTION_CODE (decl))
13910 case BUILT_IN_MEMCPY:
13911 init_block_move_fn (asmspec);
13912 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13914 case BUILT_IN_MEMSET:
13915 init_block_clear_fn (asmspec);
13916 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13918 case BUILT_IN_MEMMOVE:
13919 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13921 case BUILT_IN_MEMCMP:
13922 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13924 case BUILT_IN_ABORT:
13925 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);