1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
33 #include "hard-reg-set.h"
36 #include "insn-config.h"
42 #include "typeclass.h"
47 #include "langhooks.h"
48 #include "basic-block.h"
49 #include "tree-mudflap.h"
50 #include "tree-flow.h"
51 #include "value-prof.h"
52 #include "diagnostic-core.h"
55 #ifndef SLOW_UNALIGNED_ACCESS
56 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
59 #ifndef PAD_VARARGS_DOWN
60 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
62 static tree
do_mpc_arg1 (tree
, tree
, int (*)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
));
64 struct target_builtins default_target_builtins
;
66 struct target_builtins
*this_target_builtins
= &default_target_builtins
;
69 /* Define the names of the builtin function types and codes. */
70 const char *const built_in_class_names
[4]
71 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
73 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
74 const char * built_in_names
[(int) END_BUILTINS
] =
76 #include "builtins.def"
80 /* Setup an array of _DECL trees, make sure each element is
81 initialized to NULL_TREE. */
82 tree built_in_decls
[(int) END_BUILTINS
];
83 /* Declarations used when constructing the builtin implicitly in the compiler.
84 It may be NULL_TREE when this is invalid (for instance runtime is not
85 required to implement the function call in all cases). */
86 tree implicit_built_in_decls
[(int) END_BUILTINS
];
88 static const char *c_getstr (tree
);
89 static rtx
c_readstr (const char *, enum machine_mode
);
90 static int target_char_cast (tree
, char *);
91 static rtx
get_memory_rtx (tree
, tree
);
92 static int apply_args_size (void);
93 static int apply_result_size (void);
94 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
95 static rtx
result_vector (int, rtx
);
97 static void expand_builtin_update_setjmp_buf (rtx
);
98 static void expand_builtin_prefetch (tree
);
99 static rtx
expand_builtin_apply_args (void);
100 static rtx
expand_builtin_apply_args_1 (void);
101 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
102 static void expand_builtin_return (rtx
);
103 static enum type_class
type_to_class (tree
);
104 static rtx
expand_builtin_classify_type (tree
);
105 static void expand_errno_check (tree
, rtx
);
106 static rtx
expand_builtin_mathfn (tree
, rtx
, rtx
);
107 static rtx
expand_builtin_mathfn_2 (tree
, rtx
, rtx
);
108 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
109 static rtx
expand_builtin_interclass_mathfn (tree
, rtx
, rtx
);
110 static rtx
expand_builtin_sincos (tree
);
111 static rtx
expand_builtin_cexpi (tree
, rtx
, rtx
);
112 static rtx
expand_builtin_int_roundingfn (tree
, rtx
);
113 static rtx
expand_builtin_int_roundingfn_2 (tree
, rtx
);
114 static rtx
expand_builtin_next_arg (void);
115 static rtx
expand_builtin_va_start (tree
);
116 static rtx
expand_builtin_va_end (tree
);
117 static rtx
expand_builtin_va_copy (tree
);
118 static rtx
expand_builtin_memcmp (tree
, rtx
, enum machine_mode
);
119 static rtx
expand_builtin_strcmp (tree
, rtx
);
120 static rtx
expand_builtin_strncmp (tree
, rtx
, enum machine_mode
);
121 static rtx
builtin_memcpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
122 static rtx
expand_builtin_memcpy (tree
, rtx
);
123 static rtx
expand_builtin_mempcpy (tree
, rtx
, enum machine_mode
);
124 static rtx
expand_builtin_mempcpy_args (tree
, tree
, tree
, rtx
,
125 enum machine_mode
, int);
126 static rtx
expand_builtin_strcpy (tree
, rtx
);
127 static rtx
expand_builtin_strcpy_args (tree
, tree
, rtx
);
128 static rtx
expand_builtin_stpcpy (tree
, rtx
, enum machine_mode
);
129 static rtx
expand_builtin_strncpy (tree
, rtx
);
130 static rtx
builtin_memset_gen_str (void *, HOST_WIDE_INT
, enum machine_mode
);
131 static rtx
expand_builtin_memset (tree
, rtx
, enum machine_mode
);
132 static rtx
expand_builtin_memset_args (tree
, tree
, tree
, rtx
, enum machine_mode
, tree
);
133 static rtx
expand_builtin_bzero (tree
);
134 static rtx
expand_builtin_strlen (tree
, rtx
, enum machine_mode
);
135 static rtx
expand_builtin_alloca (tree
, rtx
, bool);
136 static rtx
expand_builtin_unop (enum machine_mode
, tree
, rtx
, rtx
, optab
);
137 static rtx
expand_builtin_frame_address (tree
, tree
);
138 static tree
stabilize_va_list_loc (location_t
, tree
, int);
139 static rtx
expand_builtin_expect (tree
, rtx
);
140 static tree
fold_builtin_constant_p (tree
);
141 static tree
fold_builtin_expect (location_t
, tree
, tree
);
142 static tree
fold_builtin_classify_type (tree
);
143 static tree
fold_builtin_strlen (location_t
, tree
, tree
);
144 static tree
fold_builtin_inf (location_t
, tree
, int);
145 static tree
fold_builtin_nan (tree
, tree
, int);
146 static tree
rewrite_call_expr (location_t
, tree
, int, tree
, int, ...);
147 static bool validate_arg (const_tree
, enum tree_code code
);
148 static bool integer_valued_real_p (tree
);
149 static tree
fold_trunc_transparent_mathfn (location_t
, tree
, tree
);
150 static bool readonly_data_expr (tree
);
151 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
152 static rtx
expand_builtin_signbit (tree
, rtx
);
153 static tree
fold_builtin_sqrt (location_t
, tree
, tree
);
154 static tree
fold_builtin_cbrt (location_t
, tree
, tree
);
155 static tree
fold_builtin_pow (location_t
, tree
, tree
, tree
, tree
);
156 static tree
fold_builtin_powi (location_t
, tree
, tree
, tree
, tree
);
157 static tree
fold_builtin_cos (location_t
, tree
, tree
, tree
);
158 static tree
fold_builtin_cosh (location_t
, tree
, tree
, tree
);
159 static tree
fold_builtin_tan (tree
, tree
);
160 static tree
fold_builtin_trunc (location_t
, tree
, tree
);
161 static tree
fold_builtin_floor (location_t
, tree
, tree
);
162 static tree
fold_builtin_ceil (location_t
, tree
, tree
);
163 static tree
fold_builtin_round (location_t
, tree
, tree
);
164 static tree
fold_builtin_int_roundingfn (location_t
, tree
, tree
);
165 static tree
fold_builtin_bitop (tree
, tree
);
166 static tree
fold_builtin_memory_op (location_t
, tree
, tree
, tree
, tree
, bool, int);
167 static tree
fold_builtin_strchr (location_t
, tree
, tree
, tree
);
168 static tree
fold_builtin_memchr (location_t
, tree
, tree
, tree
, tree
);
169 static tree
fold_builtin_memcmp (location_t
, tree
, tree
, tree
);
170 static tree
fold_builtin_strcmp (location_t
, tree
, tree
);
171 static tree
fold_builtin_strncmp (location_t
, tree
, tree
, tree
);
172 static tree
fold_builtin_signbit (location_t
, tree
, tree
);
173 static tree
fold_builtin_copysign (location_t
, tree
, tree
, tree
, tree
);
174 static tree
fold_builtin_isascii (location_t
, tree
);
175 static tree
fold_builtin_toascii (location_t
, tree
);
176 static tree
fold_builtin_isdigit (location_t
, tree
);
177 static tree
fold_builtin_fabs (location_t
, tree
, tree
);
178 static tree
fold_builtin_abs (location_t
, tree
, tree
);
179 static tree
fold_builtin_unordered_cmp (location_t
, tree
, tree
, tree
, enum tree_code
,
181 static tree
fold_builtin_n (location_t
, tree
, tree
*, int, bool);
182 static tree
fold_builtin_0 (location_t
, tree
, bool);
183 static tree
fold_builtin_1 (location_t
, tree
, tree
, bool);
184 static tree
fold_builtin_2 (location_t
, tree
, tree
, tree
, bool);
185 static tree
fold_builtin_3 (location_t
, tree
, tree
, tree
, tree
, bool);
186 static tree
fold_builtin_4 (location_t
, tree
, tree
, tree
, tree
, tree
, bool);
187 static tree
fold_builtin_varargs (location_t
, tree
, tree
, bool);
189 static tree
fold_builtin_strpbrk (location_t
, tree
, tree
, tree
);
190 static tree
fold_builtin_strstr (location_t
, tree
, tree
, tree
);
191 static tree
fold_builtin_strrchr (location_t
, tree
, tree
, tree
);
192 static tree
fold_builtin_strcat (location_t
, tree
, tree
);
193 static tree
fold_builtin_strncat (location_t
, tree
, tree
, tree
);
194 static tree
fold_builtin_strspn (location_t
, tree
, tree
);
195 static tree
fold_builtin_strcspn (location_t
, tree
, tree
);
196 static tree
fold_builtin_sprintf (location_t
, tree
, tree
, tree
, int);
198 static rtx
expand_builtin_object_size (tree
);
199 static rtx
expand_builtin_memory_chk (tree
, rtx
, enum machine_mode
,
200 enum built_in_function
);
201 static void maybe_emit_chk_warning (tree
, enum built_in_function
);
202 static void maybe_emit_sprintf_chk_warning (tree
, enum built_in_function
);
203 static void maybe_emit_free_warning (tree
);
204 static tree
fold_builtin_object_size (tree
, tree
);
205 static tree
fold_builtin_strcat_chk (location_t
, tree
, tree
, tree
, tree
);
206 static tree
fold_builtin_strncat_chk (location_t
, tree
, tree
, tree
, tree
, tree
);
207 static tree
fold_builtin_sprintf_chk (location_t
, tree
, enum built_in_function
);
208 static tree
fold_builtin_printf (location_t
, tree
, tree
, tree
, bool, enum built_in_function
);
209 static tree
fold_builtin_fprintf (location_t
, tree
, tree
, tree
, tree
, bool,
210 enum built_in_function
);
211 static bool init_target_chars (void);
213 static unsigned HOST_WIDE_INT target_newline
;
214 static unsigned HOST_WIDE_INT target_percent
;
215 static unsigned HOST_WIDE_INT target_c
;
216 static unsigned HOST_WIDE_INT target_s
;
217 static char target_percent_c
[3];
218 static char target_percent_s
[3];
219 static char target_percent_s_newline
[4];
220 static tree
do_mpfr_arg1 (tree
, tree
, int (*)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
221 const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, bool);
222 static tree
do_mpfr_arg2 (tree
, tree
, tree
,
223 int (*)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
));
224 static tree
do_mpfr_arg3 (tree
, tree
, tree
, tree
,
225 int (*)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
));
226 static tree
do_mpfr_sincos (tree
, tree
, tree
);
227 static tree
do_mpfr_bessel_n (tree
, tree
, tree
,
228 int (*)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
229 const REAL_VALUE_TYPE
*, bool);
230 static tree
do_mpfr_remquo (tree
, tree
, tree
);
231 static tree
do_mpfr_lgamma_r (tree
, tree
, tree
);
233 /* Return true if NAME starts with __builtin_ or __sync_. */
236 is_builtin_name (const char *name
)
238 if (strncmp (name
, "__builtin_", 10) == 0)
240 if (strncmp (name
, "__sync_", 7) == 0)
246 /* Return true if DECL is a function symbol representing a built-in. */
249 is_builtin_fn (tree decl
)
251 return TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
);
255 /* Return true if NODE should be considered for inline expansion regardless
256 of the optimization level. This means whenever a function is invoked with
257 its "internal" name, which normally contains the prefix "__builtin". */
260 called_as_built_in (tree node
)
262 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
263 we want the name used to call the function, not the name it
265 const char *name
= IDENTIFIER_POINTER (DECL_NAME (node
));
266 return is_builtin_name (name
);
269 /* Return the alignment in bits of EXP, an object.
270 Don't return more than MAX_ALIGN no matter what. */
273 get_object_alignment (tree exp
, unsigned int max_align
)
275 HOST_WIDE_INT bitsize
, bitpos
;
277 enum machine_mode mode
;
278 int unsignedp
, volatilep
;
279 unsigned int align
, inner
;
281 /* Get the innermost object and the constant (bitpos) and possibly
282 variable (offset) offset of the access. */
283 exp
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
284 &mode
, &unsignedp
, &volatilep
, true);
286 /* Extract alignment information from the innermost object and
287 possibly adjust bitpos and offset. */
288 if (TREE_CODE (exp
) == CONST_DECL
)
289 exp
= DECL_INITIAL (exp
);
291 && TREE_CODE (exp
) != LABEL_DECL
)
292 align
= DECL_ALIGN (exp
);
293 else if (CONSTANT_CLASS_P (exp
))
295 align
= TYPE_ALIGN (TREE_TYPE (exp
));
296 #ifdef CONSTANT_ALIGNMENT
297 align
= (unsigned)CONSTANT_ALIGNMENT (exp
, align
);
300 else if (TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
301 align
= TYPE_ALIGN (TREE_TYPE (exp
));
302 else if (TREE_CODE (exp
) == INDIRECT_REF
)
303 align
= TYPE_ALIGN (TREE_TYPE (exp
));
304 else if (TREE_CODE (exp
) == MISALIGNED_INDIRECT_REF
)
306 tree op1
= TREE_OPERAND (exp
, 1);
307 align
= integer_zerop (op1
) ? BITS_PER_UNIT
: TREE_INT_CST_LOW (op1
);
309 else if (TREE_CODE (exp
) == MEM_REF
)
311 tree addr
= TREE_OPERAND (exp
, 0);
312 struct ptr_info_def
*pi
;
313 if (TREE_CODE (addr
) == BIT_AND_EXPR
314 && TREE_CODE (TREE_OPERAND (addr
, 1)) == INTEGER_CST
)
316 align
= (TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1))
317 & -TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1)));
318 align
*= BITS_PER_UNIT
;
319 addr
= TREE_OPERAND (addr
, 0);
322 align
= BITS_PER_UNIT
;
323 if (TREE_CODE (addr
) == SSA_NAME
324 && (pi
= SSA_NAME_PTR_INFO (addr
)))
326 bitpos
+= (pi
->misalign
* BITS_PER_UNIT
) & ~(align
- 1);
327 align
= MAX (pi
->align
* BITS_PER_UNIT
, align
);
329 else if (TREE_CODE (addr
) == ADDR_EXPR
)
330 align
= MAX (align
, get_object_alignment (TREE_OPERAND (addr
, 0),
332 bitpos
+= mem_ref_offset (exp
).low
* BITS_PER_UNIT
;
334 else if (TREE_CODE (exp
) == TARGET_MEM_REF
336 && POINTER_TYPE_P (TREE_TYPE (TMR_BASE (exp
))))
338 struct ptr_info_def
*pi
;
339 tree addr
= TMR_BASE (exp
);
340 if (TREE_CODE (addr
) == BIT_AND_EXPR
341 && TREE_CODE (TREE_OPERAND (addr
, 1)) == INTEGER_CST
)
343 align
= (TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1))
344 & -TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1)));
345 align
*= BITS_PER_UNIT
;
346 addr
= TREE_OPERAND (addr
, 0);
349 align
= BITS_PER_UNIT
;
350 if (TREE_CODE (addr
) == SSA_NAME
351 && (pi
= SSA_NAME_PTR_INFO (addr
)))
353 bitpos
+= (pi
->misalign
* BITS_PER_UNIT
) & ~(align
- 1);
354 align
= MAX (pi
->align
* BITS_PER_UNIT
, align
);
356 else if (TREE_CODE (addr
) == ADDR_EXPR
)
357 align
= MAX (align
, get_object_alignment (TREE_OPERAND (addr
, 0),
359 if (TMR_OFFSET (exp
))
360 bitpos
+= TREE_INT_CST_LOW (TMR_OFFSET (exp
)) * BITS_PER_UNIT
;
361 if (TMR_INDEX (exp
) && TMR_STEP (exp
))
363 unsigned HOST_WIDE_INT step
= TREE_INT_CST_LOW (TMR_STEP (exp
));
364 align
= MIN (align
, (step
& -step
) * BITS_PER_UNIT
);
366 else if (TMR_INDEX (exp
))
367 align
= BITS_PER_UNIT
;
369 else if (TREE_CODE (exp
) == TARGET_MEM_REF
372 align
= get_object_alignment (TREE_OPERAND (TMR_SYMBOL (exp
), 0),
374 if (TMR_OFFSET (exp
))
375 bitpos
+= TREE_INT_CST_LOW (TMR_OFFSET (exp
)) * BITS_PER_UNIT
;
376 if (TMR_INDEX (exp
) && TMR_STEP (exp
))
378 unsigned HOST_WIDE_INT step
= TREE_INT_CST_LOW (TMR_STEP (exp
));
379 align
= MIN (align
, (step
& -step
) * BITS_PER_UNIT
);
381 else if (TMR_INDEX (exp
))
382 align
= BITS_PER_UNIT
;
384 align
= BITS_PER_UNIT
;
387 align
= BITS_PER_UNIT
;
389 /* If there is a non-constant offset part extract the maximum
390 alignment that can prevail. */
396 if (TREE_CODE (offset
) == PLUS_EXPR
)
398 next_offset
= TREE_OPERAND (offset
, 0);
399 offset
= TREE_OPERAND (offset
, 1);
403 if (host_integerp (offset
, 1))
405 /* Any overflow in calculating offset_bits won't change
408 = ((unsigned) tree_low_cst (offset
, 1) * BITS_PER_UNIT
);
411 inner
= MIN (inner
, (offset_bits
& -offset_bits
));
413 else if (TREE_CODE (offset
) == MULT_EXPR
414 && host_integerp (TREE_OPERAND (offset
, 1), 1))
416 /* Any overflow in calculating offset_factor won't change
418 unsigned offset_factor
419 = ((unsigned) tree_low_cst (TREE_OPERAND (offset
, 1), 1)
423 inner
= MIN (inner
, (offset_factor
& -offset_factor
));
427 inner
= MIN (inner
, BITS_PER_UNIT
);
430 offset
= next_offset
;
433 /* Alignment is innermost object alignment adjusted by the constant
434 and non-constant offset parts. */
435 align
= MIN (align
, inner
);
436 bitpos
= bitpos
& (align
- 1);
438 /* align and bitpos now specify known low bits of the pointer.
439 ptr & (align - 1) == bitpos. */
442 align
= (bitpos
& -bitpos
);
444 return MIN (align
, max_align
);
447 /* Returns true iff we can trust that alignment information has been
448 calculated properly. */
451 can_trust_pointer_alignment (void)
453 /* We rely on TER to compute accurate alignment information. */
454 return (optimize
&& flag_tree_ter
);
457 /* Return the alignment in bits of EXP, a pointer valued expression.
458 But don't return more than MAX_ALIGN no matter what.
459 The alignment returned is, by default, the alignment of the thing that
460 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
462 Otherwise, look at the expression to see if we can do better, i.e., if the
463 expression is actually pointing at an object whose alignment is tighter. */
466 get_pointer_alignment (tree exp
, unsigned int max_align
)
470 if (TREE_CODE (exp
) == ADDR_EXPR
)
471 return get_object_alignment (TREE_OPERAND (exp
, 0), max_align
);
472 else if (TREE_CODE (exp
) == SSA_NAME
473 && POINTER_TYPE_P (TREE_TYPE (exp
)))
475 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (exp
);
478 return BITS_PER_UNIT
;
479 if (pi
->misalign
!= 0)
480 align
= (pi
->misalign
& -pi
->misalign
);
483 return MIN (max_align
, align
* BITS_PER_UNIT
);
486 return POINTER_TYPE_P (TREE_TYPE (exp
)) ? BITS_PER_UNIT
: 0;
489 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
490 way, because it could contain a zero byte in the middle.
491 TREE_STRING_LENGTH is the size of the character array, not the string.
493 ONLY_VALUE should be nonzero if the result is not going to be emitted
494 into the instruction stream and zero if it is going to be expanded.
495 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
496 is returned, otherwise NULL, since
497 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
498 evaluate the side-effects.
500 The value returned is of type `ssizetype'.
502 Unfortunately, string_constant can't access the values of const char
503 arrays with initializers, so neither can we do so here. */
506 c_strlen (tree src
, int only_value
)
509 HOST_WIDE_INT offset
;
515 if (TREE_CODE (src
) == COND_EXPR
516 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
520 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
521 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
522 if (tree_int_cst_equal (len1
, len2
))
526 if (TREE_CODE (src
) == COMPOUND_EXPR
527 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
528 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
530 if (EXPR_HAS_LOCATION (src
))
531 loc
= EXPR_LOCATION (src
);
533 loc
= input_location
;
535 src
= string_constant (src
, &offset_node
);
539 max
= TREE_STRING_LENGTH (src
) - 1;
540 ptr
= TREE_STRING_POINTER (src
);
542 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
544 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
545 compute the offset to the following null if we don't know where to
546 start searching for it. */
549 for (i
= 0; i
< max
; i
++)
553 /* We don't know the starting offset, but we do know that the string
554 has no internal zero bytes. We can assume that the offset falls
555 within the bounds of the string; otherwise, the programmer deserves
556 what he gets. Subtract the offset from the length of the string,
557 and return that. This would perhaps not be valid if we were dealing
558 with named arrays in addition to literal string constants. */
560 return size_diffop_loc (loc
, size_int (max
), offset_node
);
563 /* We have a known offset into the string. Start searching there for
564 a null character if we can represent it as a single HOST_WIDE_INT. */
565 if (offset_node
== 0)
567 else if (! host_integerp (offset_node
, 0))
570 offset
= tree_low_cst (offset_node
, 0);
572 /* If the offset is known to be out of bounds, warn, and call strlen at
574 if (offset
< 0 || offset
> max
)
576 /* Suppress multiple warnings for propagated constant strings. */
577 if (! TREE_NO_WARNING (src
))
579 warning_at (loc
, 0, "offset outside bounds of constant string");
580 TREE_NO_WARNING (src
) = 1;
585 /* Use strlen to search for the first zero byte. Since any strings
586 constructed with build_string will have nulls appended, we win even
587 if we get handed something like (char[4])"abcd".
589 Since OFFSET is our starting index into the string, no further
590 calculation is needed. */
591 return ssize_int (strlen (ptr
+ offset
));
594 /* Return a char pointer for a C string if it is a string constant
595 or sum of string constant and integer constant. */
602 src
= string_constant (src
, &offset_node
);
606 if (offset_node
== 0)
607 return TREE_STRING_POINTER (src
);
608 else if (!host_integerp (offset_node
, 1)
609 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
612 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
615 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
616 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
619 c_readstr (const char *str
, enum machine_mode mode
)
625 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
630 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
633 if (WORDS_BIG_ENDIAN
)
634 j
= GET_MODE_SIZE (mode
) - i
- 1;
635 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
636 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
637 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
639 gcc_assert (j
< 2 * HOST_BITS_PER_WIDE_INT
);
642 ch
= (unsigned char) str
[i
];
643 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
645 return immed_double_const (c
[0], c
[1], mode
);
648 /* Cast a target constant CST to target CHAR and if that value fits into
649 host char type, return zero and put that value into variable pointed to by
653 target_char_cast (tree cst
, char *p
)
655 unsigned HOST_WIDE_INT val
, hostval
;
657 if (!host_integerp (cst
, 1)
658 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
661 val
= tree_low_cst (cst
, 1);
662 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
663 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
666 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
667 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
676 /* Similar to save_expr, but assumes that arbitrary code is not executed
677 in between the multiple evaluations. In particular, we assume that a
678 non-addressable local variable will not be modified. */
681 builtin_save_expr (tree exp
)
683 if (TREE_ADDRESSABLE (exp
) == 0
684 && (TREE_CODE (exp
) == PARM_DECL
685 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
))))
688 return save_expr (exp
);
691 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
692 times to get the address of either a higher stack frame, or a return
693 address located within it (depending on FNDECL_CODE). */
696 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
700 #ifdef INITIAL_FRAME_ADDRESS_RTX
701 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
705 /* For a zero count with __builtin_return_address, we don't care what
706 frame address we return, because target-specific definitions will
707 override us. Therefore frame pointer elimination is OK, and using
708 the soft frame pointer is OK.
710 For a nonzero count, or a zero count with __builtin_frame_address,
711 we require a stable offset from the current frame pointer to the
712 previous one, so we must use the hard frame pointer, and
713 we must disable frame pointer elimination. */
714 if (count
== 0 && fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
715 tem
= frame_pointer_rtx
;
718 tem
= hard_frame_pointer_rtx
;
720 /* Tell reload not to eliminate the frame pointer. */
721 crtl
->accesses_prior_frames
= 1;
725 /* Some machines need special handling before we can access
726 arbitrary frames. For example, on the SPARC, we must first flush
727 all register windows to the stack. */
728 #ifdef SETUP_FRAME_ADDRESSES
730 SETUP_FRAME_ADDRESSES ();
733 /* On the SPARC, the return address is not in the frame, it is in a
734 register. There is no way to access it off of the current frame
735 pointer, but it can be accessed off the previous frame pointer by
736 reading the value from the register window save area. */
737 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
738 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
742 /* Scan back COUNT frames to the specified frame. */
743 for (i
= 0; i
< count
; i
++)
745 /* Assume the dynamic chain pointer is in the word that the
746 frame address points to, unless otherwise specified. */
747 #ifdef DYNAMIC_CHAIN_ADDRESS
748 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
750 tem
= memory_address (Pmode
, tem
);
751 tem
= gen_frame_mem (Pmode
, tem
);
752 tem
= copy_to_reg (tem
);
755 /* For __builtin_frame_address, return what we've got. But, on
756 the SPARC for example, we may have to add a bias. */
757 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
758 #ifdef FRAME_ADDR_RTX
759 return FRAME_ADDR_RTX (tem
);
764 /* For __builtin_return_address, get the return address from that frame. */
765 #ifdef RETURN_ADDR_RTX
766 tem
= RETURN_ADDR_RTX (count
, tem
);
768 tem
= memory_address (Pmode
,
769 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
770 tem
= gen_frame_mem (Pmode
, tem
);
775 /* Alias set used for setjmp buffer. */
776 static alias_set_type setjmp_alias_set
= -1;
778 /* Construct the leading half of a __builtin_setjmp call. Control will
779 return to RECEIVER_LABEL. This is also called directly by the SJLJ
780 exception handling code. */
783 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
785 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
789 if (setjmp_alias_set
== -1)
790 setjmp_alias_set
= new_alias_set ();
792 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
794 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
796 /* We store the frame pointer and the address of receiver_label in
797 the buffer and use the rest of it for the stack save area, which
798 is machine-dependent. */
800 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
801 set_mem_alias_set (mem
, setjmp_alias_set
);
802 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
804 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
805 set_mem_alias_set (mem
, setjmp_alias_set
);
807 emit_move_insn (validize_mem (mem
),
808 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
810 stack_save
= gen_rtx_MEM (sa_mode
,
811 plus_constant (buf_addr
,
812 2 * GET_MODE_SIZE (Pmode
)));
813 set_mem_alias_set (stack_save
, setjmp_alias_set
);
814 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
816 /* If there is further processing to do, do it. */
817 #ifdef HAVE_builtin_setjmp_setup
818 if (HAVE_builtin_setjmp_setup
)
819 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
822 /* Tell optimize_save_area_alloca that extra work is going to
823 need to go on during alloca. */
824 cfun
->calls_setjmp
= 1;
826 /* We have a nonlocal label. */
827 cfun
->has_nonlocal_label
= 1;
830 /* Construct the trailing part of a __builtin_setjmp call. This is
831 also called directly by the SJLJ exception handling code. */
834 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
838 /* Clobber the FP when we get here, so we have to make sure it's
839 marked as used by this function. */
840 emit_use (hard_frame_pointer_rtx
);
842 /* Mark the static chain as clobbered here so life information
843 doesn't get messed up for it. */
844 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
845 if (chain
&& REG_P (chain
))
846 emit_clobber (chain
);
848 /* Now put in the code to restore the frame pointer, and argument
849 pointer, if needed. */
850 #ifdef HAVE_nonlocal_goto
851 if (! HAVE_nonlocal_goto
)
854 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
855 /* This might change the hard frame pointer in ways that aren't
856 apparent to early optimization passes, so force a clobber. */
857 emit_clobber (hard_frame_pointer_rtx
);
860 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
861 if (fixed_regs
[ARG_POINTER_REGNUM
])
863 #ifdef ELIMINABLE_REGS
865 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
867 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
868 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
869 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
872 if (i
== ARRAY_SIZE (elim_regs
))
875 /* Now restore our arg pointer from the address at which it
876 was saved in our stack frame. */
877 emit_move_insn (crtl
->args
.internal_arg_pointer
,
878 copy_to_reg (get_arg_pointer_save_area ()));
883 #ifdef HAVE_builtin_setjmp_receiver
884 if (HAVE_builtin_setjmp_receiver
)
885 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
888 #ifdef HAVE_nonlocal_goto_receiver
889 if (HAVE_nonlocal_goto_receiver
)
890 emit_insn (gen_nonlocal_goto_receiver ());
895 /* We must not allow the code we just generated to be reordered by
896 scheduling. Specifically, the update of the frame pointer must
897 happen immediately, not later. */
898 emit_insn (gen_blockage ());
901 /* __builtin_longjmp is passed a pointer to an array of five words (not
902 all will be used on all machines). It operates similarly to the C
903 library function of the same name, but is more efficient. Much of
904 the code below is copied from the handling of non-local gotos. */
907 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
909 rtx fp
, lab
, stack
, insn
, last
;
910 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
912 /* DRAP is needed for stack realign if longjmp is expanded to current
914 if (SUPPORTS_STACK_ALIGNMENT
)
915 crtl
->need_drap
= true;
917 if (setjmp_alias_set
== -1)
918 setjmp_alias_set
= new_alias_set ();
920 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
922 buf_addr
= force_reg (Pmode
, buf_addr
);
924 /* We require that the user must pass a second argument of 1, because
925 that is what builtin_setjmp will return. */
926 gcc_assert (value
== const1_rtx
);
928 last
= get_last_insn ();
929 #ifdef HAVE_builtin_longjmp
930 if (HAVE_builtin_longjmp
)
931 emit_insn (gen_builtin_longjmp (buf_addr
));
935 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
936 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
937 GET_MODE_SIZE (Pmode
)));
939 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
940 2 * GET_MODE_SIZE (Pmode
)));
941 set_mem_alias_set (fp
, setjmp_alias_set
);
942 set_mem_alias_set (lab
, setjmp_alias_set
);
943 set_mem_alias_set (stack
, setjmp_alias_set
);
945 /* Pick up FP, label, and SP from the block and jump. This code is
946 from expand_goto in stmt.c; see there for detailed comments. */
947 #ifdef HAVE_nonlocal_goto
948 if (HAVE_nonlocal_goto
)
949 /* We have to pass a value to the nonlocal_goto pattern that will
950 get copied into the static_chain pointer, but it does not matter
951 what that value is, because builtin_setjmp does not use it. */
952 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
956 lab
= copy_to_reg (lab
);
958 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
959 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
961 emit_move_insn (hard_frame_pointer_rtx
, fp
);
962 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
964 emit_use (hard_frame_pointer_rtx
);
965 emit_use (stack_pointer_rtx
);
966 emit_indirect_jump (lab
);
970 /* Search backwards and mark the jump insn as a non-local goto.
971 Note that this precludes the use of __builtin_longjmp to a
972 __builtin_setjmp target in the same function. However, we've
973 already cautioned the user that these functions are for
974 internal exception handling use only. */
975 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
977 gcc_assert (insn
!= last
);
981 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
984 else if (CALL_P (insn
))
989 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
990 and the address of the save area. */
993 expand_builtin_nonlocal_goto (tree exp
)
995 tree t_label
, t_save_area
;
996 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
998 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1001 t_label
= CALL_EXPR_ARG (exp
, 0);
1002 t_save_area
= CALL_EXPR_ARG (exp
, 1);
1004 r_label
= expand_normal (t_label
);
1005 r_label
= convert_memory_address (Pmode
, r_label
);
1006 r_save_area
= expand_normal (t_save_area
);
1007 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
1008 /* Copy the address of the save location to a register just in case it was based
1009 on the frame pointer. */
1010 r_save_area
= copy_to_reg (r_save_area
);
1011 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
1012 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
1013 plus_constant (r_save_area
, GET_MODE_SIZE (Pmode
)));
1015 crtl
->has_nonlocal_goto
= 1;
1017 #ifdef HAVE_nonlocal_goto
1018 /* ??? We no longer need to pass the static chain value, afaik. */
1019 if (HAVE_nonlocal_goto
)
1020 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
1024 r_label
= copy_to_reg (r_label
);
1026 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1027 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1029 /* Restore frame pointer for containing function.
1030 This sets the actual hard register used for the frame pointer
1031 to the location of the function's incoming static chain info.
1032 The non-local goto handler will then adjust it to contain the
1033 proper value and reload the argument pointer, if needed. */
1034 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
1035 emit_stack_restore (SAVE_NONLOCAL
, r_sp
, NULL_RTX
);
1037 /* USE of hard_frame_pointer_rtx added for consistency;
1038 not clear if really needed. */
1039 emit_use (hard_frame_pointer_rtx
);
1040 emit_use (stack_pointer_rtx
);
1042 /* If the architecture is using a GP register, we must
1043 conservatively assume that the target function makes use of it.
1044 The prologue of functions with nonlocal gotos must therefore
1045 initialize the GP register to the appropriate value, and we
1046 must then make sure that this value is live at the point
1047 of the jump. (Note that this doesn't necessarily apply
1048 to targets with a nonlocal_goto pattern; they are free
1049 to implement it in their own way. Note also that this is
1050 a no-op if the GP register is a global invariant.) */
1051 if ((unsigned) PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
1052 && fixed_regs
[PIC_OFFSET_TABLE_REGNUM
])
1053 emit_use (pic_offset_table_rtx
);
1055 emit_indirect_jump (r_label
);
1058 /* Search backwards to the jump insn and mark it as a
1060 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1064 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1067 else if (CALL_P (insn
))
1074 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1075 (not all will be used on all machines) that was passed to __builtin_setjmp.
1076 It updates the stack pointer in that block to correspond to the current
1080 expand_builtin_update_setjmp_buf (rtx buf_addr
)
1082 enum machine_mode sa_mode
= Pmode
;
1086 #ifdef HAVE_save_stack_nonlocal
1087 if (HAVE_save_stack_nonlocal
)
1088 sa_mode
= insn_data
[(int) CODE_FOR_save_stack_nonlocal
].operand
[0].mode
;
1090 #ifdef STACK_SAVEAREA_MODE
1091 sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
1095 = gen_rtx_MEM (sa_mode
,
1098 plus_constant (buf_addr
, 2 * GET_MODE_SIZE (Pmode
))));
1102 emit_insn (gen_setjmp ());
1105 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
1108 /* Expand a call to __builtin_prefetch. For a target that does not support
1109 data prefetch, evaluate the memory address argument in case it has side
1113 expand_builtin_prefetch (tree exp
)
1115 tree arg0
, arg1
, arg2
;
1119 if (!validate_arglist (exp
, POINTER_TYPE
, 0))
1122 arg0
= CALL_EXPR_ARG (exp
, 0);
1124 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1125 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1127 nargs
= call_expr_nargs (exp
);
1129 arg1
= CALL_EXPR_ARG (exp
, 1);
1131 arg1
= integer_zero_node
;
1133 arg2
= CALL_EXPR_ARG (exp
, 2);
1135 arg2
= integer_three_node
;
1137 /* Argument 0 is an address. */
1138 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
1140 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1141 if (TREE_CODE (arg1
) != INTEGER_CST
)
1143 error ("second argument to %<__builtin_prefetch%> must be a constant");
1144 arg1
= integer_zero_node
;
1146 op1
= expand_normal (arg1
);
1147 /* Argument 1 must be either zero or one. */
1148 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
1150 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1155 /* Argument 2 (locality) must be a compile-time constant int. */
1156 if (TREE_CODE (arg2
) != INTEGER_CST
)
1158 error ("third argument to %<__builtin_prefetch%> must be a constant");
1159 arg2
= integer_zero_node
;
1161 op2
= expand_normal (arg2
);
1162 /* Argument 2 must be 0, 1, 2, or 3. */
1163 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
1165 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1169 #ifdef HAVE_prefetch
1172 if ((! (*insn_data
[(int) CODE_FOR_prefetch
].operand
[0].predicate
)
1174 insn_data
[(int) CODE_FOR_prefetch
].operand
[0].mode
))
1175 || (GET_MODE (op0
) != Pmode
))
1177 op0
= convert_memory_address (Pmode
, op0
);
1178 op0
= force_reg (Pmode
, op0
);
1180 emit_insn (gen_prefetch (op0
, op1
, op2
));
1184 /* Don't do anything with direct references to volatile memory, but
1185 generate code to handle other side effects. */
1186 if (!MEM_P (op0
) && side_effects_p (op0
))
1190 /* Get a MEM rtx for expression EXP which is the address of an operand
1191 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1192 the maximum length of the block of memory that might be accessed or
1196 get_memory_rtx (tree exp
, tree len
)
1198 tree orig_exp
= exp
;
1202 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1203 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1204 if (TREE_CODE (exp
) == SAVE_EXPR
&& !SAVE_EXPR_RESOLVED_P (exp
))
1205 exp
= TREE_OPERAND (exp
, 0);
1207 addr
= expand_expr (orig_exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1208 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1210 /* Get an expression we can use to find the attributes to assign to MEM.
1211 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1212 we can. First remove any nops. */
1213 while (CONVERT_EXPR_P (exp
)
1214 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1215 exp
= TREE_OPERAND (exp
, 0);
1218 if (TREE_CODE (exp
) == POINTER_PLUS_EXPR
1219 && TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
1220 && host_integerp (TREE_OPERAND (exp
, 1), 0)
1221 && (off
= tree_low_cst (TREE_OPERAND (exp
, 1), 0)) > 0)
1222 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
1223 else if (TREE_CODE (exp
) == ADDR_EXPR
)
1224 exp
= TREE_OPERAND (exp
, 0);
1225 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
1226 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
1230 /* Honor attributes derived from exp, except for the alias set
1231 (as builtin stringops may alias with anything) and the size
1232 (as stringops may access multiple array elements). */
1235 set_mem_attributes (mem
, exp
, 0);
1238 mem
= adjust_automodify_address_nv (mem
, BLKmode
, NULL
, off
);
1240 /* Allow the string and memory builtins to overflow from one
1241 field into another, see http://gcc.gnu.org/PR23561.
1242 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1243 memory accessed by the string or memory builtin will fit
1244 within the field. */
1245 if (MEM_EXPR (mem
) && TREE_CODE (MEM_EXPR (mem
)) == COMPONENT_REF
)
1247 tree mem_expr
= MEM_EXPR (mem
);
1248 HOST_WIDE_INT offset
= -1, length
= -1;
1251 while (TREE_CODE (inner
) == ARRAY_REF
1252 || CONVERT_EXPR_P (inner
)
1253 || TREE_CODE (inner
) == VIEW_CONVERT_EXPR
1254 || TREE_CODE (inner
) == SAVE_EXPR
)
1255 inner
= TREE_OPERAND (inner
, 0);
1257 gcc_assert (TREE_CODE (inner
) == COMPONENT_REF
);
1259 if (MEM_OFFSET (mem
)
1260 && CONST_INT_P (MEM_OFFSET (mem
)))
1261 offset
= INTVAL (MEM_OFFSET (mem
));
1263 if (offset
>= 0 && len
&& host_integerp (len
, 0))
1264 length
= tree_low_cst (len
, 0);
1266 while (TREE_CODE (inner
) == COMPONENT_REF
)
1268 tree field
= TREE_OPERAND (inner
, 1);
1269 gcc_assert (TREE_CODE (mem_expr
) == COMPONENT_REF
);
1270 gcc_assert (field
== TREE_OPERAND (mem_expr
, 1));
1272 /* Bitfields are generally not byte-addressable. */
1273 gcc_assert (!DECL_BIT_FIELD (field
)
1274 || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1275 % BITS_PER_UNIT
) == 0
1276 && host_integerp (DECL_SIZE (field
), 0)
1277 && (TREE_INT_CST_LOW (DECL_SIZE (field
))
1278 % BITS_PER_UNIT
) == 0));
1280 /* If we can prove that the memory starting at XEXP (mem, 0) and
1281 ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1282 can keep the COMPONENT_REF in MEM_EXPR. But be careful with
1283 fields without DECL_SIZE_UNIT like flexible array members. */
1285 && DECL_SIZE_UNIT (field
)
1286 && host_integerp (DECL_SIZE_UNIT (field
), 0))
1289 = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field
));
1292 && offset
+ length
<= size
)
1297 && host_integerp (DECL_FIELD_OFFSET (field
), 0))
1298 offset
+= TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field
))
1299 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1307 mem_expr
= TREE_OPERAND (mem_expr
, 0);
1308 inner
= TREE_OPERAND (inner
, 0);
1311 if (mem_expr
== NULL
)
1313 if (mem_expr
!= MEM_EXPR (mem
))
1315 set_mem_expr (mem
, mem_expr
);
1316 set_mem_offset (mem
, offset
>= 0 ? GEN_INT (offset
) : NULL_RTX
);
1319 set_mem_alias_set (mem
, 0);
1320 set_mem_size (mem
, NULL_RTX
);
1326 /* Built-in functions to perform an untyped call and return. */
1328 #define apply_args_mode \
1329 (this_target_builtins->x_apply_args_mode)
1330 #define apply_result_mode \
1331 (this_target_builtins->x_apply_result_mode)
1333 /* Return the size required for the block returned by __builtin_apply_args,
1334 and initialize apply_args_mode. */
1337 apply_args_size (void)
1339 static int size
= -1;
1342 enum machine_mode mode
;
1344 /* The values computed by this function never change. */
1347 /* The first value is the incoming arg-pointer. */
1348 size
= GET_MODE_SIZE (Pmode
);
1350 /* The second value is the structure value address unless this is
1351 passed as an "invisible" first argument. */
1352 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1353 size
+= GET_MODE_SIZE (Pmode
);
1355 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1356 if (FUNCTION_ARG_REGNO_P (regno
))
1358 mode
= reg_raw_mode
[regno
];
1360 gcc_assert (mode
!= VOIDmode
);
1362 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1363 if (size
% align
!= 0)
1364 size
= CEIL (size
, align
) * align
;
1365 size
+= GET_MODE_SIZE (mode
);
1366 apply_args_mode
[regno
] = mode
;
1370 apply_args_mode
[regno
] = VOIDmode
;
1376 /* Return the size required for the block returned by __builtin_apply,
1377 and initialize apply_result_mode. */
1380 apply_result_size (void)
1382 static int size
= -1;
1384 enum machine_mode mode
;
1386 /* The values computed by this function never change. */
1391 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1392 if (targetm
.calls
.function_value_regno_p (regno
))
1394 mode
= reg_raw_mode
[regno
];
1396 gcc_assert (mode
!= VOIDmode
);
1398 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1399 if (size
% align
!= 0)
1400 size
= CEIL (size
, align
) * align
;
1401 size
+= GET_MODE_SIZE (mode
);
1402 apply_result_mode
[regno
] = mode
;
1405 apply_result_mode
[regno
] = VOIDmode
;
1407 /* Allow targets that use untyped_call and untyped_return to override
1408 the size so that machine-specific information can be stored here. */
1409 #ifdef APPLY_RESULT_SIZE
1410 size
= APPLY_RESULT_SIZE
;
1416 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1417 /* Create a vector describing the result block RESULT. If SAVEP is true,
1418 the result block is used to save the values; otherwise it is used to
1419 restore the values. */
1422 result_vector (int savep
, rtx result
)
1424 int regno
, size
, align
, nelts
;
1425 enum machine_mode mode
;
1427 rtx
*savevec
= XALLOCAVEC (rtx
, FIRST_PSEUDO_REGISTER
);
1430 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1431 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1433 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1434 if (size
% align
!= 0)
1435 size
= CEIL (size
, align
) * align
;
1436 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1437 mem
= adjust_address (result
, mode
, size
);
1438 savevec
[nelts
++] = (savep
1439 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1440 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1441 size
+= GET_MODE_SIZE (mode
);
1443 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1445 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1447 /* Save the state required to perform an untyped call with the same
1448 arguments as were passed to the current function. */
1451 expand_builtin_apply_args_1 (void)
1454 int size
, align
, regno
;
1455 enum machine_mode mode
;
1456 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1458 /* Create a block where the arg-pointer, structure value address,
1459 and argument registers can be saved. */
1460 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1462 /* Walk past the arg-pointer and structure value address. */
1463 size
= GET_MODE_SIZE (Pmode
);
1464 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1465 size
+= GET_MODE_SIZE (Pmode
);
1467 /* Save each register used in calling a function to the block. */
1468 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1469 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1471 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1472 if (size
% align
!= 0)
1473 size
= CEIL (size
, align
) * align
;
1475 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1477 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1478 size
+= GET_MODE_SIZE (mode
);
1481 /* Save the arg pointer to the block. */
1482 tem
= copy_to_reg (crtl
->args
.internal_arg_pointer
);
1483 #ifdef STACK_GROWS_DOWNWARD
1484 /* We need the pointer as the caller actually passed them to us, not
1485 as we might have pretended they were passed. Make sure it's a valid
1486 operand, as emit_move_insn isn't expected to handle a PLUS. */
1488 = force_operand (plus_constant (tem
, crtl
->args
.pretend_args_size
),
1491 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1493 size
= GET_MODE_SIZE (Pmode
);
1495 /* Save the structure value address unless this is passed as an
1496 "invisible" first argument. */
1497 if (struct_incoming_value
)
1499 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1500 copy_to_reg (struct_incoming_value
));
1501 size
+= GET_MODE_SIZE (Pmode
);
1504 /* Return the address of the block. */
1505 return copy_addr_to_reg (XEXP (registers
, 0));
1508 /* __builtin_apply_args returns block of memory allocated on
1509 the stack into which is stored the arg pointer, structure
1510 value address, static chain, and all the registers that might
1511 possibly be used in performing a function call. The code is
1512 moved to the start of the function so the incoming values are
1516 expand_builtin_apply_args (void)
1518 /* Don't do __builtin_apply_args more than once in a function.
1519 Save the result of the first call and reuse it. */
1520 if (apply_args_value
!= 0)
1521 return apply_args_value
;
1523 /* When this function is called, it means that registers must be
1524 saved on entry to this function. So we migrate the
1525 call to the first insn of this function. */
1530 temp
= expand_builtin_apply_args_1 ();
1534 apply_args_value
= temp
;
1536 /* Put the insns after the NOTE that starts the function.
1537 If this is inside a start_sequence, make the outer-level insn
1538 chain current, so the code is placed at the start of the
1539 function. If internal_arg_pointer is a non-virtual pseudo,
1540 it needs to be placed after the function that initializes
1542 push_topmost_sequence ();
1543 if (REG_P (crtl
->args
.internal_arg_pointer
)
1544 && REGNO (crtl
->args
.internal_arg_pointer
) > LAST_VIRTUAL_REGISTER
)
1545 emit_insn_before (seq
, parm_birth_insn
);
1547 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1548 pop_topmost_sequence ();
1553 /* Perform an untyped call and save the state required to perform an
1554 untyped return of whatever value was returned by the given function. */
1557 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1559 int size
, align
, regno
;
1560 enum machine_mode mode
;
1561 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1562 rtx old_stack_level
= 0;
1563 rtx call_fusage
= 0;
1564 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1566 arguments
= convert_memory_address (Pmode
, arguments
);
1568 /* Create a block where the return registers can be saved. */
1569 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1571 /* Fetch the arg pointer from the ARGUMENTS block. */
1572 incoming_args
= gen_reg_rtx (Pmode
);
1573 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1574 #ifndef STACK_GROWS_DOWNWARD
1575 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1576 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1579 /* Push a new argument block and copy the arguments. Do not allow
1580 the (potential) memcpy call below to interfere with our stack
1582 do_pending_stack_adjust ();
1585 /* Save the stack with nonlocal if available. */
1586 #ifdef HAVE_save_stack_nonlocal
1587 if (HAVE_save_stack_nonlocal
)
1588 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1591 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1593 /* Allocate a block of memory onto the stack and copy the memory
1594 arguments to the outgoing arguments address. We can pass TRUE
1595 as the 4th argument because we just saved the stack pointer
1596 and will restore it right after the call. */
1597 allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
, TRUE
);
1599 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1600 may have already set current_function_calls_alloca to true.
1601 current_function_calls_alloca won't be set if argsize is zero,
1602 so we have to guarantee need_drap is true here. */
1603 if (SUPPORTS_STACK_ALIGNMENT
)
1604 crtl
->need_drap
= true;
1606 dest
= virtual_outgoing_args_rtx
;
1607 #ifndef STACK_GROWS_DOWNWARD
1608 if (CONST_INT_P (argsize
))
1609 dest
= plus_constant (dest
, -INTVAL (argsize
));
1611 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1613 dest
= gen_rtx_MEM (BLKmode
, dest
);
1614 set_mem_align (dest
, PARM_BOUNDARY
);
1615 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1616 set_mem_align (src
, PARM_BOUNDARY
);
1617 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1619 /* Refer to the argument block. */
1621 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1622 set_mem_align (arguments
, PARM_BOUNDARY
);
1624 /* Walk past the arg-pointer and structure value address. */
1625 size
= GET_MODE_SIZE (Pmode
);
1627 size
+= GET_MODE_SIZE (Pmode
);
1629 /* Restore each of the registers previously saved. Make USE insns
1630 for each of these registers for use in making the call. */
1631 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1632 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1634 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1635 if (size
% align
!= 0)
1636 size
= CEIL (size
, align
) * align
;
1637 reg
= gen_rtx_REG (mode
, regno
);
1638 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1639 use_reg (&call_fusage
, reg
);
1640 size
+= GET_MODE_SIZE (mode
);
1643 /* Restore the structure value address unless this is passed as an
1644 "invisible" first argument. */
1645 size
= GET_MODE_SIZE (Pmode
);
1648 rtx value
= gen_reg_rtx (Pmode
);
1649 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1650 emit_move_insn (struct_value
, value
);
1651 if (REG_P (struct_value
))
1652 use_reg (&call_fusage
, struct_value
);
1653 size
+= GET_MODE_SIZE (Pmode
);
1656 /* All arguments and registers used for the call are set up by now! */
1657 function
= prepare_call_address (NULL
, function
, NULL
, &call_fusage
, 0, 0);
1659 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1660 and we don't want to load it into a register as an optimization,
1661 because prepare_call_address already did it if it should be done. */
1662 if (GET_CODE (function
) != SYMBOL_REF
)
1663 function
= memory_address (FUNCTION_MODE
, function
);
1665 /* Generate the actual call instruction and save the return value. */
1666 #ifdef HAVE_untyped_call
1667 if (HAVE_untyped_call
)
1668 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1669 result
, result_vector (1, result
)));
1672 #ifdef HAVE_call_value
1673 if (HAVE_call_value
)
1677 /* Locate the unique return register. It is not possible to
1678 express a call that sets more than one return register using
1679 call_value; use untyped_call for that. In fact, untyped_call
1680 only needs to save the return registers in the given block. */
1681 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1682 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1684 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1686 valreg
= gen_rtx_REG (mode
, regno
);
1689 emit_call_insn (GEN_CALL_VALUE (valreg
,
1690 gen_rtx_MEM (FUNCTION_MODE
, function
),
1691 const0_rtx
, NULL_RTX
, const0_rtx
));
1693 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1699 /* Find the CALL insn we just emitted, and attach the register usage
1701 call_insn
= last_call_insn ();
1702 add_function_usage_to (call_insn
, call_fusage
);
1704 /* Restore the stack. */
1705 #ifdef HAVE_save_stack_nonlocal
1706 if (HAVE_save_stack_nonlocal
)
1707 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1710 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1714 /* Return the address of the result block. */
1715 result
= copy_addr_to_reg (XEXP (result
, 0));
1716 return convert_memory_address (ptr_mode
, result
);
1719 /* Perform an untyped return. */
1722 expand_builtin_return (rtx result
)
1724 int size
, align
, regno
;
1725 enum machine_mode mode
;
1727 rtx call_fusage
= 0;
1729 result
= convert_memory_address (Pmode
, result
);
1731 apply_result_size ();
1732 result
= gen_rtx_MEM (BLKmode
, result
);
1734 #ifdef HAVE_untyped_return
1735 if (HAVE_untyped_return
)
1737 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1743 /* Restore the return value and note that each value is used. */
1745 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1746 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1748 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1749 if (size
% align
!= 0)
1750 size
= CEIL (size
, align
) * align
;
1751 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1752 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1754 push_to_sequence (call_fusage
);
1756 call_fusage
= get_insns ();
1758 size
+= GET_MODE_SIZE (mode
);
1761 /* Put the USE insns before the return. */
1762 emit_insn (call_fusage
);
1764 /* Return whatever values was restored by jumping directly to the end
1766 expand_naked_return ();
1769 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1771 static enum type_class
1772 type_to_class (tree type
)
1774 switch (TREE_CODE (type
))
1776 case VOID_TYPE
: return void_type_class
;
1777 case INTEGER_TYPE
: return integer_type_class
;
1778 case ENUMERAL_TYPE
: return enumeral_type_class
;
1779 case BOOLEAN_TYPE
: return boolean_type_class
;
1780 case POINTER_TYPE
: return pointer_type_class
;
1781 case REFERENCE_TYPE
: return reference_type_class
;
1782 case OFFSET_TYPE
: return offset_type_class
;
1783 case REAL_TYPE
: return real_type_class
;
1784 case COMPLEX_TYPE
: return complex_type_class
;
1785 case FUNCTION_TYPE
: return function_type_class
;
1786 case METHOD_TYPE
: return method_type_class
;
1787 case RECORD_TYPE
: return record_type_class
;
1789 case QUAL_UNION_TYPE
: return union_type_class
;
1790 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1791 ? string_type_class
: array_type_class
);
1792 case LANG_TYPE
: return lang_type_class
;
1793 default: return no_type_class
;
1797 /* Expand a call EXP to __builtin_classify_type. */
1800 expand_builtin_classify_type (tree exp
)
1802 if (call_expr_nargs (exp
))
1803 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))));
1804 return GEN_INT (no_type_class
);
1807 /* This helper macro, meant to be used in mathfn_built_in below,
1808 determines which among a set of three builtin math functions is
1809 appropriate for a given type mode. The `F' and `L' cases are
1810 automatically generated from the `double' case. */
1811 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1812 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1813 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1814 fcodel = BUILT_IN_MATHFN##L ; break;
1815 /* Similar to above, but appends _R after any F/L suffix. */
1816 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1817 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1818 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1819 fcodel = BUILT_IN_MATHFN##L_R ; break;
1821 /* Return mathematic function equivalent to FN but operating directly
1822 on TYPE, if available. If IMPLICIT is true find the function in
1823 implicit_built_in_decls[], otherwise use built_in_decls[]. If we
1824 can't do the conversion, return zero. */
1827 mathfn_built_in_1 (tree type
, enum built_in_function fn
, bool implicit
)
1829 tree
const *const fn_arr
1830 = implicit
? implicit_built_in_decls
: built_in_decls
;
1831 enum built_in_function fcode
, fcodef
, fcodel
;
1835 CASE_MATHFN (BUILT_IN_ACOS
)
1836 CASE_MATHFN (BUILT_IN_ACOSH
)
1837 CASE_MATHFN (BUILT_IN_ASIN
)
1838 CASE_MATHFN (BUILT_IN_ASINH
)
1839 CASE_MATHFN (BUILT_IN_ATAN
)
1840 CASE_MATHFN (BUILT_IN_ATAN2
)
1841 CASE_MATHFN (BUILT_IN_ATANH
)
1842 CASE_MATHFN (BUILT_IN_CBRT
)
1843 CASE_MATHFN (BUILT_IN_CEIL
)
1844 CASE_MATHFN (BUILT_IN_CEXPI
)
1845 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1846 CASE_MATHFN (BUILT_IN_COS
)
1847 CASE_MATHFN (BUILT_IN_COSH
)
1848 CASE_MATHFN (BUILT_IN_DREM
)
1849 CASE_MATHFN (BUILT_IN_ERF
)
1850 CASE_MATHFN (BUILT_IN_ERFC
)
1851 CASE_MATHFN (BUILT_IN_EXP
)
1852 CASE_MATHFN (BUILT_IN_EXP10
)
1853 CASE_MATHFN (BUILT_IN_EXP2
)
1854 CASE_MATHFN (BUILT_IN_EXPM1
)
1855 CASE_MATHFN (BUILT_IN_FABS
)
1856 CASE_MATHFN (BUILT_IN_FDIM
)
1857 CASE_MATHFN (BUILT_IN_FLOOR
)
1858 CASE_MATHFN (BUILT_IN_FMA
)
1859 CASE_MATHFN (BUILT_IN_FMAX
)
1860 CASE_MATHFN (BUILT_IN_FMIN
)
1861 CASE_MATHFN (BUILT_IN_FMOD
)
1862 CASE_MATHFN (BUILT_IN_FREXP
)
1863 CASE_MATHFN (BUILT_IN_GAMMA
)
1864 CASE_MATHFN_REENT (BUILT_IN_GAMMA
) /* GAMMA_R */
1865 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1866 CASE_MATHFN (BUILT_IN_HYPOT
)
1867 CASE_MATHFN (BUILT_IN_ILOGB
)
1868 CASE_MATHFN (BUILT_IN_INF
)
1869 CASE_MATHFN (BUILT_IN_ISINF
)
1870 CASE_MATHFN (BUILT_IN_J0
)
1871 CASE_MATHFN (BUILT_IN_J1
)
1872 CASE_MATHFN (BUILT_IN_JN
)
1873 CASE_MATHFN (BUILT_IN_LCEIL
)
1874 CASE_MATHFN (BUILT_IN_LDEXP
)
1875 CASE_MATHFN (BUILT_IN_LFLOOR
)
1876 CASE_MATHFN (BUILT_IN_LGAMMA
)
1877 CASE_MATHFN_REENT (BUILT_IN_LGAMMA
) /* LGAMMA_R */
1878 CASE_MATHFN (BUILT_IN_LLCEIL
)
1879 CASE_MATHFN (BUILT_IN_LLFLOOR
)
1880 CASE_MATHFN (BUILT_IN_LLRINT
)
1881 CASE_MATHFN (BUILT_IN_LLROUND
)
1882 CASE_MATHFN (BUILT_IN_LOG
)
1883 CASE_MATHFN (BUILT_IN_LOG10
)
1884 CASE_MATHFN (BUILT_IN_LOG1P
)
1885 CASE_MATHFN (BUILT_IN_LOG2
)
1886 CASE_MATHFN (BUILT_IN_LOGB
)
1887 CASE_MATHFN (BUILT_IN_LRINT
)
1888 CASE_MATHFN (BUILT_IN_LROUND
)
1889 CASE_MATHFN (BUILT_IN_MODF
)
1890 CASE_MATHFN (BUILT_IN_NAN
)
1891 CASE_MATHFN (BUILT_IN_NANS
)
1892 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1893 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1894 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1895 CASE_MATHFN (BUILT_IN_POW
)
1896 CASE_MATHFN (BUILT_IN_POWI
)
1897 CASE_MATHFN (BUILT_IN_POW10
)
1898 CASE_MATHFN (BUILT_IN_REMAINDER
)
1899 CASE_MATHFN (BUILT_IN_REMQUO
)
1900 CASE_MATHFN (BUILT_IN_RINT
)
1901 CASE_MATHFN (BUILT_IN_ROUND
)
1902 CASE_MATHFN (BUILT_IN_SCALB
)
1903 CASE_MATHFN (BUILT_IN_SCALBLN
)
1904 CASE_MATHFN (BUILT_IN_SCALBN
)
1905 CASE_MATHFN (BUILT_IN_SIGNBIT
)
1906 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1907 CASE_MATHFN (BUILT_IN_SIN
)
1908 CASE_MATHFN (BUILT_IN_SINCOS
)
1909 CASE_MATHFN (BUILT_IN_SINH
)
1910 CASE_MATHFN (BUILT_IN_SQRT
)
1911 CASE_MATHFN (BUILT_IN_TAN
)
1912 CASE_MATHFN (BUILT_IN_TANH
)
1913 CASE_MATHFN (BUILT_IN_TGAMMA
)
1914 CASE_MATHFN (BUILT_IN_TRUNC
)
1915 CASE_MATHFN (BUILT_IN_Y0
)
1916 CASE_MATHFN (BUILT_IN_Y1
)
1917 CASE_MATHFN (BUILT_IN_YN
)
1923 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1924 return fn_arr
[fcode
];
1925 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1926 return fn_arr
[fcodef
];
1927 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1928 return fn_arr
[fcodel
];
1933 /* Like mathfn_built_in_1(), but always use the implicit array. */
1936 mathfn_built_in (tree type
, enum built_in_function fn
)
1938 return mathfn_built_in_1 (type
, fn
, /*implicit=*/ 1);
1941 /* If errno must be maintained, expand the RTL to check if the result,
1942 TARGET, of a built-in function call, EXP, is NaN, and if so set
1946 expand_errno_check (tree exp
, rtx target
)
1948 rtx lab
= gen_label_rtx ();
1950 /* Test the result; if it is NaN, set errno=EDOM because
1951 the argument was not in the domain. */
1952 do_compare_rtx_and_jump (target
, target
, EQ
, 0, GET_MODE (target
),
1953 NULL_RTX
, NULL_RTX
, lab
,
1954 /* The jump is very likely. */
1955 REG_BR_PROB_BASE
- (REG_BR_PROB_BASE
/ 2000 - 1));
1958 /* If this built-in doesn't throw an exception, set errno directly. */
1959 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp
), 0)))
1961 #ifdef GEN_ERRNO_RTX
1962 rtx errno_rtx
= GEN_ERRNO_RTX
;
1965 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1967 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1973 /* Make sure the library call isn't expanded as a tail call. */
1974 CALL_EXPR_TAILCALL (exp
) = 0;
1976 /* We can't set errno=EDOM directly; let the library call do it.
1977 Pop the arguments right away in case the call gets deleted. */
1979 expand_call (exp
, target
, 0);
1984 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1985 Return NULL_RTX if a normal call should be emitted rather than expanding
1986 the function in-line. EXP is the expression that is a call to the builtin
1987 function; if convenient, the result should be placed in TARGET.
1988 SUBTARGET may be used as the target for computing one of EXP's operands. */
1991 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
1993 optab builtin_optab
;
1995 tree fndecl
= get_callee_fndecl (exp
);
1996 enum machine_mode mode
;
1997 bool errno_set
= false;
2000 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2003 arg
= CALL_EXPR_ARG (exp
, 0);
2005 switch (DECL_FUNCTION_CODE (fndecl
))
2007 CASE_FLT_FN (BUILT_IN_SQRT
):
2008 errno_set
= ! tree_expr_nonnegative_p (arg
);
2009 builtin_optab
= sqrt_optab
;
2011 CASE_FLT_FN (BUILT_IN_EXP
):
2012 errno_set
= true; builtin_optab
= exp_optab
; break;
2013 CASE_FLT_FN (BUILT_IN_EXP10
):
2014 CASE_FLT_FN (BUILT_IN_POW10
):
2015 errno_set
= true; builtin_optab
= exp10_optab
; break;
2016 CASE_FLT_FN (BUILT_IN_EXP2
):
2017 errno_set
= true; builtin_optab
= exp2_optab
; break;
2018 CASE_FLT_FN (BUILT_IN_EXPM1
):
2019 errno_set
= true; builtin_optab
= expm1_optab
; break;
2020 CASE_FLT_FN (BUILT_IN_LOGB
):
2021 errno_set
= true; builtin_optab
= logb_optab
; break;
2022 CASE_FLT_FN (BUILT_IN_LOG
):
2023 errno_set
= true; builtin_optab
= log_optab
; break;
2024 CASE_FLT_FN (BUILT_IN_LOG10
):
2025 errno_set
= true; builtin_optab
= log10_optab
; break;
2026 CASE_FLT_FN (BUILT_IN_LOG2
):
2027 errno_set
= true; builtin_optab
= log2_optab
; break;
2028 CASE_FLT_FN (BUILT_IN_LOG1P
):
2029 errno_set
= true; builtin_optab
= log1p_optab
; break;
2030 CASE_FLT_FN (BUILT_IN_ASIN
):
2031 builtin_optab
= asin_optab
; break;
2032 CASE_FLT_FN (BUILT_IN_ACOS
):
2033 builtin_optab
= acos_optab
; break;
2034 CASE_FLT_FN (BUILT_IN_TAN
):
2035 builtin_optab
= tan_optab
; break;
2036 CASE_FLT_FN (BUILT_IN_ATAN
):
2037 builtin_optab
= atan_optab
; break;
2038 CASE_FLT_FN (BUILT_IN_FLOOR
):
2039 builtin_optab
= floor_optab
; break;
2040 CASE_FLT_FN (BUILT_IN_CEIL
):
2041 builtin_optab
= ceil_optab
; break;
2042 CASE_FLT_FN (BUILT_IN_TRUNC
):
2043 builtin_optab
= btrunc_optab
; break;
2044 CASE_FLT_FN (BUILT_IN_ROUND
):
2045 builtin_optab
= round_optab
; break;
2046 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
2047 builtin_optab
= nearbyint_optab
;
2048 if (flag_trapping_math
)
2050 /* Else fallthrough and expand as rint. */
2051 CASE_FLT_FN (BUILT_IN_RINT
):
2052 builtin_optab
= rint_optab
; break;
2053 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
2054 builtin_optab
= significand_optab
; break;
2059 /* Make a suitable register to place result in. */
2060 mode
= TYPE_MODE (TREE_TYPE (exp
));
2062 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2065 /* Before working hard, check whether the instruction is available. */
2066 if (optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
)
2068 target
= gen_reg_rtx (mode
);
2070 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2071 need to expand the argument again. This way, we will not perform
2072 side-effects more the once. */
2073 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2075 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2079 /* Compute into TARGET.
2080 Set TARGET to wherever the result comes back. */
2081 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2086 expand_errno_check (exp
, target
);
2088 /* Output the entire sequence. */
2089 insns
= get_insns ();
2095 /* If we were unable to expand via the builtin, stop the sequence
2096 (without outputting the insns) and call to the library function
2097 with the stabilized argument list. */
2101 return expand_call (exp
, target
, target
== const0_rtx
);
2104 /* Expand a call to the builtin binary math functions (pow and atan2).
2105 Return NULL_RTX if a normal call should be emitted rather than expanding the
2106 function in-line. EXP is the expression that is a call to the builtin
2107 function; if convenient, the result should be placed in TARGET.
2108 SUBTARGET may be used as the target for computing one of EXP's
2112 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
2114 optab builtin_optab
;
2115 rtx op0
, op1
, insns
;
2116 int op1_type
= REAL_TYPE
;
2117 tree fndecl
= get_callee_fndecl (exp
);
2119 enum machine_mode mode
;
2120 bool errno_set
= true;
2122 switch (DECL_FUNCTION_CODE (fndecl
))
2124 CASE_FLT_FN (BUILT_IN_SCALBN
):
2125 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2126 CASE_FLT_FN (BUILT_IN_LDEXP
):
2127 op1_type
= INTEGER_TYPE
;
2132 if (!validate_arglist (exp
, REAL_TYPE
, op1_type
, VOID_TYPE
))
2135 arg0
= CALL_EXPR_ARG (exp
, 0);
2136 arg1
= CALL_EXPR_ARG (exp
, 1);
2138 switch (DECL_FUNCTION_CODE (fndecl
))
2140 CASE_FLT_FN (BUILT_IN_POW
):
2141 builtin_optab
= pow_optab
; break;
2142 CASE_FLT_FN (BUILT_IN_ATAN2
):
2143 builtin_optab
= atan2_optab
; break;
2144 CASE_FLT_FN (BUILT_IN_SCALB
):
2145 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2147 builtin_optab
= scalb_optab
; break;
2148 CASE_FLT_FN (BUILT_IN_SCALBN
):
2149 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2150 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2152 /* Fall through... */
2153 CASE_FLT_FN (BUILT_IN_LDEXP
):
2154 builtin_optab
= ldexp_optab
; break;
2155 CASE_FLT_FN (BUILT_IN_FMOD
):
2156 builtin_optab
= fmod_optab
; break;
2157 CASE_FLT_FN (BUILT_IN_REMAINDER
):
2158 CASE_FLT_FN (BUILT_IN_DREM
):
2159 builtin_optab
= remainder_optab
; break;
2164 /* Make a suitable register to place result in. */
2165 mode
= TYPE_MODE (TREE_TYPE (exp
));
2167 /* Before working hard, check whether the instruction is available. */
2168 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2171 target
= gen_reg_rtx (mode
);
2173 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2176 /* Always stabilize the argument list. */
2177 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2178 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2180 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2181 op1
= expand_normal (arg1
);
2185 /* Compute into TARGET.
2186 Set TARGET to wherever the result comes back. */
2187 target
= expand_binop (mode
, builtin_optab
, op0
, op1
,
2188 target
, 0, OPTAB_DIRECT
);
2190 /* If we were unable to expand via the builtin, stop the sequence
2191 (without outputting the insns) and call to the library function
2192 with the stabilized argument list. */
2196 return expand_call (exp
, target
, target
== const0_rtx
);
2200 expand_errno_check (exp
, target
);
2202 /* Output the entire sequence. */
2203 insns
= get_insns ();
2210 /* Expand a call to the builtin sin and cos math functions.
2211 Return NULL_RTX if a normal call should be emitted rather than expanding the
2212 function in-line. EXP is the expression that is a call to the builtin
2213 function; if convenient, the result should be placed in TARGET.
2214 SUBTARGET may be used as the target for computing one of EXP's
2218 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2220 optab builtin_optab
;
2222 tree fndecl
= get_callee_fndecl (exp
);
2223 enum machine_mode mode
;
2226 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2229 arg
= CALL_EXPR_ARG (exp
, 0);
2231 switch (DECL_FUNCTION_CODE (fndecl
))
2233 CASE_FLT_FN (BUILT_IN_SIN
):
2234 CASE_FLT_FN (BUILT_IN_COS
):
2235 builtin_optab
= sincos_optab
; break;
2240 /* Make a suitable register to place result in. */
2241 mode
= TYPE_MODE (TREE_TYPE (exp
));
2243 /* Check if sincos insn is available, otherwise fallback
2244 to sin or cos insn. */
2245 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2246 switch (DECL_FUNCTION_CODE (fndecl
))
2248 CASE_FLT_FN (BUILT_IN_SIN
):
2249 builtin_optab
= sin_optab
; break;
2250 CASE_FLT_FN (BUILT_IN_COS
):
2251 builtin_optab
= cos_optab
; break;
2256 /* Before working hard, check whether the instruction is available. */
2257 if (optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
)
2259 target
= gen_reg_rtx (mode
);
2261 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2262 need to expand the argument again. This way, we will not perform
2263 side-effects more the once. */
2264 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2266 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2270 /* Compute into TARGET.
2271 Set TARGET to wherever the result comes back. */
2272 if (builtin_optab
== sincos_optab
)
2276 switch (DECL_FUNCTION_CODE (fndecl
))
2278 CASE_FLT_FN (BUILT_IN_SIN
):
2279 result
= expand_twoval_unop (builtin_optab
, op0
, 0, target
, 0);
2281 CASE_FLT_FN (BUILT_IN_COS
):
2282 result
= expand_twoval_unop (builtin_optab
, op0
, target
, 0, 0);
2287 gcc_assert (result
);
2291 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2296 /* Output the entire sequence. */
2297 insns
= get_insns ();
2303 /* If we were unable to expand via the builtin, stop the sequence
2304 (without outputting the insns) and call to the library function
2305 with the stabilized argument list. */
2309 target
= expand_call (exp
, target
, target
== const0_rtx
);
2314 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2315 return an RTL instruction code that implements the functionality.
2316 If that isn't possible or available return CODE_FOR_nothing. */
2318 static enum insn_code
2319 interclass_mathfn_icode (tree arg
, tree fndecl
)
2321 bool errno_set
= false;
2322 optab builtin_optab
= 0;
2323 enum machine_mode mode
;
2325 switch (DECL_FUNCTION_CODE (fndecl
))
2327 CASE_FLT_FN (BUILT_IN_ILOGB
):
2328 errno_set
= true; builtin_optab
= ilogb_optab
; break;
2329 CASE_FLT_FN (BUILT_IN_ISINF
):
2330 builtin_optab
= isinf_optab
; break;
2331 case BUILT_IN_ISNORMAL
:
2332 case BUILT_IN_ISFINITE
:
2333 CASE_FLT_FN (BUILT_IN_FINITE
):
2334 case BUILT_IN_FINITED32
:
2335 case BUILT_IN_FINITED64
:
2336 case BUILT_IN_FINITED128
:
2337 case BUILT_IN_ISINFD32
:
2338 case BUILT_IN_ISINFD64
:
2339 case BUILT_IN_ISINFD128
:
2340 /* These builtins have no optabs (yet). */
2346 /* There's no easy way to detect the case we need to set EDOM. */
2347 if (flag_errno_math
&& errno_set
)
2348 return CODE_FOR_nothing
;
2350 /* Optab mode depends on the mode of the input argument. */
2351 mode
= TYPE_MODE (TREE_TYPE (arg
));
2354 return optab_handler (builtin_optab
, mode
);
2355 return CODE_FOR_nothing
;
2358 /* Expand a call to one of the builtin math functions that operate on
2359 floating point argument and output an integer result (ilogb, isinf,
2361 Return 0 if a normal call should be emitted rather than expanding the
2362 function in-line. EXP is the expression that is a call to the builtin
2363 function; if convenient, the result should be placed in TARGET.
2364 SUBTARGET may be used as the target for computing one of EXP's operands. */
2367 expand_builtin_interclass_mathfn (tree exp
, rtx target
, rtx subtarget
)
2369 enum insn_code icode
= CODE_FOR_nothing
;
2371 tree fndecl
= get_callee_fndecl (exp
);
2372 enum machine_mode mode
;
2375 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2378 arg
= CALL_EXPR_ARG (exp
, 0);
2379 icode
= interclass_mathfn_icode (arg
, fndecl
);
2380 mode
= TYPE_MODE (TREE_TYPE (arg
));
2382 if (icode
!= CODE_FOR_nothing
)
2384 rtx last
= get_last_insn ();
2385 tree orig_arg
= arg
;
2386 /* Make a suitable register to place result in. */
2388 || GET_MODE (target
) != TYPE_MODE (TREE_TYPE (exp
))
2389 || !insn_data
[icode
].operand
[0].predicate (target
, GET_MODE (target
)))
2390 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
2392 gcc_assert (insn_data
[icode
].operand
[0].predicate
2393 (target
, GET_MODE (target
)));
2395 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2396 need to expand the argument again. This way, we will not perform
2397 side-effects more the once. */
2398 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2400 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2402 if (mode
!= GET_MODE (op0
))
2403 op0
= convert_to_mode (mode
, op0
, 0);
2405 /* Compute into TARGET.
2406 Set TARGET to wherever the result comes back. */
2407 if (maybe_emit_unop_insn (icode
, target
, op0
, UNKNOWN
))
2409 delete_insns_since (last
);
2410 CALL_EXPR_ARG (exp
, 0) = orig_arg
;
2416 /* Expand a call to the builtin sincos math function.
2417 Return NULL_RTX if a normal call should be emitted rather than expanding the
2418 function in-line. EXP is the expression that is a call to the builtin
2422 expand_builtin_sincos (tree exp
)
2424 rtx op0
, op1
, op2
, target1
, target2
;
2425 enum machine_mode mode
;
2426 tree arg
, sinp
, cosp
;
2428 location_t loc
= EXPR_LOCATION (exp
);
2430 if (!validate_arglist (exp
, REAL_TYPE
,
2431 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2434 arg
= CALL_EXPR_ARG (exp
, 0);
2435 sinp
= CALL_EXPR_ARG (exp
, 1);
2436 cosp
= CALL_EXPR_ARG (exp
, 2);
2438 /* Make a suitable register to place result in. */
2439 mode
= TYPE_MODE (TREE_TYPE (arg
));
2441 /* Check if sincos insn is available, otherwise emit the call. */
2442 if (optab_handler (sincos_optab
, mode
) == CODE_FOR_nothing
)
2445 target1
= gen_reg_rtx (mode
);
2446 target2
= gen_reg_rtx (mode
);
2448 op0
= expand_normal (arg
);
2449 op1
= expand_normal (build_fold_indirect_ref_loc (loc
, sinp
));
2450 op2
= expand_normal (build_fold_indirect_ref_loc (loc
, cosp
));
2452 /* Compute into target1 and target2.
2453 Set TARGET to wherever the result comes back. */
2454 result
= expand_twoval_unop (sincos_optab
, op0
, target2
, target1
, 0);
2455 gcc_assert (result
);
2457 /* Move target1 and target2 to the memory locations indicated
2459 emit_move_insn (op1
, target1
);
2460 emit_move_insn (op2
, target2
);
2465 /* Expand a call to the internal cexpi builtin to the sincos math function.
2466 EXP is the expression that is a call to the builtin function; if convenient,
2467 the result should be placed in TARGET. SUBTARGET may be used as the target
2468 for computing one of EXP's operands. */
2471 expand_builtin_cexpi (tree exp
, rtx target
, rtx subtarget
)
2473 tree fndecl
= get_callee_fndecl (exp
);
2475 enum machine_mode mode
;
2477 location_t loc
= EXPR_LOCATION (exp
);
2479 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2482 arg
= CALL_EXPR_ARG (exp
, 0);
2483 type
= TREE_TYPE (arg
);
2484 mode
= TYPE_MODE (TREE_TYPE (arg
));
2486 /* Try expanding via a sincos optab, fall back to emitting a libcall
2487 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2488 is only generated from sincos, cexp or if we have either of them. */
2489 if (optab_handler (sincos_optab
, mode
) != CODE_FOR_nothing
)
2491 op1
= gen_reg_rtx (mode
);
2492 op2
= gen_reg_rtx (mode
);
2494 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2496 /* Compute into op1 and op2. */
2497 expand_twoval_unop (sincos_optab
, op0
, op2
, op1
, 0);
2499 else if (TARGET_HAS_SINCOS
)
2501 tree call
, fn
= NULL_TREE
;
2505 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2506 fn
= built_in_decls
[BUILT_IN_SINCOSF
];
2507 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2508 fn
= built_in_decls
[BUILT_IN_SINCOS
];
2509 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2510 fn
= built_in_decls
[BUILT_IN_SINCOSL
];
2514 op1
= assign_temp (TREE_TYPE (arg
), 0, 1, 1);
2515 op2
= assign_temp (TREE_TYPE (arg
), 0, 1, 1);
2516 op1a
= copy_to_mode_reg (Pmode
, XEXP (op1
, 0));
2517 op2a
= copy_to_mode_reg (Pmode
, XEXP (op2
, 0));
2518 top1
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op1a
);
2519 top2
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op2a
);
2521 /* Make sure not to fold the sincos call again. */
2522 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2523 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn
)),
2524 call
, 3, arg
, top1
, top2
));
2528 tree call
, fn
= NULL_TREE
, narg
;
2529 tree ctype
= build_complex_type (type
);
2531 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2532 fn
= built_in_decls
[BUILT_IN_CEXPF
];
2533 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2534 fn
= built_in_decls
[BUILT_IN_CEXP
];
2535 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2536 fn
= built_in_decls
[BUILT_IN_CEXPL
];
2540 /* If we don't have a decl for cexp create one. This is the
2541 friendliest fallback if the user calls __builtin_cexpi
2542 without full target C99 function support. */
2543 if (fn
== NULL_TREE
)
2546 const char *name
= NULL
;
2548 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2550 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2552 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2555 fntype
= build_function_type_list (ctype
, ctype
, NULL_TREE
);
2556 fn
= build_fn_decl (name
, fntype
);
2559 narg
= fold_build2_loc (loc
, COMPLEX_EXPR
, ctype
,
2560 build_real (type
, dconst0
), arg
);
2562 /* Make sure not to fold the cexp call again. */
2563 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2564 return expand_expr (build_call_nary (ctype
, call
, 1, narg
),
2565 target
, VOIDmode
, EXPAND_NORMAL
);
2568 /* Now build the proper return type. */
2569 return expand_expr (build2 (COMPLEX_EXPR
, build_complex_type (type
),
2570 make_tree (TREE_TYPE (arg
), op2
),
2571 make_tree (TREE_TYPE (arg
), op1
)),
2572 target
, VOIDmode
, EXPAND_NORMAL
);
2575 /* Conveniently construct a function call expression. FNDECL names the
2576 function to be called, N is the number of arguments, and the "..."
2577 parameters are the argument expressions. Unlike build_call_exr
2578 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2581 build_call_nofold_loc (location_t loc
, tree fndecl
, int n
, ...)
2584 tree fntype
= TREE_TYPE (fndecl
);
2585 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
2588 fn
= build_call_valist (TREE_TYPE (fntype
), fn
, n
, ap
);
2590 SET_EXPR_LOCATION (fn
, loc
);
2594 /* Expand a call to one of the builtin rounding functions gcc defines
2595 as an extension (lfloor and lceil). As these are gcc extensions we
2596 do not need to worry about setting errno to EDOM.
2597 If expanding via optab fails, lower expression to (int)(floor(x)).
2598 EXP is the expression that is a call to the builtin function;
2599 if convenient, the result should be placed in TARGET. */
2602 expand_builtin_int_roundingfn (tree exp
, rtx target
)
2604 convert_optab builtin_optab
;
2605 rtx op0
, insns
, tmp
;
2606 tree fndecl
= get_callee_fndecl (exp
);
2607 enum built_in_function fallback_fn
;
2608 tree fallback_fndecl
;
2609 enum machine_mode mode
;
2612 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2615 arg
= CALL_EXPR_ARG (exp
, 0);
2617 switch (DECL_FUNCTION_CODE (fndecl
))
2619 CASE_FLT_FN (BUILT_IN_LCEIL
):
2620 CASE_FLT_FN (BUILT_IN_LLCEIL
):
2621 builtin_optab
= lceil_optab
;
2622 fallback_fn
= BUILT_IN_CEIL
;
2625 CASE_FLT_FN (BUILT_IN_LFLOOR
):
2626 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
2627 builtin_optab
= lfloor_optab
;
2628 fallback_fn
= BUILT_IN_FLOOR
;
2635 /* Make a suitable register to place result in. */
2636 mode
= TYPE_MODE (TREE_TYPE (exp
));
2638 target
= gen_reg_rtx (mode
);
2640 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2641 need to expand the argument again. This way, we will not perform
2642 side-effects more the once. */
2643 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2645 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2649 /* Compute into TARGET. */
2650 if (expand_sfix_optab (target
, op0
, builtin_optab
))
2652 /* Output the entire sequence. */
2653 insns
= get_insns ();
2659 /* If we were unable to expand via the builtin, stop the sequence
2660 (without outputting the insns). */
2663 /* Fall back to floating point rounding optab. */
2664 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
2666 /* For non-C99 targets we may end up without a fallback fndecl here
2667 if the user called __builtin_lfloor directly. In this case emit
2668 a call to the floor/ceil variants nevertheless. This should result
2669 in the best user experience for not full C99 targets. */
2670 if (fallback_fndecl
== NULL_TREE
)
2673 const char *name
= NULL
;
2675 switch (DECL_FUNCTION_CODE (fndecl
))
2677 case BUILT_IN_LCEIL
:
2678 case BUILT_IN_LLCEIL
:
2681 case BUILT_IN_LCEILF
:
2682 case BUILT_IN_LLCEILF
:
2685 case BUILT_IN_LCEILL
:
2686 case BUILT_IN_LLCEILL
:
2689 case BUILT_IN_LFLOOR
:
2690 case BUILT_IN_LLFLOOR
:
2693 case BUILT_IN_LFLOORF
:
2694 case BUILT_IN_LLFLOORF
:
2697 case BUILT_IN_LFLOORL
:
2698 case BUILT_IN_LLFLOORL
:
2705 fntype
= build_function_type_list (TREE_TYPE (arg
),
2706 TREE_TYPE (arg
), NULL_TREE
);
2707 fallback_fndecl
= build_fn_decl (name
, fntype
);
2710 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
), fallback_fndecl
, 1, arg
);
2712 tmp
= expand_normal (exp
);
2714 /* Truncate the result of floating point optab to integer
2715 via expand_fix (). */
2716 target
= gen_reg_rtx (mode
);
2717 expand_fix (target
, tmp
, 0);
2722 /* Expand a call to one of the builtin math functions doing integer
2724 Return 0 if a normal call should be emitted rather than expanding the
2725 function in-line. EXP is the expression that is a call to the builtin
2726 function; if convenient, the result should be placed in TARGET. */
2729 expand_builtin_int_roundingfn_2 (tree exp
, rtx target
)
2731 convert_optab builtin_optab
;
2733 tree fndecl
= get_callee_fndecl (exp
);
2735 enum machine_mode mode
;
2737 /* There's no easy way to detect the case we need to set EDOM. */
2738 if (flag_errno_math
)
2741 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2744 arg
= CALL_EXPR_ARG (exp
, 0);
2746 switch (DECL_FUNCTION_CODE (fndecl
))
2748 CASE_FLT_FN (BUILT_IN_LRINT
):
2749 CASE_FLT_FN (BUILT_IN_LLRINT
):
2750 builtin_optab
= lrint_optab
; break;
2751 CASE_FLT_FN (BUILT_IN_LROUND
):
2752 CASE_FLT_FN (BUILT_IN_LLROUND
):
2753 builtin_optab
= lround_optab
; break;
2758 /* Make a suitable register to place result in. */
2759 mode
= TYPE_MODE (TREE_TYPE (exp
));
2761 target
= gen_reg_rtx (mode
);
2763 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2764 need to expand the argument again. This way, we will not perform
2765 side-effects more the once. */
2766 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2768 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2772 if (expand_sfix_optab (target
, op0
, builtin_optab
))
2774 /* Output the entire sequence. */
2775 insns
= get_insns ();
2781 /* If we were unable to expand via the builtin, stop the sequence
2782 (without outputting the insns) and call to the library function
2783 with the stabilized argument list. */
2786 target
= expand_call (exp
, target
, target
== const0_rtx
);
2791 /* To evaluate powi(x,n), the floating point value x raised to the
2792 constant integer exponent n, we use a hybrid algorithm that
2793 combines the "window method" with look-up tables. For an
2794 introduction to exponentiation algorithms and "addition chains",
2795 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2796 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2797 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2798 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2800 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2801 multiplications to inline before calling the system library's pow
2802 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2803 so this default never requires calling pow, powf or powl. */
2805 #ifndef POWI_MAX_MULTS
2806 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2809 /* The size of the "optimal power tree" lookup table. All
2810 exponents less than this value are simply looked up in the
2811 powi_table below. This threshold is also used to size the
2812 cache of pseudo registers that hold intermediate results. */
2813 #define POWI_TABLE_SIZE 256
2815 /* The size, in bits of the window, used in the "window method"
2816 exponentiation algorithm. This is equivalent to a radix of
2817 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2818 #define POWI_WINDOW_SIZE 3
2820 /* The following table is an efficient representation of an
2821 "optimal power tree". For each value, i, the corresponding
2822 value, j, in the table states than an optimal evaluation
2823 sequence for calculating pow(x,i) can be found by evaluating
2824 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2825 100 integers is given in Knuth's "Seminumerical algorithms". */
2827 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
2829 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2830 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2831 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2832 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2833 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2834 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2835 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2836 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2837 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2838 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2839 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2840 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2841 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2842 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2843 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2844 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2845 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2846 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2847 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2848 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2849 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2850 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2851 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2852 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2853 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2854 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2855 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2856 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2857 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2858 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2859 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2860 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2864 /* Return the number of multiplications required to calculate
2865 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2866 subroutine of powi_cost. CACHE is an array indicating
2867 which exponents have already been calculated. */
2870 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
2872 /* If we've already calculated this exponent, then this evaluation
2873 doesn't require any additional multiplications. */
2878 return powi_lookup_cost (n
- powi_table
[n
], cache
)
2879 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
2882 /* Return the number of multiplications required to calculate
2883 powi(x,n) for an arbitrary x, given the exponent N. This
2884 function needs to be kept in sync with expand_powi below. */
2887 powi_cost (HOST_WIDE_INT n
)
2889 bool cache
[POWI_TABLE_SIZE
];
2890 unsigned HOST_WIDE_INT digit
;
2891 unsigned HOST_WIDE_INT val
;
2897 /* Ignore the reciprocal when calculating the cost. */
2898 val
= (n
< 0) ? -n
: n
;
2900 /* Initialize the exponent cache. */
2901 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
2906 while (val
>= POWI_TABLE_SIZE
)
2910 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
2911 result
+= powi_lookup_cost (digit
, cache
)
2912 + POWI_WINDOW_SIZE
+ 1;
2913 val
>>= POWI_WINDOW_SIZE
;
2922 return result
+ powi_lookup_cost (val
, cache
);
2925 /* Recursive subroutine of expand_powi. This function takes the array,
2926 CACHE, of already calculated exponents and an exponent N and returns
2927 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2930 expand_powi_1 (enum machine_mode mode
, unsigned HOST_WIDE_INT n
, rtx
*cache
)
2932 unsigned HOST_WIDE_INT digit
;
2936 if (n
< POWI_TABLE_SIZE
)
2941 target
= gen_reg_rtx (mode
);
2944 op0
= expand_powi_1 (mode
, n
- powi_table
[n
], cache
);
2945 op1
= expand_powi_1 (mode
, powi_table
[n
], cache
);
2949 target
= gen_reg_rtx (mode
);
2950 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
2951 op0
= expand_powi_1 (mode
, n
- digit
, cache
);
2952 op1
= expand_powi_1 (mode
, digit
, cache
);
2956 target
= gen_reg_rtx (mode
);
2957 op0
= expand_powi_1 (mode
, n
>> 1, cache
);
2961 result
= expand_mult (mode
, op0
, op1
, target
, 0);
2962 if (result
!= target
)
2963 emit_move_insn (target
, result
);
2967 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2968 floating point operand in mode MODE, and N is the exponent. This
2969 function needs to be kept in sync with powi_cost above. */
2972 expand_powi (rtx x
, enum machine_mode mode
, HOST_WIDE_INT n
)
2974 rtx cache
[POWI_TABLE_SIZE
];
2978 return CONST1_RTX (mode
);
2980 memset (cache
, 0, sizeof (cache
));
2983 result
= expand_powi_1 (mode
, (n
< 0) ? -n
: n
, cache
);
2985 /* If the original exponent was negative, reciprocate the result. */
2987 result
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
2988 result
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2993 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2994 cbrts. Return NULL_RTX if no simplification can be made or expand the tree
2995 if we can simplify it. */
2997 expand_builtin_pow_root (location_t loc
, tree arg0
, tree arg1
, tree type
,
3000 if (TREE_CODE (arg1
) == REAL_CST
3001 && !TREE_OVERFLOW (arg1
)
3002 && flag_unsafe_math_optimizations
)
3004 enum machine_mode mode
= TYPE_MODE (type
);
3005 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
3006 tree cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
3007 REAL_VALUE_TYPE c
= TREE_REAL_CST (arg1
);
3008 tree op
= NULL_TREE
;
3012 /* Optimize pow (x, 0.5) into sqrt. */
3013 if (REAL_VALUES_EQUAL (c
, dconsthalf
))
3014 op
= build_call_nofold_loc (loc
, sqrtfn
, 1, arg0
);
3018 REAL_VALUE_TYPE dconst1_4
= dconst1
;
3019 REAL_VALUE_TYPE dconst3_4
;
3020 SET_REAL_EXP (&dconst1_4
, REAL_EXP (&dconst1_4
) - 2);
3022 real_from_integer (&dconst3_4
, VOIDmode
, 3, 0, 0);
3023 SET_REAL_EXP (&dconst3_4
, REAL_EXP (&dconst3_4
) - 2);
3025 /* Optimize pow (x, 0.25) into sqrt (sqrt (x)). Assume on most
3026 machines that a builtin sqrt instruction is smaller than a
3027 call to pow with 0.25, so do this optimization even if
3029 if (REAL_VALUES_EQUAL (c
, dconst1_4
))
3031 op
= build_call_nofold_loc (loc
, sqrtfn
, 1, arg0
);
3032 op
= build_call_nofold_loc (loc
, sqrtfn
, 1, op
);
3035 /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3036 are optimizing for space. */
3037 else if (optimize_insn_for_speed_p ()
3038 && !TREE_SIDE_EFFECTS (arg0
)
3039 && REAL_VALUES_EQUAL (c
, dconst3_4
))
3041 tree sqrt1
= build_call_expr_loc (loc
, sqrtfn
, 1, arg0
);
3042 tree sqrt2
= builtin_save_expr (sqrt1
);
3043 tree sqrt3
= build_call_expr_loc (loc
, sqrtfn
, 1, sqrt1
);
3044 op
= fold_build2_loc (loc
, MULT_EXPR
, type
, sqrt2
, sqrt3
);
3049 /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3050 cbrt/sqrts instead of pow (x, 1./6.). */
3052 && (tree_expr_nonnegative_p (arg0
) || !HONOR_NANS (mode
)))
3054 /* First try 1/3. */
3055 REAL_VALUE_TYPE dconst1_3
3056 = real_value_truncate (mode
, dconst_third ());
3058 if (REAL_VALUES_EQUAL (c
, dconst1_3
))
3059 op
= build_call_nofold_loc (loc
, cbrtfn
, 1, arg0
);
3062 else if (optimize_insn_for_speed_p ())
3064 REAL_VALUE_TYPE dconst1_6
= dconst1_3
;
3065 SET_REAL_EXP (&dconst1_6
, REAL_EXP (&dconst1_6
) - 1);
3067 if (REAL_VALUES_EQUAL (c
, dconst1_6
))
3069 op
= build_call_nofold_loc (loc
, sqrtfn
, 1, arg0
);
3070 op
= build_call_nofold_loc (loc
, cbrtfn
, 1, op
);
3076 return expand_expr (op
, subtarget
, mode
, EXPAND_NORMAL
);
3082 /* Expand a call to the pow built-in mathematical function. Return NULL_RTX if
3083 a normal call should be emitted rather than expanding the function
3084 in-line. EXP is the expression that is a call to the builtin
3085 function; if convenient, the result should be placed in TARGET. */
3088 expand_builtin_pow (tree exp
, rtx target
, rtx subtarget
)
3092 tree type
= TREE_TYPE (exp
);
3093 REAL_VALUE_TYPE cint
, c
, c2
;
3096 enum machine_mode mode
= TYPE_MODE (type
);
3098 if (! validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
3101 arg0
= CALL_EXPR_ARG (exp
, 0);
3102 arg1
= CALL_EXPR_ARG (exp
, 1);
3104 if (TREE_CODE (arg1
) != REAL_CST
3105 || TREE_OVERFLOW (arg1
))
3106 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
3108 /* Handle constant exponents. */
3110 /* For integer valued exponents we can expand to an optimal multiplication
3111 sequence using expand_powi. */
3112 c
= TREE_REAL_CST (arg1
);
3113 n
= real_to_integer (&c
);
3114 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
3115 if (real_identical (&c
, &cint
)
3116 && ((n
>= -1 && n
<= 2)
3117 || (flag_unsafe_math_optimizations
3118 && optimize_insn_for_speed_p ()
3119 && powi_cost (n
) <= POWI_MAX_MULTS
)))
3121 op
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
3124 op
= force_reg (mode
, op
);
3125 op
= expand_powi (op
, mode
, n
);
3130 narg0
= builtin_save_expr (arg0
);
3132 /* If the exponent is not integer valued, check if it is half of an integer.
3133 In this case we can expand to sqrt (x) * x**(n/2). */
3134 fn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
3135 if (fn
!= NULL_TREE
)
3137 real_arithmetic (&c2
, MULT_EXPR
, &c
, &dconst2
);
3138 n
= real_to_integer (&c2
);
3139 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
3140 if (real_identical (&c2
, &cint
)
3141 && ((flag_unsafe_math_optimizations
3142 && optimize_insn_for_speed_p ()
3143 && powi_cost (n
/2) <= POWI_MAX_MULTS
)
3144 /* Even the c == 0.5 case cannot be done unconditionally
3145 when we need to preserve signed zeros, as
3146 pow (-0, 0.5) is +0, while sqrt(-0) is -0. */
3147 || (!HONOR_SIGNED_ZEROS (mode
) && n
== 1)
3148 /* For c == 1.5 we can assume that x * sqrt (x) is always
3149 smaller than pow (x, 1.5) if sqrt will not be expanded
3152 && optab_handler (sqrt_optab
, mode
) != CODE_FOR_nothing
)))
3154 tree call_expr
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 1,
3156 /* Use expand_expr in case the newly built call expression
3157 was folded to a non-call. */
3158 op
= expand_expr (call_expr
, subtarget
, mode
, EXPAND_NORMAL
);
3161 op2
= expand_expr (narg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
3162 op2
= force_reg (mode
, op2
);
3163 op2
= expand_powi (op2
, mode
, abs (n
/ 2));
3164 op
= expand_simple_binop (mode
, MULT
, op
, op2
, NULL_RTX
,
3165 0, OPTAB_LIB_WIDEN
);
3166 /* If the original exponent was negative, reciprocate the
3169 op
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
3170 op
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
3176 /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3178 op
= expand_builtin_pow_root (EXPR_LOCATION (exp
), arg0
, arg1
, type
,
3183 /* Try if the exponent is a third of an integer. In this case
3184 we can expand to x**(n/3) * cbrt(x)**(n%3). As cbrt (x) is
3185 different from pow (x, 1./3.) due to rounding and behavior
3186 with negative x we need to constrain this transformation to
3187 unsafe math and positive x or finite math. */
3188 fn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
3190 && flag_unsafe_math_optimizations
3191 && (tree_expr_nonnegative_p (arg0
)
3192 || !HONOR_NANS (mode
)))
3194 REAL_VALUE_TYPE dconst3
;
3195 real_from_integer (&dconst3
, VOIDmode
, 3, 0, 0);
3196 real_arithmetic (&c2
, MULT_EXPR
, &c
, &dconst3
);
3197 real_round (&c2
, mode
, &c2
);
3198 n
= real_to_integer (&c2
);
3199 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
3200 real_arithmetic (&c2
, RDIV_EXPR
, &cint
, &dconst3
);
3201 real_convert (&c2
, mode
, &c2
);
3202 if (real_identical (&c2
, &c
)
3203 && ((optimize_insn_for_speed_p ()
3204 && powi_cost (n
/3) <= POWI_MAX_MULTS
)
3207 tree call_expr
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 1,
3209 op
= expand_builtin (call_expr
, NULL_RTX
, subtarget
, mode
, 0);
3210 if (abs (n
) % 3 == 2)
3211 op
= expand_simple_binop (mode
, MULT
, op
, op
, op
,
3212 0, OPTAB_LIB_WIDEN
);
3215 op2
= expand_expr (narg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
3216 op2
= force_reg (mode
, op2
);
3217 op2
= expand_powi (op2
, mode
, abs (n
/ 3));
3218 op
= expand_simple_binop (mode
, MULT
, op
, op2
, NULL_RTX
,
3219 0, OPTAB_LIB_WIDEN
);
3220 /* If the original exponent was negative, reciprocate the
3223 op
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
3224 op
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
3230 /* Fall back to optab expansion. */
3231 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
3234 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
3235 a normal call should be emitted rather than expanding the function
3236 in-line. EXP is the expression that is a call to the builtin
3237 function; if convenient, the result should be placed in TARGET. */
3240 expand_builtin_powi (tree exp
, rtx target
, rtx subtarget
)
3244 enum machine_mode mode
;
3245 enum machine_mode mode2
;
3247 if (! validate_arglist (exp
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3250 arg0
= CALL_EXPR_ARG (exp
, 0);
3251 arg1
= CALL_EXPR_ARG (exp
, 1);
3252 mode
= TYPE_MODE (TREE_TYPE (exp
));
3254 /* Handle constant power. */
3256 if (TREE_CODE (arg1
) == INTEGER_CST
3257 && !TREE_OVERFLOW (arg1
))
3259 HOST_WIDE_INT n
= TREE_INT_CST_LOW (arg1
);
3261 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3262 Otherwise, check the number of multiplications required. */
3263 if ((TREE_INT_CST_HIGH (arg1
) == 0
3264 || TREE_INT_CST_HIGH (arg1
) == -1)
3265 && ((n
>= -1 && n
<= 2)
3266 || (optimize_insn_for_speed_p ()
3267 && powi_cost (n
) <= POWI_MAX_MULTS
)))
3269 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
3270 op0
= force_reg (mode
, op0
);
3271 return expand_powi (op0
, mode
, n
);
3275 /* Emit a libcall to libgcc. */
3277 /* Mode of the 2nd argument must match that of an int. */
3278 mode2
= mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0);
3280 if (target
== NULL_RTX
)
3281 target
= gen_reg_rtx (mode
);
3283 op0
= expand_expr (arg0
, subtarget
, mode
, EXPAND_NORMAL
);
3284 if (GET_MODE (op0
) != mode
)
3285 op0
= convert_to_mode (mode
, op0
, 0);
3286 op1
= expand_expr (arg1
, NULL_RTX
, mode2
, EXPAND_NORMAL
);
3287 if (GET_MODE (op1
) != mode2
)
3288 op1
= convert_to_mode (mode2
, op1
, 0);
3290 target
= emit_library_call_value (optab_libfunc (powi_optab
, mode
),
3291 target
, LCT_CONST
, mode
, 2,
3292 op0
, mode
, op1
, mode2
);
3297 /* Expand expression EXP which is a call to the strlen builtin. Return
3298 NULL_RTX if we failed the caller should emit a normal call, otherwise
3299 try to get the result in TARGET, if convenient. */
3302 expand_builtin_strlen (tree exp
, rtx target
,
3303 enum machine_mode target_mode
)
3305 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
3311 tree src
= CALL_EXPR_ARG (exp
, 0);
3312 rtx result
, src_reg
, char_rtx
, before_strlen
;
3313 enum machine_mode insn_mode
= target_mode
, char_mode
;
3314 enum insn_code icode
= CODE_FOR_nothing
;
3317 /* If the length can be computed at compile-time, return it. */
3318 len
= c_strlen (src
, 0);
3320 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3322 /* If the length can be computed at compile-time and is constant
3323 integer, but there are side-effects in src, evaluate
3324 src for side-effects, then return len.
3325 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3326 can be optimized into: i++; x = 3; */
3327 len
= c_strlen (src
, 1);
3328 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
3330 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3331 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3334 align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3336 /* If SRC is not a pointer type, don't do this operation inline. */
3340 /* Bail out if we can't compute strlen in the right mode. */
3341 while (insn_mode
!= VOIDmode
)
3343 icode
= optab_handler (strlen_optab
, insn_mode
);
3344 if (icode
!= CODE_FOR_nothing
)
3347 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
3349 if (insn_mode
== VOIDmode
)
3352 /* Make a place to write the result of the instruction. */
3356 && GET_MODE (result
) == insn_mode
3357 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3358 result
= gen_reg_rtx (insn_mode
);
3360 /* Make a place to hold the source address. We will not expand
3361 the actual source until we are sure that the expansion will
3362 not fail -- there are trees that cannot be expanded twice. */
3363 src_reg
= gen_reg_rtx (Pmode
);
3365 /* Mark the beginning of the strlen sequence so we can emit the
3366 source operand later. */
3367 before_strlen
= get_last_insn ();
3369 char_rtx
= const0_rtx
;
3370 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
3371 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
3373 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
3375 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
3376 char_rtx
, GEN_INT (align
));
3381 /* Now that we are assured of success, expand the source. */
3383 pat
= expand_expr (src
, src_reg
, ptr_mode
, EXPAND_NORMAL
);
3385 emit_move_insn (src_reg
, pat
);
3390 emit_insn_after (pat
, before_strlen
);
3392 emit_insn_before (pat
, get_insns ());
3394 /* Return the value in the proper mode for this function. */
3395 if (GET_MODE (result
) == target_mode
)
3397 else if (target
!= 0)
3398 convert_move (target
, result
, 0);
3400 target
= convert_to_mode (target_mode
, result
, 0);
3406 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3407 bytes from constant string DATA + OFFSET and return it as target
3411 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
3412 enum machine_mode mode
)
3414 const char *str
= (const char *) data
;
3416 gcc_assert (offset
>= 0
3417 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
3418 <= strlen (str
) + 1));
3420 return c_readstr (str
+ offset
, mode
);
3423 /* Expand a call EXP to the memcpy builtin.
3424 Return NULL_RTX if we failed, the caller should emit a normal call,
3425 otherwise try to get the result in TARGET, if convenient (and in
3426 mode MODE if that's convenient). */
3429 expand_builtin_memcpy (tree exp
, rtx target
)
3431 if (!validate_arglist (exp
,
3432 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3436 tree dest
= CALL_EXPR_ARG (exp
, 0);
3437 tree src
= CALL_EXPR_ARG (exp
, 1);
3438 tree len
= CALL_EXPR_ARG (exp
, 2);
3439 const char *src_str
;
3440 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
3441 unsigned int dest_align
3442 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3443 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
3444 HOST_WIDE_INT expected_size
= -1;
3445 unsigned int expected_align
= 0;
3447 /* If DEST is not a pointer type, call the normal function. */
3448 if (dest_align
== 0)
3451 /* If either SRC is not a pointer type, don't do this
3452 operation in-line. */
3456 if (currently_expanding_gimple_stmt
)
3457 stringop_block_profile (currently_expanding_gimple_stmt
,
3458 &expected_align
, &expected_size
);
3460 if (expected_align
< dest_align
)
3461 expected_align
= dest_align
;
3462 dest_mem
= get_memory_rtx (dest
, len
);
3463 set_mem_align (dest_mem
, dest_align
);
3464 len_rtx
= expand_normal (len
);
3465 src_str
= c_getstr (src
);
3467 /* If SRC is a string constant and block move would be done
3468 by pieces, we can avoid loading the string from memory
3469 and only stored the computed constants. */
3471 && CONST_INT_P (len_rtx
)
3472 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3473 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3474 CONST_CAST (char *, src_str
),
3477 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3478 builtin_memcpy_read_str
,
3479 CONST_CAST (char *, src_str
),
3480 dest_align
, false, 0);
3481 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3482 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3486 src_mem
= get_memory_rtx (src
, len
);
3487 set_mem_align (src_mem
, src_align
);
3489 /* Copy word part most expediently. */
3490 dest_addr
= emit_block_move_hints (dest_mem
, src_mem
, len_rtx
,
3491 CALL_EXPR_TAILCALL (exp
)
3492 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3493 expected_align
, expected_size
);
3497 dest_addr
= force_operand (XEXP (dest_mem
, 0), target
);
3498 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3504 /* Expand a call EXP to the mempcpy builtin.
3505 Return NULL_RTX if we failed; the caller should emit a normal call,
3506 otherwise try to get the result in TARGET, if convenient (and in
3507 mode MODE if that's convenient). If ENDP is 0 return the
3508 destination pointer, if ENDP is 1 return the end pointer ala
3509 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3513 expand_builtin_mempcpy (tree exp
, rtx target
, enum machine_mode mode
)
3515 if (!validate_arglist (exp
,
3516 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3520 tree dest
= CALL_EXPR_ARG (exp
, 0);
3521 tree src
= CALL_EXPR_ARG (exp
, 1);
3522 tree len
= CALL_EXPR_ARG (exp
, 2);
3523 return expand_builtin_mempcpy_args (dest
, src
, len
,
3524 target
, mode
, /*endp=*/ 1);
3528 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3529 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3530 so that this can also be called without constructing an actual CALL_EXPR.
3531 The other arguments and return value are the same as for
3532 expand_builtin_mempcpy. */
3535 expand_builtin_mempcpy_args (tree dest
, tree src
, tree len
,
3536 rtx target
, enum machine_mode mode
, int endp
)
3538 /* If return value is ignored, transform mempcpy into memcpy. */
3539 if (target
== const0_rtx
&& implicit_built_in_decls
[BUILT_IN_MEMCPY
])
3541 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3542 tree result
= build_call_nofold_loc (UNKNOWN_LOCATION
, fn
, 3,
3544 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3548 const char *src_str
;
3549 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
3550 unsigned int dest_align
3551 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3552 rtx dest_mem
, src_mem
, len_rtx
;
3554 /* If either SRC or DEST is not a pointer type, don't do this
3555 operation in-line. */
3556 if (dest_align
== 0 || src_align
== 0)
3559 /* If LEN is not constant, call the normal function. */
3560 if (! host_integerp (len
, 1))
3563 len_rtx
= expand_normal (len
);
3564 src_str
= c_getstr (src
);
3566 /* If SRC is a string constant and block move would be done
3567 by pieces, we can avoid loading the string from memory
3568 and only stored the computed constants. */
3570 && CONST_INT_P (len_rtx
)
3571 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3572 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3573 CONST_CAST (char *, src_str
),
3576 dest_mem
= get_memory_rtx (dest
, len
);
3577 set_mem_align (dest_mem
, dest_align
);
3578 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3579 builtin_memcpy_read_str
,
3580 CONST_CAST (char *, src_str
),
3581 dest_align
, false, endp
);
3582 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3583 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3587 if (CONST_INT_P (len_rtx
)
3588 && can_move_by_pieces (INTVAL (len_rtx
),
3589 MIN (dest_align
, src_align
)))
3591 dest_mem
= get_memory_rtx (dest
, len
);
3592 set_mem_align (dest_mem
, dest_align
);
3593 src_mem
= get_memory_rtx (src
, len
);
3594 set_mem_align (src_mem
, src_align
);
3595 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
3596 MIN (dest_align
, src_align
), endp
);
3597 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3598 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3607 # define HAVE_movstr 0
3608 # define CODE_FOR_movstr CODE_FOR_nothing
3611 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3612 we failed, the caller should emit a normal call, otherwise try to
3613 get the result in TARGET, if convenient. If ENDP is 0 return the
3614 destination pointer, if ENDP is 1 return the end pointer ala
3615 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3619 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3625 const struct insn_data_d
* data
;
3630 dest_mem
= get_memory_rtx (dest
, NULL
);
3631 src_mem
= get_memory_rtx (src
, NULL
);
3632 data
= insn_data
+ CODE_FOR_movstr
;
3635 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3636 dest_mem
= replace_equiv_address (dest_mem
, target
);
3637 end
= gen_reg_rtx (Pmode
);
3642 || target
== const0_rtx
3643 || ! (*data
->operand
[0].predicate
) (target
, Pmode
))
3645 end
= gen_reg_rtx (Pmode
);
3646 if (target
!= const0_rtx
)
3653 if (data
->operand
[0].mode
!= VOIDmode
)
3654 end
= gen_lowpart (data
->operand
[0].mode
, end
);
3656 insn
= data
->genfun (end
, dest_mem
, src_mem
);
3662 /* movstr is supposed to set end to the address of the NUL
3663 terminator. If the caller requested a mempcpy-like return value,
3665 if (endp
== 1 && target
!= const0_rtx
)
3667 rtx tem
= plus_constant (gen_lowpart (GET_MODE (target
), end
), 1);
3668 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3674 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3675 NULL_RTX if we failed the caller should emit a normal call, otherwise
3676 try to get the result in TARGET, if convenient (and in mode MODE if that's
3680 expand_builtin_strcpy (tree exp
, rtx target
)
3682 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3684 tree dest
= CALL_EXPR_ARG (exp
, 0);
3685 tree src
= CALL_EXPR_ARG (exp
, 1);
3686 return expand_builtin_strcpy_args (dest
, src
, target
);
3691 /* Helper function to do the actual work for expand_builtin_strcpy. The
3692 arguments to the builtin_strcpy call DEST and SRC are broken out
3693 so that this can also be called without constructing an actual CALL_EXPR.
3694 The other arguments and return value are the same as for
3695 expand_builtin_strcpy. */
3698 expand_builtin_strcpy_args (tree dest
, tree src
, rtx target
)
3700 return expand_movstr (dest
, src
, target
, /*endp=*/0);
3703 /* Expand a call EXP to the stpcpy builtin.
3704 Return NULL_RTX if we failed the caller should emit a normal call,
3705 otherwise try to get the result in TARGET, if convenient (and in
3706 mode MODE if that's convenient). */
3709 expand_builtin_stpcpy (tree exp
, rtx target
, enum machine_mode mode
)
3712 location_t loc
= EXPR_LOCATION (exp
);
3714 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3717 dst
= CALL_EXPR_ARG (exp
, 0);
3718 src
= CALL_EXPR_ARG (exp
, 1);
3720 /* If return value is ignored, transform stpcpy into strcpy. */
3721 if (target
== const0_rtx
&& implicit_built_in_decls
[BUILT_IN_STRCPY
])
3723 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
3724 tree result
= build_call_nofold_loc (loc
, fn
, 2, dst
, src
);
3725 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3732 /* Ensure we get an actual string whose length can be evaluated at
3733 compile-time, not an expression containing a string. This is
3734 because the latter will potentially produce pessimized code
3735 when used to produce the return value. */
3736 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3737 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3739 lenp1
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
3740 ret
= expand_builtin_mempcpy_args (dst
, src
, lenp1
,
3741 target
, mode
, /*endp=*/2);
3746 if (TREE_CODE (len
) == INTEGER_CST
)
3748 rtx len_rtx
= expand_normal (len
);
3750 if (CONST_INT_P (len_rtx
))
3752 ret
= expand_builtin_strcpy_args (dst
, src
, target
);
3758 if (mode
!= VOIDmode
)
3759 target
= gen_reg_rtx (mode
);
3761 target
= gen_reg_rtx (GET_MODE (ret
));
3763 if (GET_MODE (target
) != GET_MODE (ret
))
3764 ret
= gen_lowpart (GET_MODE (target
), ret
);
3766 ret
= plus_constant (ret
, INTVAL (len_rtx
));
3767 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3775 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3779 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3780 bytes from constant string DATA + OFFSET and return it as target
3784 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3785 enum machine_mode mode
)
3787 const char *str
= (const char *) data
;
3789 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3792 return c_readstr (str
+ offset
, mode
);
3795 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3796 NULL_RTX if we failed the caller should emit a normal call. */
3799 expand_builtin_strncpy (tree exp
, rtx target
)
3801 location_t loc
= EXPR_LOCATION (exp
);
3803 if (validate_arglist (exp
,
3804 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3806 tree dest
= CALL_EXPR_ARG (exp
, 0);
3807 tree src
= CALL_EXPR_ARG (exp
, 1);
3808 tree len
= CALL_EXPR_ARG (exp
, 2);
3809 tree slen
= c_strlen (src
, 1);
3811 /* We must be passed a constant len and src parameter. */
3812 if (!host_integerp (len
, 1) || !slen
|| !host_integerp (slen
, 1))
3815 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
3817 /* We're required to pad with trailing zeros if the requested
3818 len is greater than strlen(s2)+1. In that case try to
3819 use store_by_pieces, if it fails, punt. */
3820 if (tree_int_cst_lt (slen
, len
))
3822 unsigned int dest_align
3823 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3824 const char *p
= c_getstr (src
);
3827 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
3828 || !can_store_by_pieces (tree_low_cst (len
, 1),
3829 builtin_strncpy_read_str
,
3830 CONST_CAST (char *, p
),
3834 dest_mem
= get_memory_rtx (dest
, len
);
3835 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3836 builtin_strncpy_read_str
,
3837 CONST_CAST (char *, p
), dest_align
, false, 0);
3838 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3839 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3846 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3847 bytes from constant string DATA + OFFSET and return it as target
3851 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3852 enum machine_mode mode
)
3854 const char *c
= (const char *) data
;
3855 char *p
= XALLOCAVEC (char, GET_MODE_SIZE (mode
));
3857 memset (p
, *c
, GET_MODE_SIZE (mode
));
3859 return c_readstr (p
, mode
);
3862 /* Callback routine for store_by_pieces. Return the RTL of a register
3863 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3864 char value given in the RTL register data. For example, if mode is
3865 4 bytes wide, return the RTL for 0x01010101*data. */
3868 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3869 enum machine_mode mode
)
3875 size
= GET_MODE_SIZE (mode
);
3879 p
= XALLOCAVEC (char, size
);
3880 memset (p
, 1, size
);
3881 coeff
= c_readstr (p
, mode
);
3883 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3884 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3885 return force_reg (mode
, target
);
3888 /* Expand expression EXP, which is a call to the memset builtin. Return
3889 NULL_RTX if we failed the caller should emit a normal call, otherwise
3890 try to get the result in TARGET, if convenient (and in mode MODE if that's
3894 expand_builtin_memset (tree exp
, rtx target
, enum machine_mode mode
)
3896 if (!validate_arglist (exp
,
3897 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3901 tree dest
= CALL_EXPR_ARG (exp
, 0);
3902 tree val
= CALL_EXPR_ARG (exp
, 1);
3903 tree len
= CALL_EXPR_ARG (exp
, 2);
3904 return expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
3908 /* Helper function to do the actual work for expand_builtin_memset. The
3909 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3910 so that this can also be called without constructing an actual CALL_EXPR.
3911 The other arguments and return value are the same as for
3912 expand_builtin_memset. */
3915 expand_builtin_memset_args (tree dest
, tree val
, tree len
,
3916 rtx target
, enum machine_mode mode
, tree orig_exp
)
3919 enum built_in_function fcode
;
3921 unsigned int dest_align
;
3922 rtx dest_mem
, dest_addr
, len_rtx
;
3923 HOST_WIDE_INT expected_size
= -1;
3924 unsigned int expected_align
= 0;
3926 dest_align
= get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3928 /* If DEST is not a pointer type, don't do this operation in-line. */
3929 if (dest_align
== 0)
3932 if (currently_expanding_gimple_stmt
)
3933 stringop_block_profile (currently_expanding_gimple_stmt
,
3934 &expected_align
, &expected_size
);
3936 if (expected_align
< dest_align
)
3937 expected_align
= dest_align
;
3939 /* If the LEN parameter is zero, return DEST. */
3940 if (integer_zerop (len
))
3942 /* Evaluate and ignore VAL in case it has side-effects. */
3943 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3944 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3947 /* Stabilize the arguments in case we fail. */
3948 dest
= builtin_save_expr (dest
);
3949 val
= builtin_save_expr (val
);
3950 len
= builtin_save_expr (len
);
3952 len_rtx
= expand_normal (len
);
3953 dest_mem
= get_memory_rtx (dest
, len
);
3955 if (TREE_CODE (val
) != INTEGER_CST
)
3959 val_rtx
= expand_normal (val
);
3960 val_rtx
= convert_to_mode (TYPE_MODE (unsigned_char_type_node
),
3963 /* Assume that we can memset by pieces if we can store
3964 * the coefficients by pieces (in the required modes).
3965 * We can't pass builtin_memset_gen_str as that emits RTL. */
3967 if (host_integerp (len
, 1)
3968 && can_store_by_pieces (tree_low_cst (len
, 1),
3969 builtin_memset_read_str
, &c
, dest_align
,
3972 val_rtx
= force_reg (TYPE_MODE (unsigned_char_type_node
),
3974 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3975 builtin_memset_gen_str
, val_rtx
, dest_align
,
3978 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, val_rtx
,
3979 dest_align
, expected_align
,
3983 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3984 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3988 if (target_char_cast (val
, &c
))
3993 if (host_integerp (len
, 1)
3994 && can_store_by_pieces (tree_low_cst (len
, 1),
3995 builtin_memset_read_str
, &c
, dest_align
,
3997 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3998 builtin_memset_read_str
, &c
, dest_align
, true, 0);
3999 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, GEN_INT (c
),
4000 dest_align
, expected_align
,
4004 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
4005 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
4009 set_mem_align (dest_mem
, dest_align
);
4010 dest_addr
= clear_storage_hints (dest_mem
, len_rtx
,
4011 CALL_EXPR_TAILCALL (orig_exp
)
4012 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
4013 expected_align
, expected_size
);
4017 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
4018 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
4024 fndecl
= get_callee_fndecl (orig_exp
);
4025 fcode
= DECL_FUNCTION_CODE (fndecl
);
4026 if (fcode
== BUILT_IN_MEMSET
)
4027 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 3,
4029 else if (fcode
== BUILT_IN_BZERO
)
4030 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 2,
4034 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4035 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
4036 return expand_call (fn
, target
, target
== const0_rtx
);
4039 /* Expand expression EXP, which is a call to the bzero builtin. Return
4040 NULL_RTX if we failed the caller should emit a normal call. */
4043 expand_builtin_bzero (tree exp
)
4046 location_t loc
= EXPR_LOCATION (exp
);
4048 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4051 dest
= CALL_EXPR_ARG (exp
, 0);
4052 size
= CALL_EXPR_ARG (exp
, 1);
4054 /* New argument list transforming bzero(ptr x, int y) to
4055 memset(ptr x, int 0, size_t y). This is done this way
4056 so that if it isn't expanded inline, we fallback to
4057 calling bzero instead of memset. */
4059 return expand_builtin_memset_args (dest
, integer_zero_node
,
4060 fold_convert_loc (loc
, sizetype
, size
),
4061 const0_rtx
, VOIDmode
, exp
);
4064 /* Expand expression EXP, which is a call to the memcmp built-in function.
4065 Return NULL_RTX if we failed and the
4066 caller should emit a normal call, otherwise try to get the result in
4067 TARGET, if convenient (and in mode MODE, if that's convenient). */
4070 expand_builtin_memcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
4071 ATTRIBUTE_UNUSED
enum machine_mode mode
)
4073 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
4075 if (!validate_arglist (exp
,
4076 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4079 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4081 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
4084 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4085 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4086 tree len
= CALL_EXPR_ARG (exp
, 2);
4088 unsigned int arg1_align
4089 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
4090 unsigned int arg2_align
4091 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
4092 enum machine_mode insn_mode
;
4094 #ifdef HAVE_cmpmemsi
4096 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
4099 #ifdef HAVE_cmpstrnsi
4101 insn_mode
= insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4106 /* If we don't have POINTER_TYPE, call the function. */
4107 if (arg1_align
== 0 || arg2_align
== 0)
4110 /* Make a place to write the result of the instruction. */
4113 && REG_P (result
) && GET_MODE (result
) == insn_mode
4114 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4115 result
= gen_reg_rtx (insn_mode
);
4117 arg1_rtx
= get_memory_rtx (arg1
, len
);
4118 arg2_rtx
= get_memory_rtx (arg2
, len
);
4119 arg3_rtx
= expand_normal (fold_convert_loc (loc
, sizetype
, len
));
4121 /* Set MEM_SIZE as appropriate. */
4122 if (CONST_INT_P (arg3_rtx
))
4124 set_mem_size (arg1_rtx
, arg3_rtx
);
4125 set_mem_size (arg2_rtx
, arg3_rtx
);
4128 #ifdef HAVE_cmpmemsi
4130 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4131 GEN_INT (MIN (arg1_align
, arg2_align
)));
4134 #ifdef HAVE_cmpstrnsi
4136 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4137 GEN_INT (MIN (arg1_align
, arg2_align
)));
4145 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE
,
4146 TYPE_MODE (integer_type_node
), 3,
4147 XEXP (arg1_rtx
, 0), Pmode
,
4148 XEXP (arg2_rtx
, 0), Pmode
,
4149 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
4150 TYPE_UNSIGNED (sizetype
)),
4151 TYPE_MODE (sizetype
));
4153 /* Return the value in the proper mode for this function. */
4154 mode
= TYPE_MODE (TREE_TYPE (exp
));
4155 if (GET_MODE (result
) == mode
)
4157 else if (target
!= 0)
4159 convert_move (target
, result
, 0);
4163 return convert_to_mode (mode
, result
, 0);
4170 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4171 if we failed the caller should emit a normal call, otherwise try to get
4172 the result in TARGET, if convenient. */
4175 expand_builtin_strcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
)
4177 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4180 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4181 if (direct_optab_handler (cmpstr_optab
, SImode
) != CODE_FOR_nothing
4182 || direct_optab_handler (cmpstrn_optab
, SImode
) != CODE_FOR_nothing
)
4184 rtx arg1_rtx
, arg2_rtx
;
4185 rtx result
, insn
= NULL_RTX
;
4187 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4188 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4190 unsigned int arg1_align
4191 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
4192 unsigned int arg2_align
4193 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
4195 /* If we don't have POINTER_TYPE, call the function. */
4196 if (arg1_align
== 0 || arg2_align
== 0)
4199 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4200 arg1
= builtin_save_expr (arg1
);
4201 arg2
= builtin_save_expr (arg2
);
4203 arg1_rtx
= get_memory_rtx (arg1
, NULL
);
4204 arg2_rtx
= get_memory_rtx (arg2
, NULL
);
4206 #ifdef HAVE_cmpstrsi
4207 /* Try to call cmpstrsi. */
4210 enum machine_mode insn_mode
4211 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
4213 /* Make a place to write the result of the instruction. */
4216 && REG_P (result
) && GET_MODE (result
) == insn_mode
4217 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4218 result
= gen_reg_rtx (insn_mode
);
4220 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
,
4221 GEN_INT (MIN (arg1_align
, arg2_align
)));
4224 #ifdef HAVE_cmpstrnsi
4225 /* Try to determine at least one length and call cmpstrnsi. */
4226 if (!insn
&& HAVE_cmpstrnsi
)
4231 enum machine_mode insn_mode
4232 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4233 tree len1
= c_strlen (arg1
, 1);
4234 tree len2
= c_strlen (arg2
, 1);
4237 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
4239 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
4241 /* If we don't have a constant length for the first, use the length
4242 of the second, if we know it. We don't require a constant for
4243 this case; some cost analysis could be done if both are available
4244 but neither is constant. For now, assume they're equally cheap,
4245 unless one has side effects. If both strings have constant lengths,
4252 else if (TREE_SIDE_EFFECTS (len1
))
4254 else if (TREE_SIDE_EFFECTS (len2
))
4256 else if (TREE_CODE (len1
) != INTEGER_CST
)
4258 else if (TREE_CODE (len2
) != INTEGER_CST
)
4260 else if (tree_int_cst_lt (len1
, len2
))
4265 /* If both arguments have side effects, we cannot optimize. */
4266 if (!len
|| TREE_SIDE_EFFECTS (len
))
4269 arg3_rtx
= expand_normal (len
);
4271 /* Make a place to write the result of the instruction. */
4274 && REG_P (result
) && GET_MODE (result
) == insn_mode
4275 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4276 result
= gen_reg_rtx (insn_mode
);
4278 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4279 GEN_INT (MIN (arg1_align
, arg2_align
)));
4285 enum machine_mode mode
;
4288 /* Return the value in the proper mode for this function. */
4289 mode
= TYPE_MODE (TREE_TYPE (exp
));
4290 if (GET_MODE (result
) == mode
)
4293 return convert_to_mode (mode
, result
, 0);
4294 convert_move (target
, result
, 0);
4298 /* Expand the library call ourselves using a stabilized argument
4299 list to avoid re-evaluating the function's arguments twice. */
4300 #ifdef HAVE_cmpstrnsi
4303 fndecl
= get_callee_fndecl (exp
);
4304 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 2, arg1
, arg2
);
4305 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4306 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4307 return expand_call (fn
, target
, target
== const0_rtx
);
4313 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4314 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4315 the result in TARGET, if convenient. */
4318 expand_builtin_strncmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
4319 ATTRIBUTE_UNUSED
enum machine_mode mode
)
4321 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
4323 if (!validate_arglist (exp
,
4324 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4327 /* If c_strlen can determine an expression for one of the string
4328 lengths, and it doesn't have side effects, then emit cmpstrnsi
4329 using length MIN(strlen(string)+1, arg3). */
4330 #ifdef HAVE_cmpstrnsi
4333 tree len
, len1
, len2
;
4334 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
4337 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4338 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4339 tree arg3
= CALL_EXPR_ARG (exp
, 2);
4341 unsigned int arg1_align
4342 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
4343 unsigned int arg2_align
4344 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
4345 enum machine_mode insn_mode
4346 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4348 len1
= c_strlen (arg1
, 1);
4349 len2
= c_strlen (arg2
, 1);
4352 len1
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len1
);
4354 len2
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len2
);
4356 /* If we don't have a constant length for the first, use the length
4357 of the second, if we know it. We don't require a constant for
4358 this case; some cost analysis could be done if both are available
4359 but neither is constant. For now, assume they're equally cheap,
4360 unless one has side effects. If both strings have constant lengths,
4367 else if (TREE_SIDE_EFFECTS (len1
))
4369 else if (TREE_SIDE_EFFECTS (len2
))
4371 else if (TREE_CODE (len1
) != INTEGER_CST
)
4373 else if (TREE_CODE (len2
) != INTEGER_CST
)
4375 else if (tree_int_cst_lt (len1
, len2
))
4380 /* If both arguments have side effects, we cannot optimize. */
4381 if (!len
|| TREE_SIDE_EFFECTS (len
))
4384 /* The actual new length parameter is MIN(len,arg3). */
4385 len
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (len
), len
,
4386 fold_convert_loc (loc
, TREE_TYPE (len
), arg3
));
4388 /* If we don't have POINTER_TYPE, call the function. */
4389 if (arg1_align
== 0 || arg2_align
== 0)
4392 /* Make a place to write the result of the instruction. */
4395 && REG_P (result
) && GET_MODE (result
) == insn_mode
4396 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4397 result
= gen_reg_rtx (insn_mode
);
4399 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4400 arg1
= builtin_save_expr (arg1
);
4401 arg2
= builtin_save_expr (arg2
);
4402 len
= builtin_save_expr (len
);
4404 arg1_rtx
= get_memory_rtx (arg1
, len
);
4405 arg2_rtx
= get_memory_rtx (arg2
, len
);
4406 arg3_rtx
= expand_normal (len
);
4407 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4408 GEN_INT (MIN (arg1_align
, arg2_align
)));
4413 /* Return the value in the proper mode for this function. */
4414 mode
= TYPE_MODE (TREE_TYPE (exp
));
4415 if (GET_MODE (result
) == mode
)
4418 return convert_to_mode (mode
, result
, 0);
4419 convert_move (target
, result
, 0);
4423 /* Expand the library call ourselves using a stabilized argument
4424 list to avoid re-evaluating the function's arguments twice. */
4425 fndecl
= get_callee_fndecl (exp
);
4426 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 3,
4428 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4429 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4430 return expand_call (fn
, target
, target
== const0_rtx
);
4436 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4437 if that's convenient. */
4440 expand_builtin_saveregs (void)
4444 /* Don't do __builtin_saveregs more than once in a function.
4445 Save the result of the first call and reuse it. */
4446 if (saveregs_value
!= 0)
4447 return saveregs_value
;
4449 /* When this function is called, it means that registers must be
4450 saved on entry to this function. So we migrate the call to the
4451 first insn of this function. */
4455 /* Do whatever the machine needs done in this case. */
4456 val
= targetm
.calls
.expand_builtin_saveregs ();
4461 saveregs_value
= val
;
4463 /* Put the insns after the NOTE that starts the function. If this
4464 is inside a start_sequence, make the outer-level insn chain current, so
4465 the code is placed at the start of the function. */
4466 push_topmost_sequence ();
4467 emit_insn_after (seq
, entry_of_function ());
4468 pop_topmost_sequence ();
4473 /* Expand a call to __builtin_next_arg. */
4476 expand_builtin_next_arg (void)
4478 /* Checking arguments is already done in fold_builtin_next_arg
4479 that must be called before this function. */
4480 return expand_binop (ptr_mode
, add_optab
,
4481 crtl
->args
.internal_arg_pointer
,
4482 crtl
->args
.arg_offset_rtx
,
4483 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4486 /* Make it easier for the backends by protecting the valist argument
4487 from multiple evaluations. */
4490 stabilize_va_list_loc (location_t loc
, tree valist
, int needs_lvalue
)
4492 tree vatype
= targetm
.canonical_va_list_type (TREE_TYPE (valist
));
4494 /* The current way of determining the type of valist is completely
4495 bogus. We should have the information on the va builtin instead. */
4497 vatype
= targetm
.fn_abi_va_list (cfun
->decl
);
4499 if (TREE_CODE (vatype
) == ARRAY_TYPE
)
4501 if (TREE_SIDE_EFFECTS (valist
))
4502 valist
= save_expr (valist
);
4504 /* For this case, the backends will be expecting a pointer to
4505 vatype, but it's possible we've actually been given an array
4506 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4508 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4510 tree p1
= build_pointer_type (TREE_TYPE (vatype
));
4511 valist
= build_fold_addr_expr_with_type_loc (loc
, valist
, p1
);
4516 tree pt
= build_pointer_type (vatype
);
4520 if (! TREE_SIDE_EFFECTS (valist
))
4523 valist
= fold_build1_loc (loc
, ADDR_EXPR
, pt
, valist
);
4524 TREE_SIDE_EFFECTS (valist
) = 1;
4527 if (TREE_SIDE_EFFECTS (valist
))
4528 valist
= save_expr (valist
);
4529 valist
= fold_build2_loc (loc
, MEM_REF
,
4530 vatype
, valist
, build_int_cst (pt
, 0));
4536 /* The "standard" definition of va_list is void*. */
4539 std_build_builtin_va_list (void)
4541 return ptr_type_node
;
4544 /* The "standard" abi va_list is va_list_type_node. */
4547 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED
)
4549 return va_list_type_node
;
4552 /* The "standard" type of va_list is va_list_type_node. */
4555 std_canonical_va_list_type (tree type
)
4559 if (INDIRECT_REF_P (type
))
4560 type
= TREE_TYPE (type
);
4561 else if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (TREE_TYPE(type
)))
4562 type
= TREE_TYPE (type
);
4563 wtype
= va_list_type_node
;
4565 /* Treat structure va_list types. */
4566 if (TREE_CODE (wtype
) == RECORD_TYPE
&& POINTER_TYPE_P (htype
))
4567 htype
= TREE_TYPE (htype
);
4568 else if (TREE_CODE (wtype
) == ARRAY_TYPE
)
4570 /* If va_list is an array type, the argument may have decayed
4571 to a pointer type, e.g. by being passed to another function.
4572 In that case, unwrap both types so that we can compare the
4573 underlying records. */
4574 if (TREE_CODE (htype
) == ARRAY_TYPE
4575 || POINTER_TYPE_P (htype
))
4577 wtype
= TREE_TYPE (wtype
);
4578 htype
= TREE_TYPE (htype
);
4581 if (TYPE_MAIN_VARIANT (wtype
) == TYPE_MAIN_VARIANT (htype
))
4582 return va_list_type_node
;
4587 /* The "standard" implementation of va_start: just assign `nextarg' to
4591 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4593 rtx va_r
= expand_expr (valist
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4594 convert_move (va_r
, nextarg
, 0);
4597 /* Expand EXP, a call to __builtin_va_start. */
4600 expand_builtin_va_start (tree exp
)
4604 location_t loc
= EXPR_LOCATION (exp
);
4606 if (call_expr_nargs (exp
) < 2)
4608 error_at (loc
, "too few arguments to function %<va_start%>");
4612 if (fold_builtin_next_arg (exp
, true))
4615 nextarg
= expand_builtin_next_arg ();
4616 valist
= stabilize_va_list_loc (loc
, CALL_EXPR_ARG (exp
, 0), 1);
4618 if (targetm
.expand_builtin_va_start
)
4619 targetm
.expand_builtin_va_start (valist
, nextarg
);
4621 std_expand_builtin_va_start (valist
, nextarg
);
4626 /* The "standard" implementation of va_arg: read the value from the
4627 current (padded) address and increment by the (padded) size. */
4630 std_gimplify_va_arg_expr (tree valist
, tree type
, gimple_seq
*pre_p
,
4633 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
4634 unsigned HOST_WIDE_INT align
, boundary
;
4637 #ifdef ARGS_GROW_DOWNWARD
4638 /* All of the alignment and movement below is for args-grow-up machines.
4639 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4640 implement their own specialized gimplify_va_arg_expr routines. */
4644 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
4646 type
= build_pointer_type (type
);
4648 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
4649 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
);
4651 /* When we align parameter on stack for caller, if the parameter
4652 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4653 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
4654 here with caller. */
4655 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
4656 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
4658 boundary
/= BITS_PER_UNIT
;
4660 /* Hoist the valist value into a temporary for the moment. */
4661 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
4663 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4664 requires greater alignment, we must perform dynamic alignment. */
4665 if (boundary
> align
4666 && !integer_zerop (TYPE_SIZE (type
)))
4668 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4669 fold_build2 (POINTER_PLUS_EXPR
,
4671 valist_tmp
, size_int (boundary
- 1)));
4672 gimplify_and_add (t
, pre_p
);
4674 t
= fold_convert (sizetype
, valist_tmp
);
4675 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4676 fold_convert (TREE_TYPE (valist
),
4677 fold_build2 (BIT_AND_EXPR
, sizetype
, t
,
4678 size_int (-boundary
))));
4679 gimplify_and_add (t
, pre_p
);
4684 /* If the actual alignment is less than the alignment of the type,
4685 adjust the type accordingly so that we don't assume strict alignment
4686 when dereferencing the pointer. */
4687 boundary
*= BITS_PER_UNIT
;
4688 if (boundary
< TYPE_ALIGN (type
))
4690 type
= build_variant_type_copy (type
);
4691 TYPE_ALIGN (type
) = boundary
;
4694 /* Compute the rounded size of the type. */
4695 type_size
= size_in_bytes (type
);
4696 rounded_size
= round_up (type_size
, align
);
4698 /* Reduce rounded_size so it's sharable with the postqueue. */
4699 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4703 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
4705 /* Small args are padded downward. */
4706 t
= fold_build2_loc (input_location
, GT_EXPR
, sizetype
,
4707 rounded_size
, size_int (align
));
4708 t
= fold_build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
4709 size_binop (MINUS_EXPR
, rounded_size
, type_size
));
4710 addr
= fold_build2 (POINTER_PLUS_EXPR
,
4711 TREE_TYPE (addr
), addr
, t
);
4714 /* Compute new value for AP. */
4715 t
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, rounded_size
);
4716 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
4717 gimplify_and_add (t
, pre_p
);
4719 addr
= fold_convert (build_pointer_type (type
), addr
);
4722 addr
= build_va_arg_indirect_ref (addr
);
4724 return build_va_arg_indirect_ref (addr
);
4727 /* Build an indirect-ref expression over the given TREE, which represents a
4728 piece of a va_arg() expansion. */
4730 build_va_arg_indirect_ref (tree addr
)
4732 addr
= build_fold_indirect_ref_loc (EXPR_LOCATION (addr
), addr
);
4734 if (flag_mudflap
) /* Don't instrument va_arg INDIRECT_REF. */
4740 /* Return a dummy expression of type TYPE in order to keep going after an
4744 dummy_object (tree type
)
4746 tree t
= build_int_cst (build_pointer_type (type
), 0);
4747 return build2 (MEM_REF
, type
, t
, t
);
4750 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4751 builtin function, but a very special sort of operator. */
4753 enum gimplify_status
4754 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4756 tree promoted_type
, have_va_type
;
4757 tree valist
= TREE_OPERAND (*expr_p
, 0);
4758 tree type
= TREE_TYPE (*expr_p
);
4760 location_t loc
= EXPR_LOCATION (*expr_p
);
4762 /* Verify that valist is of the proper type. */
4763 have_va_type
= TREE_TYPE (valist
);
4764 if (have_va_type
== error_mark_node
)
4766 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
4768 if (have_va_type
== NULL_TREE
)
4770 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
4774 /* Generate a diagnostic for requesting data of a type that cannot
4775 be passed through `...' due to type promotion at the call site. */
4776 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4779 static bool gave_help
;
4782 /* Unfortunately, this is merely undefined, rather than a constraint
4783 violation, so we cannot make this an error. If this call is never
4784 executed, the program is still strictly conforming. */
4785 warned
= warning_at (loc
, 0,
4786 "%qT is promoted to %qT when passed through %<...%>",
4787 type
, promoted_type
);
4788 if (!gave_help
&& warned
)
4791 inform (loc
, "(so you should pass %qT not %qT to %<va_arg%>)",
4792 promoted_type
, type
);
4795 /* We can, however, treat "undefined" any way we please.
4796 Call abort to encourage the user to fix the program. */
4798 inform (loc
, "if this code is reached, the program will abort");
4799 /* Before the abort, allow the evaluation of the va_list
4800 expression to exit or longjmp. */
4801 gimplify_and_add (valist
, pre_p
);
4802 t
= build_call_expr_loc (loc
,
4803 implicit_built_in_decls
[BUILT_IN_TRAP
], 0);
4804 gimplify_and_add (t
, pre_p
);
4806 /* This is dead code, but go ahead and finish so that the
4807 mode of the result comes out right. */
4808 *expr_p
= dummy_object (type
);
4813 /* Make it easier for the backends by protecting the valist argument
4814 from multiple evaluations. */
4815 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
)
4817 /* For this case, the backends will be expecting a pointer to
4818 TREE_TYPE (abi), but it's possible we've
4819 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4821 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4823 tree p1
= build_pointer_type (TREE_TYPE (have_va_type
));
4824 valist
= fold_convert_loc (loc
, p1
,
4825 build_fold_addr_expr_loc (loc
, valist
));
4828 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4831 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
4833 if (!targetm
.gimplify_va_arg_expr
)
4834 /* FIXME: Once most targets are converted we should merely
4835 assert this is non-null. */
4838 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
4843 /* Expand EXP, a call to __builtin_va_end. */
4846 expand_builtin_va_end (tree exp
)
4848 tree valist
= CALL_EXPR_ARG (exp
, 0);
4850 /* Evaluate for side effects, if needed. I hate macros that don't
4852 if (TREE_SIDE_EFFECTS (valist
))
4853 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4858 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4859 builtin rather than just as an assignment in stdarg.h because of the
4860 nastiness of array-type va_list types. */
4863 expand_builtin_va_copy (tree exp
)
4866 location_t loc
= EXPR_LOCATION (exp
);
4868 dst
= CALL_EXPR_ARG (exp
, 0);
4869 src
= CALL_EXPR_ARG (exp
, 1);
4871 dst
= stabilize_va_list_loc (loc
, dst
, 1);
4872 src
= stabilize_va_list_loc (loc
, src
, 0);
4874 gcc_assert (cfun
!= NULL
&& cfun
->decl
!= NULL_TREE
);
4876 if (TREE_CODE (targetm
.fn_abi_va_list (cfun
->decl
)) != ARRAY_TYPE
)
4878 t
= build2 (MODIFY_EXPR
, targetm
.fn_abi_va_list (cfun
->decl
), dst
, src
);
4879 TREE_SIDE_EFFECTS (t
) = 1;
4880 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4884 rtx dstb
, srcb
, size
;
4886 /* Evaluate to pointers. */
4887 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4888 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4889 size
= expand_expr (TYPE_SIZE_UNIT (targetm
.fn_abi_va_list (cfun
->decl
)),
4890 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
4892 dstb
= convert_memory_address (Pmode
, dstb
);
4893 srcb
= convert_memory_address (Pmode
, srcb
);
4895 /* "Dereference" to BLKmode memories. */
4896 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4897 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4898 set_mem_align (dstb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4899 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4900 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4901 set_mem_align (srcb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4904 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4910 /* Expand a call to one of the builtin functions __builtin_frame_address or
4911 __builtin_return_address. */
4914 expand_builtin_frame_address (tree fndecl
, tree exp
)
4916 /* The argument must be a nonnegative integer constant.
4917 It counts the number of frames to scan up the stack.
4918 The value is the return address saved in that frame. */
4919 if (call_expr_nargs (exp
) == 0)
4920 /* Warning about missing arg was already issued. */
4922 else if (! host_integerp (CALL_EXPR_ARG (exp
, 0), 1))
4924 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4925 error ("invalid argument to %<__builtin_frame_address%>");
4927 error ("invalid argument to %<__builtin_return_address%>");
4933 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4934 tree_low_cst (CALL_EXPR_ARG (exp
, 0), 1));
4936 /* Some ports cannot access arbitrary stack frames. */
4939 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4940 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4942 warning (0, "unsupported argument to %<__builtin_return_address%>");
4946 /* For __builtin_frame_address, return what we've got. */
4947 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4951 && ! CONSTANT_P (tem
))
4952 tem
= copy_to_mode_reg (Pmode
, tem
);
4957 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4958 failed and the caller should emit a normal call, otherwise try to
4959 get the result in TARGET, if convenient. CANNOT_ACCUMULATE is the
4960 same as for allocate_dynamic_stack_space. */
4963 expand_builtin_alloca (tree exp
, rtx target
, bool cannot_accumulate
)
4968 /* Emit normal call if marked not-inlineable. */
4969 if (CALL_CANNOT_INLINE_P (exp
))
4972 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4975 /* Compute the argument. */
4976 op0
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4978 /* Allocate the desired space. */
4979 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
,
4981 result
= convert_memory_address (ptr_mode
, result
);
4986 /* Expand a call to a bswap builtin with argument ARG0. MODE
4987 is the mode to expand with. */
4990 expand_builtin_bswap (tree exp
, rtx target
, rtx subtarget
)
4992 enum machine_mode mode
;
4996 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4999 arg
= CALL_EXPR_ARG (exp
, 0);
5000 mode
= TYPE_MODE (TREE_TYPE (arg
));
5001 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
5003 target
= expand_unop (mode
, bswap_optab
, op0
, target
, 1);
5005 gcc_assert (target
);
5007 return convert_to_mode (mode
, target
, 0);
5010 /* Expand a call to a unary builtin in EXP.
5011 Return NULL_RTX if a normal call should be emitted rather than expanding the
5012 function in-line. If convenient, the result should be placed in TARGET.
5013 SUBTARGET may be used as the target for computing one of EXP's operands. */
5016 expand_builtin_unop (enum machine_mode target_mode
, tree exp
, rtx target
,
5017 rtx subtarget
, optab op_optab
)
5021 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
5024 /* Compute the argument. */
5025 op0
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
5026 VOIDmode
, EXPAND_NORMAL
);
5027 /* Compute op, into TARGET if possible.
5028 Set TARGET to wherever the result comes back. */
5029 target
= expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))),
5030 op_optab
, op0
, target
, 1);
5031 gcc_assert (target
);
5033 return convert_to_mode (target_mode
, target
, 0);
5036 /* Expand a call to __builtin_expect. We just return our argument
5037 as the builtin_expect semantic should've been already executed by
5038 tree branch prediction pass. */
5041 expand_builtin_expect (tree exp
, rtx target
)
5045 if (call_expr_nargs (exp
) < 2)
5047 arg
= CALL_EXPR_ARG (exp
, 0);
5049 target
= expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5050 /* When guessing was done, the hints should be already stripped away. */
5051 gcc_assert (!flag_guess_branch_prob
5052 || optimize
== 0 || seen_error ());
5057 expand_builtin_trap (void)
5061 emit_insn (gen_trap ());
5064 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
5068 /* Expand a call to __builtin_unreachable. We do nothing except emit
5069 a barrier saying that control flow will not pass here.
5071 It is the responsibility of the program being compiled to ensure
5072 that control flow does never reach __builtin_unreachable. */
5074 expand_builtin_unreachable (void)
5079 /* Expand EXP, a call to fabs, fabsf or fabsl.
5080 Return NULL_RTX if a normal call should be emitted rather than expanding
5081 the function inline. If convenient, the result should be placed
5082 in TARGET. SUBTARGET may be used as the target for computing
5086 expand_builtin_fabs (tree exp
, rtx target
, rtx subtarget
)
5088 enum machine_mode mode
;
5092 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
5095 arg
= CALL_EXPR_ARG (exp
, 0);
5096 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
5097 mode
= TYPE_MODE (TREE_TYPE (arg
));
5098 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
5099 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
5102 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5103 Return NULL is a normal call should be emitted rather than expanding the
5104 function inline. If convenient, the result should be placed in TARGET.
5105 SUBTARGET may be used as the target for computing the operand. */
5108 expand_builtin_copysign (tree exp
, rtx target
, rtx subtarget
)
5113 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
5116 arg
= CALL_EXPR_ARG (exp
, 0);
5117 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
5119 arg
= CALL_EXPR_ARG (exp
, 1);
5120 op1
= expand_normal (arg
);
5122 return expand_copysign (op0
, op1
, target
);
5125 /* Create a new constant string literal and return a char* pointer to it.
5126 The STRING_CST value is the LEN characters at STR. */
5128 build_string_literal (int len
, const char *str
)
5130 tree t
, elem
, index
, type
;
5132 t
= build_string (len
, str
);
5133 elem
= build_type_variant (char_type_node
, 1, 0);
5134 index
= build_index_type (size_int (len
- 1));
5135 type
= build_array_type (elem
, index
);
5136 TREE_TYPE (t
) = type
;
5137 TREE_CONSTANT (t
) = 1;
5138 TREE_READONLY (t
) = 1;
5139 TREE_STATIC (t
) = 1;
5141 type
= build_pointer_type (elem
);
5142 t
= build1 (ADDR_EXPR
, type
,
5143 build4 (ARRAY_REF
, elem
,
5144 t
, integer_zero_node
, NULL_TREE
, NULL_TREE
));
5148 /* Expand a call to either the entry or exit function profiler. */
5151 expand_builtin_profile_func (bool exitp
)
5153 rtx this_rtx
, which
;
5155 this_rtx
= DECL_RTL (current_function_decl
);
5156 gcc_assert (MEM_P (this_rtx
));
5157 this_rtx
= XEXP (this_rtx
, 0);
5160 which
= profile_function_exit_libfunc
;
5162 which
= profile_function_entry_libfunc
;
5164 emit_library_call (which
, LCT_NORMAL
, VOIDmode
, 2, this_rtx
, Pmode
,
5165 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
5172 /* Expand a call to __builtin___clear_cache. */
5175 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED
)
5177 #ifndef HAVE_clear_cache
5178 #ifdef CLEAR_INSN_CACHE
5179 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5180 does something. Just do the default expansion to a call to
5184 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5185 does nothing. There is no need to call it. Do nothing. */
5187 #endif /* CLEAR_INSN_CACHE */
5189 /* We have a "clear_cache" insn, and it will handle everything. */
5191 rtx begin_rtx
, end_rtx
;
5192 enum insn_code icode
;
5194 /* We must not expand to a library call. If we did, any
5195 fallback library function in libgcc that might contain a call to
5196 __builtin___clear_cache() would recurse infinitely. */
5197 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
5199 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5203 if (HAVE_clear_cache
)
5205 icode
= CODE_FOR_clear_cache
;
5207 begin
= CALL_EXPR_ARG (exp
, 0);
5208 begin_rtx
= expand_expr (begin
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
5209 begin_rtx
= convert_memory_address (Pmode
, begin_rtx
);
5210 if (!insn_data
[icode
].operand
[0].predicate (begin_rtx
, Pmode
))
5211 begin_rtx
= copy_to_mode_reg (Pmode
, begin_rtx
);
5213 end
= CALL_EXPR_ARG (exp
, 1);
5214 end_rtx
= expand_expr (end
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
5215 end_rtx
= convert_memory_address (Pmode
, end_rtx
);
5216 if (!insn_data
[icode
].operand
[1].predicate (end_rtx
, Pmode
))
5217 end_rtx
= copy_to_mode_reg (Pmode
, end_rtx
);
5219 emit_insn (gen_clear_cache (begin_rtx
, end_rtx
));
5222 #endif /* HAVE_clear_cache */
5225 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5228 round_trampoline_addr (rtx tramp
)
5230 rtx temp
, addend
, mask
;
5232 /* If we don't need too much alignment, we'll have been guaranteed
5233 proper alignment by get_trampoline_type. */
5234 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
5237 /* Round address up to desired boundary. */
5238 temp
= gen_reg_rtx (Pmode
);
5239 addend
= GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1);
5240 mask
= GEN_INT (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
5242 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
5243 temp
, 0, OPTAB_LIB_WIDEN
);
5244 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
5245 temp
, 0, OPTAB_LIB_WIDEN
);
5251 expand_builtin_init_trampoline (tree exp
)
5253 tree t_tramp
, t_func
, t_chain
;
5254 rtx m_tramp
, r_tramp
, r_chain
, tmp
;
5256 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
,
5257 POINTER_TYPE
, VOID_TYPE
))
5260 t_tramp
= CALL_EXPR_ARG (exp
, 0);
5261 t_func
= CALL_EXPR_ARG (exp
, 1);
5262 t_chain
= CALL_EXPR_ARG (exp
, 2);
5264 r_tramp
= expand_normal (t_tramp
);
5265 m_tramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
5266 MEM_NOTRAP_P (m_tramp
) = 1;
5268 /* The TRAMP argument should be the address of a field within the
5269 local function's FRAME decl. Let's see if we can fill in the
5270 to fill in the MEM_ATTRs for this memory. */
5271 if (TREE_CODE (t_tramp
) == ADDR_EXPR
)
5272 set_mem_attributes_minus_bitpos (m_tramp
, TREE_OPERAND (t_tramp
, 0),
5275 tmp
= round_trampoline_addr (r_tramp
);
5278 m_tramp
= change_address (m_tramp
, BLKmode
, tmp
);
5279 set_mem_align (m_tramp
, TRAMPOLINE_ALIGNMENT
);
5280 set_mem_size (m_tramp
, GEN_INT (TRAMPOLINE_SIZE
));
5283 /* The FUNC argument should be the address of the nested function.
5284 Extract the actual function decl to pass to the hook. */
5285 gcc_assert (TREE_CODE (t_func
) == ADDR_EXPR
);
5286 t_func
= TREE_OPERAND (t_func
, 0);
5287 gcc_assert (TREE_CODE (t_func
) == FUNCTION_DECL
);
5289 r_chain
= expand_normal (t_chain
);
5291 /* Generate insns to initialize the trampoline. */
5292 targetm
.calls
.trampoline_init (m_tramp
, t_func
, r_chain
);
5294 trampolines_created
= 1;
5296 warning_at (DECL_SOURCE_LOCATION (t_func
), OPT_Wtrampolines
,
5297 "trampoline generated for nested function %qD", t_func
);
5303 expand_builtin_adjust_trampoline (tree exp
)
5307 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5310 tramp
= expand_normal (CALL_EXPR_ARG (exp
, 0));
5311 tramp
= round_trampoline_addr (tramp
);
5312 if (targetm
.calls
.trampoline_adjust_address
)
5313 tramp
= targetm
.calls
.trampoline_adjust_address (tramp
);
5318 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5319 function. The function first checks whether the back end provides
5320 an insn to implement signbit for the respective mode. If not, it
5321 checks whether the floating point format of the value is such that
5322 the sign bit can be extracted. If that is not the case, the
5323 function returns NULL_RTX to indicate that a normal call should be
5324 emitted rather than expanding the function in-line. EXP is the
5325 expression that is a call to the builtin function; if convenient,
5326 the result should be placed in TARGET. */
5328 expand_builtin_signbit (tree exp
, rtx target
)
5330 const struct real_format
*fmt
;
5331 enum machine_mode fmode
, imode
, rmode
;
5334 enum insn_code icode
;
5336 location_t loc
= EXPR_LOCATION (exp
);
5338 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
5341 arg
= CALL_EXPR_ARG (exp
, 0);
5342 fmode
= TYPE_MODE (TREE_TYPE (arg
));
5343 rmode
= TYPE_MODE (TREE_TYPE (exp
));
5344 fmt
= REAL_MODE_FORMAT (fmode
);
5346 arg
= builtin_save_expr (arg
);
5348 /* Expand the argument yielding a RTX expression. */
5349 temp
= expand_normal (arg
);
5351 /* Check if the back end provides an insn that handles signbit for the
5353 icode
= optab_handler (signbit_optab
, fmode
);
5354 if (icode
!= CODE_FOR_nothing
)
5356 rtx last
= get_last_insn ();
5357 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
5358 if (maybe_emit_unop_insn (icode
, target
, temp
, UNKNOWN
))
5360 delete_insns_since (last
);
5363 /* For floating point formats without a sign bit, implement signbit
5365 bitpos
= fmt
->signbit_ro
;
5368 /* But we can't do this if the format supports signed zero. */
5369 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5372 arg
= fold_build2_loc (loc
, LT_EXPR
, TREE_TYPE (exp
), arg
,
5373 build_real (TREE_TYPE (arg
), dconst0
));
5374 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5377 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
5379 imode
= int_mode_for_mode (fmode
);
5380 if (imode
== BLKmode
)
5382 temp
= gen_lowpart (imode
, temp
);
5387 /* Handle targets with different FP word orders. */
5388 if (FLOAT_WORDS_BIG_ENDIAN
)
5389 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
5391 word
= bitpos
/ BITS_PER_WORD
;
5392 temp
= operand_subword_force (temp
, word
, fmode
);
5393 bitpos
= bitpos
% BITS_PER_WORD
;
5396 /* Force the intermediate word_mode (or narrower) result into a
5397 register. This avoids attempting to create paradoxical SUBREGs
5398 of floating point modes below. */
5399 temp
= force_reg (imode
, temp
);
5401 /* If the bitpos is within the "result mode" lowpart, the operation
5402 can be implement with a single bitwise AND. Otherwise, we need
5403 a right shift and an AND. */
5405 if (bitpos
< GET_MODE_BITSIZE (rmode
))
5407 double_int mask
= double_int_setbit (double_int_zero
, bitpos
);
5409 if (GET_MODE_SIZE (imode
) > GET_MODE_SIZE (rmode
))
5410 temp
= gen_lowpart (rmode
, temp
);
5411 temp
= expand_binop (rmode
, and_optab
, temp
,
5412 immed_double_int_const (mask
, rmode
),
5413 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5417 /* Perform a logical right shift to place the signbit in the least
5418 significant bit, then truncate the result to the desired mode
5419 and mask just this bit. */
5420 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
,
5421 build_int_cst (NULL_TREE
, bitpos
), NULL_RTX
, 1);
5422 temp
= gen_lowpart (rmode
, temp
);
5423 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
5424 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5430 /* Expand fork or exec calls. TARGET is the desired target of the
5431 call. EXP is the call. FN is the
5432 identificator of the actual function. IGNORE is nonzero if the
5433 value is to be ignored. */
5436 expand_builtin_fork_or_exec (tree fn
, tree exp
, rtx target
, int ignore
)
5441 /* If we are not profiling, just call the function. */
5442 if (!profile_arc_flag
)
5445 /* Otherwise call the wrapper. This should be equivalent for the rest of
5446 compiler, so the code does not diverge, and the wrapper may run the
5447 code necessary for keeping the profiling sane. */
5449 switch (DECL_FUNCTION_CODE (fn
))
5452 id
= get_identifier ("__gcov_fork");
5455 case BUILT_IN_EXECL
:
5456 id
= get_identifier ("__gcov_execl");
5459 case BUILT_IN_EXECV
:
5460 id
= get_identifier ("__gcov_execv");
5463 case BUILT_IN_EXECLP
:
5464 id
= get_identifier ("__gcov_execlp");
5467 case BUILT_IN_EXECLE
:
5468 id
= get_identifier ("__gcov_execle");
5471 case BUILT_IN_EXECVP
:
5472 id
= get_identifier ("__gcov_execvp");
5475 case BUILT_IN_EXECVE
:
5476 id
= get_identifier ("__gcov_execve");
5483 decl
= build_decl (DECL_SOURCE_LOCATION (fn
),
5484 FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5485 DECL_EXTERNAL (decl
) = 1;
5486 TREE_PUBLIC (decl
) = 1;
5487 DECL_ARTIFICIAL (decl
) = 1;
5488 TREE_NOTHROW (decl
) = 1;
5489 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5490 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5491 call
= rewrite_call_expr (EXPR_LOCATION (exp
), exp
, 0, decl
, 0);
5492 return expand_call (call
, target
, ignore
);
5497 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5498 the pointer in these functions is void*, the tree optimizers may remove
5499 casts. The mode computed in expand_builtin isn't reliable either, due
5500 to __sync_bool_compare_and_swap.
5502 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5503 group of builtins. This gives us log2 of the mode size. */
5505 static inline enum machine_mode
5506 get_builtin_sync_mode (int fcode_diff
)
5508 /* The size is not negotiable, so ask not to get BLKmode in return
5509 if the target indicates that a smaller size would be better. */
5510 return mode_for_size (BITS_PER_UNIT
<< fcode_diff
, MODE_INT
, 0);
5513 /* Expand the memory expression LOC and return the appropriate memory operand
5514 for the builtin_sync operations. */
5517 get_builtin_sync_mem (tree loc
, enum machine_mode mode
)
5521 addr
= expand_expr (loc
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
5522 addr
= convert_memory_address (Pmode
, addr
);
5524 /* Note that we explicitly do not want any alias information for this
5525 memory, so that we kill all other live memories. Otherwise we don't
5526 satisfy the full barrier semantics of the intrinsic. */
5527 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5529 /* The alignment needs to be at least according to that of the mode. */
5530 set_mem_align (mem
, MAX (GET_MODE_ALIGNMENT (mode
),
5531 get_pointer_alignment (loc
, BIGGEST_ALIGNMENT
)));
5532 set_mem_alias_set (mem
, ALIAS_SET_MEMORY_BARRIER
);
5533 MEM_VOLATILE_P (mem
) = 1;
5538 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5539 EXP is the CALL_EXPR. CODE is the rtx code
5540 that corresponds to the arithmetic or logical operation from the name;
5541 an exception here is that NOT actually means NAND. TARGET is an optional
5542 place for us to store the results; AFTER is true if this is the
5543 fetch_and_xxx form. IGNORE is true if we don't actually care about
5544 the result of the operation at all. */
5547 expand_builtin_sync_operation (enum machine_mode mode
, tree exp
,
5548 enum rtx_code code
, bool after
,
5549 rtx target
, bool ignore
)
5552 enum machine_mode old_mode
;
5553 location_t loc
= EXPR_LOCATION (exp
);
5555 if (code
== NOT
&& warn_sync_nand
)
5557 tree fndecl
= get_callee_fndecl (exp
);
5558 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5560 static bool warned_f_a_n
, warned_n_a_f
;
5564 case BUILT_IN_FETCH_AND_NAND_1
:
5565 case BUILT_IN_FETCH_AND_NAND_2
:
5566 case BUILT_IN_FETCH_AND_NAND_4
:
5567 case BUILT_IN_FETCH_AND_NAND_8
:
5568 case BUILT_IN_FETCH_AND_NAND_16
:
5573 fndecl
= implicit_built_in_decls
[BUILT_IN_FETCH_AND_NAND_N
];
5574 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5575 warned_f_a_n
= true;
5578 case BUILT_IN_NAND_AND_FETCH_1
:
5579 case BUILT_IN_NAND_AND_FETCH_2
:
5580 case BUILT_IN_NAND_AND_FETCH_4
:
5581 case BUILT_IN_NAND_AND_FETCH_8
:
5582 case BUILT_IN_NAND_AND_FETCH_16
:
5587 fndecl
= implicit_built_in_decls
[BUILT_IN_NAND_AND_FETCH_N
];
5588 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5589 warned_n_a_f
= true;
5597 /* Expand the operands. */
5598 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5600 val
= expand_expr (CALL_EXPR_ARG (exp
, 1), NULL_RTX
, mode
, EXPAND_NORMAL
);
5601 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5602 of CONST_INTs, where we know the old_mode only from the call argument. */
5603 old_mode
= GET_MODE (val
);
5604 if (old_mode
== VOIDmode
)
5605 old_mode
= TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 1)));
5606 val
= convert_modes (mode
, old_mode
, val
, 1);
5609 return expand_sync_operation (mem
, val
, code
);
5611 return expand_sync_fetch_operation (mem
, val
, code
, after
, target
);
5614 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5615 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5616 true if this is the boolean form. TARGET is a place for us to store the
5617 results; this is NOT optional if IS_BOOL is true. */
5620 expand_builtin_compare_and_swap (enum machine_mode mode
, tree exp
,
5621 bool is_bool
, rtx target
)
5623 rtx old_val
, new_val
, mem
;
5624 enum machine_mode old_mode
;
5626 /* Expand the operands. */
5627 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5630 old_val
= expand_expr (CALL_EXPR_ARG (exp
, 1), NULL_RTX
,
5631 mode
, EXPAND_NORMAL
);
5632 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5633 of CONST_INTs, where we know the old_mode only from the call argument. */
5634 old_mode
= GET_MODE (old_val
);
5635 if (old_mode
== VOIDmode
)
5636 old_mode
= TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 1)));
5637 old_val
= convert_modes (mode
, old_mode
, old_val
, 1);
5639 new_val
= expand_expr (CALL_EXPR_ARG (exp
, 2), NULL_RTX
,
5640 mode
, EXPAND_NORMAL
);
5641 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5642 of CONST_INTs, where we know the old_mode only from the call argument. */
5643 old_mode
= GET_MODE (new_val
);
5644 if (old_mode
== VOIDmode
)
5645 old_mode
= TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 2)));
5646 new_val
= convert_modes (mode
, old_mode
, new_val
, 1);
5649 return expand_bool_compare_and_swap (mem
, old_val
, new_val
, target
);
5651 return expand_val_compare_and_swap (mem
, old_val
, new_val
, target
);
5654 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5655 general form is actually an atomic exchange, and some targets only
5656 support a reduced form with the second argument being a constant 1.
5657 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5661 expand_builtin_lock_test_and_set (enum machine_mode mode
, tree exp
,
5665 enum machine_mode old_mode
;
5667 /* Expand the operands. */
5668 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5669 val
= expand_expr (CALL_EXPR_ARG (exp
, 1), NULL_RTX
, mode
, EXPAND_NORMAL
);
5670 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5671 of CONST_INTs, where we know the old_mode only from the call argument. */
5672 old_mode
= GET_MODE (val
);
5673 if (old_mode
== VOIDmode
)
5674 old_mode
= TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 1)));
5675 val
= convert_modes (mode
, old_mode
, val
, 1);
5677 return expand_sync_lock_test_and_set (mem
, val
, target
);
5680 /* Expand the __sync_synchronize intrinsic. */
5683 expand_builtin_synchronize (void)
5686 VEC (tree
, gc
) *v_clobbers
;
5688 #ifdef HAVE_memory_barrier
5689 if (HAVE_memory_barrier
)
5691 emit_insn (gen_memory_barrier ());
5696 if (synchronize_libfunc
!= NULL_RTX
)
5698 emit_library_call (synchronize_libfunc
, LCT_NORMAL
, VOIDmode
, 0);
5702 /* If no explicit memory barrier instruction is available, create an
5703 empty asm stmt with a memory clobber. */
5704 v_clobbers
= VEC_alloc (tree
, gc
, 1);
5705 VEC_quick_push (tree
, v_clobbers
,
5706 tree_cons (NULL
, build_string (6, "memory"), NULL
));
5707 x
= gimple_build_asm_vec ("", NULL
, NULL
, v_clobbers
, NULL
);
5708 gimple_asm_set_volatile (x
, true);
5709 expand_asm_stmt (x
);
5712 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5715 expand_builtin_lock_release (enum machine_mode mode
, tree exp
)
5717 enum insn_code icode
;
5719 rtx val
= const0_rtx
;
5721 /* Expand the operands. */
5722 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5724 /* If there is an explicit operation in the md file, use it. */
5725 icode
= direct_optab_handler (sync_lock_release_optab
, mode
);
5726 if (icode
!= CODE_FOR_nothing
)
5728 if (!insn_data
[icode
].operand
[1].predicate (val
, mode
))
5729 val
= force_reg (mode
, val
);
5731 insn
= GEN_FCN (icode
) (mem
, val
);
5739 /* Otherwise we can implement this operation by emitting a barrier
5740 followed by a store of zero. */
5741 expand_builtin_synchronize ();
5742 emit_move_insn (mem
, val
);
5745 /* Expand an expression EXP that calls a built-in function,
5746 with result going to TARGET if that's convenient
5747 (and in mode MODE if that's convenient).
5748 SUBTARGET may be used as the target for computing one of EXP's operands.
5749 IGNORE is nonzero if the value is to be ignored. */
5752 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5755 tree fndecl
= get_callee_fndecl (exp
);
5756 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5757 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5760 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5761 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5763 /* When not optimizing, generate calls to library functions for a certain
5766 && !called_as_built_in (fndecl
)
5767 && DECL_ASSEMBLER_NAME_SET_P (fndecl
)
5768 && fcode
!= BUILT_IN_ALLOCA
5769 && fcode
!= BUILT_IN_FREE
)
5770 return expand_call (exp
, target
, ignore
);
5772 /* The built-in function expanders test for target == const0_rtx
5773 to determine whether the function's result will be ignored. */
5775 target
= const0_rtx
;
5777 /* If the result of a pure or const built-in function is ignored, and
5778 none of its arguments are volatile, we can avoid expanding the
5779 built-in call and just evaluate the arguments for side-effects. */
5780 if (target
== const0_rtx
5781 && ((flags
= flags_from_decl_or_type (fndecl
)) & (ECF_CONST
| ECF_PURE
))
5782 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
5784 bool volatilep
= false;
5786 call_expr_arg_iterator iter
;
5788 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
5789 if (TREE_THIS_VOLATILE (arg
))
5797 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
5798 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5805 CASE_FLT_FN (BUILT_IN_FABS
):
5806 target
= expand_builtin_fabs (exp
, target
, subtarget
);
5811 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
5812 target
= expand_builtin_copysign (exp
, target
, subtarget
);
5817 /* Just do a normal library call if we were unable to fold
5819 CASE_FLT_FN (BUILT_IN_CABS
):
5822 CASE_FLT_FN (BUILT_IN_EXP
):
5823 CASE_FLT_FN (BUILT_IN_EXP10
):
5824 CASE_FLT_FN (BUILT_IN_POW10
):
5825 CASE_FLT_FN (BUILT_IN_EXP2
):
5826 CASE_FLT_FN (BUILT_IN_EXPM1
):
5827 CASE_FLT_FN (BUILT_IN_LOGB
):
5828 CASE_FLT_FN (BUILT_IN_LOG
):
5829 CASE_FLT_FN (BUILT_IN_LOG10
):
5830 CASE_FLT_FN (BUILT_IN_LOG2
):
5831 CASE_FLT_FN (BUILT_IN_LOG1P
):
5832 CASE_FLT_FN (BUILT_IN_TAN
):
5833 CASE_FLT_FN (BUILT_IN_ASIN
):
5834 CASE_FLT_FN (BUILT_IN_ACOS
):
5835 CASE_FLT_FN (BUILT_IN_ATAN
):
5836 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
5837 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5838 because of possible accuracy problems. */
5839 if (! flag_unsafe_math_optimizations
)
5841 CASE_FLT_FN (BUILT_IN_SQRT
):
5842 CASE_FLT_FN (BUILT_IN_FLOOR
):
5843 CASE_FLT_FN (BUILT_IN_CEIL
):
5844 CASE_FLT_FN (BUILT_IN_TRUNC
):
5845 CASE_FLT_FN (BUILT_IN_ROUND
):
5846 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
5847 CASE_FLT_FN (BUILT_IN_RINT
):
5848 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5853 CASE_FLT_FN (BUILT_IN_ILOGB
):
5854 if (! flag_unsafe_math_optimizations
)
5856 CASE_FLT_FN (BUILT_IN_ISINF
):
5857 CASE_FLT_FN (BUILT_IN_FINITE
):
5858 case BUILT_IN_ISFINITE
:
5859 case BUILT_IN_ISNORMAL
:
5860 target
= expand_builtin_interclass_mathfn (exp
, target
, subtarget
);
5865 CASE_FLT_FN (BUILT_IN_LCEIL
):
5866 CASE_FLT_FN (BUILT_IN_LLCEIL
):
5867 CASE_FLT_FN (BUILT_IN_LFLOOR
):
5868 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
5869 target
= expand_builtin_int_roundingfn (exp
, target
);
5874 CASE_FLT_FN (BUILT_IN_LRINT
):
5875 CASE_FLT_FN (BUILT_IN_LLRINT
):
5876 CASE_FLT_FN (BUILT_IN_LROUND
):
5877 CASE_FLT_FN (BUILT_IN_LLROUND
):
5878 target
= expand_builtin_int_roundingfn_2 (exp
, target
);
5883 CASE_FLT_FN (BUILT_IN_POW
):
5884 target
= expand_builtin_pow (exp
, target
, subtarget
);
5889 CASE_FLT_FN (BUILT_IN_POWI
):
5890 target
= expand_builtin_powi (exp
, target
, subtarget
);
5895 CASE_FLT_FN (BUILT_IN_ATAN2
):
5896 CASE_FLT_FN (BUILT_IN_LDEXP
):
5897 CASE_FLT_FN (BUILT_IN_SCALB
):
5898 CASE_FLT_FN (BUILT_IN_SCALBN
):
5899 CASE_FLT_FN (BUILT_IN_SCALBLN
):
5900 if (! flag_unsafe_math_optimizations
)
5903 CASE_FLT_FN (BUILT_IN_FMOD
):
5904 CASE_FLT_FN (BUILT_IN_REMAINDER
):
5905 CASE_FLT_FN (BUILT_IN_DREM
):
5906 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5911 CASE_FLT_FN (BUILT_IN_CEXPI
):
5912 target
= expand_builtin_cexpi (exp
, target
, subtarget
);
5913 gcc_assert (target
);
5916 CASE_FLT_FN (BUILT_IN_SIN
):
5917 CASE_FLT_FN (BUILT_IN_COS
):
5918 if (! flag_unsafe_math_optimizations
)
5920 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5925 CASE_FLT_FN (BUILT_IN_SINCOS
):
5926 if (! flag_unsafe_math_optimizations
)
5928 target
= expand_builtin_sincos (exp
);
5933 case BUILT_IN_APPLY_ARGS
:
5934 return expand_builtin_apply_args ();
5936 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5937 FUNCTION with a copy of the parameters described by
5938 ARGUMENTS, and ARGSIZE. It returns a block of memory
5939 allocated on the stack into which is stored all the registers
5940 that might possibly be used for returning the result of a
5941 function. ARGUMENTS is the value returned by
5942 __builtin_apply_args. ARGSIZE is the number of bytes of
5943 arguments that must be copied. ??? How should this value be
5944 computed? We'll also need a safe worst case value for varargs
5946 case BUILT_IN_APPLY
:
5947 if (!validate_arglist (exp
, POINTER_TYPE
,
5948 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5949 && !validate_arglist (exp
, REFERENCE_TYPE
,
5950 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5956 ops
[0] = expand_normal (CALL_EXPR_ARG (exp
, 0));
5957 ops
[1] = expand_normal (CALL_EXPR_ARG (exp
, 1));
5958 ops
[2] = expand_normal (CALL_EXPR_ARG (exp
, 2));
5960 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
5963 /* __builtin_return (RESULT) causes the function to return the
5964 value described by RESULT. RESULT is address of the block of
5965 memory returned by __builtin_apply. */
5966 case BUILT_IN_RETURN
:
5967 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5968 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp
, 0)));
5971 case BUILT_IN_SAVEREGS
:
5972 return expand_builtin_saveregs ();
5974 case BUILT_IN_VA_ARG_PACK
:
5975 /* All valid uses of __builtin_va_arg_pack () are removed during
5977 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp
);
5980 case BUILT_IN_VA_ARG_PACK_LEN
:
5981 /* All valid uses of __builtin_va_arg_pack_len () are removed during
5983 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp
);
5986 /* Return the address of the first anonymous stack arg. */
5987 case BUILT_IN_NEXT_ARG
:
5988 if (fold_builtin_next_arg (exp
, false))
5990 return expand_builtin_next_arg ();
5992 case BUILT_IN_CLEAR_CACHE
:
5993 target
= expand_builtin___clear_cache (exp
);
5998 case BUILT_IN_CLASSIFY_TYPE
:
5999 return expand_builtin_classify_type (exp
);
6001 case BUILT_IN_CONSTANT_P
:
6004 case BUILT_IN_FRAME_ADDRESS
:
6005 case BUILT_IN_RETURN_ADDRESS
:
6006 return expand_builtin_frame_address (fndecl
, exp
);
6008 /* Returns the address of the area where the structure is returned.
6010 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
6011 if (call_expr_nargs (exp
) != 0
6012 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
6013 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
6016 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
6018 case BUILT_IN_ALLOCA
:
6019 /* If the allocation stems from the declaration of a variable-sized
6020 object, it cannot accumulate. */
6021 target
= expand_builtin_alloca (exp
, target
, ALLOCA_FOR_VAR_P (exp
));
6026 case BUILT_IN_STACK_SAVE
:
6027 return expand_stack_save ();
6029 case BUILT_IN_STACK_RESTORE
:
6030 expand_stack_restore (CALL_EXPR_ARG (exp
, 0));
6033 case BUILT_IN_BSWAP32
:
6034 case BUILT_IN_BSWAP64
:
6035 target
= expand_builtin_bswap (exp
, target
, subtarget
);
6041 CASE_INT_FN (BUILT_IN_FFS
):
6042 case BUILT_IN_FFSIMAX
:
6043 target
= expand_builtin_unop (target_mode
, exp
, target
,
6044 subtarget
, ffs_optab
);
6049 CASE_INT_FN (BUILT_IN_CLZ
):
6050 case BUILT_IN_CLZIMAX
:
6051 target
= expand_builtin_unop (target_mode
, exp
, target
,
6052 subtarget
, clz_optab
);
6057 CASE_INT_FN (BUILT_IN_CTZ
):
6058 case BUILT_IN_CTZIMAX
:
6059 target
= expand_builtin_unop (target_mode
, exp
, target
,
6060 subtarget
, ctz_optab
);
6065 CASE_INT_FN (BUILT_IN_POPCOUNT
):
6066 case BUILT_IN_POPCOUNTIMAX
:
6067 target
= expand_builtin_unop (target_mode
, exp
, target
,
6068 subtarget
, popcount_optab
);
6073 CASE_INT_FN (BUILT_IN_PARITY
):
6074 case BUILT_IN_PARITYIMAX
:
6075 target
= expand_builtin_unop (target_mode
, exp
, target
,
6076 subtarget
, parity_optab
);
6081 case BUILT_IN_STRLEN
:
6082 target
= expand_builtin_strlen (exp
, target
, target_mode
);
6087 case BUILT_IN_STRCPY
:
6088 target
= expand_builtin_strcpy (exp
, target
);
6093 case BUILT_IN_STRNCPY
:
6094 target
= expand_builtin_strncpy (exp
, target
);
6099 case BUILT_IN_STPCPY
:
6100 target
= expand_builtin_stpcpy (exp
, target
, mode
);
6105 case BUILT_IN_MEMCPY
:
6106 target
= expand_builtin_memcpy (exp
, target
);
6111 case BUILT_IN_MEMPCPY
:
6112 target
= expand_builtin_mempcpy (exp
, target
, mode
);
6117 case BUILT_IN_MEMSET
:
6118 target
= expand_builtin_memset (exp
, target
, mode
);
6123 case BUILT_IN_BZERO
:
6124 target
= expand_builtin_bzero (exp
);
6129 case BUILT_IN_STRCMP
:
6130 target
= expand_builtin_strcmp (exp
, target
);
6135 case BUILT_IN_STRNCMP
:
6136 target
= expand_builtin_strncmp (exp
, target
, mode
);
6142 case BUILT_IN_MEMCMP
:
6143 target
= expand_builtin_memcmp (exp
, target
, mode
);
6148 case BUILT_IN_SETJMP
:
6149 /* This should have been lowered to the builtins below. */
6152 case BUILT_IN_SETJMP_SETUP
:
6153 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6154 and the receiver label. */
6155 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
6157 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6158 VOIDmode
, EXPAND_NORMAL
);
6159 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 1), 0);
6160 rtx label_r
= label_rtx (label
);
6162 /* This is copied from the handling of non-local gotos. */
6163 expand_builtin_setjmp_setup (buf_addr
, label_r
);
6164 nonlocal_goto_handler_labels
6165 = gen_rtx_EXPR_LIST (VOIDmode
, label_r
,
6166 nonlocal_goto_handler_labels
);
6167 /* ??? Do not let expand_label treat us as such since we would
6168 not want to be both on the list of non-local labels and on
6169 the list of forced labels. */
6170 FORCED_LABEL (label
) = 0;
6175 case BUILT_IN_SETJMP_DISPATCHER
:
6176 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6177 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6179 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 0), 0);
6180 rtx label_r
= label_rtx (label
);
6182 /* Remove the dispatcher label from the list of non-local labels
6183 since the receiver labels have been added to it above. */
6184 remove_node_from_expr_list (label_r
, &nonlocal_goto_handler_labels
);
6189 case BUILT_IN_SETJMP_RECEIVER
:
6190 /* __builtin_setjmp_receiver is passed the receiver label. */
6191 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6193 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 0), 0);
6194 rtx label_r
= label_rtx (label
);
6196 expand_builtin_setjmp_receiver (label_r
);
6201 /* __builtin_longjmp is passed a pointer to an array of five words.
6202 It's similar to the C library longjmp function but works with
6203 __builtin_setjmp above. */
6204 case BUILT_IN_LONGJMP
:
6205 if (validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6207 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6208 VOIDmode
, EXPAND_NORMAL
);
6209 rtx value
= expand_normal (CALL_EXPR_ARG (exp
, 1));
6211 if (value
!= const1_rtx
)
6213 error ("%<__builtin_longjmp%> second argument must be 1");
6217 expand_builtin_longjmp (buf_addr
, value
);
6222 case BUILT_IN_NONLOCAL_GOTO
:
6223 target
= expand_builtin_nonlocal_goto (exp
);
6228 /* This updates the setjmp buffer that is its argument with the value
6229 of the current stack pointer. */
6230 case BUILT_IN_UPDATE_SETJMP_BUF
:
6231 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6234 = expand_normal (CALL_EXPR_ARG (exp
, 0));
6236 expand_builtin_update_setjmp_buf (buf_addr
);
6242 expand_builtin_trap ();
6245 case BUILT_IN_UNREACHABLE
:
6246 expand_builtin_unreachable ();
6249 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
6250 case BUILT_IN_SIGNBITD32
:
6251 case BUILT_IN_SIGNBITD64
:
6252 case BUILT_IN_SIGNBITD128
:
6253 target
= expand_builtin_signbit (exp
, target
);
6258 /* Various hooks for the DWARF 2 __throw routine. */
6259 case BUILT_IN_UNWIND_INIT
:
6260 expand_builtin_unwind_init ();
6262 case BUILT_IN_DWARF_CFA
:
6263 return virtual_cfa_rtx
;
6264 #ifdef DWARF2_UNWIND_INFO
6265 case BUILT_IN_DWARF_SP_COLUMN
:
6266 return expand_builtin_dwarf_sp_column ();
6267 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6268 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp
, 0));
6271 case BUILT_IN_FROB_RETURN_ADDR
:
6272 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp
, 0));
6273 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6274 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp
, 0));
6275 case BUILT_IN_EH_RETURN
:
6276 expand_builtin_eh_return (CALL_EXPR_ARG (exp
, 0),
6277 CALL_EXPR_ARG (exp
, 1));
6279 #ifdef EH_RETURN_DATA_REGNO
6280 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6281 return expand_builtin_eh_return_data_regno (exp
);
6283 case BUILT_IN_EXTEND_POINTER
:
6284 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp
, 0));
6285 case BUILT_IN_EH_POINTER
:
6286 return expand_builtin_eh_pointer (exp
);
6287 case BUILT_IN_EH_FILTER
:
6288 return expand_builtin_eh_filter (exp
);
6289 case BUILT_IN_EH_COPY_VALUES
:
6290 return expand_builtin_eh_copy_values (exp
);
6292 case BUILT_IN_VA_START
:
6293 return expand_builtin_va_start (exp
);
6294 case BUILT_IN_VA_END
:
6295 return expand_builtin_va_end (exp
);
6296 case BUILT_IN_VA_COPY
:
6297 return expand_builtin_va_copy (exp
);
6298 case BUILT_IN_EXPECT
:
6299 return expand_builtin_expect (exp
, target
);
6300 case BUILT_IN_PREFETCH
:
6301 expand_builtin_prefetch (exp
);
6304 case BUILT_IN_PROFILE_FUNC_ENTER
:
6305 return expand_builtin_profile_func (false);
6306 case BUILT_IN_PROFILE_FUNC_EXIT
:
6307 return expand_builtin_profile_func (true);
6309 case BUILT_IN_INIT_TRAMPOLINE
:
6310 return expand_builtin_init_trampoline (exp
);
6311 case BUILT_IN_ADJUST_TRAMPOLINE
:
6312 return expand_builtin_adjust_trampoline (exp
);
6315 case BUILT_IN_EXECL
:
6316 case BUILT_IN_EXECV
:
6317 case BUILT_IN_EXECLP
:
6318 case BUILT_IN_EXECLE
:
6319 case BUILT_IN_EXECVP
:
6320 case BUILT_IN_EXECVE
:
6321 target
= expand_builtin_fork_or_exec (fndecl
, exp
, target
, ignore
);
6326 case BUILT_IN_FETCH_AND_ADD_1
:
6327 case BUILT_IN_FETCH_AND_ADD_2
:
6328 case BUILT_IN_FETCH_AND_ADD_4
:
6329 case BUILT_IN_FETCH_AND_ADD_8
:
6330 case BUILT_IN_FETCH_AND_ADD_16
:
6331 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_ADD_1
);
6332 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
,
6333 false, target
, ignore
);
6338 case BUILT_IN_FETCH_AND_SUB_1
:
6339 case BUILT_IN_FETCH_AND_SUB_2
:
6340 case BUILT_IN_FETCH_AND_SUB_4
:
6341 case BUILT_IN_FETCH_AND_SUB_8
:
6342 case BUILT_IN_FETCH_AND_SUB_16
:
6343 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_SUB_1
);
6344 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
,
6345 false, target
, ignore
);
6350 case BUILT_IN_FETCH_AND_OR_1
:
6351 case BUILT_IN_FETCH_AND_OR_2
:
6352 case BUILT_IN_FETCH_AND_OR_4
:
6353 case BUILT_IN_FETCH_AND_OR_8
:
6354 case BUILT_IN_FETCH_AND_OR_16
:
6355 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_OR_1
);
6356 target
= expand_builtin_sync_operation (mode
, exp
, IOR
,
6357 false, target
, ignore
);
6362 case BUILT_IN_FETCH_AND_AND_1
:
6363 case BUILT_IN_FETCH_AND_AND_2
:
6364 case BUILT_IN_FETCH_AND_AND_4
:
6365 case BUILT_IN_FETCH_AND_AND_8
:
6366 case BUILT_IN_FETCH_AND_AND_16
:
6367 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_AND_1
);
6368 target
= expand_builtin_sync_operation (mode
, exp
, AND
,
6369 false, target
, ignore
);
6374 case BUILT_IN_FETCH_AND_XOR_1
:
6375 case BUILT_IN_FETCH_AND_XOR_2
:
6376 case BUILT_IN_FETCH_AND_XOR_4
:
6377 case BUILT_IN_FETCH_AND_XOR_8
:
6378 case BUILT_IN_FETCH_AND_XOR_16
:
6379 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_XOR_1
);
6380 target
= expand_builtin_sync_operation (mode
, exp
, XOR
,
6381 false, target
, ignore
);
6386 case BUILT_IN_FETCH_AND_NAND_1
:
6387 case BUILT_IN_FETCH_AND_NAND_2
:
6388 case BUILT_IN_FETCH_AND_NAND_4
:
6389 case BUILT_IN_FETCH_AND_NAND_8
:
6390 case BUILT_IN_FETCH_AND_NAND_16
:
6391 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_NAND_1
);
6392 target
= expand_builtin_sync_operation (mode
, exp
, NOT
,
6393 false, target
, ignore
);
6398 case BUILT_IN_ADD_AND_FETCH_1
:
6399 case BUILT_IN_ADD_AND_FETCH_2
:
6400 case BUILT_IN_ADD_AND_FETCH_4
:
6401 case BUILT_IN_ADD_AND_FETCH_8
:
6402 case BUILT_IN_ADD_AND_FETCH_16
:
6403 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ADD_AND_FETCH_1
);
6404 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
,
6405 true, target
, ignore
);
6410 case BUILT_IN_SUB_AND_FETCH_1
:
6411 case BUILT_IN_SUB_AND_FETCH_2
:
6412 case BUILT_IN_SUB_AND_FETCH_4
:
6413 case BUILT_IN_SUB_AND_FETCH_8
:
6414 case BUILT_IN_SUB_AND_FETCH_16
:
6415 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SUB_AND_FETCH_1
);
6416 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
,
6417 true, target
, ignore
);
6422 case BUILT_IN_OR_AND_FETCH_1
:
6423 case BUILT_IN_OR_AND_FETCH_2
:
6424 case BUILT_IN_OR_AND_FETCH_4
:
6425 case BUILT_IN_OR_AND_FETCH_8
:
6426 case BUILT_IN_OR_AND_FETCH_16
:
6427 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_OR_AND_FETCH_1
);
6428 target
= expand_builtin_sync_operation (mode
, exp
, IOR
,
6429 true, target
, ignore
);
6434 case BUILT_IN_AND_AND_FETCH_1
:
6435 case BUILT_IN_AND_AND_FETCH_2
:
6436 case BUILT_IN_AND_AND_FETCH_4
:
6437 case BUILT_IN_AND_AND_FETCH_8
:
6438 case BUILT_IN_AND_AND_FETCH_16
:
6439 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_AND_AND_FETCH_1
);
6440 target
= expand_builtin_sync_operation (mode
, exp
, AND
,
6441 true, target
, ignore
);
6446 case BUILT_IN_XOR_AND_FETCH_1
:
6447 case BUILT_IN_XOR_AND_FETCH_2
:
6448 case BUILT_IN_XOR_AND_FETCH_4
:
6449 case BUILT_IN_XOR_AND_FETCH_8
:
6450 case BUILT_IN_XOR_AND_FETCH_16
:
6451 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_XOR_AND_FETCH_1
);
6452 target
= expand_builtin_sync_operation (mode
, exp
, XOR
,
6453 true, target
, ignore
);
6458 case BUILT_IN_NAND_AND_FETCH_1
:
6459 case BUILT_IN_NAND_AND_FETCH_2
:
6460 case BUILT_IN_NAND_AND_FETCH_4
:
6461 case BUILT_IN_NAND_AND_FETCH_8
:
6462 case BUILT_IN_NAND_AND_FETCH_16
:
6463 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_NAND_AND_FETCH_1
);
6464 target
= expand_builtin_sync_operation (mode
, exp
, NOT
,
6465 true, target
, ignore
);
6470 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1
:
6471 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2
:
6472 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4
:
6473 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8
:
6474 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16
:
6475 if (mode
== VOIDmode
)
6476 mode
= TYPE_MODE (boolean_type_node
);
6477 if (!target
|| !register_operand (target
, mode
))
6478 target
= gen_reg_rtx (mode
);
6480 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_BOOL_COMPARE_AND_SWAP_1
);
6481 target
= expand_builtin_compare_and_swap (mode
, exp
, true, target
);
6486 case BUILT_IN_VAL_COMPARE_AND_SWAP_1
:
6487 case BUILT_IN_VAL_COMPARE_AND_SWAP_2
:
6488 case BUILT_IN_VAL_COMPARE_AND_SWAP_4
:
6489 case BUILT_IN_VAL_COMPARE_AND_SWAP_8
:
6490 case BUILT_IN_VAL_COMPARE_AND_SWAP_16
:
6491 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_VAL_COMPARE_AND_SWAP_1
);
6492 target
= expand_builtin_compare_and_swap (mode
, exp
, false, target
);
6497 case BUILT_IN_LOCK_TEST_AND_SET_1
:
6498 case BUILT_IN_LOCK_TEST_AND_SET_2
:
6499 case BUILT_IN_LOCK_TEST_AND_SET_4
:
6500 case BUILT_IN_LOCK_TEST_AND_SET_8
:
6501 case BUILT_IN_LOCK_TEST_AND_SET_16
:
6502 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_LOCK_TEST_AND_SET_1
);
6503 target
= expand_builtin_lock_test_and_set (mode
, exp
, target
);
6508 case BUILT_IN_LOCK_RELEASE_1
:
6509 case BUILT_IN_LOCK_RELEASE_2
:
6510 case BUILT_IN_LOCK_RELEASE_4
:
6511 case BUILT_IN_LOCK_RELEASE_8
:
6512 case BUILT_IN_LOCK_RELEASE_16
:
6513 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_LOCK_RELEASE_1
);
6514 expand_builtin_lock_release (mode
, exp
);
6517 case BUILT_IN_SYNCHRONIZE
:
6518 expand_builtin_synchronize ();
6521 case BUILT_IN_OBJECT_SIZE
:
6522 return expand_builtin_object_size (exp
);
6524 case BUILT_IN_MEMCPY_CHK
:
6525 case BUILT_IN_MEMPCPY_CHK
:
6526 case BUILT_IN_MEMMOVE_CHK
:
6527 case BUILT_IN_MEMSET_CHK
:
6528 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
6533 case BUILT_IN_STRCPY_CHK
:
6534 case BUILT_IN_STPCPY_CHK
:
6535 case BUILT_IN_STRNCPY_CHK
:
6536 case BUILT_IN_STRCAT_CHK
:
6537 case BUILT_IN_STRNCAT_CHK
:
6538 case BUILT_IN_SNPRINTF_CHK
:
6539 case BUILT_IN_VSNPRINTF_CHK
:
6540 maybe_emit_chk_warning (exp
, fcode
);
6543 case BUILT_IN_SPRINTF_CHK
:
6544 case BUILT_IN_VSPRINTF_CHK
:
6545 maybe_emit_sprintf_chk_warning (exp
, fcode
);
6549 maybe_emit_free_warning (exp
);
6552 default: /* just do library call, if unknown builtin */
6556 /* The switch statement above can drop through to cause the function
6557 to be called normally. */
6558 return expand_call (exp
, target
, ignore
);
6561 /* Determine whether a tree node represents a call to a built-in
6562 function. If the tree T is a call to a built-in function with
6563 the right number of arguments of the appropriate types, return
6564 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6565 Otherwise the return value is END_BUILTINS. */
6567 enum built_in_function
6568 builtin_mathfn_code (const_tree t
)
6570 const_tree fndecl
, arg
, parmlist
;
6571 const_tree argtype
, parmtype
;
6572 const_call_expr_arg_iterator iter
;
6574 if (TREE_CODE (t
) != CALL_EXPR
6575 || TREE_CODE (CALL_EXPR_FN (t
)) != ADDR_EXPR
)
6576 return END_BUILTINS
;
6578 fndecl
= get_callee_fndecl (t
);
6579 if (fndecl
== NULL_TREE
6580 || TREE_CODE (fndecl
) != FUNCTION_DECL
6581 || ! DECL_BUILT_IN (fndecl
)
6582 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6583 return END_BUILTINS
;
6585 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6586 init_const_call_expr_arg_iterator (t
, &iter
);
6587 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
6589 /* If a function doesn't take a variable number of arguments,
6590 the last element in the list will have type `void'. */
6591 parmtype
= TREE_VALUE (parmlist
);
6592 if (VOID_TYPE_P (parmtype
))
6594 if (more_const_call_expr_args_p (&iter
))
6595 return END_BUILTINS
;
6596 return DECL_FUNCTION_CODE (fndecl
);
6599 if (! more_const_call_expr_args_p (&iter
))
6600 return END_BUILTINS
;
6602 arg
= next_const_call_expr_arg (&iter
);
6603 argtype
= TREE_TYPE (arg
);
6605 if (SCALAR_FLOAT_TYPE_P (parmtype
))
6607 if (! SCALAR_FLOAT_TYPE_P (argtype
))
6608 return END_BUILTINS
;
6610 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
6612 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
6613 return END_BUILTINS
;
6615 else if (POINTER_TYPE_P (parmtype
))
6617 if (! POINTER_TYPE_P (argtype
))
6618 return END_BUILTINS
;
6620 else if (INTEGRAL_TYPE_P (parmtype
))
6622 if (! INTEGRAL_TYPE_P (argtype
))
6623 return END_BUILTINS
;
6626 return END_BUILTINS
;
6629 /* Variable-length argument list. */
6630 return DECL_FUNCTION_CODE (fndecl
);
6633 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6634 evaluate to a constant. */
6637 fold_builtin_constant_p (tree arg
)
6639 /* We return 1 for a numeric type that's known to be a constant
6640 value at compile-time or for an aggregate type that's a
6641 literal constant. */
6644 /* If we know this is a constant, emit the constant of one. */
6645 if (CONSTANT_CLASS_P (arg
)
6646 || (TREE_CODE (arg
) == CONSTRUCTOR
6647 && TREE_CONSTANT (arg
)))
6648 return integer_one_node
;
6649 if (TREE_CODE (arg
) == ADDR_EXPR
)
6651 tree op
= TREE_OPERAND (arg
, 0);
6652 if (TREE_CODE (op
) == STRING_CST
6653 || (TREE_CODE (op
) == ARRAY_REF
6654 && integer_zerop (TREE_OPERAND (op
, 1))
6655 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
6656 return integer_one_node
;
6659 /* If this expression has side effects, show we don't know it to be a
6660 constant. Likewise if it's a pointer or aggregate type since in
6661 those case we only want literals, since those are only optimized
6662 when generating RTL, not later.
6663 And finally, if we are compiling an initializer, not code, we
6664 need to return a definite result now; there's not going to be any
6665 more optimization done. */
6666 if (TREE_SIDE_EFFECTS (arg
)
6667 || AGGREGATE_TYPE_P (TREE_TYPE (arg
))
6668 || POINTER_TYPE_P (TREE_TYPE (arg
))
6670 || folding_initializer
)
6671 return integer_zero_node
;
6676 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6677 return it as a truthvalue. */
6680 build_builtin_expect_predicate (location_t loc
, tree pred
, tree expected
)
6682 tree fn
, arg_types
, pred_type
, expected_type
, call_expr
, ret_type
;
6684 fn
= built_in_decls
[BUILT_IN_EXPECT
];
6685 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6686 ret_type
= TREE_TYPE (TREE_TYPE (fn
));
6687 pred_type
= TREE_VALUE (arg_types
);
6688 expected_type
= TREE_VALUE (TREE_CHAIN (arg_types
));
6690 pred
= fold_convert_loc (loc
, pred_type
, pred
);
6691 expected
= fold_convert_loc (loc
, expected_type
, expected
);
6692 call_expr
= build_call_expr_loc (loc
, fn
, 2, pred
, expected
);
6694 return build2 (NE_EXPR
, TREE_TYPE (pred
), call_expr
,
6695 build_int_cst (ret_type
, 0));
6698 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6699 NULL_TREE if no simplification is possible. */
6702 fold_builtin_expect (location_t loc
, tree arg0
, tree arg1
)
6705 enum tree_code code
;
6707 /* If this is a builtin_expect within a builtin_expect keep the
6708 inner one. See through a comparison against a constant. It
6709 might have been added to create a thruthvalue. */
6711 if (COMPARISON_CLASS_P (inner
)
6712 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
)
6713 inner
= TREE_OPERAND (inner
, 0);
6715 if (TREE_CODE (inner
) == CALL_EXPR
6716 && (fndecl
= get_callee_fndecl (inner
))
6717 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
6718 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
)
6721 /* Distribute the expected value over short-circuiting operators.
6722 See through the cast from truthvalue_type_node to long. */
6724 while (TREE_CODE (inner
) == NOP_EXPR
6725 && INTEGRAL_TYPE_P (TREE_TYPE (inner
))
6726 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner
, 0))))
6727 inner
= TREE_OPERAND (inner
, 0);
6729 code
= TREE_CODE (inner
);
6730 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
6732 tree op0
= TREE_OPERAND (inner
, 0);
6733 tree op1
= TREE_OPERAND (inner
, 1);
6735 op0
= build_builtin_expect_predicate (loc
, op0
, arg1
);
6736 op1
= build_builtin_expect_predicate (loc
, op1
, arg1
);
6737 inner
= build2 (code
, TREE_TYPE (inner
), op0
, op1
);
6739 return fold_convert_loc (loc
, TREE_TYPE (arg0
), inner
);
6742 /* If the argument isn't invariant then there's nothing else we can do. */
6743 if (!TREE_CONSTANT (arg0
))
6746 /* If we expect that a comparison against the argument will fold to
6747 a constant return the constant. In practice, this means a true
6748 constant or the address of a non-weak symbol. */
6751 if (TREE_CODE (inner
) == ADDR_EXPR
)
6755 inner
= TREE_OPERAND (inner
, 0);
6757 while (TREE_CODE (inner
) == COMPONENT_REF
6758 || TREE_CODE (inner
) == ARRAY_REF
);
6759 if ((TREE_CODE (inner
) == VAR_DECL
6760 || TREE_CODE (inner
) == FUNCTION_DECL
)
6761 && DECL_WEAK (inner
))
6765 /* Otherwise, ARG0 already has the proper type for the return value. */
6769 /* Fold a call to __builtin_classify_type with argument ARG. */
6772 fold_builtin_classify_type (tree arg
)
6775 return build_int_cst (NULL_TREE
, no_type_class
);
6777 return build_int_cst (NULL_TREE
, type_to_class (TREE_TYPE (arg
)));
6780 /* Fold a call to __builtin_strlen with argument ARG. */
6783 fold_builtin_strlen (location_t loc
, tree type
, tree arg
)
6785 if (!validate_arg (arg
, POINTER_TYPE
))
6789 tree len
= c_strlen (arg
, 0);
6792 return fold_convert_loc (loc
, type
, len
);
6798 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6801 fold_builtin_inf (location_t loc
, tree type
, int warn
)
6803 REAL_VALUE_TYPE real
;
6805 /* __builtin_inff is intended to be usable to define INFINITY on all
6806 targets. If an infinity is not available, INFINITY expands "to a
6807 positive constant of type float that overflows at translation
6808 time", footnote "In this case, using INFINITY will violate the
6809 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6810 Thus we pedwarn to ensure this constraint violation is
6812 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
6813 pedwarn (loc
, 0, "target format does not support infinity");
6816 return build_real (type
, real
);
6819 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
6822 fold_builtin_nan (tree arg
, tree type
, int quiet
)
6824 REAL_VALUE_TYPE real
;
6827 if (!validate_arg (arg
, POINTER_TYPE
))
6829 str
= c_getstr (arg
);
6833 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
6836 return build_real (type
, real
);
6839 /* Return true if the floating point expression T has an integer value.
6840 We also allow +Inf, -Inf and NaN to be considered integer values. */
6843 integer_valued_real_p (tree t
)
6845 switch (TREE_CODE (t
))
6852 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6857 return integer_valued_real_p (TREE_OPERAND (t
, 1));
6864 return integer_valued_real_p (TREE_OPERAND (t
, 0))
6865 && integer_valued_real_p (TREE_OPERAND (t
, 1));
6868 return integer_valued_real_p (TREE_OPERAND (t
, 1))
6869 && integer_valued_real_p (TREE_OPERAND (t
, 2));
6872 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
6876 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6877 if (TREE_CODE (type
) == INTEGER_TYPE
)
6879 if (TREE_CODE (type
) == REAL_TYPE
)
6880 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6885 switch (builtin_mathfn_code (t
))
6887 CASE_FLT_FN (BUILT_IN_CEIL
):
6888 CASE_FLT_FN (BUILT_IN_FLOOR
):
6889 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
6890 CASE_FLT_FN (BUILT_IN_RINT
):
6891 CASE_FLT_FN (BUILT_IN_ROUND
):
6892 CASE_FLT_FN (BUILT_IN_TRUNC
):
6895 CASE_FLT_FN (BUILT_IN_FMIN
):
6896 CASE_FLT_FN (BUILT_IN_FMAX
):
6897 return integer_valued_real_p (CALL_EXPR_ARG (t
, 0))
6898 && integer_valued_real_p (CALL_EXPR_ARG (t
, 1));
6911 /* FNDECL is assumed to be a builtin where truncation can be propagated
6912 across (for instance floor((double)f) == (double)floorf (f).
6913 Do the transformation for a call with argument ARG. */
6916 fold_trunc_transparent_mathfn (location_t loc
, tree fndecl
, tree arg
)
6918 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6920 if (!validate_arg (arg
, REAL_TYPE
))
6923 /* Integer rounding functions are idempotent. */
6924 if (fcode
== builtin_mathfn_code (arg
))
6927 /* If argument is already integer valued, and we don't need to worry
6928 about setting errno, there's no need to perform rounding. */
6929 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6934 tree arg0
= strip_float_extensions (arg
);
6935 tree ftype
= TREE_TYPE (TREE_TYPE (fndecl
));
6936 tree newtype
= TREE_TYPE (arg0
);
6939 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6940 && (decl
= mathfn_built_in (newtype
, fcode
)))
6941 return fold_convert_loc (loc
, ftype
,
6942 build_call_expr_loc (loc
, decl
, 1,
6943 fold_convert_loc (loc
,
6950 /* FNDECL is assumed to be builtin which can narrow the FP type of
6951 the argument, for instance lround((double)f) -> lroundf (f).
6952 Do the transformation for a call with argument ARG. */
6955 fold_fixed_mathfn (location_t loc
, tree fndecl
, tree arg
)
6957 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6959 if (!validate_arg (arg
, REAL_TYPE
))
6962 /* If argument is already integer valued, and we don't need to worry
6963 about setting errno, there's no need to perform rounding. */
6964 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6965 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
6966 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
6970 tree ftype
= TREE_TYPE (arg
);
6971 tree arg0
= strip_float_extensions (arg
);
6972 tree newtype
= TREE_TYPE (arg0
);
6975 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6976 && (decl
= mathfn_built_in (newtype
, fcode
)))
6977 return build_call_expr_loc (loc
, decl
, 1,
6978 fold_convert_loc (loc
, newtype
, arg0
));
6981 /* Canonicalize llround (x) to lround (x) on LP64 targets where
6982 sizeof (long long) == sizeof (long). */
6983 if (TYPE_PRECISION (long_long_integer_type_node
)
6984 == TYPE_PRECISION (long_integer_type_node
))
6986 tree newfn
= NULL_TREE
;
6989 CASE_FLT_FN (BUILT_IN_LLCEIL
):
6990 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
6993 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
6994 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
6997 CASE_FLT_FN (BUILT_IN_LLROUND
):
6998 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7001 CASE_FLT_FN (BUILT_IN_LLRINT
):
7002 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7011 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7012 return fold_convert_loc (loc
,
7013 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7020 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7021 return type. Return NULL_TREE if no simplification can be made. */
7024 fold_builtin_cabs (location_t loc
, tree arg
, tree type
, tree fndecl
)
7028 if (!validate_arg (arg
, COMPLEX_TYPE
)
7029 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7032 /* Calculate the result when the argument is a constant. */
7033 if (TREE_CODE (arg
) == COMPLEX_CST
7034 && (res
= do_mpfr_arg2 (TREE_REALPART (arg
), TREE_IMAGPART (arg
),
7038 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7040 tree real
= TREE_OPERAND (arg
, 0);
7041 tree imag
= TREE_OPERAND (arg
, 1);
7043 /* If either part is zero, cabs is fabs of the other. */
7044 if (real_zerop (real
))
7045 return fold_build1_loc (loc
, ABS_EXPR
, type
, imag
);
7046 if (real_zerop (imag
))
7047 return fold_build1_loc (loc
, ABS_EXPR
, type
, real
);
7049 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7050 if (flag_unsafe_math_optimizations
7051 && operand_equal_p (real
, imag
, OEP_PURE_SAME
))
7053 const REAL_VALUE_TYPE sqrt2_trunc
7054 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
7056 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7057 fold_build1_loc (loc
, ABS_EXPR
, type
, real
),
7058 build_real (type
, sqrt2_trunc
));
7062 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7063 if (TREE_CODE (arg
) == NEGATE_EXPR
7064 || TREE_CODE (arg
) == CONJ_EXPR
)
7065 return build_call_expr_loc (loc
, fndecl
, 1, TREE_OPERAND (arg
, 0));
7067 /* Don't do this when optimizing for size. */
7068 if (flag_unsafe_math_optimizations
7069 && optimize
&& optimize_function_for_speed_p (cfun
))
7071 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7073 if (sqrtfn
!= NULL_TREE
)
7075 tree rpart
, ipart
, result
;
7077 arg
= builtin_save_expr (arg
);
7079 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, type
, arg
);
7080 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg
);
7082 rpart
= builtin_save_expr (rpart
);
7083 ipart
= builtin_save_expr (ipart
);
7085 result
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
7086 fold_build2_loc (loc
, MULT_EXPR
, type
,
7088 fold_build2_loc (loc
, MULT_EXPR
, type
,
7091 return build_call_expr_loc (loc
, sqrtfn
, 1, result
);
7098 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7099 complex tree type of the result. If NEG is true, the imaginary
7100 zero is negative. */
7103 build_complex_cproj (tree type
, bool neg
)
7105 REAL_VALUE_TYPE rinf
, rzero
= dconst0
;
7109 return build_complex (type
, build_real (TREE_TYPE (type
), rinf
),
7110 build_real (TREE_TYPE (type
), rzero
));
7113 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7114 return type. Return NULL_TREE if no simplification can be made. */
7117 fold_builtin_cproj (location_t loc
, tree arg
, tree type
)
7119 if (!validate_arg (arg
, COMPLEX_TYPE
)
7120 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7123 /* If there are no infinities, return arg. */
7124 if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type
))))
7125 return non_lvalue_loc (loc
, arg
);
7127 /* Calculate the result when the argument is a constant. */
7128 if (TREE_CODE (arg
) == COMPLEX_CST
)
7130 const REAL_VALUE_TYPE
*real
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
7131 const REAL_VALUE_TYPE
*imag
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
7133 if (real_isinf (real
) || real_isinf (imag
))
7134 return build_complex_cproj (type
, imag
->sign
);
7138 else if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7140 tree real
= TREE_OPERAND (arg
, 0);
7141 tree imag
= TREE_OPERAND (arg
, 1);
7146 /* If the real part is inf and the imag part is known to be
7147 nonnegative, return (inf + 0i). Remember side-effects are
7148 possible in the imag part. */
7149 if (TREE_CODE (real
) == REAL_CST
7150 && real_isinf (TREE_REAL_CST_PTR (real
))
7151 && tree_expr_nonnegative_p (imag
))
7152 return omit_one_operand_loc (loc
, type
,
7153 build_complex_cproj (type
, false),
7156 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7157 Remember side-effects are possible in the real part. */
7158 if (TREE_CODE (imag
) == REAL_CST
7159 && real_isinf (TREE_REAL_CST_PTR (imag
)))
7161 omit_one_operand_loc (loc
, type
,
7162 build_complex_cproj (type
, TREE_REAL_CST_PTR
7163 (imag
)->sign
), arg
);
7169 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7170 Return NULL_TREE if no simplification can be made. */
7173 fold_builtin_sqrt (location_t loc
, tree arg
, tree type
)
7176 enum built_in_function fcode
;
7179 if (!validate_arg (arg
, REAL_TYPE
))
7182 /* Calculate the result when the argument is a constant. */
7183 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_sqrt
, &dconst0
, NULL
, true)))
7186 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7187 fcode
= builtin_mathfn_code (arg
);
7188 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
7190 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7191 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7192 CALL_EXPR_ARG (arg
, 0),
7193 build_real (type
, dconsthalf
));
7194 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7197 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7198 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
7200 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7204 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7206 /* The inner root was either sqrt or cbrt. */
7207 /* This was a conditional expression but it triggered a bug
7209 REAL_VALUE_TYPE dconstroot
;
7210 if (BUILTIN_SQRT_P (fcode
))
7211 dconstroot
= dconsthalf
;
7213 dconstroot
= dconst_third ();
7215 /* Adjust for the outer root. */
7216 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7217 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7218 tree_root
= build_real (type
, dconstroot
);
7219 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7223 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7224 if (flag_unsafe_math_optimizations
7225 && (fcode
== BUILT_IN_POW
7226 || fcode
== BUILT_IN_POWF
7227 || fcode
== BUILT_IN_POWL
))
7229 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7230 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7231 tree arg1
= CALL_EXPR_ARG (arg
, 1);
7233 if (!tree_expr_nonnegative_p (arg0
))
7234 arg0
= build1 (ABS_EXPR
, type
, arg0
);
7235 narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
7236 build_real (type
, dconsthalf
));
7237 return build_call_expr_loc (loc
, powfn
, 2, arg0
, narg1
);
7243 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7244 Return NULL_TREE if no simplification can be made. */
7247 fold_builtin_cbrt (location_t loc
, tree arg
, tree type
)
7249 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7252 if (!validate_arg (arg
, REAL_TYPE
))
7255 /* Calculate the result when the argument is a constant. */
7256 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cbrt
, NULL
, NULL
, 0)))
7259 if (flag_unsafe_math_optimizations
)
7261 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7262 if (BUILTIN_EXPONENT_P (fcode
))
7264 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7265 const REAL_VALUE_TYPE third_trunc
=
7266 real_value_truncate (TYPE_MODE (type
), dconst_third ());
7267 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7268 CALL_EXPR_ARG (arg
, 0),
7269 build_real (type
, third_trunc
));
7270 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7273 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7274 if (BUILTIN_SQRT_P (fcode
))
7276 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7280 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7282 REAL_VALUE_TYPE dconstroot
= dconst_third ();
7284 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7285 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7286 tree_root
= build_real (type
, dconstroot
);
7287 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7291 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7292 if (BUILTIN_CBRT_P (fcode
))
7294 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7295 if (tree_expr_nonnegative_p (arg0
))
7297 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7302 REAL_VALUE_TYPE dconstroot
;
7304 real_arithmetic (&dconstroot
, MULT_EXPR
,
7305 dconst_third_ptr (), dconst_third_ptr ());
7306 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7307 tree_root
= build_real (type
, dconstroot
);
7308 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7313 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7314 if (fcode
== BUILT_IN_POW
7315 || fcode
== BUILT_IN_POWF
7316 || fcode
== BUILT_IN_POWL
)
7318 tree arg00
= CALL_EXPR_ARG (arg
, 0);
7319 tree arg01
= CALL_EXPR_ARG (arg
, 1);
7320 if (tree_expr_nonnegative_p (arg00
))
7322 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7323 const REAL_VALUE_TYPE dconstroot
7324 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
7325 tree narg01
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
,
7326 build_real (type
, dconstroot
));
7327 return build_call_expr_loc (loc
, powfn
, 2, arg00
, narg01
);
7334 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7335 TYPE is the type of the return value. Return NULL_TREE if no
7336 simplification can be made. */
7339 fold_builtin_cos (location_t loc
,
7340 tree arg
, tree type
, tree fndecl
)
7344 if (!validate_arg (arg
, REAL_TYPE
))
7347 /* Calculate the result when the argument is a constant. */
7348 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cos
, NULL
, NULL
, 0)))
7351 /* Optimize cos(-x) into cos (x). */
7352 if ((narg
= fold_strip_sign_ops (arg
)))
7353 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7358 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7359 Return NULL_TREE if no simplification can be made. */
7362 fold_builtin_cosh (location_t loc
, tree arg
, tree type
, tree fndecl
)
7364 if (validate_arg (arg
, REAL_TYPE
))
7368 /* Calculate the result when the argument is a constant. */
7369 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cosh
, NULL
, NULL
, 0)))
7372 /* Optimize cosh(-x) into cosh (x). */
7373 if ((narg
= fold_strip_sign_ops (arg
)))
7374 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7380 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7381 argument ARG. TYPE is the type of the return value. Return
7382 NULL_TREE if no simplification can be made. */
7385 fold_builtin_ccos (location_t loc
, tree arg
, tree type
, tree fndecl
,
7388 if (validate_arg (arg
, COMPLEX_TYPE
)
7389 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
7393 /* Calculate the result when the argument is a constant. */
7394 if ((tmp
= do_mpc_arg1 (arg
, type
, (hyper
? mpc_cosh
: mpc_cos
))))
7397 /* Optimize fn(-x) into fn(x). */
7398 if ((tmp
= fold_strip_sign_ops (arg
)))
7399 return build_call_expr_loc (loc
, fndecl
, 1, tmp
);
7405 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7406 Return NULL_TREE if no simplification can be made. */
7409 fold_builtin_tan (tree arg
, tree type
)
7411 enum built_in_function fcode
;
7414 if (!validate_arg (arg
, REAL_TYPE
))
7417 /* Calculate the result when the argument is a constant. */
7418 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_tan
, NULL
, NULL
, 0)))
7421 /* Optimize tan(atan(x)) = x. */
7422 fcode
= builtin_mathfn_code (arg
);
7423 if (flag_unsafe_math_optimizations
7424 && (fcode
== BUILT_IN_ATAN
7425 || fcode
== BUILT_IN_ATANF
7426 || fcode
== BUILT_IN_ATANL
))
7427 return CALL_EXPR_ARG (arg
, 0);
7432 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7433 NULL_TREE if no simplification can be made. */
7436 fold_builtin_sincos (location_t loc
,
7437 tree arg0
, tree arg1
, tree arg2
)
7442 if (!validate_arg (arg0
, REAL_TYPE
)
7443 || !validate_arg (arg1
, POINTER_TYPE
)
7444 || !validate_arg (arg2
, POINTER_TYPE
))
7447 type
= TREE_TYPE (arg0
);
7449 /* Calculate the result when the argument is a constant. */
7450 if ((res
= do_mpfr_sincos (arg0
, arg1
, arg2
)))
7453 /* Canonicalize sincos to cexpi. */
7454 if (!TARGET_C99_FUNCTIONS
)
7456 fn
= mathfn_built_in (type
, BUILT_IN_CEXPI
);
7460 call
= build_call_expr_loc (loc
, fn
, 1, arg0
);
7461 call
= builtin_save_expr (call
);
7463 return build2 (COMPOUND_EXPR
, void_type_node
,
7464 build2 (MODIFY_EXPR
, void_type_node
,
7465 build_fold_indirect_ref_loc (loc
, arg1
),
7466 build1 (IMAGPART_EXPR
, type
, call
)),
7467 build2 (MODIFY_EXPR
, void_type_node
,
7468 build_fold_indirect_ref_loc (loc
, arg2
),
7469 build1 (REALPART_EXPR
, type
, call
)));
7472 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7473 NULL_TREE if no simplification can be made. */
7476 fold_builtin_cexp (location_t loc
, tree arg0
, tree type
)
7479 tree realp
, imagp
, ifn
;
7482 if (!validate_arg (arg0
, COMPLEX_TYPE
)
7483 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) != REAL_TYPE
)
7486 /* Calculate the result when the argument is a constant. */
7487 if ((res
= do_mpc_arg1 (arg0
, type
, mpc_exp
)))
7490 rtype
= TREE_TYPE (TREE_TYPE (arg0
));
7492 /* In case we can figure out the real part of arg0 and it is constant zero
7494 if (!TARGET_C99_FUNCTIONS
)
7496 ifn
= mathfn_built_in (rtype
, BUILT_IN_CEXPI
);
7500 if ((realp
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
))
7501 && real_zerop (realp
))
7503 tree narg
= fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
7504 return build_call_expr_loc (loc
, ifn
, 1, narg
);
7507 /* In case we can easily decompose real and imaginary parts split cexp
7508 to exp (r) * cexpi (i). */
7509 if (flag_unsafe_math_optimizations
7512 tree rfn
, rcall
, icall
;
7514 rfn
= mathfn_built_in (rtype
, BUILT_IN_EXP
);
7518 imagp
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
7522 icall
= build_call_expr_loc (loc
, ifn
, 1, imagp
);
7523 icall
= builtin_save_expr (icall
);
7524 rcall
= build_call_expr_loc (loc
, rfn
, 1, realp
);
7525 rcall
= builtin_save_expr (rcall
);
7526 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
7527 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
7529 fold_build1_loc (loc
, REALPART_EXPR
,
7531 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
7533 fold_build1_loc (loc
, IMAGPART_EXPR
,
7540 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7541 Return NULL_TREE if no simplification can be made. */
7544 fold_builtin_trunc (location_t loc
, tree fndecl
, tree arg
)
7546 if (!validate_arg (arg
, REAL_TYPE
))
7549 /* Optimize trunc of constant value. */
7550 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7552 REAL_VALUE_TYPE r
, x
;
7553 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7555 x
= TREE_REAL_CST (arg
);
7556 real_trunc (&r
, TYPE_MODE (type
), &x
);
7557 return build_real (type
, r
);
7560 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7563 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7564 Return NULL_TREE if no simplification can be made. */
7567 fold_builtin_floor (location_t loc
, tree fndecl
, tree arg
)
7569 if (!validate_arg (arg
, REAL_TYPE
))
7572 /* Optimize floor of constant value. */
7573 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7577 x
= TREE_REAL_CST (arg
);
7578 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7580 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7583 real_floor (&r
, TYPE_MODE (type
), &x
);
7584 return build_real (type
, r
);
7588 /* Fold floor (x) where x is nonnegative to trunc (x). */
7589 if (tree_expr_nonnegative_p (arg
))
7591 tree truncfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_TRUNC
);
7593 return build_call_expr_loc (loc
, truncfn
, 1, arg
);
7596 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7599 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7600 Return NULL_TREE if no simplification can be made. */
7603 fold_builtin_ceil (location_t loc
, tree fndecl
, tree arg
)
7605 if (!validate_arg (arg
, REAL_TYPE
))
7608 /* Optimize ceil of constant value. */
7609 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7613 x
= TREE_REAL_CST (arg
);
7614 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7616 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7619 real_ceil (&r
, TYPE_MODE (type
), &x
);
7620 return build_real (type
, r
);
7624 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7627 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7628 Return NULL_TREE if no simplification can be made. */
7631 fold_builtin_round (location_t loc
, tree fndecl
, tree arg
)
7633 if (!validate_arg (arg
, REAL_TYPE
))
7636 /* Optimize round of constant value. */
7637 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7641 x
= TREE_REAL_CST (arg
);
7642 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7644 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7647 real_round (&r
, TYPE_MODE (type
), &x
);
7648 return build_real (type
, r
);
7652 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7655 /* Fold function call to builtin lround, lroundf or lroundl (or the
7656 corresponding long long versions) and other rounding functions. ARG
7657 is the argument to the call. Return NULL_TREE if no simplification
7661 fold_builtin_int_roundingfn (location_t loc
, tree fndecl
, tree arg
)
7663 if (!validate_arg (arg
, REAL_TYPE
))
7666 /* Optimize lround of constant value. */
7667 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7669 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
7671 if (real_isfinite (&x
))
7673 tree itype
= TREE_TYPE (TREE_TYPE (fndecl
));
7674 tree ftype
= TREE_TYPE (arg
);
7678 switch (DECL_FUNCTION_CODE (fndecl
))
7680 CASE_FLT_FN (BUILT_IN_LFLOOR
):
7681 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7682 real_floor (&r
, TYPE_MODE (ftype
), &x
);
7685 CASE_FLT_FN (BUILT_IN_LCEIL
):
7686 CASE_FLT_FN (BUILT_IN_LLCEIL
):
7687 real_ceil (&r
, TYPE_MODE (ftype
), &x
);
7690 CASE_FLT_FN (BUILT_IN_LROUND
):
7691 CASE_FLT_FN (BUILT_IN_LLROUND
):
7692 real_round (&r
, TYPE_MODE (ftype
), &x
);
7699 real_to_integer2 ((HOST_WIDE_INT
*)&val
.low
, &val
.high
, &r
);
7700 if (double_int_fits_to_tree_p (itype
, val
))
7701 return double_int_to_tree (itype
, val
);
7705 switch (DECL_FUNCTION_CODE (fndecl
))
7707 CASE_FLT_FN (BUILT_IN_LFLOOR
):
7708 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7709 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
7710 if (tree_expr_nonnegative_p (arg
))
7711 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
7712 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
7717 return fold_fixed_mathfn (loc
, fndecl
, arg
);
7720 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7721 and their long and long long variants (i.e. ffsl and ffsll). ARG is
7722 the argument to the call. Return NULL_TREE if no simplification can
7726 fold_builtin_bitop (tree fndecl
, tree arg
)
7728 if (!validate_arg (arg
, INTEGER_TYPE
))
7731 /* Optimize for constant argument. */
7732 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
7734 HOST_WIDE_INT hi
, width
, result
;
7735 unsigned HOST_WIDE_INT lo
;
7738 type
= TREE_TYPE (arg
);
7739 width
= TYPE_PRECISION (type
);
7740 lo
= TREE_INT_CST_LOW (arg
);
7742 /* Clear all the bits that are beyond the type's precision. */
7743 if (width
> HOST_BITS_PER_WIDE_INT
)
7745 hi
= TREE_INT_CST_HIGH (arg
);
7746 if (width
< 2 * HOST_BITS_PER_WIDE_INT
)
7747 hi
&= ~((HOST_WIDE_INT
) (-1) >> (width
- HOST_BITS_PER_WIDE_INT
));
7752 if (width
< HOST_BITS_PER_WIDE_INT
)
7753 lo
&= ~((unsigned HOST_WIDE_INT
) (-1) << width
);
7756 switch (DECL_FUNCTION_CODE (fndecl
))
7758 CASE_INT_FN (BUILT_IN_FFS
):
7760 result
= ffs_hwi (lo
);
7762 result
= HOST_BITS_PER_WIDE_INT
+ ffs_hwi (hi
);
7767 CASE_INT_FN (BUILT_IN_CLZ
):
7769 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
7771 result
= width
- floor_log2 (lo
) - 1;
7772 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7776 CASE_INT_FN (BUILT_IN_CTZ
):
7778 result
= ctz_hwi (lo
);
7780 result
= HOST_BITS_PER_WIDE_INT
+ ctz_hwi (hi
);
7781 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7785 CASE_INT_FN (BUILT_IN_POPCOUNT
):
7788 result
++, lo
&= lo
- 1;
7790 result
++, hi
&= (unsigned HOST_WIDE_INT
) hi
- 1;
7793 CASE_INT_FN (BUILT_IN_PARITY
):
7796 result
++, lo
&= lo
- 1;
7798 result
++, hi
&= (unsigned HOST_WIDE_INT
) hi
- 1;
7806 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), result
);
7812 /* Fold function call to builtin_bswap and the long and long long
7813 variants. Return NULL_TREE if no simplification can be made. */
7815 fold_builtin_bswap (tree fndecl
, tree arg
)
7817 if (! validate_arg (arg
, INTEGER_TYPE
))
7820 /* Optimize constant value. */
7821 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
7823 HOST_WIDE_INT hi
, width
, r_hi
= 0;
7824 unsigned HOST_WIDE_INT lo
, r_lo
= 0;
7827 type
= TREE_TYPE (arg
);
7828 width
= TYPE_PRECISION (type
);
7829 lo
= TREE_INT_CST_LOW (arg
);
7830 hi
= TREE_INT_CST_HIGH (arg
);
7832 switch (DECL_FUNCTION_CODE (fndecl
))
7834 case BUILT_IN_BSWAP32
:
7835 case BUILT_IN_BSWAP64
:
7839 for (s
= 0; s
< width
; s
+= 8)
7841 int d
= width
- s
- 8;
7842 unsigned HOST_WIDE_INT byte
;
7844 if (s
< HOST_BITS_PER_WIDE_INT
)
7845 byte
= (lo
>> s
) & 0xff;
7847 byte
= (hi
>> (s
- HOST_BITS_PER_WIDE_INT
)) & 0xff;
7849 if (d
< HOST_BITS_PER_WIDE_INT
)
7852 r_hi
|= byte
<< (d
- HOST_BITS_PER_WIDE_INT
);
7862 if (width
< HOST_BITS_PER_WIDE_INT
)
7863 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), r_lo
);
7865 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl
)), r_lo
, r_hi
);
7871 /* A subroutine of fold_builtin to fold the various logarithmic
7872 functions. Return NULL_TREE if no simplification can me made.
7873 FUNC is the corresponding MPFR logarithm function. */
7876 fold_builtin_logarithm (location_t loc
, tree fndecl
, tree arg
,
7877 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
))
7879 if (validate_arg (arg
, REAL_TYPE
))
7881 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7883 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7885 /* Calculate the result when the argument is a constant. */
7886 if ((res
= do_mpfr_arg1 (arg
, type
, func
, &dconst0
, NULL
, false)))
7889 /* Special case, optimize logN(expN(x)) = x. */
7890 if (flag_unsafe_math_optimizations
7891 && ((func
== mpfr_log
7892 && (fcode
== BUILT_IN_EXP
7893 || fcode
== BUILT_IN_EXPF
7894 || fcode
== BUILT_IN_EXPL
))
7895 || (func
== mpfr_log2
7896 && (fcode
== BUILT_IN_EXP2
7897 || fcode
== BUILT_IN_EXP2F
7898 || fcode
== BUILT_IN_EXP2L
))
7899 || (func
== mpfr_log10
&& (BUILTIN_EXP10_P (fcode
)))))
7900 return fold_convert_loc (loc
, type
, CALL_EXPR_ARG (arg
, 0));
7902 /* Optimize logN(func()) for various exponential functions. We
7903 want to determine the value "x" and the power "exponent" in
7904 order to transform logN(x**exponent) into exponent*logN(x). */
7905 if (flag_unsafe_math_optimizations
)
7907 tree exponent
= 0, x
= 0;
7911 CASE_FLT_FN (BUILT_IN_EXP
):
7912 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7913 x
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
7915 exponent
= CALL_EXPR_ARG (arg
, 0);
7917 CASE_FLT_FN (BUILT_IN_EXP2
):
7918 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7919 x
= build_real (type
, dconst2
);
7920 exponent
= CALL_EXPR_ARG (arg
, 0);
7922 CASE_FLT_FN (BUILT_IN_EXP10
):
7923 CASE_FLT_FN (BUILT_IN_POW10
):
7924 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7926 REAL_VALUE_TYPE dconst10
;
7927 real_from_integer (&dconst10
, VOIDmode
, 10, 0, 0);
7928 x
= build_real (type
, dconst10
);
7930 exponent
= CALL_EXPR_ARG (arg
, 0);
7932 CASE_FLT_FN (BUILT_IN_SQRT
):
7933 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7934 x
= CALL_EXPR_ARG (arg
, 0);
7935 exponent
= build_real (type
, dconsthalf
);
7937 CASE_FLT_FN (BUILT_IN_CBRT
):
7938 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7939 x
= CALL_EXPR_ARG (arg
, 0);
7940 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
7943 CASE_FLT_FN (BUILT_IN_POW
):
7944 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7945 x
= CALL_EXPR_ARG (arg
, 0);
7946 exponent
= CALL_EXPR_ARG (arg
, 1);
7952 /* Now perform the optimization. */
7955 tree logfn
= build_call_expr_loc (loc
, fndecl
, 1, x
);
7956 return fold_build2_loc (loc
, MULT_EXPR
, type
, exponent
, logfn
);
7964 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
7965 NULL_TREE if no simplification can be made. */
7968 fold_builtin_hypot (location_t loc
, tree fndecl
,
7969 tree arg0
, tree arg1
, tree type
)
7971 tree res
, narg0
, narg1
;
7973 if (!validate_arg (arg0
, REAL_TYPE
)
7974 || !validate_arg (arg1
, REAL_TYPE
))
7977 /* Calculate the result when the argument is a constant. */
7978 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_hypot
)))
7981 /* If either argument to hypot has a negate or abs, strip that off.
7982 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
7983 narg0
= fold_strip_sign_ops (arg0
);
7984 narg1
= fold_strip_sign_ops (arg1
);
7987 return build_call_expr_loc (loc
, fndecl
, 2, narg0
? narg0
: arg0
,
7988 narg1
? narg1
: arg1
);
7991 /* If either argument is zero, hypot is fabs of the other. */
7992 if (real_zerop (arg0
))
7993 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
);
7994 else if (real_zerop (arg1
))
7995 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
);
7997 /* hypot(x,x) -> fabs(x)*sqrt(2). */
7998 if (flag_unsafe_math_optimizations
7999 && operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
8001 const REAL_VALUE_TYPE sqrt2_trunc
8002 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
8003 return fold_build2_loc (loc
, MULT_EXPR
, type
,
8004 fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
),
8005 build_real (type
, sqrt2_trunc
));
8012 /* Fold a builtin function call to pow, powf, or powl. Return
8013 NULL_TREE if no simplification can be made. */
8015 fold_builtin_pow (location_t loc
, tree fndecl
, tree arg0
, tree arg1
, tree type
)
8019 if (!validate_arg (arg0
, REAL_TYPE
)
8020 || !validate_arg (arg1
, REAL_TYPE
))
8023 /* Calculate the result when the argument is a constant. */
8024 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_pow
)))
8027 /* Optimize pow(1.0,y) = 1.0. */
8028 if (real_onep (arg0
))
8029 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8031 if (TREE_CODE (arg1
) == REAL_CST
8032 && !TREE_OVERFLOW (arg1
))
8034 REAL_VALUE_TYPE cint
;
8038 c
= TREE_REAL_CST (arg1
);
8040 /* Optimize pow(x,0.0) = 1.0. */
8041 if (REAL_VALUES_EQUAL (c
, dconst0
))
8042 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8045 /* Optimize pow(x,1.0) = x. */
8046 if (REAL_VALUES_EQUAL (c
, dconst1
))
8049 /* Optimize pow(x,-1.0) = 1.0/x. */
8050 if (REAL_VALUES_EQUAL (c
, dconstm1
))
8051 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8052 build_real (type
, dconst1
), arg0
);
8054 /* Optimize pow(x,0.5) = sqrt(x). */
8055 if (flag_unsafe_math_optimizations
8056 && REAL_VALUES_EQUAL (c
, dconsthalf
))
8058 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
8060 if (sqrtfn
!= NULL_TREE
)
8061 return build_call_expr_loc (loc
, sqrtfn
, 1, arg0
);
8064 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8065 if (flag_unsafe_math_optimizations
)
8067 const REAL_VALUE_TYPE dconstroot
8068 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8070 if (REAL_VALUES_EQUAL (c
, dconstroot
))
8072 tree cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
8073 if (cbrtfn
!= NULL_TREE
)
8074 return build_call_expr_loc (loc
, cbrtfn
, 1, arg0
);
8078 /* Check for an integer exponent. */
8079 n
= real_to_integer (&c
);
8080 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
8081 if (real_identical (&c
, &cint
))
8083 /* Attempt to evaluate pow at compile-time, unless this should
8084 raise an exception. */
8085 if (TREE_CODE (arg0
) == REAL_CST
8086 && !TREE_OVERFLOW (arg0
)
8088 || (!flag_trapping_math
&& !flag_errno_math
)
8089 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
), dconst0
)))
8094 x
= TREE_REAL_CST (arg0
);
8095 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
8096 if (flag_unsafe_math_optimizations
|| !inexact
)
8097 return build_real (type
, x
);
8100 /* Strip sign ops from even integer powers. */
8101 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
8103 tree narg0
= fold_strip_sign_ops (arg0
);
8105 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, arg1
);
8110 if (flag_unsafe_math_optimizations
)
8112 const enum built_in_function fcode
= builtin_mathfn_code (arg0
);
8114 /* Optimize pow(expN(x),y) = expN(x*y). */
8115 if (BUILTIN_EXPONENT_P (fcode
))
8117 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
8118 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8119 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg
, arg1
);
8120 return build_call_expr_loc (loc
, expfn
, 1, arg
);
8123 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8124 if (BUILTIN_SQRT_P (fcode
))
8126 tree narg0
= CALL_EXPR_ARG (arg0
, 0);
8127 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8128 build_real (type
, dconsthalf
));
8129 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, narg1
);
8132 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8133 if (BUILTIN_CBRT_P (fcode
))
8135 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8136 if (tree_expr_nonnegative_p (arg
))
8138 const REAL_VALUE_TYPE dconstroot
8139 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8140 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8141 build_real (type
, dconstroot
));
8142 return build_call_expr_loc (loc
, fndecl
, 2, arg
, narg1
);
8146 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8147 if (fcode
== BUILT_IN_POW
8148 || fcode
== BUILT_IN_POWF
8149 || fcode
== BUILT_IN_POWL
)
8151 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
8152 if (tree_expr_nonnegative_p (arg00
))
8154 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
8155 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
, arg1
);
8156 return build_call_expr_loc (loc
, fndecl
, 2, arg00
, narg1
);
8164 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8165 Return NULL_TREE if no simplification can be made. */
8167 fold_builtin_powi (location_t loc
, tree fndecl ATTRIBUTE_UNUSED
,
8168 tree arg0
, tree arg1
, tree type
)
8170 if (!validate_arg (arg0
, REAL_TYPE
)
8171 || !validate_arg (arg1
, INTEGER_TYPE
))
8174 /* Optimize pow(1.0,y) = 1.0. */
8175 if (real_onep (arg0
))
8176 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8178 if (host_integerp (arg1
, 0))
8180 HOST_WIDE_INT c
= TREE_INT_CST_LOW (arg1
);
8182 /* Evaluate powi at compile-time. */
8183 if (TREE_CODE (arg0
) == REAL_CST
8184 && !TREE_OVERFLOW (arg0
))
8187 x
= TREE_REAL_CST (arg0
);
8188 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
8189 return build_real (type
, x
);
8192 /* Optimize pow(x,0) = 1.0. */
8194 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8197 /* Optimize pow(x,1) = x. */
8201 /* Optimize pow(x,-1) = 1.0/x. */
8203 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8204 build_real (type
, dconst1
), arg0
);
8210 /* A subroutine of fold_builtin to fold the various exponent
8211 functions. Return NULL_TREE if no simplification can be made.
8212 FUNC is the corresponding MPFR exponent function. */
8215 fold_builtin_exponent (location_t loc
, tree fndecl
, tree arg
,
8216 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
))
8218 if (validate_arg (arg
, REAL_TYPE
))
8220 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8223 /* Calculate the result when the argument is a constant. */
8224 if ((res
= do_mpfr_arg1 (arg
, type
, func
, NULL
, NULL
, 0)))
8227 /* Optimize expN(logN(x)) = x. */
8228 if (flag_unsafe_math_optimizations
)
8230 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
8232 if ((func
== mpfr_exp
8233 && (fcode
== BUILT_IN_LOG
8234 || fcode
== BUILT_IN_LOGF
8235 || fcode
== BUILT_IN_LOGL
))
8236 || (func
== mpfr_exp2
8237 && (fcode
== BUILT_IN_LOG2
8238 || fcode
== BUILT_IN_LOG2F
8239 || fcode
== BUILT_IN_LOG2L
))
8240 || (func
== mpfr_exp10
8241 && (fcode
== BUILT_IN_LOG10
8242 || fcode
== BUILT_IN_LOG10F
8243 || fcode
== BUILT_IN_LOG10L
)))
8244 return fold_convert_loc (loc
, type
, CALL_EXPR_ARG (arg
, 0));
8251 /* Return true if VAR is a VAR_DECL or a component thereof. */
8254 var_decl_component_p (tree var
)
8257 while (handled_component_p (inner
))
8258 inner
= TREE_OPERAND (inner
, 0);
8259 return SSA_VAR_P (inner
);
8262 /* Fold function call to builtin memset. Return
8263 NULL_TREE if no simplification can be made. */
8266 fold_builtin_memset (location_t loc
, tree dest
, tree c
, tree len
,
8267 tree type
, bool ignore
)
8269 tree var
, ret
, etype
;
8270 unsigned HOST_WIDE_INT length
, cval
;
8272 if (! validate_arg (dest
, POINTER_TYPE
)
8273 || ! validate_arg (c
, INTEGER_TYPE
)
8274 || ! validate_arg (len
, INTEGER_TYPE
))
8277 if (! host_integerp (len
, 1))
8280 /* If the LEN parameter is zero, return DEST. */
8281 if (integer_zerop (len
))
8282 return omit_one_operand_loc (loc
, type
, dest
, c
);
8284 if (! host_integerp (c
, 1) || TREE_SIDE_EFFECTS (dest
))
8289 if (TREE_CODE (var
) != ADDR_EXPR
)
8292 var
= TREE_OPERAND (var
, 0);
8293 if (TREE_THIS_VOLATILE (var
))
8296 etype
= TREE_TYPE (var
);
8297 if (TREE_CODE (etype
) == ARRAY_TYPE
)
8298 etype
= TREE_TYPE (etype
);
8300 if (!INTEGRAL_TYPE_P (etype
)
8301 && !POINTER_TYPE_P (etype
))
8304 if (! var_decl_component_p (var
))
8307 length
= tree_low_cst (len
, 1);
8308 if (GET_MODE_SIZE (TYPE_MODE (etype
)) != length
8309 || get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
8313 if (length
> HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
)
8316 if (integer_zerop (c
))
8320 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8 || HOST_BITS_PER_WIDE_INT
> 64)
8323 cval
= tree_low_cst (c
, 1);
8327 cval
|= (cval
<< 31) << 1;
8330 ret
= build_int_cst_type (etype
, cval
);
8331 var
= build_fold_indirect_ref_loc (loc
,
8332 fold_convert_loc (loc
,
8333 build_pointer_type (etype
),
8335 ret
= build2 (MODIFY_EXPR
, etype
, var
, ret
);
8339 return omit_one_operand_loc (loc
, type
, dest
, ret
);
8342 /* Fold function call to builtin memset. Return
8343 NULL_TREE if no simplification can be made. */
8346 fold_builtin_bzero (location_t loc
, tree dest
, tree size
, bool ignore
)
8348 if (! validate_arg (dest
, POINTER_TYPE
)
8349 || ! validate_arg (size
, INTEGER_TYPE
))
8355 /* New argument list transforming bzero(ptr x, int y) to
8356 memset(ptr x, int 0, size_t y). This is done this way
8357 so that if it isn't expanded inline, we fallback to
8358 calling bzero instead of memset. */
8360 return fold_builtin_memset (loc
, dest
, integer_zero_node
,
8361 fold_convert_loc (loc
, sizetype
, size
),
8362 void_type_node
, ignore
);
8365 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8366 NULL_TREE if no simplification can be made.
8367 If ENDP is 0, return DEST (like memcpy).
8368 If ENDP is 1, return DEST+LEN (like mempcpy).
8369 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8370 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8374 fold_builtin_memory_op (location_t loc
, tree dest
, tree src
,
8375 tree len
, tree type
, bool ignore
, int endp
)
8377 tree destvar
, srcvar
, expr
;
8379 if (! validate_arg (dest
, POINTER_TYPE
)
8380 || ! validate_arg (src
, POINTER_TYPE
)
8381 || ! validate_arg (len
, INTEGER_TYPE
))
8384 /* If the LEN parameter is zero, return DEST. */
8385 if (integer_zerop (len
))
8386 return omit_one_operand_loc (loc
, type
, dest
, src
);
8388 /* If SRC and DEST are the same (and not volatile), return
8389 DEST{,+LEN,+LEN-1}. */
8390 if (operand_equal_p (src
, dest
, 0))
8394 tree srctype
, desttype
;
8395 unsigned int src_align
, dest_align
;
8400 src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
8401 dest_align
= get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
8403 /* Both DEST and SRC must be pointer types.
8404 ??? This is what old code did. Is the testing for pointer types
8407 If either SRC is readonly or length is 1, we can use memcpy. */
8408 if (!dest_align
|| !src_align
)
8410 if (readonly_data_expr (src
)
8411 || (host_integerp (len
, 1)
8412 && (MIN (src_align
, dest_align
) / BITS_PER_UNIT
8413 >= (unsigned HOST_WIDE_INT
) tree_low_cst (len
, 1))))
8415 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8418 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
8421 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8422 if (TREE_CODE (src
) == ADDR_EXPR
8423 && TREE_CODE (dest
) == ADDR_EXPR
)
8425 tree src_base
, dest_base
, fn
;
8426 HOST_WIDE_INT src_offset
= 0, dest_offset
= 0;
8427 HOST_WIDE_INT size
= -1;
8428 HOST_WIDE_INT maxsize
= -1;
8430 srcvar
= TREE_OPERAND (src
, 0);
8431 src_base
= get_ref_base_and_extent (srcvar
, &src_offset
,
8433 destvar
= TREE_OPERAND (dest
, 0);
8434 dest_base
= get_ref_base_and_extent (destvar
, &dest_offset
,
8436 if (host_integerp (len
, 1))
8437 maxsize
= tree_low_cst (len
, 1);
8440 src_offset
/= BITS_PER_UNIT
;
8441 dest_offset
/= BITS_PER_UNIT
;
8442 if (SSA_VAR_P (src_base
)
8443 && SSA_VAR_P (dest_base
))
8445 if (operand_equal_p (src_base
, dest_base
, 0)
8446 && ranges_overlap_p (src_offset
, maxsize
,
8447 dest_offset
, maxsize
))
8450 else if (TREE_CODE (src_base
) == MEM_REF
8451 && TREE_CODE (dest_base
) == MEM_REF
)
8454 if (! operand_equal_p (TREE_OPERAND (src_base
, 0),
8455 TREE_OPERAND (dest_base
, 0), 0))
8457 off
= double_int_add (mem_ref_offset (src_base
),
8458 shwi_to_double_int (src_offset
));
8459 if (!double_int_fits_in_shwi_p (off
))
8461 src_offset
= off
.low
;
8462 off
= double_int_add (mem_ref_offset (dest_base
),
8463 shwi_to_double_int (dest_offset
));
8464 if (!double_int_fits_in_shwi_p (off
))
8466 dest_offset
= off
.low
;
8467 if (ranges_overlap_p (src_offset
, maxsize
,
8468 dest_offset
, maxsize
))
8474 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8477 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
8480 /* If the destination and source do not alias optimize into
8482 if ((is_gimple_min_invariant (dest
)
8483 || TREE_CODE (dest
) == SSA_NAME
)
8484 && (is_gimple_min_invariant (src
)
8485 || TREE_CODE (src
) == SSA_NAME
))
8488 ao_ref_init_from_ptr_and_size (&destr
, dest
, len
);
8489 ao_ref_init_from_ptr_and_size (&srcr
, src
, len
);
8490 if (!refs_may_alias_p_1 (&destr
, &srcr
, false))
8493 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8496 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
8503 if (!host_integerp (len
, 0))
8506 This logic lose for arguments like (type *)malloc (sizeof (type)),
8507 since we strip the casts of up to VOID return value from malloc.
8508 Perhaps we ought to inherit type from non-VOID argument here? */
8511 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8512 if (TREE_CODE (src
) == POINTER_PLUS_EXPR
)
8514 tree tem
= TREE_OPERAND (src
, 0);
8516 if (tem
!= TREE_OPERAND (src
, 0))
8517 src
= build1 (NOP_EXPR
, TREE_TYPE (tem
), src
);
8519 if (TREE_CODE (dest
) == POINTER_PLUS_EXPR
)
8521 tree tem
= TREE_OPERAND (dest
, 0);
8523 if (tem
!= TREE_OPERAND (dest
, 0))
8524 dest
= build1 (NOP_EXPR
, TREE_TYPE (tem
), dest
);
8526 srctype
= TREE_TYPE (TREE_TYPE (src
));
8528 && TREE_CODE (srctype
) == ARRAY_TYPE
8529 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
8531 srctype
= TREE_TYPE (srctype
);
8533 src
= build1 (NOP_EXPR
, build_pointer_type (srctype
), src
);
8535 desttype
= TREE_TYPE (TREE_TYPE (dest
));
8537 && TREE_CODE (desttype
) == ARRAY_TYPE
8538 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
8540 desttype
= TREE_TYPE (desttype
);
8542 dest
= build1 (NOP_EXPR
, build_pointer_type (desttype
), dest
);
8544 if (!srctype
|| !desttype
8545 || TREE_ADDRESSABLE (srctype
)
8546 || TREE_ADDRESSABLE (desttype
)
8547 || !TYPE_SIZE_UNIT (srctype
)
8548 || !TYPE_SIZE_UNIT (desttype
)
8549 || TREE_CODE (TYPE_SIZE_UNIT (srctype
)) != INTEGER_CST
8550 || TREE_CODE (TYPE_SIZE_UNIT (desttype
)) != INTEGER_CST
)
8553 src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
8554 dest_align
= get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
8555 if (dest_align
< TYPE_ALIGN (desttype
)
8556 || src_align
< TYPE_ALIGN (srctype
))
8560 dest
= builtin_save_expr (dest
);
8562 /* Build accesses at offset zero with a ref-all character type. */
8563 off0
= build_int_cst (build_pointer_type_for_mode (char_type_node
,
8564 ptr_mode
, true), 0);
8567 STRIP_NOPS (destvar
);
8568 if (TREE_CODE (destvar
) == ADDR_EXPR
8569 && var_decl_component_p (TREE_OPERAND (destvar
, 0))
8570 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
8571 destvar
= fold_build2 (MEM_REF
, desttype
, destvar
, off0
);
8573 destvar
= NULL_TREE
;
8576 STRIP_NOPS (srcvar
);
8577 if (TREE_CODE (srcvar
) == ADDR_EXPR
8578 && var_decl_component_p (TREE_OPERAND (srcvar
, 0))
8579 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
)
8580 && (!STRICT_ALIGNMENT
8582 || src_align
>= TYPE_ALIGN (desttype
)))
8583 srcvar
= fold_build2 (MEM_REF
, destvar
? desttype
: srctype
,
8588 if (srcvar
== NULL_TREE
&& destvar
== NULL_TREE
)
8591 if (srcvar
== NULL_TREE
)
8593 if (STRICT_ALIGNMENT
8594 && src_align
< TYPE_ALIGN (desttype
))
8597 srcvar
= fold_build2 (MEM_REF
, desttype
, src
, off0
);
8599 else if (destvar
== NULL_TREE
)
8601 if (STRICT_ALIGNMENT
8602 && dest_align
< TYPE_ALIGN (srctype
))
8605 destvar
= fold_build2 (MEM_REF
, srctype
, dest
, off0
);
8608 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (destvar
), destvar
, srcvar
);
8614 if (endp
== 0 || endp
== 3)
8615 return omit_one_operand_loc (loc
, type
, dest
, expr
);
8621 len
= fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (len
), len
,
8624 len
= fold_convert_loc (loc
, sizetype
, len
);
8625 dest
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
8626 dest
= fold_convert_loc (loc
, type
, dest
);
8628 dest
= omit_one_operand_loc (loc
, type
, dest
, expr
);
8632 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8633 If LEN is not NULL, it represents the length of the string to be
8634 copied. Return NULL_TREE if no simplification can be made. */
8637 fold_builtin_strcpy (location_t loc
, tree fndecl
, tree dest
, tree src
, tree len
)
8641 if (!validate_arg (dest
, POINTER_TYPE
)
8642 || !validate_arg (src
, POINTER_TYPE
))
8645 /* If SRC and DEST are the same (and not volatile), return DEST. */
8646 if (operand_equal_p (src
, dest
, 0))
8647 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
8649 if (optimize_function_for_size_p (cfun
))
8652 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8658 len
= c_strlen (src
, 1);
8659 if (! len
|| TREE_SIDE_EFFECTS (len
))
8663 len
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
8664 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
8665 build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
));
8668 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8669 Return NULL_TREE if no simplification can be made. */
8672 fold_builtin_stpcpy (location_t loc
, tree fndecl
, tree dest
, tree src
)
8674 tree fn
, len
, lenp1
, call
, type
;
8676 if (!validate_arg (dest
, POINTER_TYPE
)
8677 || !validate_arg (src
, POINTER_TYPE
))
8680 len
= c_strlen (src
, 1);
8682 || TREE_CODE (len
) != INTEGER_CST
)
8685 if (optimize_function_for_size_p (cfun
)
8686 /* If length is zero it's small enough. */
8687 && !integer_zerop (len
))
8690 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8694 lenp1
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
8695 /* We use dest twice in building our expression. Save it from
8696 multiple expansions. */
8697 dest
= builtin_save_expr (dest
);
8698 call
= build_call_expr_loc (loc
, fn
, 3, dest
, src
, lenp1
);
8700 type
= TREE_TYPE (TREE_TYPE (fndecl
));
8701 len
= fold_convert_loc (loc
, sizetype
, len
);
8702 dest
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
8703 dest
= fold_convert_loc (loc
, type
, dest
);
8704 dest
= omit_one_operand_loc (loc
, type
, dest
, call
);
8708 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8709 If SLEN is not NULL, it represents the length of the source string.
8710 Return NULL_TREE if no simplification can be made. */
8713 fold_builtin_strncpy (location_t loc
, tree fndecl
, tree dest
,
8714 tree src
, tree len
, tree slen
)
8718 if (!validate_arg (dest
, POINTER_TYPE
)
8719 || !validate_arg (src
, POINTER_TYPE
)
8720 || !validate_arg (len
, INTEGER_TYPE
))
8723 /* If the LEN parameter is zero, return DEST. */
8724 if (integer_zerop (len
))
8725 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
8727 /* We can't compare slen with len as constants below if len is not a
8729 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
8733 slen
= c_strlen (src
, 1);
8735 /* Now, we must be passed a constant src ptr parameter. */
8736 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
8739 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
8741 /* We do not support simplification of this case, though we do
8742 support it when expanding trees into RTL. */
8743 /* FIXME: generate a call to __builtin_memset. */
8744 if (tree_int_cst_lt (slen
, len
))
8747 /* OK transform into builtin memcpy. */
8748 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8751 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
8752 build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
));
8755 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8756 arguments to the call, and TYPE is its return type.
8757 Return NULL_TREE if no simplification can be made. */
8760 fold_builtin_memchr (location_t loc
, tree arg1
, tree arg2
, tree len
, tree type
)
8762 if (!validate_arg (arg1
, POINTER_TYPE
)
8763 || !validate_arg (arg2
, INTEGER_TYPE
)
8764 || !validate_arg (len
, INTEGER_TYPE
))
8770 if (TREE_CODE (arg2
) != INTEGER_CST
8771 || !host_integerp (len
, 1))
8774 p1
= c_getstr (arg1
);
8775 if (p1
&& compare_tree_int (len
, strlen (p1
) + 1) <= 0)
8781 if (target_char_cast (arg2
, &c
))
8784 r
= (char *) memchr (p1
, c
, tree_low_cst (len
, 1));
8787 return build_int_cst (TREE_TYPE (arg1
), 0);
8789 tem
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (arg1
), arg1
,
8791 return fold_convert_loc (loc
, type
, tem
);
8797 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8798 Return NULL_TREE if no simplification can be made. */
8801 fold_builtin_memcmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
8803 const char *p1
, *p2
;
8805 if (!validate_arg (arg1
, POINTER_TYPE
)
8806 || !validate_arg (arg2
, POINTER_TYPE
)
8807 || !validate_arg (len
, INTEGER_TYPE
))
8810 /* If the LEN parameter is zero, return zero. */
8811 if (integer_zerop (len
))
8812 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
8815 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8816 if (operand_equal_p (arg1
, arg2
, 0))
8817 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
8819 p1
= c_getstr (arg1
);
8820 p2
= c_getstr (arg2
);
8822 /* If all arguments are constant, and the value of len is not greater
8823 than the lengths of arg1 and arg2, evaluate at compile-time. */
8824 if (host_integerp (len
, 1) && p1
&& p2
8825 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
8826 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
8828 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
8831 return integer_one_node
;
8833 return integer_minus_one_node
;
8835 return integer_zero_node
;
8838 /* If len parameter is one, return an expression corresponding to
8839 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8840 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
8842 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8843 tree cst_uchar_ptr_node
8844 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8847 = fold_convert_loc (loc
, integer_type_node
,
8848 build1 (INDIRECT_REF
, cst_uchar_node
,
8849 fold_convert_loc (loc
,
8853 = fold_convert_loc (loc
, integer_type_node
,
8854 build1 (INDIRECT_REF
, cst_uchar_node
,
8855 fold_convert_loc (loc
,
8858 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8864 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8865 Return NULL_TREE if no simplification can be made. */
8868 fold_builtin_strcmp (location_t loc
, tree arg1
, tree arg2
)
8870 const char *p1
, *p2
;
8872 if (!validate_arg (arg1
, POINTER_TYPE
)
8873 || !validate_arg (arg2
, POINTER_TYPE
))
8876 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8877 if (operand_equal_p (arg1
, arg2
, 0))
8878 return integer_zero_node
;
8880 p1
= c_getstr (arg1
);
8881 p2
= c_getstr (arg2
);
8885 const int i
= strcmp (p1
, p2
);
8887 return integer_minus_one_node
;
8889 return integer_one_node
;
8891 return integer_zero_node
;
8894 /* If the second arg is "", return *(const unsigned char*)arg1. */
8895 if (p2
&& *p2
== '\0')
8897 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8898 tree cst_uchar_ptr_node
8899 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8901 return fold_convert_loc (loc
, integer_type_node
,
8902 build1 (INDIRECT_REF
, cst_uchar_node
,
8903 fold_convert_loc (loc
,
8908 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8909 if (p1
&& *p1
== '\0')
8911 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8912 tree cst_uchar_ptr_node
8913 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8916 = fold_convert_loc (loc
, integer_type_node
,
8917 build1 (INDIRECT_REF
, cst_uchar_node
,
8918 fold_convert_loc (loc
,
8921 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
8927 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8928 Return NULL_TREE if no simplification can be made. */
8931 fold_builtin_strncmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
8933 const char *p1
, *p2
;
8935 if (!validate_arg (arg1
, POINTER_TYPE
)
8936 || !validate_arg (arg2
, POINTER_TYPE
)
8937 || !validate_arg (len
, INTEGER_TYPE
))
8940 /* If the LEN parameter is zero, return zero. */
8941 if (integer_zerop (len
))
8942 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
8945 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8946 if (operand_equal_p (arg1
, arg2
, 0))
8947 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
8949 p1
= c_getstr (arg1
);
8950 p2
= c_getstr (arg2
);
8952 if (host_integerp (len
, 1) && p1
&& p2
)
8954 const int i
= strncmp (p1
, p2
, tree_low_cst (len
, 1));
8956 return integer_one_node
;
8958 return integer_minus_one_node
;
8960 return integer_zero_node
;
8963 /* If the second arg is "", and the length is greater than zero,
8964 return *(const unsigned char*)arg1. */
8965 if (p2
&& *p2
== '\0'
8966 && TREE_CODE (len
) == INTEGER_CST
8967 && tree_int_cst_sgn (len
) == 1)
8969 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8970 tree cst_uchar_ptr_node
8971 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8973 return fold_convert_loc (loc
, integer_type_node
,
8974 build1 (INDIRECT_REF
, cst_uchar_node
,
8975 fold_convert_loc (loc
,
8980 /* If the first arg is "", and the length is greater than zero,
8981 return -*(const unsigned char*)arg2. */
8982 if (p1
&& *p1
== '\0'
8983 && TREE_CODE (len
) == INTEGER_CST
8984 && tree_int_cst_sgn (len
) == 1)
8986 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8987 tree cst_uchar_ptr_node
8988 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8990 tree temp
= fold_convert_loc (loc
, integer_type_node
,
8991 build1 (INDIRECT_REF
, cst_uchar_node
,
8992 fold_convert_loc (loc
,
8995 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
8998 /* If len parameter is one, return an expression corresponding to
8999 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9000 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
9002 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9003 tree cst_uchar_ptr_node
9004 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9006 tree ind1
= fold_convert_loc (loc
, integer_type_node
,
9007 build1 (INDIRECT_REF
, cst_uchar_node
,
9008 fold_convert_loc (loc
,
9011 tree ind2
= fold_convert_loc (loc
, integer_type_node
,
9012 build1 (INDIRECT_REF
, cst_uchar_node
,
9013 fold_convert_loc (loc
,
9016 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
9022 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9023 ARG. Return NULL_TREE if no simplification can be made. */
9026 fold_builtin_signbit (location_t loc
, tree arg
, tree type
)
9030 if (!validate_arg (arg
, REAL_TYPE
))
9033 /* If ARG is a compile-time constant, determine the result. */
9034 if (TREE_CODE (arg
) == REAL_CST
9035 && !TREE_OVERFLOW (arg
))
9039 c
= TREE_REAL_CST (arg
);
9040 temp
= REAL_VALUE_NEGATIVE (c
) ? integer_one_node
: integer_zero_node
;
9041 return fold_convert_loc (loc
, type
, temp
);
9044 /* If ARG is non-negative, the result is always zero. */
9045 if (tree_expr_nonnegative_p (arg
))
9046 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9048 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9049 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
9050 return fold_build2_loc (loc
, LT_EXPR
, type
, arg
,
9051 build_real (TREE_TYPE (arg
), dconst0
));
9056 /* Fold function call to builtin copysign, copysignf or copysignl with
9057 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9061 fold_builtin_copysign (location_t loc
, tree fndecl
,
9062 tree arg1
, tree arg2
, tree type
)
9066 if (!validate_arg (arg1
, REAL_TYPE
)
9067 || !validate_arg (arg2
, REAL_TYPE
))
9070 /* copysign(X,X) is X. */
9071 if (operand_equal_p (arg1
, arg2
, 0))
9072 return fold_convert_loc (loc
, type
, arg1
);
9074 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9075 if (TREE_CODE (arg1
) == REAL_CST
9076 && TREE_CODE (arg2
) == REAL_CST
9077 && !TREE_OVERFLOW (arg1
)
9078 && !TREE_OVERFLOW (arg2
))
9080 REAL_VALUE_TYPE c1
, c2
;
9082 c1
= TREE_REAL_CST (arg1
);
9083 c2
= TREE_REAL_CST (arg2
);
9084 /* c1.sign := c2.sign. */
9085 real_copysign (&c1
, &c2
);
9086 return build_real (type
, c1
);
9089 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9090 Remember to evaluate Y for side-effects. */
9091 if (tree_expr_nonnegative_p (arg2
))
9092 return omit_one_operand_loc (loc
, type
,
9093 fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
),
9096 /* Strip sign changing operations for the first argument. */
9097 tem
= fold_strip_sign_ops (arg1
);
9099 return build_call_expr_loc (loc
, fndecl
, 2, tem
, arg2
);
9104 /* Fold a call to builtin isascii with argument ARG. */
9107 fold_builtin_isascii (location_t loc
, tree arg
)
9109 if (!validate_arg (arg
, INTEGER_TYPE
))
9113 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9114 arg
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
9115 build_int_cst (NULL_TREE
,
9116 ~ (unsigned HOST_WIDE_INT
) 0x7f));
9117 return fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
,
9118 arg
, integer_zero_node
);
9122 /* Fold a call to builtin toascii with argument ARG. */
9125 fold_builtin_toascii (location_t loc
, tree arg
)
9127 if (!validate_arg (arg
, INTEGER_TYPE
))
9130 /* Transform toascii(c) -> (c & 0x7f). */
9131 return fold_build2_loc (loc
, BIT_AND_EXPR
, integer_type_node
, arg
,
9132 build_int_cst (NULL_TREE
, 0x7f));
9135 /* Fold a call to builtin isdigit with argument ARG. */
9138 fold_builtin_isdigit (location_t loc
, tree arg
)
9140 if (!validate_arg (arg
, INTEGER_TYPE
))
9144 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9145 /* According to the C standard, isdigit is unaffected by locale.
9146 However, it definitely is affected by the target character set. */
9147 unsigned HOST_WIDE_INT target_digit0
9148 = lang_hooks
.to_target_charset ('0');
9150 if (target_digit0
== 0)
9153 arg
= fold_convert_loc (loc
, unsigned_type_node
, arg
);
9154 arg
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
9155 build_int_cst (unsigned_type_node
, target_digit0
));
9156 return fold_build2_loc (loc
, LE_EXPR
, integer_type_node
, arg
,
9157 build_int_cst (unsigned_type_node
, 9));
9161 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9164 fold_builtin_fabs (location_t loc
, tree arg
, tree type
)
9166 if (!validate_arg (arg
, REAL_TYPE
))
9169 arg
= fold_convert_loc (loc
, type
, arg
);
9170 if (TREE_CODE (arg
) == REAL_CST
)
9171 return fold_abs_const (arg
, type
);
9172 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9175 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9178 fold_builtin_abs (location_t loc
, tree arg
, tree type
)
9180 if (!validate_arg (arg
, INTEGER_TYPE
))
9183 arg
= fold_convert_loc (loc
, type
, arg
);
9184 if (TREE_CODE (arg
) == INTEGER_CST
)
9185 return fold_abs_const (arg
, type
);
9186 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9189 /* Fold a call to builtin fmin or fmax. */
9192 fold_builtin_fmin_fmax (location_t loc
, tree arg0
, tree arg1
,
9193 tree type
, bool max
)
9195 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, REAL_TYPE
))
9197 /* Calculate the result when the argument is a constant. */
9198 tree res
= do_mpfr_arg2 (arg0
, arg1
, type
, (max
? mpfr_max
: mpfr_min
));
9203 /* If either argument is NaN, return the other one. Avoid the
9204 transformation if we get (and honor) a signalling NaN. Using
9205 omit_one_operand() ensures we create a non-lvalue. */
9206 if (TREE_CODE (arg0
) == REAL_CST
9207 && real_isnan (&TREE_REAL_CST (arg0
))
9208 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
9209 || ! TREE_REAL_CST (arg0
).signalling
))
9210 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
9211 if (TREE_CODE (arg1
) == REAL_CST
9212 && real_isnan (&TREE_REAL_CST (arg1
))
9213 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
9214 || ! TREE_REAL_CST (arg1
).signalling
))
9215 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9217 /* Transform fmin/fmax(x,x) -> x. */
9218 if (operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
9219 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9221 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9222 functions to return the numeric arg if the other one is NaN.
9223 These tree codes don't honor that, so only transform if
9224 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9225 handled, so we don't have to worry about it either. */
9226 if (flag_finite_math_only
)
9227 return fold_build2_loc (loc
, (max
? MAX_EXPR
: MIN_EXPR
), type
,
9228 fold_convert_loc (loc
, type
, arg0
),
9229 fold_convert_loc (loc
, type
, arg1
));
9234 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9237 fold_builtin_carg (location_t loc
, tree arg
, tree type
)
9239 if (validate_arg (arg
, COMPLEX_TYPE
)
9240 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
9242 tree atan2_fn
= mathfn_built_in (type
, BUILT_IN_ATAN2
);
9246 tree new_arg
= builtin_save_expr (arg
);
9247 tree r_arg
= fold_build1_loc (loc
, REALPART_EXPR
, type
, new_arg
);
9248 tree i_arg
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, new_arg
);
9249 return build_call_expr_loc (loc
, atan2_fn
, 2, i_arg
, r_arg
);
9256 /* Fold a call to builtin logb/ilogb. */
9259 fold_builtin_logb (location_t loc
, tree arg
, tree rettype
)
9261 if (! validate_arg (arg
, REAL_TYPE
))
9266 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9268 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9274 /* If arg is Inf or NaN and we're logb, return it. */
9275 if (TREE_CODE (rettype
) == REAL_TYPE
)
9276 return fold_convert_loc (loc
, rettype
, arg
);
9277 /* Fall through... */
9279 /* Zero may set errno and/or raise an exception for logb, also
9280 for ilogb we don't know FP_ILOGB0. */
9283 /* For normal numbers, proceed iff radix == 2. In GCC,
9284 normalized significands are in the range [0.5, 1.0). We
9285 want the exponent as if they were [1.0, 2.0) so get the
9286 exponent and subtract 1. */
9287 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9288 return fold_convert_loc (loc
, rettype
,
9289 build_int_cst (NULL_TREE
,
9290 REAL_EXP (value
)-1));
9298 /* Fold a call to builtin significand, if radix == 2. */
9301 fold_builtin_significand (location_t loc
, tree arg
, tree rettype
)
9303 if (! validate_arg (arg
, REAL_TYPE
))
9308 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9310 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9317 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9318 return fold_convert_loc (loc
, rettype
, arg
);
9320 /* For normal numbers, proceed iff radix == 2. */
9321 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9323 REAL_VALUE_TYPE result
= *value
;
9324 /* In GCC, normalized significands are in the range [0.5,
9325 1.0). We want them to be [1.0, 2.0) so set the
9327 SET_REAL_EXP (&result
, 1);
9328 return build_real (rettype
, result
);
9337 /* Fold a call to builtin frexp, we can assume the base is 2. */
9340 fold_builtin_frexp (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9342 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9347 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9350 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9352 /* Proceed if a valid pointer type was passed in. */
9353 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == integer_type_node
)
9355 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9361 /* For +-0, return (*exp = 0, +-0). */
9362 exp
= integer_zero_node
;
9367 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9368 return omit_one_operand_loc (loc
, rettype
, arg0
, arg1
);
9371 /* Since the frexp function always expects base 2, and in
9372 GCC normalized significands are already in the range
9373 [0.5, 1.0), we have exactly what frexp wants. */
9374 REAL_VALUE_TYPE frac_rvt
= *value
;
9375 SET_REAL_EXP (&frac_rvt
, 0);
9376 frac
= build_real (rettype
, frac_rvt
);
9377 exp
= build_int_cst (NULL_TREE
, REAL_EXP (value
));
9384 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9385 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
, exp
);
9386 TREE_SIDE_EFFECTS (arg1
) = 1;
9387 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
, frac
);
9393 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9394 then we can assume the base is two. If it's false, then we have to
9395 check the mode of the TYPE parameter in certain cases. */
9398 fold_builtin_load_exponent (location_t loc
, tree arg0
, tree arg1
,
9399 tree type
, bool ldexp
)
9401 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, INTEGER_TYPE
))
9406 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9407 if (real_zerop (arg0
) || integer_zerop (arg1
)
9408 || (TREE_CODE (arg0
) == REAL_CST
9409 && !real_isfinite (&TREE_REAL_CST (arg0
))))
9410 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9412 /* If both arguments are constant, then try to evaluate it. */
9413 if ((ldexp
|| REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2)
9414 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
9415 && host_integerp (arg1
, 0))
9417 /* Bound the maximum adjustment to twice the range of the
9418 mode's valid exponents. Use abs to ensure the range is
9419 positive as a sanity check. */
9420 const long max_exp_adj
= 2 *
9421 labs (REAL_MODE_FORMAT (TYPE_MODE (type
))->emax
9422 - REAL_MODE_FORMAT (TYPE_MODE (type
))->emin
);
9424 /* Get the user-requested adjustment. */
9425 const HOST_WIDE_INT req_exp_adj
= tree_low_cst (arg1
, 0);
9427 /* The requested adjustment must be inside this range. This
9428 is a preliminary cap to avoid things like overflow, we
9429 may still fail to compute the result for other reasons. */
9430 if (-max_exp_adj
< req_exp_adj
&& req_exp_adj
< max_exp_adj
)
9432 REAL_VALUE_TYPE initial_result
;
9434 real_ldexp (&initial_result
, &TREE_REAL_CST (arg0
), req_exp_adj
);
9436 /* Ensure we didn't overflow. */
9437 if (! real_isinf (&initial_result
))
9439 const REAL_VALUE_TYPE trunc_result
9440 = real_value_truncate (TYPE_MODE (type
), initial_result
);
9442 /* Only proceed if the target mode can hold the
9444 if (REAL_VALUES_EQUAL (initial_result
, trunc_result
))
9445 return build_real (type
, trunc_result
);
9454 /* Fold a call to builtin modf. */
9457 fold_builtin_modf (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9459 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9464 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9467 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9469 /* Proceed if a valid pointer type was passed in. */
9470 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == TYPE_MAIN_VARIANT (rettype
))
9472 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9473 REAL_VALUE_TYPE trunc
, frac
;
9479 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9480 trunc
= frac
= *value
;
9483 /* For +-Inf, return (*arg1 = arg0, +-0). */
9485 frac
.sign
= value
->sign
;
9489 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9490 real_trunc (&trunc
, VOIDmode
, value
);
9491 real_arithmetic (&frac
, MINUS_EXPR
, value
, &trunc
);
9492 /* If the original number was negative and already
9493 integral, then the fractional part is -0.0. */
9494 if (value
->sign
&& frac
.cl
== rvc_zero
)
9495 frac
.sign
= value
->sign
;
9499 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9500 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
,
9501 build_real (rettype
, trunc
));
9502 TREE_SIDE_EFFECTS (arg1
) = 1;
9503 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
,
9504 build_real (rettype
, frac
));
9510 /* Given a location LOC, an interclass builtin function decl FNDECL
9511 and its single argument ARG, return an folded expression computing
9512 the same, or NULL_TREE if we either couldn't or didn't want to fold
9513 (the latter happen if there's an RTL instruction available). */
9516 fold_builtin_interclass_mathfn (location_t loc
, tree fndecl
, tree arg
)
9518 enum machine_mode mode
;
9520 if (!validate_arg (arg
, REAL_TYPE
))
9523 if (interclass_mathfn_icode (arg
, fndecl
) != CODE_FOR_nothing
)
9526 mode
= TYPE_MODE (TREE_TYPE (arg
));
9528 /* If there is no optab, try generic code. */
9529 switch (DECL_FUNCTION_CODE (fndecl
))
9533 CASE_FLT_FN (BUILT_IN_ISINF
):
9535 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9536 tree
const isgr_fn
= built_in_decls
[BUILT_IN_ISGREATER
];
9537 tree
const type
= TREE_TYPE (arg
);
9541 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9542 real_from_string (&r
, buf
);
9543 result
= build_call_expr (isgr_fn
, 2,
9544 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9545 build_real (type
, r
));
9548 CASE_FLT_FN (BUILT_IN_FINITE
):
9549 case BUILT_IN_ISFINITE
:
9551 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9552 tree
const isle_fn
= built_in_decls
[BUILT_IN_ISLESSEQUAL
];
9553 tree
const type
= TREE_TYPE (arg
);
9557 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9558 real_from_string (&r
, buf
);
9559 result
= build_call_expr (isle_fn
, 2,
9560 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9561 build_real (type
, r
));
9562 /*result = fold_build2_loc (loc, UNGT_EXPR,
9563 TREE_TYPE (TREE_TYPE (fndecl)),
9564 fold_build1_loc (loc, ABS_EXPR, type, arg),
9565 build_real (type, r));
9566 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9567 TREE_TYPE (TREE_TYPE (fndecl)),
9571 case BUILT_IN_ISNORMAL
:
9573 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9574 islessequal(fabs(x),DBL_MAX). */
9575 tree
const isle_fn
= built_in_decls
[BUILT_IN_ISLESSEQUAL
];
9576 tree
const isge_fn
= built_in_decls
[BUILT_IN_ISGREATEREQUAL
];
9577 tree
const type
= TREE_TYPE (arg
);
9578 REAL_VALUE_TYPE rmax
, rmin
;
9581 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9582 real_from_string (&rmax
, buf
);
9583 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9584 real_from_string (&rmin
, buf
);
9585 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9586 result
= build_call_expr (isle_fn
, 2, arg
,
9587 build_real (type
, rmax
));
9588 result
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, result
,
9589 build_call_expr (isge_fn
, 2, arg
,
9590 build_real (type
, rmin
)));
9600 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9601 ARG is the argument for the call. */
9604 fold_builtin_classify (location_t loc
, tree fndecl
, tree arg
, int builtin_index
)
9606 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9609 if (!validate_arg (arg
, REAL_TYPE
))
9612 switch (builtin_index
)
9614 case BUILT_IN_ISINF
:
9615 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
9616 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9618 if (TREE_CODE (arg
) == REAL_CST
)
9620 r
= TREE_REAL_CST (arg
);
9621 if (real_isinf (&r
))
9622 return real_compare (GT_EXPR
, &r
, &dconst0
)
9623 ? integer_one_node
: integer_minus_one_node
;
9625 return integer_zero_node
;
9630 case BUILT_IN_ISINF_SIGN
:
9632 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9633 /* In a boolean context, GCC will fold the inner COND_EXPR to
9634 1. So e.g. "if (isinf_sign(x))" would be folded to just
9635 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9636 tree signbit_fn
= mathfn_built_in_1 (TREE_TYPE (arg
), BUILT_IN_SIGNBIT
, 0);
9637 tree isinf_fn
= built_in_decls
[BUILT_IN_ISINF
];
9638 tree tmp
= NULL_TREE
;
9640 arg
= builtin_save_expr (arg
);
9642 if (signbit_fn
&& isinf_fn
)
9644 tree signbit_call
= build_call_expr_loc (loc
, signbit_fn
, 1, arg
);
9645 tree isinf_call
= build_call_expr_loc (loc
, isinf_fn
, 1, arg
);
9647 signbit_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9648 signbit_call
, integer_zero_node
);
9649 isinf_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9650 isinf_call
, integer_zero_node
);
9652 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, signbit_call
,
9653 integer_minus_one_node
, integer_one_node
);
9654 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9662 case BUILT_IN_ISFINITE
:
9663 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg
)))
9664 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
9665 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
9667 if (TREE_CODE (arg
) == REAL_CST
)
9669 r
= TREE_REAL_CST (arg
);
9670 return real_isfinite (&r
) ? integer_one_node
: integer_zero_node
;
9675 case BUILT_IN_ISNAN
:
9676 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg
))))
9677 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9679 if (TREE_CODE (arg
) == REAL_CST
)
9681 r
= TREE_REAL_CST (arg
);
9682 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
9685 arg
= builtin_save_expr (arg
);
9686 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg
, arg
);
9693 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9694 This builtin will generate code to return the appropriate floating
9695 point classification depending on the value of the floating point
9696 number passed in. The possible return values must be supplied as
9697 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9698 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9699 one floating point argument which is "type generic". */
9702 fold_builtin_fpclassify (location_t loc
, tree exp
)
9704 tree fp_nan
, fp_infinite
, fp_normal
, fp_subnormal
, fp_zero
,
9705 arg
, type
, res
, tmp
;
9706 enum machine_mode mode
;
9710 /* Verify the required arguments in the original call. */
9711 if (!validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
,
9712 INTEGER_TYPE
, INTEGER_TYPE
,
9713 INTEGER_TYPE
, REAL_TYPE
, VOID_TYPE
))
9716 fp_nan
= CALL_EXPR_ARG (exp
, 0);
9717 fp_infinite
= CALL_EXPR_ARG (exp
, 1);
9718 fp_normal
= CALL_EXPR_ARG (exp
, 2);
9719 fp_subnormal
= CALL_EXPR_ARG (exp
, 3);
9720 fp_zero
= CALL_EXPR_ARG (exp
, 4);
9721 arg
= CALL_EXPR_ARG (exp
, 5);
9722 type
= TREE_TYPE (arg
);
9723 mode
= TYPE_MODE (type
);
9724 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9728 (fabs(x) == Inf ? FP_INFINITE :
9729 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9730 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9732 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9733 build_real (type
, dconst0
));
9734 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9735 tmp
, fp_zero
, fp_subnormal
);
9737 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9738 real_from_string (&r
, buf
);
9739 tmp
= fold_build2_loc (loc
, GE_EXPR
, integer_type_node
,
9740 arg
, build_real (type
, r
));
9741 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, fp_normal
, res
);
9743 if (HONOR_INFINITIES (mode
))
9746 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9747 build_real (type
, r
));
9748 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
,
9752 if (HONOR_NANS (mode
))
9754 tmp
= fold_build2_loc (loc
, ORDERED_EXPR
, integer_type_node
, arg
, arg
);
9755 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, res
, fp_nan
);
9761 /* Fold a call to an unordered comparison function such as
9762 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9763 being called and ARG0 and ARG1 are the arguments for the call.
9764 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9765 the opposite of the desired result. UNORDERED_CODE is used
9766 for modes that can hold NaNs and ORDERED_CODE is used for
9770 fold_builtin_unordered_cmp (location_t loc
, tree fndecl
, tree arg0
, tree arg1
,
9771 enum tree_code unordered_code
,
9772 enum tree_code ordered_code
)
9774 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9775 enum tree_code code
;
9777 enum tree_code code0
, code1
;
9778 tree cmp_type
= NULL_TREE
;
9780 type0
= TREE_TYPE (arg0
);
9781 type1
= TREE_TYPE (arg1
);
9783 code0
= TREE_CODE (type0
);
9784 code1
= TREE_CODE (type1
);
9786 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
9787 /* Choose the wider of two real types. */
9788 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
9790 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
9792 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
9795 arg0
= fold_convert_loc (loc
, cmp_type
, arg0
);
9796 arg1
= fold_convert_loc (loc
, cmp_type
, arg1
);
9798 if (unordered_code
== UNORDERED_EXPR
)
9800 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9801 return omit_two_operands_loc (loc
, type
, integer_zero_node
, arg0
, arg1
);
9802 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg0
, arg1
);
9805 code
= HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
9807 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
,
9808 fold_build2_loc (loc
, code
, type
, arg0
, arg1
));
9811 /* Fold a call to built-in function FNDECL with 0 arguments.
9812 IGNORE is true if the result of the function call is ignored. This
9813 function returns NULL_TREE if no simplification was possible. */
9816 fold_builtin_0 (location_t loc
, tree fndecl
, bool ignore ATTRIBUTE_UNUSED
)
9818 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9819 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
9822 CASE_FLT_FN (BUILT_IN_INF
):
9823 case BUILT_IN_INFD32
:
9824 case BUILT_IN_INFD64
:
9825 case BUILT_IN_INFD128
:
9826 return fold_builtin_inf (loc
, type
, true);
9828 CASE_FLT_FN (BUILT_IN_HUGE_VAL
):
9829 return fold_builtin_inf (loc
, type
, false);
9831 case BUILT_IN_CLASSIFY_TYPE
:
9832 return fold_builtin_classify_type (NULL_TREE
);
9840 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9841 IGNORE is true if the result of the function call is ignored. This
9842 function returns NULL_TREE if no simplification was possible. */
9845 fold_builtin_1 (location_t loc
, tree fndecl
, tree arg0
, bool ignore
)
9847 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9848 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
9851 case BUILT_IN_CONSTANT_P
:
9853 tree val
= fold_builtin_constant_p (arg0
);
9855 /* Gimplification will pull the CALL_EXPR for the builtin out of
9856 an if condition. When not optimizing, we'll not CSE it back.
9857 To avoid link error types of regressions, return false now. */
9858 if (!val
&& !optimize
)
9859 val
= integer_zero_node
;
9864 case BUILT_IN_CLASSIFY_TYPE
:
9865 return fold_builtin_classify_type (arg0
);
9867 case BUILT_IN_STRLEN
:
9868 return fold_builtin_strlen (loc
, type
, arg0
);
9870 CASE_FLT_FN (BUILT_IN_FABS
):
9871 return fold_builtin_fabs (loc
, arg0
, type
);
9875 case BUILT_IN_LLABS
:
9876 case BUILT_IN_IMAXABS
:
9877 return fold_builtin_abs (loc
, arg0
, type
);
9879 CASE_FLT_FN (BUILT_IN_CONJ
):
9880 if (validate_arg (arg0
, COMPLEX_TYPE
)
9881 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9882 return fold_build1_loc (loc
, CONJ_EXPR
, type
, arg0
);
9885 CASE_FLT_FN (BUILT_IN_CREAL
):
9886 if (validate_arg (arg0
, COMPLEX_TYPE
)
9887 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9888 return non_lvalue_loc (loc
, fold_build1_loc (loc
, REALPART_EXPR
, type
, arg0
));;
9891 CASE_FLT_FN (BUILT_IN_CIMAG
):
9892 if (validate_arg (arg0
, COMPLEX_TYPE
)
9893 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9894 return non_lvalue_loc (loc
, fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg0
));
9897 CASE_FLT_FN (BUILT_IN_CCOS
):
9898 return fold_builtin_ccos(loc
, arg0
, type
, fndecl
, /*hyper=*/ false);
9900 CASE_FLT_FN (BUILT_IN_CCOSH
):
9901 return fold_builtin_ccos(loc
, arg0
, type
, fndecl
, /*hyper=*/ true);
9903 CASE_FLT_FN (BUILT_IN_CPROJ
):
9904 return fold_builtin_cproj(loc
, arg0
, type
);
9906 CASE_FLT_FN (BUILT_IN_CSIN
):
9907 if (validate_arg (arg0
, COMPLEX_TYPE
)
9908 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9909 return do_mpc_arg1 (arg0
, type
, mpc_sin
);
9912 CASE_FLT_FN (BUILT_IN_CSINH
):
9913 if (validate_arg (arg0
, COMPLEX_TYPE
)
9914 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9915 return do_mpc_arg1 (arg0
, type
, mpc_sinh
);
9918 CASE_FLT_FN (BUILT_IN_CTAN
):
9919 if (validate_arg (arg0
, COMPLEX_TYPE
)
9920 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9921 return do_mpc_arg1 (arg0
, type
, mpc_tan
);
9924 CASE_FLT_FN (BUILT_IN_CTANH
):
9925 if (validate_arg (arg0
, COMPLEX_TYPE
)
9926 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9927 return do_mpc_arg1 (arg0
, type
, mpc_tanh
);
9930 CASE_FLT_FN (BUILT_IN_CLOG
):
9931 if (validate_arg (arg0
, COMPLEX_TYPE
)
9932 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9933 return do_mpc_arg1 (arg0
, type
, mpc_log
);
9936 CASE_FLT_FN (BUILT_IN_CSQRT
):
9937 if (validate_arg (arg0
, COMPLEX_TYPE
)
9938 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9939 return do_mpc_arg1 (arg0
, type
, mpc_sqrt
);
9942 CASE_FLT_FN (BUILT_IN_CASIN
):
9943 if (validate_arg (arg0
, COMPLEX_TYPE
)
9944 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9945 return do_mpc_arg1 (arg0
, type
, mpc_asin
);
9948 CASE_FLT_FN (BUILT_IN_CACOS
):
9949 if (validate_arg (arg0
, COMPLEX_TYPE
)
9950 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9951 return do_mpc_arg1 (arg0
, type
, mpc_acos
);
9954 CASE_FLT_FN (BUILT_IN_CATAN
):
9955 if (validate_arg (arg0
, COMPLEX_TYPE
)
9956 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9957 return do_mpc_arg1 (arg0
, type
, mpc_atan
);
9960 CASE_FLT_FN (BUILT_IN_CASINH
):
9961 if (validate_arg (arg0
, COMPLEX_TYPE
)
9962 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9963 return do_mpc_arg1 (arg0
, type
, mpc_asinh
);
9966 CASE_FLT_FN (BUILT_IN_CACOSH
):
9967 if (validate_arg (arg0
, COMPLEX_TYPE
)
9968 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9969 return do_mpc_arg1 (arg0
, type
, mpc_acosh
);
9972 CASE_FLT_FN (BUILT_IN_CATANH
):
9973 if (validate_arg (arg0
, COMPLEX_TYPE
)
9974 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9975 return do_mpc_arg1 (arg0
, type
, mpc_atanh
);
9978 CASE_FLT_FN (BUILT_IN_CABS
):
9979 return fold_builtin_cabs (loc
, arg0
, type
, fndecl
);
9981 CASE_FLT_FN (BUILT_IN_CARG
):
9982 return fold_builtin_carg (loc
, arg0
, type
);
9984 CASE_FLT_FN (BUILT_IN_SQRT
):
9985 return fold_builtin_sqrt (loc
, arg0
, type
);
9987 CASE_FLT_FN (BUILT_IN_CBRT
):
9988 return fold_builtin_cbrt (loc
, arg0
, type
);
9990 CASE_FLT_FN (BUILT_IN_ASIN
):
9991 if (validate_arg (arg0
, REAL_TYPE
))
9992 return do_mpfr_arg1 (arg0
, type
, mpfr_asin
,
9993 &dconstm1
, &dconst1
, true);
9996 CASE_FLT_FN (BUILT_IN_ACOS
):
9997 if (validate_arg (arg0
, REAL_TYPE
))
9998 return do_mpfr_arg1 (arg0
, type
, mpfr_acos
,
9999 &dconstm1
, &dconst1
, true);
10002 CASE_FLT_FN (BUILT_IN_ATAN
):
10003 if (validate_arg (arg0
, REAL_TYPE
))
10004 return do_mpfr_arg1 (arg0
, type
, mpfr_atan
, NULL
, NULL
, 0);
10007 CASE_FLT_FN (BUILT_IN_ASINH
):
10008 if (validate_arg (arg0
, REAL_TYPE
))
10009 return do_mpfr_arg1 (arg0
, type
, mpfr_asinh
, NULL
, NULL
, 0);
10012 CASE_FLT_FN (BUILT_IN_ACOSH
):
10013 if (validate_arg (arg0
, REAL_TYPE
))
10014 return do_mpfr_arg1 (arg0
, type
, mpfr_acosh
,
10015 &dconst1
, NULL
, true);
10018 CASE_FLT_FN (BUILT_IN_ATANH
):
10019 if (validate_arg (arg0
, REAL_TYPE
))
10020 return do_mpfr_arg1 (arg0
, type
, mpfr_atanh
,
10021 &dconstm1
, &dconst1
, false);
10024 CASE_FLT_FN (BUILT_IN_SIN
):
10025 if (validate_arg (arg0
, REAL_TYPE
))
10026 return do_mpfr_arg1 (arg0
, type
, mpfr_sin
, NULL
, NULL
, 0);
10029 CASE_FLT_FN (BUILT_IN_COS
):
10030 return fold_builtin_cos (loc
, arg0
, type
, fndecl
);
10032 CASE_FLT_FN (BUILT_IN_TAN
):
10033 return fold_builtin_tan (arg0
, type
);
10035 CASE_FLT_FN (BUILT_IN_CEXP
):
10036 return fold_builtin_cexp (loc
, arg0
, type
);
10038 CASE_FLT_FN (BUILT_IN_CEXPI
):
10039 if (validate_arg (arg0
, REAL_TYPE
))
10040 return do_mpfr_sincos (arg0
, NULL_TREE
, NULL_TREE
);
10043 CASE_FLT_FN (BUILT_IN_SINH
):
10044 if (validate_arg (arg0
, REAL_TYPE
))
10045 return do_mpfr_arg1 (arg0
, type
, mpfr_sinh
, NULL
, NULL
, 0);
10048 CASE_FLT_FN (BUILT_IN_COSH
):
10049 return fold_builtin_cosh (loc
, arg0
, type
, fndecl
);
10051 CASE_FLT_FN (BUILT_IN_TANH
):
10052 if (validate_arg (arg0
, REAL_TYPE
))
10053 return do_mpfr_arg1 (arg0
, type
, mpfr_tanh
, NULL
, NULL
, 0);
10056 CASE_FLT_FN (BUILT_IN_ERF
):
10057 if (validate_arg (arg0
, REAL_TYPE
))
10058 return do_mpfr_arg1 (arg0
, type
, mpfr_erf
, NULL
, NULL
, 0);
10061 CASE_FLT_FN (BUILT_IN_ERFC
):
10062 if (validate_arg (arg0
, REAL_TYPE
))
10063 return do_mpfr_arg1 (arg0
, type
, mpfr_erfc
, NULL
, NULL
, 0);
10066 CASE_FLT_FN (BUILT_IN_TGAMMA
):
10067 if (validate_arg (arg0
, REAL_TYPE
))
10068 return do_mpfr_arg1 (arg0
, type
, mpfr_gamma
, NULL
, NULL
, 0);
10071 CASE_FLT_FN (BUILT_IN_EXP
):
10072 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp
);
10074 CASE_FLT_FN (BUILT_IN_EXP2
):
10075 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp2
);
10077 CASE_FLT_FN (BUILT_IN_EXP10
):
10078 CASE_FLT_FN (BUILT_IN_POW10
):
10079 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp10
);
10081 CASE_FLT_FN (BUILT_IN_EXPM1
):
10082 if (validate_arg (arg0
, REAL_TYPE
))
10083 return do_mpfr_arg1 (arg0
, type
, mpfr_expm1
, NULL
, NULL
, 0);
10086 CASE_FLT_FN (BUILT_IN_LOG
):
10087 return fold_builtin_logarithm (loc
, fndecl
, arg0
, mpfr_log
);
10089 CASE_FLT_FN (BUILT_IN_LOG2
):
10090 return fold_builtin_logarithm (loc
, fndecl
, arg0
, mpfr_log2
);
10092 CASE_FLT_FN (BUILT_IN_LOG10
):
10093 return fold_builtin_logarithm (loc
, fndecl
, arg0
, mpfr_log10
);
10095 CASE_FLT_FN (BUILT_IN_LOG1P
):
10096 if (validate_arg (arg0
, REAL_TYPE
))
10097 return do_mpfr_arg1 (arg0
, type
, mpfr_log1p
,
10098 &dconstm1
, NULL
, false);
10101 CASE_FLT_FN (BUILT_IN_J0
):
10102 if (validate_arg (arg0
, REAL_TYPE
))
10103 return do_mpfr_arg1 (arg0
, type
, mpfr_j0
,
10107 CASE_FLT_FN (BUILT_IN_J1
):
10108 if (validate_arg (arg0
, REAL_TYPE
))
10109 return do_mpfr_arg1 (arg0
, type
, mpfr_j1
,
10113 CASE_FLT_FN (BUILT_IN_Y0
):
10114 if (validate_arg (arg0
, REAL_TYPE
))
10115 return do_mpfr_arg1 (arg0
, type
, mpfr_y0
,
10116 &dconst0
, NULL
, false);
10119 CASE_FLT_FN (BUILT_IN_Y1
):
10120 if (validate_arg (arg0
, REAL_TYPE
))
10121 return do_mpfr_arg1 (arg0
, type
, mpfr_y1
,
10122 &dconst0
, NULL
, false);
10125 CASE_FLT_FN (BUILT_IN_NAN
):
10126 case BUILT_IN_NAND32
:
10127 case BUILT_IN_NAND64
:
10128 case BUILT_IN_NAND128
:
10129 return fold_builtin_nan (arg0
, type
, true);
10131 CASE_FLT_FN (BUILT_IN_NANS
):
10132 return fold_builtin_nan (arg0
, type
, false);
10134 CASE_FLT_FN (BUILT_IN_FLOOR
):
10135 return fold_builtin_floor (loc
, fndecl
, arg0
);
10137 CASE_FLT_FN (BUILT_IN_CEIL
):
10138 return fold_builtin_ceil (loc
, fndecl
, arg0
);
10140 CASE_FLT_FN (BUILT_IN_TRUNC
):
10141 return fold_builtin_trunc (loc
, fndecl
, arg0
);
10143 CASE_FLT_FN (BUILT_IN_ROUND
):
10144 return fold_builtin_round (loc
, fndecl
, arg0
);
10146 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
10147 CASE_FLT_FN (BUILT_IN_RINT
):
10148 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg0
);
10150 CASE_FLT_FN (BUILT_IN_LCEIL
):
10151 CASE_FLT_FN (BUILT_IN_LLCEIL
):
10152 CASE_FLT_FN (BUILT_IN_LFLOOR
):
10153 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
10154 CASE_FLT_FN (BUILT_IN_LROUND
):
10155 CASE_FLT_FN (BUILT_IN_LLROUND
):
10156 return fold_builtin_int_roundingfn (loc
, fndecl
, arg0
);
10158 CASE_FLT_FN (BUILT_IN_LRINT
):
10159 CASE_FLT_FN (BUILT_IN_LLRINT
):
10160 return fold_fixed_mathfn (loc
, fndecl
, arg0
);
10162 case BUILT_IN_BSWAP32
:
10163 case BUILT_IN_BSWAP64
:
10164 return fold_builtin_bswap (fndecl
, arg0
);
10166 CASE_INT_FN (BUILT_IN_FFS
):
10167 CASE_INT_FN (BUILT_IN_CLZ
):
10168 CASE_INT_FN (BUILT_IN_CTZ
):
10169 CASE_INT_FN (BUILT_IN_POPCOUNT
):
10170 CASE_INT_FN (BUILT_IN_PARITY
):
10171 return fold_builtin_bitop (fndecl
, arg0
);
10173 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
10174 return fold_builtin_signbit (loc
, arg0
, type
);
10176 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
10177 return fold_builtin_significand (loc
, arg0
, type
);
10179 CASE_FLT_FN (BUILT_IN_ILOGB
):
10180 CASE_FLT_FN (BUILT_IN_LOGB
):
10181 return fold_builtin_logb (loc
, arg0
, type
);
10183 case BUILT_IN_ISASCII
:
10184 return fold_builtin_isascii (loc
, arg0
);
10186 case BUILT_IN_TOASCII
:
10187 return fold_builtin_toascii (loc
, arg0
);
10189 case BUILT_IN_ISDIGIT
:
10190 return fold_builtin_isdigit (loc
, arg0
);
10192 CASE_FLT_FN (BUILT_IN_FINITE
):
10193 case BUILT_IN_FINITED32
:
10194 case BUILT_IN_FINITED64
:
10195 case BUILT_IN_FINITED128
:
10196 case BUILT_IN_ISFINITE
:
10198 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISFINITE
);
10201 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10204 CASE_FLT_FN (BUILT_IN_ISINF
):
10205 case BUILT_IN_ISINFD32
:
10206 case BUILT_IN_ISINFD64
:
10207 case BUILT_IN_ISINFD128
:
10209 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF
);
10212 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10215 case BUILT_IN_ISNORMAL
:
10216 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10218 case BUILT_IN_ISINF_SIGN
:
10219 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF_SIGN
);
10221 CASE_FLT_FN (BUILT_IN_ISNAN
):
10222 case BUILT_IN_ISNAND32
:
10223 case BUILT_IN_ISNAND64
:
10224 case BUILT_IN_ISNAND128
:
10225 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISNAN
);
10227 case BUILT_IN_PRINTF
:
10228 case BUILT_IN_PRINTF_UNLOCKED
:
10229 case BUILT_IN_VPRINTF
:
10230 return fold_builtin_printf (loc
, fndecl
, arg0
, NULL_TREE
, ignore
, fcode
);
10232 case BUILT_IN_FREE
:
10233 if (integer_zerop (arg0
))
10234 return build_empty_stmt (loc
);
10245 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10246 IGNORE is true if the result of the function call is ignored. This
10247 function returns NULL_TREE if no simplification was possible. */
10250 fold_builtin_2 (location_t loc
, tree fndecl
, tree arg0
, tree arg1
, bool ignore
)
10252 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10253 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10257 CASE_FLT_FN (BUILT_IN_JN
):
10258 if (validate_arg (arg0
, INTEGER_TYPE
)
10259 && validate_arg (arg1
, REAL_TYPE
))
10260 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_jn
, NULL
, 0);
10263 CASE_FLT_FN (BUILT_IN_YN
):
10264 if (validate_arg (arg0
, INTEGER_TYPE
)
10265 && validate_arg (arg1
, REAL_TYPE
))
10266 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_yn
,
10270 CASE_FLT_FN (BUILT_IN_DREM
):
10271 CASE_FLT_FN (BUILT_IN_REMAINDER
):
10272 if (validate_arg (arg0
, REAL_TYPE
)
10273 && validate_arg(arg1
, REAL_TYPE
))
10274 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_remainder
);
10277 CASE_FLT_FN_REENT (BUILT_IN_GAMMA
): /* GAMMA_R */
10278 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA
): /* LGAMMA_R */
10279 if (validate_arg (arg0
, REAL_TYPE
)
10280 && validate_arg(arg1
, POINTER_TYPE
))
10281 return do_mpfr_lgamma_r (arg0
, arg1
, type
);
10284 CASE_FLT_FN (BUILT_IN_ATAN2
):
10285 if (validate_arg (arg0
, REAL_TYPE
)
10286 && validate_arg(arg1
, REAL_TYPE
))
10287 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_atan2
);
10290 CASE_FLT_FN (BUILT_IN_FDIM
):
10291 if (validate_arg (arg0
, REAL_TYPE
)
10292 && validate_arg(arg1
, REAL_TYPE
))
10293 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_dim
);
10296 CASE_FLT_FN (BUILT_IN_HYPOT
):
10297 return fold_builtin_hypot (loc
, fndecl
, arg0
, arg1
, type
);
10299 CASE_FLT_FN (BUILT_IN_CPOW
):
10300 if (validate_arg (arg0
, COMPLEX_TYPE
)
10301 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
10302 && validate_arg (arg1
, COMPLEX_TYPE
)
10303 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
)
10304 return do_mpc_arg2 (arg0
, arg1
, type
, /*do_nonfinite=*/ 0, mpc_pow
);
10307 CASE_FLT_FN (BUILT_IN_LDEXP
):
10308 return fold_builtin_load_exponent (loc
, arg0
, arg1
, type
, /*ldexp=*/true);
10309 CASE_FLT_FN (BUILT_IN_SCALBN
):
10310 CASE_FLT_FN (BUILT_IN_SCALBLN
):
10311 return fold_builtin_load_exponent (loc
, arg0
, arg1
,
10312 type
, /*ldexp=*/false);
10314 CASE_FLT_FN (BUILT_IN_FREXP
):
10315 return fold_builtin_frexp (loc
, arg0
, arg1
, type
);
10317 CASE_FLT_FN (BUILT_IN_MODF
):
10318 return fold_builtin_modf (loc
, arg0
, arg1
, type
);
10320 case BUILT_IN_BZERO
:
10321 return fold_builtin_bzero (loc
, arg0
, arg1
, ignore
);
10323 case BUILT_IN_FPUTS
:
10324 return fold_builtin_fputs (loc
, arg0
, arg1
, ignore
, false, NULL_TREE
);
10326 case BUILT_IN_FPUTS_UNLOCKED
:
10327 return fold_builtin_fputs (loc
, arg0
, arg1
, ignore
, true, NULL_TREE
);
10329 case BUILT_IN_STRSTR
:
10330 return fold_builtin_strstr (loc
, arg0
, arg1
, type
);
10332 case BUILT_IN_STRCAT
:
10333 return fold_builtin_strcat (loc
, arg0
, arg1
);
10335 case BUILT_IN_STRSPN
:
10336 return fold_builtin_strspn (loc
, arg0
, arg1
);
10338 case BUILT_IN_STRCSPN
:
10339 return fold_builtin_strcspn (loc
, arg0
, arg1
);
10341 case BUILT_IN_STRCHR
:
10342 case BUILT_IN_INDEX
:
10343 return fold_builtin_strchr (loc
, arg0
, arg1
, type
);
10345 case BUILT_IN_STRRCHR
:
10346 case BUILT_IN_RINDEX
:
10347 return fold_builtin_strrchr (loc
, arg0
, arg1
, type
);
10349 case BUILT_IN_STRCPY
:
10350 return fold_builtin_strcpy (loc
, fndecl
, arg0
, arg1
, NULL_TREE
);
10352 case BUILT_IN_STPCPY
:
10355 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
10359 return build_call_expr_loc (loc
, fn
, 2, arg0
, arg1
);
10362 return fold_builtin_stpcpy (loc
, fndecl
, arg0
, arg1
);
10365 case BUILT_IN_STRCMP
:
10366 return fold_builtin_strcmp (loc
, arg0
, arg1
);
10368 case BUILT_IN_STRPBRK
:
10369 return fold_builtin_strpbrk (loc
, arg0
, arg1
, type
);
10371 case BUILT_IN_EXPECT
:
10372 return fold_builtin_expect (loc
, arg0
, arg1
);
10374 CASE_FLT_FN (BUILT_IN_POW
):
10375 return fold_builtin_pow (loc
, fndecl
, arg0
, arg1
, type
);
10377 CASE_FLT_FN (BUILT_IN_POWI
):
10378 return fold_builtin_powi (loc
, fndecl
, arg0
, arg1
, type
);
10380 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
10381 return fold_builtin_copysign (loc
, fndecl
, arg0
, arg1
, type
);
10383 CASE_FLT_FN (BUILT_IN_FMIN
):
10384 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/false);
10386 CASE_FLT_FN (BUILT_IN_FMAX
):
10387 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/true);
10389 case BUILT_IN_ISGREATER
:
10390 return fold_builtin_unordered_cmp (loc
, fndecl
,
10391 arg0
, arg1
, UNLE_EXPR
, LE_EXPR
);
10392 case BUILT_IN_ISGREATEREQUAL
:
10393 return fold_builtin_unordered_cmp (loc
, fndecl
,
10394 arg0
, arg1
, UNLT_EXPR
, LT_EXPR
);
10395 case BUILT_IN_ISLESS
:
10396 return fold_builtin_unordered_cmp (loc
, fndecl
,
10397 arg0
, arg1
, UNGE_EXPR
, GE_EXPR
);
10398 case BUILT_IN_ISLESSEQUAL
:
10399 return fold_builtin_unordered_cmp (loc
, fndecl
,
10400 arg0
, arg1
, UNGT_EXPR
, GT_EXPR
);
10401 case BUILT_IN_ISLESSGREATER
:
10402 return fold_builtin_unordered_cmp (loc
, fndecl
,
10403 arg0
, arg1
, UNEQ_EXPR
, EQ_EXPR
);
10404 case BUILT_IN_ISUNORDERED
:
10405 return fold_builtin_unordered_cmp (loc
, fndecl
,
10406 arg0
, arg1
, UNORDERED_EXPR
,
10409 /* We do the folding for va_start in the expander. */
10410 case BUILT_IN_VA_START
:
10413 case BUILT_IN_SPRINTF
:
10414 return fold_builtin_sprintf (loc
, arg0
, arg1
, NULL_TREE
, ignore
);
10416 case BUILT_IN_OBJECT_SIZE
:
10417 return fold_builtin_object_size (arg0
, arg1
);
10419 case BUILT_IN_PRINTF
:
10420 case BUILT_IN_PRINTF_UNLOCKED
:
10421 case BUILT_IN_VPRINTF
:
10422 return fold_builtin_printf (loc
, fndecl
, arg0
, arg1
, ignore
, fcode
);
10424 case BUILT_IN_PRINTF_CHK
:
10425 case BUILT_IN_VPRINTF_CHK
:
10426 if (!validate_arg (arg0
, INTEGER_TYPE
)
10427 || TREE_SIDE_EFFECTS (arg0
))
10430 return fold_builtin_printf (loc
, fndecl
,
10431 arg1
, NULL_TREE
, ignore
, fcode
);
10434 case BUILT_IN_FPRINTF
:
10435 case BUILT_IN_FPRINTF_UNLOCKED
:
10436 case BUILT_IN_VFPRINTF
:
10437 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg1
, NULL_TREE
,
10446 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10447 and ARG2. IGNORE is true if the result of the function call is ignored.
10448 This function returns NULL_TREE if no simplification was possible. */
10451 fold_builtin_3 (location_t loc
, tree fndecl
,
10452 tree arg0
, tree arg1
, tree arg2
, bool ignore
)
10454 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10455 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10459 CASE_FLT_FN (BUILT_IN_SINCOS
):
10460 return fold_builtin_sincos (loc
, arg0
, arg1
, arg2
);
10462 CASE_FLT_FN (BUILT_IN_FMA
):
10463 if (validate_arg (arg0
, REAL_TYPE
)
10464 && validate_arg(arg1
, REAL_TYPE
)
10465 && validate_arg(arg2
, REAL_TYPE
))
10466 return do_mpfr_arg3 (arg0
, arg1
, arg2
, type
, mpfr_fma
);
10469 CASE_FLT_FN (BUILT_IN_REMQUO
):
10470 if (validate_arg (arg0
, REAL_TYPE
)
10471 && validate_arg(arg1
, REAL_TYPE
)
10472 && validate_arg(arg2
, POINTER_TYPE
))
10473 return do_mpfr_remquo (arg0
, arg1
, arg2
);
10476 case BUILT_IN_MEMSET
:
10477 return fold_builtin_memset (loc
, arg0
, arg1
, arg2
, type
, ignore
);
10479 case BUILT_IN_BCOPY
:
10480 return fold_builtin_memory_op (loc
, arg1
, arg0
, arg2
,
10481 void_type_node
, true, /*endp=*/3);
10483 case BUILT_IN_MEMCPY
:
10484 return fold_builtin_memory_op (loc
, arg0
, arg1
, arg2
,
10485 type
, ignore
, /*endp=*/0);
10487 case BUILT_IN_MEMPCPY
:
10488 return fold_builtin_memory_op (loc
, arg0
, arg1
, arg2
,
10489 type
, ignore
, /*endp=*/1);
10491 case BUILT_IN_MEMMOVE
:
10492 return fold_builtin_memory_op (loc
, arg0
, arg1
, arg2
,
10493 type
, ignore
, /*endp=*/3);
10495 case BUILT_IN_STRNCAT
:
10496 return fold_builtin_strncat (loc
, arg0
, arg1
, arg2
);
10498 case BUILT_IN_STRNCPY
:
10499 return fold_builtin_strncpy (loc
, fndecl
, arg0
, arg1
, arg2
, NULL_TREE
);
10501 case BUILT_IN_STRNCMP
:
10502 return fold_builtin_strncmp (loc
, arg0
, arg1
, arg2
);
10504 case BUILT_IN_MEMCHR
:
10505 return fold_builtin_memchr (loc
, arg0
, arg1
, arg2
, type
);
10507 case BUILT_IN_BCMP
:
10508 case BUILT_IN_MEMCMP
:
10509 return fold_builtin_memcmp (loc
, arg0
, arg1
, arg2
);;
10511 case BUILT_IN_SPRINTF
:
10512 return fold_builtin_sprintf (loc
, arg0
, arg1
, arg2
, ignore
);
10514 case BUILT_IN_STRCPY_CHK
:
10515 case BUILT_IN_STPCPY_CHK
:
10516 return fold_builtin_stxcpy_chk (loc
, fndecl
, arg0
, arg1
, arg2
, NULL_TREE
,
10519 case BUILT_IN_STRCAT_CHK
:
10520 return fold_builtin_strcat_chk (loc
, fndecl
, arg0
, arg1
, arg2
);
10522 case BUILT_IN_PRINTF_CHK
:
10523 case BUILT_IN_VPRINTF_CHK
:
10524 if (!validate_arg (arg0
, INTEGER_TYPE
)
10525 || TREE_SIDE_EFFECTS (arg0
))
10528 return fold_builtin_printf (loc
, fndecl
, arg1
, arg2
, ignore
, fcode
);
10531 case BUILT_IN_FPRINTF
:
10532 case BUILT_IN_FPRINTF_UNLOCKED
:
10533 case BUILT_IN_VFPRINTF
:
10534 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg1
, arg2
,
10537 case BUILT_IN_FPRINTF_CHK
:
10538 case BUILT_IN_VFPRINTF_CHK
:
10539 if (!validate_arg (arg1
, INTEGER_TYPE
)
10540 || TREE_SIDE_EFFECTS (arg1
))
10543 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg2
, NULL_TREE
,
10552 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10553 ARG2, and ARG3. IGNORE is true if the result of the function call is
10554 ignored. This function returns NULL_TREE if no simplification was
10558 fold_builtin_4 (location_t loc
, tree fndecl
,
10559 tree arg0
, tree arg1
, tree arg2
, tree arg3
, bool ignore
)
10561 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10565 case BUILT_IN_MEMCPY_CHK
:
10566 case BUILT_IN_MEMPCPY_CHK
:
10567 case BUILT_IN_MEMMOVE_CHK
:
10568 case BUILT_IN_MEMSET_CHK
:
10569 return fold_builtin_memory_chk (loc
, fndecl
, arg0
, arg1
, arg2
, arg3
,
10571 DECL_FUNCTION_CODE (fndecl
));
10573 case BUILT_IN_STRNCPY_CHK
:
10574 return fold_builtin_strncpy_chk (loc
, arg0
, arg1
, arg2
, arg3
, NULL_TREE
);
10576 case BUILT_IN_STRNCAT_CHK
:
10577 return fold_builtin_strncat_chk (loc
, fndecl
, arg0
, arg1
, arg2
, arg3
);
10579 case BUILT_IN_FPRINTF_CHK
:
10580 case BUILT_IN_VFPRINTF_CHK
:
10581 if (!validate_arg (arg1
, INTEGER_TYPE
)
10582 || TREE_SIDE_EFFECTS (arg1
))
10585 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg2
, arg3
,
10595 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10596 arguments, where NARGS <= 4. IGNORE is true if the result of the
10597 function call is ignored. This function returns NULL_TREE if no
10598 simplification was possible. Note that this only folds builtins with
10599 fixed argument patterns. Foldings that do varargs-to-varargs
10600 transformations, or that match calls with more than 4 arguments,
10601 need to be handled with fold_builtin_varargs instead. */
10603 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10606 fold_builtin_n (location_t loc
, tree fndecl
, tree
*args
, int nargs
, bool ignore
)
10608 tree ret
= NULL_TREE
;
10613 ret
= fold_builtin_0 (loc
, fndecl
, ignore
);
10616 ret
= fold_builtin_1 (loc
, fndecl
, args
[0], ignore
);
10619 ret
= fold_builtin_2 (loc
, fndecl
, args
[0], args
[1], ignore
);
10622 ret
= fold_builtin_3 (loc
, fndecl
, args
[0], args
[1], args
[2], ignore
);
10625 ret
= fold_builtin_4 (loc
, fndecl
, args
[0], args
[1], args
[2], args
[3],
10633 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
10634 SET_EXPR_LOCATION (ret
, loc
);
10635 TREE_NO_WARNING (ret
) = 1;
10641 /* Builtins with folding operations that operate on "..." arguments
10642 need special handling; we need to store the arguments in a convenient
10643 data structure before attempting any folding. Fortunately there are
10644 only a few builtins that fall into this category. FNDECL is the
10645 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10646 result of the function call is ignored. */
10649 fold_builtin_varargs (location_t loc
, tree fndecl
, tree exp
,
10650 bool ignore ATTRIBUTE_UNUSED
)
10652 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10653 tree ret
= NULL_TREE
;
10657 case BUILT_IN_SPRINTF_CHK
:
10658 case BUILT_IN_VSPRINTF_CHK
:
10659 ret
= fold_builtin_sprintf_chk (loc
, exp
, fcode
);
10662 case BUILT_IN_SNPRINTF_CHK
:
10663 case BUILT_IN_VSNPRINTF_CHK
:
10664 ret
= fold_builtin_snprintf_chk (loc
, exp
, NULL_TREE
, fcode
);
10667 case BUILT_IN_FPCLASSIFY
:
10668 ret
= fold_builtin_fpclassify (loc
, exp
);
10676 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
10677 SET_EXPR_LOCATION (ret
, loc
);
10678 TREE_NO_WARNING (ret
) = 1;
10684 /* Return true if FNDECL shouldn't be folded right now.
10685 If a built-in function has an inline attribute always_inline
10686 wrapper, defer folding it after always_inline functions have
10687 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10688 might not be performed. */
10691 avoid_folding_inline_builtin (tree fndecl
)
10693 return (DECL_DECLARED_INLINE_P (fndecl
)
10694 && DECL_DISREGARD_INLINE_LIMITS (fndecl
)
10696 && !cfun
->always_inline_functions_inlined
10697 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl
)));
10700 /* A wrapper function for builtin folding that prevents warnings for
10701 "statement without effect" and the like, caused by removing the
10702 call node earlier than the warning is generated. */
10705 fold_call_expr (location_t loc
, tree exp
, bool ignore
)
10707 tree ret
= NULL_TREE
;
10708 tree fndecl
= get_callee_fndecl (exp
);
10710 && TREE_CODE (fndecl
) == FUNCTION_DECL
10711 && DECL_BUILT_IN (fndecl
)
10712 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10713 yet. Defer folding until we see all the arguments
10714 (after inlining). */
10715 && !CALL_EXPR_VA_ARG_PACK (exp
))
10717 int nargs
= call_expr_nargs (exp
);
10719 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10720 instead last argument is __builtin_va_arg_pack (). Defer folding
10721 even in that case, until arguments are finalized. */
10722 if (nargs
&& TREE_CODE (CALL_EXPR_ARG (exp
, nargs
- 1)) == CALL_EXPR
)
10724 tree fndecl2
= get_callee_fndecl (CALL_EXPR_ARG (exp
, nargs
- 1));
10726 && TREE_CODE (fndecl2
) == FUNCTION_DECL
10727 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
10728 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
10732 if (avoid_folding_inline_builtin (fndecl
))
10735 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10736 return targetm
.fold_builtin (fndecl
, call_expr_nargs (exp
),
10737 CALL_EXPR_ARGP (exp
), ignore
);
10740 if (nargs
<= MAX_ARGS_TO_FOLD_BUILTIN
)
10742 tree
*args
= CALL_EXPR_ARGP (exp
);
10743 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
10746 ret
= fold_builtin_varargs (loc
, fndecl
, exp
, ignore
);
10754 /* Conveniently construct a function call expression. FNDECL names the
10755 function to be called and N arguments are passed in the array
10759 build_call_expr_loc_array (location_t loc
, tree fndecl
, int n
, tree
*argarray
)
10761 tree fntype
= TREE_TYPE (fndecl
);
10762 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
10764 return fold_builtin_call_array (loc
, TREE_TYPE (fntype
), fn
, n
, argarray
);
10767 /* Conveniently construct a function call expression. FNDECL names the
10768 function to be called and the arguments are passed in the vector
10772 build_call_expr_loc_vec (location_t loc
, tree fndecl
, VEC(tree
,gc
) *vec
)
10774 return build_call_expr_loc_array (loc
, fndecl
, VEC_length (tree
, vec
),
10775 VEC_address (tree
, vec
));
10779 /* Conveniently construct a function call expression. FNDECL names the
10780 function to be called, N is the number of arguments, and the "..."
10781 parameters are the argument expressions. */
10784 build_call_expr_loc (location_t loc
, tree fndecl
, int n
, ...)
10787 tree
*argarray
= XALLOCAVEC (tree
, n
);
10791 for (i
= 0; i
< n
; i
++)
10792 argarray
[i
] = va_arg (ap
, tree
);
10794 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
10797 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
10798 varargs macros aren't supported by all bootstrap compilers. */
10801 build_call_expr (tree fndecl
, int n
, ...)
10804 tree
*argarray
= XALLOCAVEC (tree
, n
);
10808 for (i
= 0; i
< n
; i
++)
10809 argarray
[i
] = va_arg (ap
, tree
);
10811 return build_call_expr_loc_array (UNKNOWN_LOCATION
, fndecl
, n
, argarray
);
10814 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10815 N arguments are passed in the array ARGARRAY. */
10818 fold_builtin_call_array (location_t loc
, tree type
,
10823 tree ret
= NULL_TREE
;
10826 if (TREE_CODE (fn
) == ADDR_EXPR
)
10828 tree fndecl
= TREE_OPERAND (fn
, 0);
10829 if (TREE_CODE (fndecl
) == FUNCTION_DECL
10830 && DECL_BUILT_IN (fndecl
))
10832 /* If last argument is __builtin_va_arg_pack (), arguments to this
10833 function are not finalized yet. Defer folding until they are. */
10834 if (n
&& TREE_CODE (argarray
[n
- 1]) == CALL_EXPR
)
10836 tree fndecl2
= get_callee_fndecl (argarray
[n
- 1]);
10838 && TREE_CODE (fndecl2
) == FUNCTION_DECL
10839 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
10840 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
10841 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
10843 if (avoid_folding_inline_builtin (fndecl
))
10844 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
10845 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10847 ret
= targetm
.fold_builtin (fndecl
, n
, argarray
, false);
10851 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
10853 else if (n
<= MAX_ARGS_TO_FOLD_BUILTIN
)
10855 /* First try the transformations that don't require consing up
10857 ret
= fold_builtin_n (loc
, fndecl
, argarray
, n
, false);
10862 /* If we got this far, we need to build an exp. */
10863 exp
= build_call_array_loc (loc
, type
, fn
, n
, argarray
);
10864 ret
= fold_builtin_varargs (loc
, fndecl
, exp
, false);
10865 return ret
? ret
: exp
;
10869 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
10872 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10873 along with N new arguments specified as the "..." parameters. SKIP
10874 is the number of arguments in EXP to be omitted. This function is used
10875 to do varargs-to-varargs transformations. */
10878 rewrite_call_expr (location_t loc
, tree exp
, int skip
, tree fndecl
, int n
, ...)
10880 int oldnargs
= call_expr_nargs (exp
);
10881 int nargs
= oldnargs
- skip
+ n
;
10882 tree fntype
= TREE_TYPE (fndecl
);
10883 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
10891 buffer
= XALLOCAVEC (tree
, nargs
);
10893 for (i
= 0; i
< n
; i
++)
10894 buffer
[i
] = va_arg (ap
, tree
);
10896 for (j
= skip
; j
< oldnargs
; j
++, i
++)
10897 buffer
[i
] = CALL_EXPR_ARG (exp
, j
);
10900 buffer
= CALL_EXPR_ARGP (exp
) + skip
;
10902 return fold (build_call_array_loc (loc
, TREE_TYPE (exp
), fn
, nargs
, buffer
));
10905 /* Validate a single argument ARG against a tree code CODE representing
10909 validate_arg (const_tree arg
, enum tree_code code
)
10913 else if (code
== POINTER_TYPE
)
10914 return POINTER_TYPE_P (TREE_TYPE (arg
));
10915 else if (code
== INTEGER_TYPE
)
10916 return INTEGRAL_TYPE_P (TREE_TYPE (arg
));
10917 return code
== TREE_CODE (TREE_TYPE (arg
));
10920 /* This function validates the types of a function call argument list
10921 against a specified list of tree_codes. If the last specifier is a 0,
10922 that represents an ellipses, otherwise the last specifier must be a
10925 This is the GIMPLE version of validate_arglist. Eventually we want to
10926 completely convert builtins.c to work from GIMPLEs and the tree based
10927 validate_arglist will then be removed. */
10930 validate_gimple_arglist (const_gimple call
, ...)
10932 enum tree_code code
;
10938 va_start (ap
, call
);
10943 code
= (enum tree_code
) va_arg (ap
, int);
10947 /* This signifies an ellipses, any further arguments are all ok. */
10951 /* This signifies an endlink, if no arguments remain, return
10952 true, otherwise return false. */
10953 res
= (i
== gimple_call_num_args (call
));
10956 /* If no parameters remain or the parameter's code does not
10957 match the specified code, return false. Otherwise continue
10958 checking any remaining arguments. */
10959 arg
= gimple_call_arg (call
, i
++);
10960 if (!validate_arg (arg
, code
))
10967 /* We need gotos here since we can only have one VA_CLOSE in a
10975 /* This function validates the types of a function call argument list
10976 against a specified list of tree_codes. If the last specifier is a 0,
10977 that represents an ellipses, otherwise the last specifier must be a
10981 validate_arglist (const_tree callexpr
, ...)
10983 enum tree_code code
;
10986 const_call_expr_arg_iterator iter
;
10989 va_start (ap
, callexpr
);
10990 init_const_call_expr_arg_iterator (callexpr
, &iter
);
10994 code
= (enum tree_code
) va_arg (ap
, int);
10998 /* This signifies an ellipses, any further arguments are all ok. */
11002 /* This signifies an endlink, if no arguments remain, return
11003 true, otherwise return false. */
11004 res
= !more_const_call_expr_args_p (&iter
);
11007 /* If no parameters remain or the parameter's code does not
11008 match the specified code, return false. Otherwise continue
11009 checking any remaining arguments. */
11010 arg
= next_const_call_expr_arg (&iter
);
11011 if (!validate_arg (arg
, code
))
11018 /* We need gotos here since we can only have one VA_CLOSE in a
11026 /* Default target-specific builtin expander that does nothing. */
11029 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
11030 rtx target ATTRIBUTE_UNUSED
,
11031 rtx subtarget ATTRIBUTE_UNUSED
,
11032 enum machine_mode mode ATTRIBUTE_UNUSED
,
11033 int ignore ATTRIBUTE_UNUSED
)
11038 /* Returns true is EXP represents data that would potentially reside
11039 in a readonly section. */
11042 readonly_data_expr (tree exp
)
11046 if (TREE_CODE (exp
) != ADDR_EXPR
)
11049 exp
= get_base_address (TREE_OPERAND (exp
, 0));
11053 /* Make sure we call decl_readonly_section only for trees it
11054 can handle (since it returns true for everything it doesn't
11056 if (TREE_CODE (exp
) == STRING_CST
11057 || TREE_CODE (exp
) == CONSTRUCTOR
11058 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
11059 return decl_readonly_section (exp
, 0);
11064 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11065 to the call, and TYPE is its return type.
11067 Return NULL_TREE if no simplification was possible, otherwise return the
11068 simplified form of the call as a tree.
11070 The simplified form may be a constant or other expression which
11071 computes the same value, but in a more efficient manner (including
11072 calls to other builtin functions).
11074 The call may contain arguments which need to be evaluated, but
11075 which are not useful to determine the result of the call. In
11076 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11077 COMPOUND_EXPR will be an argument which must be evaluated.
11078 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11079 COMPOUND_EXPR in the chain will contain the tree for the simplified
11080 form of the builtin function call. */
11083 fold_builtin_strstr (location_t loc
, tree s1
, tree s2
, tree type
)
11085 if (!validate_arg (s1
, POINTER_TYPE
)
11086 || !validate_arg (s2
, POINTER_TYPE
))
11091 const char *p1
, *p2
;
11093 p2
= c_getstr (s2
);
11097 p1
= c_getstr (s1
);
11100 const char *r
= strstr (p1
, p2
);
11104 return build_int_cst (TREE_TYPE (s1
), 0);
11106 /* Return an offset into the constant string argument. */
11107 tem
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (s1
),
11108 s1
, size_int (r
- p1
));
11109 return fold_convert_loc (loc
, type
, tem
);
11112 /* The argument is const char *, and the result is char *, so we need
11113 a type conversion here to avoid a warning. */
11115 return fold_convert_loc (loc
, type
, s1
);
11120 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
11124 /* New argument list transforming strstr(s1, s2) to
11125 strchr(s1, s2[0]). */
11126 return build_call_expr_loc (loc
, fn
, 2, s1
, build_int_cst (NULL_TREE
, p2
[0]));
11130 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11131 the call, and TYPE is its return type.
11133 Return NULL_TREE if no simplification was possible, otherwise return the
11134 simplified form of the call as a tree.
11136 The simplified form may be a constant or other expression which
11137 computes the same value, but in a more efficient manner (including
11138 calls to other builtin functions).
11140 The call may contain arguments which need to be evaluated, but
11141 which are not useful to determine the result of the call. In
11142 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11143 COMPOUND_EXPR will be an argument which must be evaluated.
11144 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11145 COMPOUND_EXPR in the chain will contain the tree for the simplified
11146 form of the builtin function call. */
11149 fold_builtin_strchr (location_t loc
, tree s1
, tree s2
, tree type
)
11151 if (!validate_arg (s1
, POINTER_TYPE
)
11152 || !validate_arg (s2
, INTEGER_TYPE
))
11158 if (TREE_CODE (s2
) != INTEGER_CST
)
11161 p1
= c_getstr (s1
);
11168 if (target_char_cast (s2
, &c
))
11171 r
= strchr (p1
, c
);
11174 return build_int_cst (TREE_TYPE (s1
), 0);
11176 /* Return an offset into the constant string argument. */
11177 tem
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (s1
),
11178 s1
, size_int (r
- p1
));
11179 return fold_convert_loc (loc
, type
, tem
);
11185 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11186 the call, and TYPE is its return type.
11188 Return NULL_TREE if no simplification was possible, otherwise return the
11189 simplified form of the call as a tree.
11191 The simplified form may be a constant or other expression which
11192 computes the same value, but in a more efficient manner (including
11193 calls to other builtin functions).
11195 The call may contain arguments which need to be evaluated, but
11196 which are not useful to determine the result of the call. In
11197 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11198 COMPOUND_EXPR will be an argument which must be evaluated.
11199 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11200 COMPOUND_EXPR in the chain will contain the tree for the simplified
11201 form of the builtin function call. */
11204 fold_builtin_strrchr (location_t loc
, tree s1
, tree s2
, tree type
)
11206 if (!validate_arg (s1
, POINTER_TYPE
)
11207 || !validate_arg (s2
, INTEGER_TYPE
))
11214 if (TREE_CODE (s2
) != INTEGER_CST
)
11217 p1
= c_getstr (s1
);
11224 if (target_char_cast (s2
, &c
))
11227 r
= strrchr (p1
, c
);
11230 return build_int_cst (TREE_TYPE (s1
), 0);
11232 /* Return an offset into the constant string argument. */
11233 tem
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (s1
),
11234 s1
, size_int (r
- p1
));
11235 return fold_convert_loc (loc
, type
, tem
);
11238 if (! integer_zerop (s2
))
11241 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
11245 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11246 return build_call_expr_loc (loc
, fn
, 2, s1
, s2
);
11250 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11251 to the call, and TYPE is its return type.
11253 Return NULL_TREE if no simplification was possible, otherwise return the
11254 simplified form of the call as a tree.
11256 The simplified form may be a constant or other expression which
11257 computes the same value, but in a more efficient manner (including
11258 calls to other builtin functions).
11260 The call may contain arguments which need to be evaluated, but
11261 which are not useful to determine the result of the call. In
11262 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11263 COMPOUND_EXPR will be an argument which must be evaluated.
11264 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11265 COMPOUND_EXPR in the chain will contain the tree for the simplified
11266 form of the builtin function call. */
11269 fold_builtin_strpbrk (location_t loc
, tree s1
, tree s2
, tree type
)
11271 if (!validate_arg (s1
, POINTER_TYPE
)
11272 || !validate_arg (s2
, POINTER_TYPE
))
11277 const char *p1
, *p2
;
11279 p2
= c_getstr (s2
);
11283 p1
= c_getstr (s1
);
11286 const char *r
= strpbrk (p1
, p2
);
11290 return build_int_cst (TREE_TYPE (s1
), 0);
11292 /* Return an offset into the constant string argument. */
11293 tem
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (s1
),
11294 s1
, size_int (r
- p1
));
11295 return fold_convert_loc (loc
, type
, tem
);
11299 /* strpbrk(x, "") == NULL.
11300 Evaluate and ignore s1 in case it had side-effects. */
11301 return omit_one_operand_loc (loc
, TREE_TYPE (s1
), integer_zero_node
, s1
);
11304 return NULL_TREE
; /* Really call strpbrk. */
11306 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
11310 /* New argument list transforming strpbrk(s1, s2) to
11311 strchr(s1, s2[0]). */
11312 return build_call_expr_loc (loc
, fn
, 2, s1
, build_int_cst (NULL_TREE
, p2
[0]));
11316 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11319 Return NULL_TREE if no simplification was possible, otherwise return the
11320 simplified form of the call as a tree.
11322 The simplified form may be a constant or other expression which
11323 computes the same value, but in a more efficient manner (including
11324 calls to other builtin functions).
11326 The call may contain arguments which need to be evaluated, but
11327 which are not useful to determine the result of the call. In
11328 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11329 COMPOUND_EXPR will be an argument which must be evaluated.
11330 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11331 COMPOUND_EXPR in the chain will contain the tree for the simplified
11332 form of the builtin function call. */
11335 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED
, tree dst
, tree src
)
11337 if (!validate_arg (dst
, POINTER_TYPE
)
11338 || !validate_arg (src
, POINTER_TYPE
))
11342 const char *p
= c_getstr (src
);
11344 /* If the string length is zero, return the dst parameter. */
11345 if (p
&& *p
== '\0')
11348 if (optimize_insn_for_speed_p ())
11350 /* See if we can store by pieces into (dst + strlen(dst)). */
11352 tree strlen_fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
11353 tree strcpy_fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
11355 if (!strlen_fn
|| !strcpy_fn
)
11358 /* If we don't have a movstr we don't want to emit an strcpy
11359 call. We have to do that if the length of the source string
11360 isn't computable (in that case we can use memcpy probably
11361 later expanding to a sequence of mov instructions). If we
11362 have movstr instructions we can emit strcpy calls. */
11365 tree len
= c_strlen (src
, 1);
11366 if (! len
|| TREE_SIDE_EFFECTS (len
))
11370 /* Stabilize the argument list. */
11371 dst
= builtin_save_expr (dst
);
11373 /* Create strlen (dst). */
11374 newdst
= build_call_expr_loc (loc
, strlen_fn
, 1, dst
);
11375 /* Create (dst p+ strlen (dst)). */
11377 newdst
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
,
11378 TREE_TYPE (dst
), dst
, newdst
);
11379 newdst
= builtin_save_expr (newdst
);
11381 call
= build_call_expr_loc (loc
, strcpy_fn
, 2, newdst
, src
);
11382 return build2 (COMPOUND_EXPR
, TREE_TYPE (dst
), call
, dst
);
11388 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11389 arguments to the call.
11391 Return NULL_TREE if no simplification was possible, otherwise return the
11392 simplified form of the call as a tree.
11394 The simplified form may be a constant or other expression which
11395 computes the same value, but in a more efficient manner (including
11396 calls to other builtin functions).
11398 The call may contain arguments which need to be evaluated, but
11399 which are not useful to determine the result of the call. In
11400 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11401 COMPOUND_EXPR will be an argument which must be evaluated.
11402 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11403 COMPOUND_EXPR in the chain will contain the tree for the simplified
11404 form of the builtin function call. */
11407 fold_builtin_strncat (location_t loc
, tree dst
, tree src
, tree len
)
11409 if (!validate_arg (dst
, POINTER_TYPE
)
11410 || !validate_arg (src
, POINTER_TYPE
)
11411 || !validate_arg (len
, INTEGER_TYPE
))
11415 const char *p
= c_getstr (src
);
11417 /* If the requested length is zero, or the src parameter string
11418 length is zero, return the dst parameter. */
11419 if (integer_zerop (len
) || (p
&& *p
== '\0'))
11420 return omit_two_operands_loc (loc
, TREE_TYPE (dst
), dst
, src
, len
);
11422 /* If the requested len is greater than or equal to the string
11423 length, call strcat. */
11424 if (TREE_CODE (len
) == INTEGER_CST
&& p
11425 && compare_tree_int (len
, strlen (p
)) >= 0)
11427 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
11429 /* If the replacement _DECL isn't initialized, don't do the
11434 return build_call_expr_loc (loc
, fn
, 2, dst
, src
);
11440 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11443 Return NULL_TREE if no simplification was possible, otherwise return the
11444 simplified form of the call as a tree.
11446 The simplified form may be a constant or other expression which
11447 computes the same value, but in a more efficient manner (including
11448 calls to other builtin functions).
11450 The call may contain arguments which need to be evaluated, but
11451 which are not useful to determine the result of the call. In
11452 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11453 COMPOUND_EXPR will be an argument which must be evaluated.
11454 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11455 COMPOUND_EXPR in the chain will contain the tree for the simplified
11456 form of the builtin function call. */
11459 fold_builtin_strspn (location_t loc
, tree s1
, tree s2
)
11461 if (!validate_arg (s1
, POINTER_TYPE
)
11462 || !validate_arg (s2
, POINTER_TYPE
))
11466 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11468 /* If both arguments are constants, evaluate at compile-time. */
11471 const size_t r
= strspn (p1
, p2
);
11472 return size_int (r
);
11475 /* If either argument is "", return NULL_TREE. */
11476 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
11477 /* Evaluate and ignore both arguments in case either one has
11479 return omit_two_operands_loc (loc
, size_type_node
, size_zero_node
,
11485 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11488 Return NULL_TREE if no simplification was possible, otherwise return the
11489 simplified form of the call as a tree.
11491 The simplified form may be a constant or other expression which
11492 computes the same value, but in a more efficient manner (including
11493 calls to other builtin functions).
11495 The call may contain arguments which need to be evaluated, but
11496 which are not useful to determine the result of the call. In
11497 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11498 COMPOUND_EXPR will be an argument which must be evaluated.
11499 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11500 COMPOUND_EXPR in the chain will contain the tree for the simplified
11501 form of the builtin function call. */
11504 fold_builtin_strcspn (location_t loc
, tree s1
, tree s2
)
11506 if (!validate_arg (s1
, POINTER_TYPE
)
11507 || !validate_arg (s2
, POINTER_TYPE
))
11511 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11513 /* If both arguments are constants, evaluate at compile-time. */
11516 const size_t r
= strcspn (p1
, p2
);
11517 return size_int (r
);
11520 /* If the first argument is "", return NULL_TREE. */
11521 if (p1
&& *p1
== '\0')
11523 /* Evaluate and ignore argument s2 in case it has
11525 return omit_one_operand_loc (loc
, size_type_node
,
11526 size_zero_node
, s2
);
11529 /* If the second argument is "", return __builtin_strlen(s1). */
11530 if (p2
&& *p2
== '\0')
11532 tree fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
11534 /* If the replacement _DECL isn't initialized, don't do the
11539 return build_call_expr_loc (loc
, fn
, 1, s1
);
11545 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
11546 to the call. IGNORE is true if the value returned
11547 by the builtin will be ignored. UNLOCKED is true is true if this
11548 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
11549 the known length of the string. Return NULL_TREE if no simplification
11553 fold_builtin_fputs (location_t loc
, tree arg0
, tree arg1
,
11554 bool ignore
, bool unlocked
, tree len
)
11556 /* If we're using an unlocked function, assume the other unlocked
11557 functions exist explicitly. */
11558 tree
const fn_fputc
= unlocked
? built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
11559 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
11560 tree
const fn_fwrite
= unlocked
? built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
11561 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
11563 /* If the return value is used, don't do the transformation. */
11567 /* Verify the arguments in the original call. */
11568 if (!validate_arg (arg0
, POINTER_TYPE
)
11569 || !validate_arg (arg1
, POINTER_TYPE
))
11573 len
= c_strlen (arg0
, 0);
11575 /* Get the length of the string passed to fputs. If the length
11576 can't be determined, punt. */
11578 || TREE_CODE (len
) != INTEGER_CST
)
11581 switch (compare_tree_int (len
, 1))
11583 case -1: /* length is 0, delete the call entirely . */
11584 return omit_one_operand_loc (loc
, integer_type_node
,
11585 integer_zero_node
, arg1
);;
11587 case 0: /* length is 1, call fputc. */
11589 const char *p
= c_getstr (arg0
);
11594 return build_call_expr_loc (loc
, fn_fputc
, 2,
11595 build_int_cst (NULL_TREE
, p
[0]), arg1
);
11601 case 1: /* length is greater than 1, call fwrite. */
11603 /* If optimizing for size keep fputs. */
11604 if (optimize_function_for_size_p (cfun
))
11606 /* New argument list transforming fputs(string, stream) to
11607 fwrite(string, 1, len, stream). */
11609 return build_call_expr_loc (loc
, fn_fwrite
, 4, arg0
,
11610 size_one_node
, len
, arg1
);
11615 gcc_unreachable ();
11620 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11621 produced. False otherwise. This is done so that we don't output the error
11622 or warning twice or three times. */
11625 fold_builtin_next_arg (tree exp
, bool va_start_p
)
11627 tree fntype
= TREE_TYPE (current_function_decl
);
11628 int nargs
= call_expr_nargs (exp
);
11631 if (!stdarg_p (fntype
))
11633 error ("%<va_start%> used in function with fixed args");
11639 if (va_start_p
&& (nargs
!= 2))
11641 error ("wrong number of arguments to function %<va_start%>");
11644 arg
= CALL_EXPR_ARG (exp
, 1);
11646 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11647 when we checked the arguments and if needed issued a warning. */
11652 /* Evidently an out of date version of <stdarg.h>; can't validate
11653 va_start's second argument, but can still work as intended. */
11654 warning (0, "%<__builtin_next_arg%> called without an argument");
11657 else if (nargs
> 1)
11659 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11662 arg
= CALL_EXPR_ARG (exp
, 0);
11665 if (TREE_CODE (arg
) == SSA_NAME
)
11666 arg
= SSA_NAME_VAR (arg
);
11668 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11669 or __builtin_next_arg (0) the first time we see it, after checking
11670 the arguments and if needed issuing a warning. */
11671 if (!integer_zerop (arg
))
11673 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
11675 /* Strip off all nops for the sake of the comparison. This
11676 is not quite the same as STRIP_NOPS. It does more.
11677 We must also strip off INDIRECT_EXPR for C++ reference
11679 while (CONVERT_EXPR_P (arg
)
11680 || TREE_CODE (arg
) == INDIRECT_REF
)
11681 arg
= TREE_OPERAND (arg
, 0);
11682 if (arg
!= last_parm
)
11684 /* FIXME: Sometimes with the tree optimizers we can get the
11685 not the last argument even though the user used the last
11686 argument. We just warn and set the arg to be the last
11687 argument so that we will get wrong-code because of
11689 warning (0, "second parameter of %<va_start%> not last named argument");
11692 /* Undefined by C99 7.15.1.4p4 (va_start):
11693 "If the parameter parmN is declared with the register storage
11694 class, with a function or array type, or with a type that is
11695 not compatible with the type that results after application of
11696 the default argument promotions, the behavior is undefined."
11698 else if (DECL_REGISTER (arg
))
11699 warning (0, "undefined behaviour when second parameter of "
11700 "%<va_start%> is declared with %<register%> storage");
11702 /* We want to verify the second parameter just once before the tree
11703 optimizers are run and then avoid keeping it in the tree,
11704 as otherwise we could warn even for correct code like:
11705 void foo (int i, ...)
11706 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11708 CALL_EXPR_ARG (exp
, 1) = integer_zero_node
;
11710 CALL_EXPR_ARG (exp
, 0) = integer_zero_node
;
11716 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11717 ORIG may be null if this is a 2-argument call. We don't attempt to
11718 simplify calls with more than 3 arguments.
11720 Return NULL_TREE if no simplification was possible, otherwise return the
11721 simplified form of the call as a tree. If IGNORED is true, it means that
11722 the caller does not use the returned value of the function. */
11725 fold_builtin_sprintf (location_t loc
, tree dest
, tree fmt
,
11726 tree orig
, int ignored
)
11729 const char *fmt_str
= NULL
;
11731 /* Verify the required arguments in the original call. We deal with two
11732 types of sprintf() calls: 'sprintf (str, fmt)' and
11733 'sprintf (dest, "%s", orig)'. */
11734 if (!validate_arg (dest
, POINTER_TYPE
)
11735 || !validate_arg (fmt
, POINTER_TYPE
))
11737 if (orig
&& !validate_arg (orig
, POINTER_TYPE
))
11740 /* Check whether the format is a literal string constant. */
11741 fmt_str
= c_getstr (fmt
);
11742 if (fmt_str
== NULL
)
11746 retval
= NULL_TREE
;
11748 if (!init_target_chars ())
11751 /* If the format doesn't contain % args or %%, use strcpy. */
11752 if (strchr (fmt_str
, target_percent
) == NULL
)
11754 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
11759 /* Don't optimize sprintf (buf, "abc", ptr++). */
11763 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11764 'format' is known to contain no % formats. */
11765 call
= build_call_expr_loc (loc
, fn
, 2, dest
, fmt
);
11767 retval
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
11770 /* If the format is "%s", use strcpy if the result isn't used. */
11771 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
11774 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
11779 /* Don't crash on sprintf (str1, "%s"). */
11783 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
11786 retval
= c_strlen (orig
, 1);
11787 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
11790 call
= build_call_expr_loc (loc
, fn
, 2, dest
, orig
);
11793 if (call
&& retval
)
11795 retval
= fold_convert_loc
11796 (loc
, TREE_TYPE (TREE_TYPE (implicit_built_in_decls
[BUILT_IN_SPRINTF
])),
11798 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);
11804 /* Expand a call EXP to __builtin_object_size. */
11807 expand_builtin_object_size (tree exp
)
11810 int object_size_type
;
11811 tree fndecl
= get_callee_fndecl (exp
);
11813 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11815 error ("%Kfirst argument of %D must be a pointer, second integer constant",
11817 expand_builtin_trap ();
11821 ost
= CALL_EXPR_ARG (exp
, 1);
11824 if (TREE_CODE (ost
) != INTEGER_CST
11825 || tree_int_cst_sgn (ost
) < 0
11826 || compare_tree_int (ost
, 3) > 0)
11828 error ("%Klast argument of %D is not integer constant between 0 and 3",
11830 expand_builtin_trap ();
11834 object_size_type
= tree_low_cst (ost
, 0);
11836 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
11839 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11840 FCODE is the BUILT_IN_* to use.
11841 Return NULL_RTX if we failed; the caller should emit a normal call,
11842 otherwise try to get the result in TARGET, if convenient (and in
11843 mode MODE if that's convenient). */
11846 expand_builtin_memory_chk (tree exp
, rtx target
, enum machine_mode mode
,
11847 enum built_in_function fcode
)
11849 tree dest
, src
, len
, size
;
11851 if (!validate_arglist (exp
,
11853 fcode
== BUILT_IN_MEMSET_CHK
11854 ? INTEGER_TYPE
: POINTER_TYPE
,
11855 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11858 dest
= CALL_EXPR_ARG (exp
, 0);
11859 src
= CALL_EXPR_ARG (exp
, 1);
11860 len
= CALL_EXPR_ARG (exp
, 2);
11861 size
= CALL_EXPR_ARG (exp
, 3);
11863 if (! host_integerp (size
, 1))
11866 if (host_integerp (len
, 1) || integer_all_onesp (size
))
11870 if (! integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
11872 warning_at (tree_nonartificial_location (exp
),
11873 0, "%Kcall to %D will always overflow destination buffer",
11874 exp
, get_callee_fndecl (exp
));
11879 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11880 mem{cpy,pcpy,move,set} is available. */
11883 case BUILT_IN_MEMCPY_CHK
:
11884 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
11886 case BUILT_IN_MEMPCPY_CHK
:
11887 fn
= built_in_decls
[BUILT_IN_MEMPCPY
];
11889 case BUILT_IN_MEMMOVE_CHK
:
11890 fn
= built_in_decls
[BUILT_IN_MEMMOVE
];
11892 case BUILT_IN_MEMSET_CHK
:
11893 fn
= built_in_decls
[BUILT_IN_MEMSET
];
11902 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 3, dest
, src
, len
);
11903 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11904 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11905 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11907 else if (fcode
== BUILT_IN_MEMSET_CHK
)
11911 unsigned int dest_align
11912 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
11914 /* If DEST is not a pointer type, call the normal function. */
11915 if (dest_align
== 0)
11918 /* If SRC and DEST are the same (and not volatile), do nothing. */
11919 if (operand_equal_p (src
, dest
, 0))
11923 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
11925 /* Evaluate and ignore LEN in case it has side-effects. */
11926 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
11927 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
11930 expr
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
11931 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
11934 /* __memmove_chk special case. */
11935 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
11937 unsigned int src_align
11938 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
11940 if (src_align
== 0)
11943 /* If src is categorized for a readonly section we can use
11944 normal __memcpy_chk. */
11945 if (readonly_data_expr (src
))
11947 tree fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
11950 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 4,
11951 dest
, src
, len
, size
);
11952 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11953 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11954 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11961 /* Emit warning if a buffer overflow is detected at compile time. */
11964 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
11968 location_t loc
= tree_nonartificial_location (exp
);
11972 case BUILT_IN_STRCPY_CHK
:
11973 case BUILT_IN_STPCPY_CHK
:
11974 /* For __strcat_chk the warning will be emitted only if overflowing
11975 by at least strlen (dest) + 1 bytes. */
11976 case BUILT_IN_STRCAT_CHK
:
11977 len
= CALL_EXPR_ARG (exp
, 1);
11978 size
= CALL_EXPR_ARG (exp
, 2);
11981 case BUILT_IN_STRNCAT_CHK
:
11982 case BUILT_IN_STRNCPY_CHK
:
11983 len
= CALL_EXPR_ARG (exp
, 2);
11984 size
= CALL_EXPR_ARG (exp
, 3);
11986 case BUILT_IN_SNPRINTF_CHK
:
11987 case BUILT_IN_VSNPRINTF_CHK
:
11988 len
= CALL_EXPR_ARG (exp
, 1);
11989 size
= CALL_EXPR_ARG (exp
, 3);
11992 gcc_unreachable ();
11998 if (! host_integerp (size
, 1) || integer_all_onesp (size
))
12003 len
= c_strlen (len
, 1);
12004 if (! len
|| ! host_integerp (len
, 1) || tree_int_cst_lt (len
, size
))
12007 else if (fcode
== BUILT_IN_STRNCAT_CHK
)
12009 tree src
= CALL_EXPR_ARG (exp
, 1);
12010 if (! src
|| ! host_integerp (len
, 1) || tree_int_cst_lt (len
, size
))
12012 src
= c_strlen (src
, 1);
12013 if (! src
|| ! host_integerp (src
, 1))
12015 warning_at (loc
, 0, "%Kcall to %D might overflow destination buffer",
12016 exp
, get_callee_fndecl (exp
));
12019 else if (tree_int_cst_lt (src
, size
))
12022 else if (! host_integerp (len
, 1) || ! tree_int_cst_lt (size
, len
))
12025 warning_at (loc
, 0, "%Kcall to %D will always overflow destination buffer",
12026 exp
, get_callee_fndecl (exp
));
12029 /* Emit warning if a buffer overflow is detected at compile time
12030 in __sprintf_chk/__vsprintf_chk calls. */
12033 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
12035 tree size
, len
, fmt
;
12036 const char *fmt_str
;
12037 int nargs
= call_expr_nargs (exp
);
12039 /* Verify the required arguments in the original call. */
12043 size
= CALL_EXPR_ARG (exp
, 2);
12044 fmt
= CALL_EXPR_ARG (exp
, 3);
12046 if (! host_integerp (size
, 1) || integer_all_onesp (size
))
12049 /* Check whether the format is a literal string constant. */
12050 fmt_str
= c_getstr (fmt
);
12051 if (fmt_str
== NULL
)
12054 if (!init_target_chars ())
12057 /* If the format doesn't contain % args or %%, we know its size. */
12058 if (strchr (fmt_str
, target_percent
) == 0)
12059 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
12060 /* If the format is "%s" and first ... argument is a string literal,
12062 else if (fcode
== BUILT_IN_SPRINTF_CHK
12063 && strcmp (fmt_str
, target_percent_s
) == 0)
12069 arg
= CALL_EXPR_ARG (exp
, 4);
12070 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
12073 len
= c_strlen (arg
, 1);
12074 if (!len
|| ! host_integerp (len
, 1))
12080 if (! tree_int_cst_lt (len
, size
))
12081 warning_at (tree_nonartificial_location (exp
),
12082 0, "%Kcall to %D will always overflow destination buffer",
12083 exp
, get_callee_fndecl (exp
));
12086 /* Emit warning if a free is called with address of a variable. */
12089 maybe_emit_free_warning (tree exp
)
12091 tree arg
= CALL_EXPR_ARG (exp
, 0);
12094 if (TREE_CODE (arg
) != ADDR_EXPR
)
12097 arg
= get_base_address (TREE_OPERAND (arg
, 0));
12098 if (arg
== NULL
|| INDIRECT_REF_P (arg
) || TREE_CODE (arg
) == MEM_REF
)
12101 if (SSA_VAR_P (arg
))
12102 warning_at (tree_nonartificial_location (exp
),
12103 0, "%Kattempt to free a non-heap object %qD", exp
, arg
);
12105 warning_at (tree_nonartificial_location (exp
),
12106 0, "%Kattempt to free a non-heap object", exp
);
12109 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12113 fold_builtin_object_size (tree ptr
, tree ost
)
12115 unsigned HOST_WIDE_INT bytes
;
12116 int object_size_type
;
12118 if (!validate_arg (ptr
, POINTER_TYPE
)
12119 || !validate_arg (ost
, INTEGER_TYPE
))
12124 if (TREE_CODE (ost
) != INTEGER_CST
12125 || tree_int_cst_sgn (ost
) < 0
12126 || compare_tree_int (ost
, 3) > 0)
12129 object_size_type
= tree_low_cst (ost
, 0);
12131 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12132 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12133 and (size_t) 0 for types 2 and 3. */
12134 if (TREE_SIDE_EFFECTS (ptr
))
12135 return build_int_cst_type (size_type_node
, object_size_type
< 2 ? -1 : 0);
12137 if (TREE_CODE (ptr
) == ADDR_EXPR
)
12139 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
12140 if (double_int_fits_to_tree_p (size_type_node
,
12141 uhwi_to_double_int (bytes
)))
12142 return build_int_cstu (size_type_node
, bytes
);
12144 else if (TREE_CODE (ptr
) == SSA_NAME
)
12146 /* If object size is not known yet, delay folding until
12147 later. Maybe subsequent passes will help determining
12149 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
12150 if (bytes
!= (unsigned HOST_WIDE_INT
) (object_size_type
< 2 ? -1 : 0)
12151 && double_int_fits_to_tree_p (size_type_node
,
12152 uhwi_to_double_int (bytes
)))
12153 return build_int_cstu (size_type_node
, bytes
);
12159 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12160 DEST, SRC, LEN, and SIZE are the arguments to the call.
12161 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12162 code of the builtin. If MAXLEN is not NULL, it is maximum length
12163 passed as third argument. */
12166 fold_builtin_memory_chk (location_t loc
, tree fndecl
,
12167 tree dest
, tree src
, tree len
, tree size
,
12168 tree maxlen
, bool ignore
,
12169 enum built_in_function fcode
)
12173 if (!validate_arg (dest
, POINTER_TYPE
)
12174 || !validate_arg (src
,
12175 (fcode
== BUILT_IN_MEMSET_CHK
12176 ? INTEGER_TYPE
: POINTER_TYPE
))
12177 || !validate_arg (len
, INTEGER_TYPE
)
12178 || !validate_arg (size
, INTEGER_TYPE
))
12181 /* If SRC and DEST are the same (and not volatile), return DEST
12182 (resp. DEST+LEN for __mempcpy_chk). */
12183 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
12185 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
12186 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
12190 tree temp
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (dest
),
12192 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), temp
);
12196 if (! host_integerp (size
, 1))
12199 if (! integer_all_onesp (size
))
12201 if (! host_integerp (len
, 1))
12203 /* If LEN is not constant, try MAXLEN too.
12204 For MAXLEN only allow optimizing into non-_ocs function
12205 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12206 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
12208 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
12210 /* (void) __mempcpy_chk () can be optimized into
12211 (void) __memcpy_chk (). */
12212 fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
12216 return build_call_expr_loc (loc
, fn
, 4, dest
, src
, len
, size
);
12224 if (tree_int_cst_lt (size
, maxlen
))
12229 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12230 mem{cpy,pcpy,move,set} is available. */
12233 case BUILT_IN_MEMCPY_CHK
:
12234 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
12236 case BUILT_IN_MEMPCPY_CHK
:
12237 fn
= built_in_decls
[BUILT_IN_MEMPCPY
];
12239 case BUILT_IN_MEMMOVE_CHK
:
12240 fn
= built_in_decls
[BUILT_IN_MEMMOVE
];
12242 case BUILT_IN_MEMSET_CHK
:
12243 fn
= built_in_decls
[BUILT_IN_MEMSET
];
12252 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
12255 /* Fold a call to the __st[rp]cpy_chk builtin.
12256 DEST, SRC, and SIZE are the arguments to the call.
12257 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12258 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12259 strings passed as second argument. */
12262 fold_builtin_stxcpy_chk (location_t loc
, tree fndecl
, tree dest
,
12263 tree src
, tree size
,
12264 tree maxlen
, bool ignore
,
12265 enum built_in_function fcode
)
12269 if (!validate_arg (dest
, POINTER_TYPE
)
12270 || !validate_arg (src
, POINTER_TYPE
)
12271 || !validate_arg (size
, INTEGER_TYPE
))
12274 /* If SRC and DEST are the same (and not volatile), return DEST. */
12275 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
12276 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
12278 if (! host_integerp (size
, 1))
12281 if (! integer_all_onesp (size
))
12283 len
= c_strlen (src
, 1);
12284 if (! len
|| ! host_integerp (len
, 1))
12286 /* If LEN is not constant, try MAXLEN too.
12287 For MAXLEN only allow optimizing into non-_ocs function
12288 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12289 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
12291 if (fcode
== BUILT_IN_STPCPY_CHK
)
12296 /* If return value of __stpcpy_chk is ignored,
12297 optimize into __strcpy_chk. */
12298 fn
= built_in_decls
[BUILT_IN_STRCPY_CHK
];
12302 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, size
);
12305 if (! len
|| TREE_SIDE_EFFECTS (len
))
12308 /* If c_strlen returned something, but not a constant,
12309 transform __strcpy_chk into __memcpy_chk. */
12310 fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
12314 len
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
12315 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
12316 build_call_expr_loc (loc
, fn
, 4,
12317 dest
, src
, len
, size
));
12323 if (! tree_int_cst_lt (maxlen
, size
))
12327 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12328 fn
= built_in_decls
[fcode
== BUILT_IN_STPCPY_CHK
12329 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
];
12333 return build_call_expr_loc (loc
, fn
, 2, dest
, src
);
12336 /* Fold a call to the __strncpy_chk builtin. DEST, SRC, LEN, and SIZE
12337 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12338 length passed as third argument. */
12341 fold_builtin_strncpy_chk (location_t loc
, tree dest
, tree src
,
12342 tree len
, tree size
, tree maxlen
)
12346 if (!validate_arg (dest
, POINTER_TYPE
)
12347 || !validate_arg (src
, POINTER_TYPE
)
12348 || !validate_arg (len
, INTEGER_TYPE
)
12349 || !validate_arg (size
, INTEGER_TYPE
))
12352 if (! host_integerp (size
, 1))
12355 if (! integer_all_onesp (size
))
12357 if (! host_integerp (len
, 1))
12359 /* If LEN is not constant, try MAXLEN too.
12360 For MAXLEN only allow optimizing into non-_ocs function
12361 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12362 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
12368 if (tree_int_cst_lt (size
, maxlen
))
12372 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
12373 fn
= built_in_decls
[BUILT_IN_STRNCPY
];
12377 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
12380 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12381 are the arguments to the call. */
12384 fold_builtin_strcat_chk (location_t loc
, tree fndecl
, tree dest
,
12385 tree src
, tree size
)
12390 if (!validate_arg (dest
, POINTER_TYPE
)
12391 || !validate_arg (src
, POINTER_TYPE
)
12392 || !validate_arg (size
, INTEGER_TYPE
))
12395 p
= c_getstr (src
);
12396 /* If the SRC parameter is "", return DEST. */
12397 if (p
&& *p
== '\0')
12398 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
12400 if (! host_integerp (size
, 1) || ! integer_all_onesp (size
))
12403 /* If __builtin_strcat_chk is used, assume strcat is available. */
12404 fn
= built_in_decls
[BUILT_IN_STRCAT
];
12408 return build_call_expr_loc (loc
, fn
, 2, dest
, src
);
12411 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12415 fold_builtin_strncat_chk (location_t loc
, tree fndecl
,
12416 tree dest
, tree src
, tree len
, tree size
)
12421 if (!validate_arg (dest
, POINTER_TYPE
)
12422 || !validate_arg (src
, POINTER_TYPE
)
12423 || !validate_arg (size
, INTEGER_TYPE
)
12424 || !validate_arg (size
, INTEGER_TYPE
))
12427 p
= c_getstr (src
);
12428 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
12429 if (p
&& *p
== '\0')
12430 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
12431 else if (integer_zerop (len
))
12432 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
12434 if (! host_integerp (size
, 1))
12437 if (! integer_all_onesp (size
))
12439 tree src_len
= c_strlen (src
, 1);
12441 && host_integerp (src_len
, 1)
12442 && host_integerp (len
, 1)
12443 && ! tree_int_cst_lt (len
, src_len
))
12445 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
12446 fn
= built_in_decls
[BUILT_IN_STRCAT_CHK
];
12450 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, size
);
12455 /* If __builtin_strncat_chk is used, assume strncat is available. */
12456 fn
= built_in_decls
[BUILT_IN_STRNCAT
];
12460 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
12463 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
12464 a normal call should be emitted rather than expanding the function
12465 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
12468 fold_builtin_sprintf_chk (location_t loc
, tree exp
,
12469 enum built_in_function fcode
)
12471 tree dest
, size
, len
, fn
, fmt
, flag
;
12472 const char *fmt_str
;
12473 int nargs
= call_expr_nargs (exp
);
12475 /* Verify the required arguments in the original call. */
12478 dest
= CALL_EXPR_ARG (exp
, 0);
12479 if (!validate_arg (dest
, POINTER_TYPE
))
12481 flag
= CALL_EXPR_ARG (exp
, 1);
12482 if (!validate_arg (flag
, INTEGER_TYPE
))
12484 size
= CALL_EXPR_ARG (exp
, 2);
12485 if (!validate_arg (size
, INTEGER_TYPE
))
12487 fmt
= CALL_EXPR_ARG (exp
, 3);
12488 if (!validate_arg (fmt
, POINTER_TYPE
))
12491 if (! host_integerp (size
, 1))
12496 if (!init_target_chars ())
12499 /* Check whether the format is a literal string constant. */
12500 fmt_str
= c_getstr (fmt
);
12501 if (fmt_str
!= NULL
)
12503 /* If the format doesn't contain % args or %%, we know the size. */
12504 if (strchr (fmt_str
, target_percent
) == 0)
12506 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| nargs
== 4)
12507 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
12509 /* If the format is "%s" and first ... argument is a string literal,
12510 we know the size too. */
12511 else if (fcode
== BUILT_IN_SPRINTF_CHK
12512 && strcmp (fmt_str
, target_percent_s
) == 0)
12518 arg
= CALL_EXPR_ARG (exp
, 4);
12519 if (validate_arg (arg
, POINTER_TYPE
))
12521 len
= c_strlen (arg
, 1);
12522 if (! len
|| ! host_integerp (len
, 1))
12529 if (! integer_all_onesp (size
))
12531 if (! len
|| ! tree_int_cst_lt (len
, size
))
12535 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12536 or if format doesn't contain % chars or is "%s". */
12537 if (! integer_zerop (flag
))
12539 if (fmt_str
== NULL
)
12541 if (strchr (fmt_str
, target_percent
) != NULL
12542 && strcmp (fmt_str
, target_percent_s
))
12546 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
12547 fn
= built_in_decls
[fcode
== BUILT_IN_VSPRINTF_CHK
12548 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
];
12552 return rewrite_call_expr (loc
, exp
, 4, fn
, 2, dest
, fmt
);
12555 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
12556 a normal call should be emitted rather than expanding the function
12557 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
12558 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
12559 passed as second argument. */
12562 fold_builtin_snprintf_chk (location_t loc
, tree exp
, tree maxlen
,
12563 enum built_in_function fcode
)
12565 tree dest
, size
, len
, fn
, fmt
, flag
;
12566 const char *fmt_str
;
12568 /* Verify the required arguments in the original call. */
12569 if (call_expr_nargs (exp
) < 5)
12571 dest
= CALL_EXPR_ARG (exp
, 0);
12572 if (!validate_arg (dest
, POINTER_TYPE
))
12574 len
= CALL_EXPR_ARG (exp
, 1);
12575 if (!validate_arg (len
, INTEGER_TYPE
))
12577 flag
= CALL_EXPR_ARG (exp
, 2);
12578 if (!validate_arg (flag
, INTEGER_TYPE
))
12580 size
= CALL_EXPR_ARG (exp
, 3);
12581 if (!validate_arg (size
, INTEGER_TYPE
))
12583 fmt
= CALL_EXPR_ARG (exp
, 4);
12584 if (!validate_arg (fmt
, POINTER_TYPE
))
12587 if (! host_integerp (size
, 1))
12590 if (! integer_all_onesp (size
))
12592 if (! host_integerp (len
, 1))
12594 /* If LEN is not constant, try MAXLEN too.
12595 For MAXLEN only allow optimizing into non-_ocs function
12596 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12597 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
12603 if (tree_int_cst_lt (size
, maxlen
))
12607 if (!init_target_chars ())
12610 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12611 or if format doesn't contain % chars or is "%s". */
12612 if (! integer_zerop (flag
))
12614 fmt_str
= c_getstr (fmt
);
12615 if (fmt_str
== NULL
)
12617 if (strchr (fmt_str
, target_percent
) != NULL
12618 && strcmp (fmt_str
, target_percent_s
))
12622 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12624 fn
= built_in_decls
[fcode
== BUILT_IN_VSNPRINTF_CHK
12625 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
];
12629 return rewrite_call_expr (loc
, exp
, 5, fn
, 3, dest
, len
, fmt
);
12632 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12633 FMT and ARG are the arguments to the call; we don't fold cases with
12634 more than 2 arguments, and ARG may be null if this is a 1-argument case.
12636 Return NULL_TREE if no simplification was possible, otherwise return the
12637 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12638 code of the function to be simplified. */
12641 fold_builtin_printf (location_t loc
, tree fndecl
, tree fmt
,
12642 tree arg
, bool ignore
,
12643 enum built_in_function fcode
)
12645 tree fn_putchar
, fn_puts
, newarg
, call
= NULL_TREE
;
12646 const char *fmt_str
= NULL
;
12648 /* If the return value is used, don't do the transformation. */
12652 /* Verify the required arguments in the original call. */
12653 if (!validate_arg (fmt
, POINTER_TYPE
))
12656 /* Check whether the format is a literal string constant. */
12657 fmt_str
= c_getstr (fmt
);
12658 if (fmt_str
== NULL
)
12661 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
12663 /* If we're using an unlocked function, assume the other
12664 unlocked functions exist explicitly. */
12665 fn_putchar
= built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
];
12666 fn_puts
= built_in_decls
[BUILT_IN_PUTS_UNLOCKED
];
12670 fn_putchar
= implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
12671 fn_puts
= implicit_built_in_decls
[BUILT_IN_PUTS
];
12674 if (!init_target_chars ())
12677 if (strcmp (fmt_str
, target_percent_s
) == 0
12678 || strchr (fmt_str
, target_percent
) == NULL
)
12682 if (strcmp (fmt_str
, target_percent_s
) == 0)
12684 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
12687 if (!arg
|| !validate_arg (arg
, POINTER_TYPE
))
12690 str
= c_getstr (arg
);
12696 /* The format specifier doesn't contain any '%' characters. */
12697 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
12703 /* If the string was "", printf does nothing. */
12704 if (str
[0] == '\0')
12705 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
12707 /* If the string has length of 1, call putchar. */
12708 if (str
[1] == '\0')
12710 /* Given printf("c"), (where c is any one character,)
12711 convert "c"[0] to an int and pass that to the replacement
12713 newarg
= build_int_cst (NULL_TREE
, str
[0]);
12715 call
= build_call_expr_loc (loc
, fn_putchar
, 1, newarg
);
12719 /* If the string was "string\n", call puts("string"). */
12720 size_t len
= strlen (str
);
12721 if ((unsigned char)str
[len
- 1] == target_newline
)
12723 /* Create a NUL-terminated string that's one char shorter
12724 than the original, stripping off the trailing '\n'. */
12725 char *newstr
= XALLOCAVEC (char, len
);
12726 memcpy (newstr
, str
, len
- 1);
12727 newstr
[len
- 1] = 0;
12729 newarg
= build_string_literal (len
, newstr
);
12731 call
= build_call_expr_loc (loc
, fn_puts
, 1, newarg
);
12734 /* We'd like to arrange to call fputs(string,stdout) here,
12735 but we need stdout and don't have a way to get it yet. */
12740 /* The other optimizations can be done only on the non-va_list variants. */
12741 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
12744 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
12745 else if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
12747 if (!arg
|| !validate_arg (arg
, POINTER_TYPE
))
12750 call
= build_call_expr_loc (loc
, fn_puts
, 1, arg
);
12753 /* If the format specifier was "%c", call __builtin_putchar(arg). */
12754 else if (strcmp (fmt_str
, target_percent_c
) == 0)
12756 if (!arg
|| !validate_arg (arg
, INTEGER_TYPE
))
12759 call
= build_call_expr_loc (loc
, fn_putchar
, 1, arg
);
12765 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), call
);
12768 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12769 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
12770 more than 3 arguments, and ARG may be null in the 2-argument case.
12772 Return NULL_TREE if no simplification was possible, otherwise return the
12773 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12774 code of the function to be simplified. */
12777 fold_builtin_fprintf (location_t loc
, tree fndecl
, tree fp
,
12778 tree fmt
, tree arg
, bool ignore
,
12779 enum built_in_function fcode
)
12781 tree fn_fputc
, fn_fputs
, call
= NULL_TREE
;
12782 const char *fmt_str
= NULL
;
12784 /* If the return value is used, don't do the transformation. */
12788 /* Verify the required arguments in the original call. */
12789 if (!validate_arg (fp
, POINTER_TYPE
))
12791 if (!validate_arg (fmt
, POINTER_TYPE
))
12794 /* Check whether the format is a literal string constant. */
12795 fmt_str
= c_getstr (fmt
);
12796 if (fmt_str
== NULL
)
12799 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
12801 /* If we're using an unlocked function, assume the other
12802 unlocked functions exist explicitly. */
12803 fn_fputc
= built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
];
12804 fn_fputs
= built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
];
12808 fn_fputc
= implicit_built_in_decls
[BUILT_IN_FPUTC
];
12809 fn_fputs
= implicit_built_in_decls
[BUILT_IN_FPUTS
];
12812 if (!init_target_chars ())
12815 /* If the format doesn't contain % args or %%, use strcpy. */
12816 if (strchr (fmt_str
, target_percent
) == NULL
)
12818 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
12822 /* If the format specifier was "", fprintf does nothing. */
12823 if (fmt_str
[0] == '\0')
12825 /* If FP has side-effects, just wait until gimplification is
12827 if (TREE_SIDE_EFFECTS (fp
))
12830 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
12833 /* When "string" doesn't contain %, replace all cases of
12834 fprintf (fp, string) with fputs (string, fp). The fputs
12835 builtin will take care of special cases like length == 1. */
12837 call
= build_call_expr_loc (loc
, fn_fputs
, 2, fmt
, fp
);
12840 /* The other optimizations can be done only on the non-va_list variants. */
12841 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
12844 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
12845 else if (strcmp (fmt_str
, target_percent_s
) == 0)
12847 if (!arg
|| !validate_arg (arg
, POINTER_TYPE
))
12850 call
= build_call_expr_loc (loc
, fn_fputs
, 2, arg
, fp
);
12853 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
12854 else if (strcmp (fmt_str
, target_percent_c
) == 0)
12856 if (!arg
|| !validate_arg (arg
, INTEGER_TYPE
))
12859 call
= build_call_expr_loc (loc
, fn_fputc
, 2, arg
, fp
);
12864 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), call
);
12867 /* Initialize format string characters in the target charset. */
12870 init_target_chars (void)
12875 target_newline
= lang_hooks
.to_target_charset ('\n');
12876 target_percent
= lang_hooks
.to_target_charset ('%');
12877 target_c
= lang_hooks
.to_target_charset ('c');
12878 target_s
= lang_hooks
.to_target_charset ('s');
12879 if (target_newline
== 0 || target_percent
== 0 || target_c
== 0
12883 target_percent_c
[0] = target_percent
;
12884 target_percent_c
[1] = target_c
;
12885 target_percent_c
[2] = '\0';
12887 target_percent_s
[0] = target_percent
;
12888 target_percent_s
[1] = target_s
;
12889 target_percent_s
[2] = '\0';
12891 target_percent_s_newline
[0] = target_percent
;
12892 target_percent_s_newline
[1] = target_s
;
12893 target_percent_s_newline
[2] = target_newline
;
12894 target_percent_s_newline
[3] = '\0';
12901 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
12902 and no overflow/underflow occurred. INEXACT is true if M was not
12903 exactly calculated. TYPE is the tree type for the result. This
12904 function assumes that you cleared the MPFR flags and then
12905 calculated M to see if anything subsequently set a flag prior to
12906 entering this function. Return NULL_TREE if any checks fail. */
12909 do_mpfr_ckconv (mpfr_srcptr m
, tree type
, int inexact
)
12911 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12912 overflow/underflow occurred. If -frounding-math, proceed iff the
12913 result of calling FUNC was exact. */
12914 if (mpfr_number_p (m
) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12915 && (!flag_rounding_math
|| !inexact
))
12917 REAL_VALUE_TYPE rr
;
12919 real_from_mpfr (&rr
, m
, type
, GMP_RNDN
);
12920 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12921 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
12922 but the mpft_t is not, then we underflowed in the
12924 if (real_isfinite (&rr
)
12925 && (rr
.cl
== rvc_zero
) == (mpfr_zero_p (m
) != 0))
12927 REAL_VALUE_TYPE rmode
;
12929 real_convert (&rmode
, TYPE_MODE (type
), &rr
);
12930 /* Proceed iff the specified mode can hold the value. */
12931 if (real_identical (&rmode
, &rr
))
12932 return build_real (type
, rmode
);
12938 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
12939 number and no overflow/underflow occurred. INEXACT is true if M
12940 was not exactly calculated. TYPE is the tree type for the result.
12941 This function assumes that you cleared the MPFR flags and then
12942 calculated M to see if anything subsequently set a flag prior to
12943 entering this function. Return NULL_TREE if any checks fail, if
12944 FORCE_CONVERT is true, then bypass the checks. */
12947 do_mpc_ckconv (mpc_srcptr m
, tree type
, int inexact
, int force_convert
)
12949 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12950 overflow/underflow occurred. If -frounding-math, proceed iff the
12951 result of calling FUNC was exact. */
12953 || (mpfr_number_p (mpc_realref (m
)) && mpfr_number_p (mpc_imagref (m
))
12954 && !mpfr_overflow_p () && !mpfr_underflow_p ()
12955 && (!flag_rounding_math
|| !inexact
)))
12957 REAL_VALUE_TYPE re
, im
;
12959 real_from_mpfr (&re
, mpc_realref (m
), TREE_TYPE (type
), GMP_RNDN
);
12960 real_from_mpfr (&im
, mpc_imagref (m
), TREE_TYPE (type
), GMP_RNDN
);
12961 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
12962 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
12963 but the mpft_t is not, then we underflowed in the
12966 || (real_isfinite (&re
) && real_isfinite (&im
)
12967 && (re
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_realref (m
)) != 0)
12968 && (im
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_imagref (m
)) != 0)))
12970 REAL_VALUE_TYPE re_mode
, im_mode
;
12972 real_convert (&re_mode
, TYPE_MODE (TREE_TYPE (type
)), &re
);
12973 real_convert (&im_mode
, TYPE_MODE (TREE_TYPE (type
)), &im
);
12974 /* Proceed iff the specified mode can hold the value. */
12976 || (real_identical (&re_mode
, &re
)
12977 && real_identical (&im_mode
, &im
)))
12978 return build_complex (type
, build_real (TREE_TYPE (type
), re_mode
),
12979 build_real (TREE_TYPE (type
), im_mode
));
12985 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
12986 FUNC on it and return the resulting value as a tree with type TYPE.
12987 If MIN and/or MAX are not NULL, then the supplied ARG must be
12988 within those bounds. If INCLUSIVE is true, then MIN/MAX are
12989 acceptable values, otherwise they are not. The mpfr precision is
12990 set to the precision of TYPE. We assume that function FUNC returns
12991 zero if the result could be calculated exactly within the requested
12995 do_mpfr_arg1 (tree arg
, tree type
, int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
12996 const REAL_VALUE_TYPE
*min
, const REAL_VALUE_TYPE
*max
,
12999 tree result
= NULL_TREE
;
13003 /* To proceed, MPFR must exactly represent the target floating point
13004 format, which only happens when the target base equals two. */
13005 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13006 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
13008 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
13010 if (real_isfinite (ra
)
13011 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
))
13012 && (!max
|| real_compare (inclusive
? LE_EXPR
: LT_EXPR
, ra
, max
)))
13014 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13015 const int prec
= fmt
->p
;
13016 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13020 mpfr_init2 (m
, prec
);
13021 mpfr_from_real (m
, ra
, GMP_RNDN
);
13022 mpfr_clear_flags ();
13023 inexact
= func (m
, m
, rnd
);
13024 result
= do_mpfr_ckconv (m
, type
, inexact
);
13032 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13033 FUNC on it and return the resulting value as a tree with type TYPE.
13034 The mpfr precision is set to the precision of TYPE. We assume that
13035 function FUNC returns zero if the result could be calculated
13036 exactly within the requested precision. */
13039 do_mpfr_arg2 (tree arg1
, tree arg2
, tree type
,
13040 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
13042 tree result
= NULL_TREE
;
13047 /* To proceed, MPFR must exactly represent the target floating point
13048 format, which only happens when the target base equals two. */
13049 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13050 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
13051 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
13053 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
13054 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
13056 if (real_isfinite (ra1
) && real_isfinite (ra2
))
13058 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13059 const int prec
= fmt
->p
;
13060 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13064 mpfr_inits2 (prec
, m1
, m2
, NULL
);
13065 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
13066 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
13067 mpfr_clear_flags ();
13068 inexact
= func (m1
, m1
, m2
, rnd
);
13069 result
= do_mpfr_ckconv (m1
, type
, inexact
);
13070 mpfr_clears (m1
, m2
, NULL
);
13077 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13078 FUNC on it and return the resulting value as a tree with type TYPE.
13079 The mpfr precision is set to the precision of TYPE. We assume that
13080 function FUNC returns zero if the result could be calculated
13081 exactly within the requested precision. */
13084 do_mpfr_arg3 (tree arg1
, tree arg2
, tree arg3
, tree type
,
13085 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
13087 tree result
= NULL_TREE
;
13093 /* To proceed, MPFR must exactly represent the target floating point
13094 format, which only happens when the target base equals two. */
13095 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13096 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
13097 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
)
13098 && TREE_CODE (arg3
) == REAL_CST
&& !TREE_OVERFLOW (arg3
))
13100 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
13101 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
13102 const REAL_VALUE_TYPE
*const ra3
= &TREE_REAL_CST (arg3
);
13104 if (real_isfinite (ra1
) && real_isfinite (ra2
) && real_isfinite (ra3
))
13106 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13107 const int prec
= fmt
->p
;
13108 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13112 mpfr_inits2 (prec
, m1
, m2
, m3
, NULL
);
13113 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
13114 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
13115 mpfr_from_real (m3
, ra3
, GMP_RNDN
);
13116 mpfr_clear_flags ();
13117 inexact
= func (m1
, m1
, m2
, m3
, rnd
);
13118 result
= do_mpfr_ckconv (m1
, type
, inexact
);
13119 mpfr_clears (m1
, m2
, m3
, NULL
);
13126 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13127 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13128 If ARG_SINP and ARG_COSP are NULL then the result is returned
13129 as a complex value.
13130 The type is taken from the type of ARG and is used for setting the
13131 precision of the calculation and results. */
13134 do_mpfr_sincos (tree arg
, tree arg_sinp
, tree arg_cosp
)
13136 tree
const type
= TREE_TYPE (arg
);
13137 tree result
= NULL_TREE
;
13141 /* To proceed, MPFR must exactly represent the target floating point
13142 format, which only happens when the target base equals two. */
13143 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13144 && TREE_CODE (arg
) == REAL_CST
13145 && !TREE_OVERFLOW (arg
))
13147 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
13149 if (real_isfinite (ra
))
13151 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13152 const int prec
= fmt
->p
;
13153 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13154 tree result_s
, result_c
;
13158 mpfr_inits2 (prec
, m
, ms
, mc
, NULL
);
13159 mpfr_from_real (m
, ra
, GMP_RNDN
);
13160 mpfr_clear_flags ();
13161 inexact
= mpfr_sin_cos (ms
, mc
, m
, rnd
);
13162 result_s
= do_mpfr_ckconv (ms
, type
, inexact
);
13163 result_c
= do_mpfr_ckconv (mc
, type
, inexact
);
13164 mpfr_clears (m
, ms
, mc
, NULL
);
13165 if (result_s
&& result_c
)
13167 /* If we are to return in a complex value do so. */
13168 if (!arg_sinp
&& !arg_cosp
)
13169 return build_complex (build_complex_type (type
),
13170 result_c
, result_s
);
13172 /* Dereference the sin/cos pointer arguments. */
13173 arg_sinp
= build_fold_indirect_ref (arg_sinp
);
13174 arg_cosp
= build_fold_indirect_ref (arg_cosp
);
13175 /* Proceed if valid pointer type were passed in. */
13176 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp
)) == TYPE_MAIN_VARIANT (type
)
13177 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp
)) == TYPE_MAIN_VARIANT (type
))
13179 /* Set the values. */
13180 result_s
= fold_build2 (MODIFY_EXPR
, type
, arg_sinp
,
13182 TREE_SIDE_EFFECTS (result_s
) = 1;
13183 result_c
= fold_build2 (MODIFY_EXPR
, type
, arg_cosp
,
13185 TREE_SIDE_EFFECTS (result_c
) = 1;
13186 /* Combine the assignments into a compound expr. */
13187 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
13188 result_s
, result_c
));
13196 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13197 two-argument mpfr order N Bessel function FUNC on them and return
13198 the resulting value as a tree with type TYPE. The mpfr precision
13199 is set to the precision of TYPE. We assume that function FUNC
13200 returns zero if the result could be calculated exactly within the
13201 requested precision. */
13203 do_mpfr_bessel_n (tree arg1
, tree arg2
, tree type
,
13204 int (*func
)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
13205 const REAL_VALUE_TYPE
*min
, bool inclusive
)
13207 tree result
= NULL_TREE
;
13212 /* To proceed, MPFR must exactly represent the target floating point
13213 format, which only happens when the target base equals two. */
13214 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13215 && host_integerp (arg1
, 0)
13216 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
13218 const HOST_WIDE_INT n
= tree_low_cst(arg1
, 0);
13219 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg2
);
13222 && real_isfinite (ra
)
13223 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
)))
13225 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13226 const int prec
= fmt
->p
;
13227 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13231 mpfr_init2 (m
, prec
);
13232 mpfr_from_real (m
, ra
, GMP_RNDN
);
13233 mpfr_clear_flags ();
13234 inexact
= func (m
, n
, m
, rnd
);
13235 result
= do_mpfr_ckconv (m
, type
, inexact
);
13243 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13244 the pointer *(ARG_QUO) and return the result. The type is taken
13245 from the type of ARG0 and is used for setting the precision of the
13246 calculation and results. */
13249 do_mpfr_remquo (tree arg0
, tree arg1
, tree arg_quo
)
13251 tree
const type
= TREE_TYPE (arg0
);
13252 tree result
= NULL_TREE
;
13257 /* To proceed, MPFR must exactly represent the target floating point
13258 format, which only happens when the target base equals two. */
13259 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13260 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
13261 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
))
13263 const REAL_VALUE_TYPE
*const ra0
= TREE_REAL_CST_PTR (arg0
);
13264 const REAL_VALUE_TYPE
*const ra1
= TREE_REAL_CST_PTR (arg1
);
13266 if (real_isfinite (ra0
) && real_isfinite (ra1
))
13268 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13269 const int prec
= fmt
->p
;
13270 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13275 mpfr_inits2 (prec
, m0
, m1
, NULL
);
13276 mpfr_from_real (m0
, ra0
, GMP_RNDN
);
13277 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
13278 mpfr_clear_flags ();
13279 mpfr_remquo (m0
, &integer_quo
, m0
, m1
, rnd
);
13280 /* Remquo is independent of the rounding mode, so pass
13281 inexact=0 to do_mpfr_ckconv(). */
13282 result_rem
= do_mpfr_ckconv (m0
, type
, /*inexact=*/ 0);
13283 mpfr_clears (m0
, m1
, NULL
);
13286 /* MPFR calculates quo in the host's long so it may
13287 return more bits in quo than the target int can hold
13288 if sizeof(host long) > sizeof(target int). This can
13289 happen even for native compilers in LP64 mode. In
13290 these cases, modulo the quo value with the largest
13291 number that the target int can hold while leaving one
13292 bit for the sign. */
13293 if (sizeof (integer_quo
) * CHAR_BIT
> INT_TYPE_SIZE
)
13294 integer_quo
%= (long)(1UL << (INT_TYPE_SIZE
- 1));
13296 /* Dereference the quo pointer argument. */
13297 arg_quo
= build_fold_indirect_ref (arg_quo
);
13298 /* Proceed iff a valid pointer type was passed in. */
13299 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo
)) == integer_type_node
)
13301 /* Set the value. */
13302 tree result_quo
= fold_build2 (MODIFY_EXPR
,
13303 TREE_TYPE (arg_quo
), arg_quo
,
13304 build_int_cst (NULL
, integer_quo
));
13305 TREE_SIDE_EFFECTS (result_quo
) = 1;
13306 /* Combine the quo assignment with the rem. */
13307 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
13308 result_quo
, result_rem
));
13316 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13317 resulting value as a tree with type TYPE. The mpfr precision is
13318 set to the precision of TYPE. We assume that this mpfr function
13319 returns zero if the result could be calculated exactly within the
13320 requested precision. In addition, the integer pointer represented
13321 by ARG_SG will be dereferenced and set to the appropriate signgam
13325 do_mpfr_lgamma_r (tree arg
, tree arg_sg
, tree type
)
13327 tree result
= NULL_TREE
;
13331 /* To proceed, MPFR must exactly represent the target floating point
13332 format, which only happens when the target base equals two. Also
13333 verify ARG is a constant and that ARG_SG is an int pointer. */
13334 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13335 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
)
13336 && TREE_CODE (TREE_TYPE (arg_sg
)) == POINTER_TYPE
13337 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg
))) == integer_type_node
)
13339 const REAL_VALUE_TYPE
*const ra
= TREE_REAL_CST_PTR (arg
);
13341 /* In addition to NaN and Inf, the argument cannot be zero or a
13342 negative integer. */
13343 if (real_isfinite (ra
)
13344 && ra
->cl
!= rvc_zero
13345 && !(real_isneg(ra
) && real_isinteger(ra
, TYPE_MODE (type
))))
13347 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13348 const int prec
= fmt
->p
;
13349 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13354 mpfr_init2 (m
, prec
);
13355 mpfr_from_real (m
, ra
, GMP_RNDN
);
13356 mpfr_clear_flags ();
13357 inexact
= mpfr_lgamma (m
, &sg
, m
, rnd
);
13358 result_lg
= do_mpfr_ckconv (m
, type
, inexact
);
13364 /* Dereference the arg_sg pointer argument. */
13365 arg_sg
= build_fold_indirect_ref (arg_sg
);
13366 /* Assign the signgam value into *arg_sg. */
13367 result_sg
= fold_build2 (MODIFY_EXPR
,
13368 TREE_TYPE (arg_sg
), arg_sg
,
13369 build_int_cst (NULL
, sg
));
13370 TREE_SIDE_EFFECTS (result_sg
) = 1;
13371 /* Combine the signgam assignment with the lgamma result. */
13372 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
13373 result_sg
, result_lg
));
13381 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13382 function FUNC on it and return the resulting value as a tree with
13383 type TYPE. The mpfr precision is set to the precision of TYPE. We
13384 assume that function FUNC returns zero if the result could be
13385 calculated exactly within the requested precision. */
13388 do_mpc_arg1 (tree arg
, tree type
, int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
))
13390 tree result
= NULL_TREE
;
13394 /* To proceed, MPFR must exactly represent the target floating point
13395 format, which only happens when the target base equals two. */
13396 if (TREE_CODE (arg
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg
)
13397 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
13398 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg
))))->b
== 2)
13400 const REAL_VALUE_TYPE
*const re
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
13401 const REAL_VALUE_TYPE
*const im
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
13403 if (real_isfinite (re
) && real_isfinite (im
))
13405 const struct real_format
*const fmt
=
13406 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
13407 const int prec
= fmt
->p
;
13408 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13409 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
13413 mpc_init2 (m
, prec
);
13414 mpfr_from_real (mpc_realref(m
), re
, rnd
);
13415 mpfr_from_real (mpc_imagref(m
), im
, rnd
);
13416 mpfr_clear_flags ();
13417 inexact
= func (m
, m
, crnd
);
13418 result
= do_mpc_ckconv (m
, type
, inexact
, /*force_convert=*/ 0);
13426 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13427 mpc function FUNC on it and return the resulting value as a tree
13428 with type TYPE. The mpfr precision is set to the precision of
13429 TYPE. We assume that function FUNC returns zero if the result
13430 could be calculated exactly within the requested precision. If
13431 DO_NONFINITE is true, then fold expressions containing Inf or NaN
13432 in the arguments and/or results. */
13435 do_mpc_arg2 (tree arg0
, tree arg1
, tree type
, int do_nonfinite
,
13436 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
))
13438 tree result
= NULL_TREE
;
13443 /* To proceed, MPFR must exactly represent the target floating point
13444 format, which only happens when the target base equals two. */
13445 if (TREE_CODE (arg0
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg0
)
13446 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
13447 && TREE_CODE (arg1
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg1
)
13448 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
13449 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0
))))->b
== 2)
13451 const REAL_VALUE_TYPE
*const re0
= TREE_REAL_CST_PTR (TREE_REALPART (arg0
));
13452 const REAL_VALUE_TYPE
*const im0
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg0
));
13453 const REAL_VALUE_TYPE
*const re1
= TREE_REAL_CST_PTR (TREE_REALPART (arg1
));
13454 const REAL_VALUE_TYPE
*const im1
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg1
));
13457 || (real_isfinite (re0
) && real_isfinite (im0
)
13458 && real_isfinite (re1
) && real_isfinite (im1
)))
13460 const struct real_format
*const fmt
=
13461 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
13462 const int prec
= fmt
->p
;
13463 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13464 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
13468 mpc_init2 (m0
, prec
);
13469 mpc_init2 (m1
, prec
);
13470 mpfr_from_real (mpc_realref(m0
), re0
, rnd
);
13471 mpfr_from_real (mpc_imagref(m0
), im0
, rnd
);
13472 mpfr_from_real (mpc_realref(m1
), re1
, rnd
);
13473 mpfr_from_real (mpc_imagref(m1
), im1
, rnd
);
13474 mpfr_clear_flags ();
13475 inexact
= func (m0
, m0
, m1
, crnd
);
13476 result
= do_mpc_ckconv (m0
, type
, inexact
, do_nonfinite
);
13486 The functions below provide an alternate interface for folding
13487 builtin function calls presented as GIMPLE_CALL statements rather
13488 than as CALL_EXPRs. The folded result is still expressed as a
13489 tree. There is too much code duplication in the handling of
13490 varargs functions, and a more intrusive re-factoring would permit
13491 better sharing of code between the tree and statement-based
13492 versions of these functions. */
13494 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13495 along with N new arguments specified as the "..." parameters. SKIP
13496 is the number of arguments in STMT to be omitted. This function is used
13497 to do varargs-to-varargs transformations. */
13500 gimple_rewrite_call_expr (gimple stmt
, int skip
, tree fndecl
, int n
, ...)
13502 int oldnargs
= gimple_call_num_args (stmt
);
13503 int nargs
= oldnargs
- skip
+ n
;
13504 tree fntype
= TREE_TYPE (fndecl
);
13505 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
13509 location_t loc
= gimple_location (stmt
);
13511 buffer
= XALLOCAVEC (tree
, nargs
);
13513 for (i
= 0; i
< n
; i
++)
13514 buffer
[i
] = va_arg (ap
, tree
);
13516 for (j
= skip
; j
< oldnargs
; j
++, i
++)
13517 buffer
[i
] = gimple_call_arg (stmt
, j
);
13519 return fold (build_call_array_loc (loc
, TREE_TYPE (fntype
), fn
, nargs
, buffer
));
13522 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
13523 a normal call should be emitted rather than expanding the function
13524 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13527 gimple_fold_builtin_sprintf_chk (gimple stmt
, enum built_in_function fcode
)
13529 tree dest
, size
, len
, fn
, fmt
, flag
;
13530 const char *fmt_str
;
13531 int nargs
= gimple_call_num_args (stmt
);
13533 /* Verify the required arguments in the original call. */
13536 dest
= gimple_call_arg (stmt
, 0);
13537 if (!validate_arg (dest
, POINTER_TYPE
))
13539 flag
= gimple_call_arg (stmt
, 1);
13540 if (!validate_arg (flag
, INTEGER_TYPE
))
13542 size
= gimple_call_arg (stmt
, 2);
13543 if (!validate_arg (size
, INTEGER_TYPE
))
13545 fmt
= gimple_call_arg (stmt
, 3);
13546 if (!validate_arg (fmt
, POINTER_TYPE
))
13549 if (! host_integerp (size
, 1))
13554 if (!init_target_chars ())
13557 /* Check whether the format is a literal string constant. */
13558 fmt_str
= c_getstr (fmt
);
13559 if (fmt_str
!= NULL
)
13561 /* If the format doesn't contain % args or %%, we know the size. */
13562 if (strchr (fmt_str
, target_percent
) == 0)
13564 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| nargs
== 4)
13565 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
13567 /* If the format is "%s" and first ... argument is a string literal,
13568 we know the size too. */
13569 else if (fcode
== BUILT_IN_SPRINTF_CHK
13570 && strcmp (fmt_str
, target_percent_s
) == 0)
13576 arg
= gimple_call_arg (stmt
, 4);
13577 if (validate_arg (arg
, POINTER_TYPE
))
13579 len
= c_strlen (arg
, 1);
13580 if (! len
|| ! host_integerp (len
, 1))
13587 if (! integer_all_onesp (size
))
13589 if (! len
|| ! tree_int_cst_lt (len
, size
))
13593 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13594 or if format doesn't contain % chars or is "%s". */
13595 if (! integer_zerop (flag
))
13597 if (fmt_str
== NULL
)
13599 if (strchr (fmt_str
, target_percent
) != NULL
13600 && strcmp (fmt_str
, target_percent_s
))
13604 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
13605 fn
= built_in_decls
[fcode
== BUILT_IN_VSPRINTF_CHK
13606 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
];
13610 return gimple_rewrite_call_expr (stmt
, 4, fn
, 2, dest
, fmt
);
13613 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
13614 a normal call should be emitted rather than expanding the function
13615 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13616 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13617 passed as second argument. */
13620 gimple_fold_builtin_snprintf_chk (gimple stmt
, tree maxlen
,
13621 enum built_in_function fcode
)
13623 tree dest
, size
, len
, fn
, fmt
, flag
;
13624 const char *fmt_str
;
13626 /* Verify the required arguments in the original call. */
13627 if (gimple_call_num_args (stmt
) < 5)
13629 dest
= gimple_call_arg (stmt
, 0);
13630 if (!validate_arg (dest
, POINTER_TYPE
))
13632 len
= gimple_call_arg (stmt
, 1);
13633 if (!validate_arg (len
, INTEGER_TYPE
))
13635 flag
= gimple_call_arg (stmt
, 2);
13636 if (!validate_arg (flag
, INTEGER_TYPE
))
13638 size
= gimple_call_arg (stmt
, 3);
13639 if (!validate_arg (size
, INTEGER_TYPE
))
13641 fmt
= gimple_call_arg (stmt
, 4);
13642 if (!validate_arg (fmt
, POINTER_TYPE
))
13645 if (! host_integerp (size
, 1))
13648 if (! integer_all_onesp (size
))
13650 if (! host_integerp (len
, 1))
13652 /* If LEN is not constant, try MAXLEN too.
13653 For MAXLEN only allow optimizing into non-_ocs function
13654 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
13655 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
13661 if (tree_int_cst_lt (size
, maxlen
))
13665 if (!init_target_chars ())
13668 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13669 or if format doesn't contain % chars or is "%s". */
13670 if (! integer_zerop (flag
))
13672 fmt_str
= c_getstr (fmt
);
13673 if (fmt_str
== NULL
)
13675 if (strchr (fmt_str
, target_percent
) != NULL
13676 && strcmp (fmt_str
, target_percent_s
))
13680 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13682 fn
= built_in_decls
[fcode
== BUILT_IN_VSNPRINTF_CHK
13683 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
];
13687 return gimple_rewrite_call_expr (stmt
, 5, fn
, 3, dest
, len
, fmt
);
13690 /* Builtins with folding operations that operate on "..." arguments
13691 need special handling; we need to store the arguments in a convenient
13692 data structure before attempting any folding. Fortunately there are
13693 only a few builtins that fall into this category. FNDECL is the
13694 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13695 result of the function call is ignored. */
13698 gimple_fold_builtin_varargs (tree fndecl
, gimple stmt
,
13699 bool ignore ATTRIBUTE_UNUSED
)
13701 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
13702 tree ret
= NULL_TREE
;
13706 case BUILT_IN_SPRINTF_CHK
:
13707 case BUILT_IN_VSPRINTF_CHK
:
13708 ret
= gimple_fold_builtin_sprintf_chk (stmt
, fcode
);
13711 case BUILT_IN_SNPRINTF_CHK
:
13712 case BUILT_IN_VSNPRINTF_CHK
:
13713 ret
= gimple_fold_builtin_snprintf_chk (stmt
, NULL_TREE
, fcode
);
13720 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
13721 TREE_NO_WARNING (ret
) = 1;
13727 /* A wrapper function for builtin folding that prevents warnings for
13728 "statement without effect" and the like, caused by removing the
13729 call node earlier than the warning is generated. */
13732 fold_call_stmt (gimple stmt
, bool ignore
)
13734 tree ret
= NULL_TREE
;
13735 tree fndecl
= gimple_call_fndecl (stmt
);
13736 location_t loc
= gimple_location (stmt
);
13738 && TREE_CODE (fndecl
) == FUNCTION_DECL
13739 && DECL_BUILT_IN (fndecl
)
13740 && !gimple_call_va_arg_pack_p (stmt
))
13742 int nargs
= gimple_call_num_args (stmt
);
13744 if (avoid_folding_inline_builtin (fndecl
))
13746 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
13748 return targetm
.fold_builtin (fndecl
, nargs
,
13750 ? gimple_call_arg_ptr (stmt
, 0)
13751 : &error_mark_node
), ignore
);
13755 if (nargs
<= MAX_ARGS_TO_FOLD_BUILTIN
)
13757 tree args
[MAX_ARGS_TO_FOLD_BUILTIN
];
13759 for (i
= 0; i
< nargs
; i
++)
13760 args
[i
] = gimple_call_arg (stmt
, i
);
13761 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
13764 ret
= gimple_fold_builtin_varargs (fndecl
, stmt
, ignore
);
13767 /* Propagate location information from original call to
13768 expansion of builtin. Otherwise things like
13769 maybe_emit_chk_warning, that operate on the expansion
13770 of a builtin, will use the wrong location information. */
13771 if (gimple_has_location (stmt
))
13773 tree realret
= ret
;
13774 if (TREE_CODE (ret
) == NOP_EXPR
)
13775 realret
= TREE_OPERAND (ret
, 0);
13776 if (CAN_HAVE_LOCATION_P (realret
)
13777 && !EXPR_HAS_LOCATION (realret
))
13778 SET_EXPR_LOCATION (realret
, loc
);
13788 /* Look up the function in built_in_decls that corresponds to DECL
13789 and set ASMSPEC as its user assembler name. DECL must be a
13790 function decl that declares a builtin. */
13793 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
13796 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
13797 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
13800 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
13801 set_user_assembler_name (builtin
, asmspec
);
13802 switch (DECL_FUNCTION_CODE (decl
))
13804 case BUILT_IN_MEMCPY
:
13805 init_block_move_fn (asmspec
);
13806 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
13808 case BUILT_IN_MEMSET
:
13809 init_block_clear_fn (asmspec
);
13810 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
13812 case BUILT_IN_MEMMOVE
:
13813 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
13815 case BUILT_IN_MEMCMP
:
13816 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
13818 case BUILT_IN_ABORT
:
13819 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
13822 if (INT_TYPE_SIZE
< BITS_PER_WORD
)
13824 set_user_assembler_libfunc ("ffs", asmspec
);
13825 set_optab_libfunc (ffs_optab
, mode_for_size (INT_TYPE_SIZE
,
13826 MODE_INT
, 0), "ffs");
13834 /* Return true if DECL is a builtin that expands to a constant or similarly
13837 is_simple_builtin (tree decl
)
13839 if (decl
&& DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
13840 switch (DECL_FUNCTION_CODE (decl
))
13842 /* Builtins that expand to constants. */
13843 case BUILT_IN_CONSTANT_P
:
13844 case BUILT_IN_EXPECT
:
13845 case BUILT_IN_OBJECT_SIZE
:
13846 case BUILT_IN_UNREACHABLE
:
13847 /* Simple register moves or loads from stack. */
13848 case BUILT_IN_RETURN_ADDRESS
:
13849 case BUILT_IN_EXTRACT_RETURN_ADDR
:
13850 case BUILT_IN_FROB_RETURN_ADDR
:
13851 case BUILT_IN_RETURN
:
13852 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
13853 case BUILT_IN_FRAME_ADDRESS
:
13854 case BUILT_IN_VA_END
:
13855 case BUILT_IN_STACK_SAVE
:
13856 case BUILT_IN_STACK_RESTORE
:
13857 /* Exception state returns or moves registers around. */
13858 case BUILT_IN_EH_FILTER
:
13859 case BUILT_IN_EH_POINTER
:
13860 case BUILT_IN_EH_COPY_VALUES
:
13870 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13871 most probably expanded inline into reasonably simple code. This is a
13872 superset of is_simple_builtin. */
13874 is_inexpensive_builtin (tree decl
)
13878 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_MD
)
13880 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
13881 switch (DECL_FUNCTION_CODE (decl
))
13884 case BUILT_IN_ALLOCA
:
13885 case BUILT_IN_BSWAP32
:
13886 case BUILT_IN_BSWAP64
:
13888 case BUILT_IN_CLZIMAX
:
13889 case BUILT_IN_CLZL
:
13890 case BUILT_IN_CLZLL
:
13892 case BUILT_IN_CTZIMAX
:
13893 case BUILT_IN_CTZL
:
13894 case BUILT_IN_CTZLL
:
13896 case BUILT_IN_FFSIMAX
:
13897 case BUILT_IN_FFSL
:
13898 case BUILT_IN_FFSLL
:
13899 case BUILT_IN_IMAXABS
:
13900 case BUILT_IN_FINITE
:
13901 case BUILT_IN_FINITEF
:
13902 case BUILT_IN_FINITEL
:
13903 case BUILT_IN_FINITED32
:
13904 case BUILT_IN_FINITED64
:
13905 case BUILT_IN_FINITED128
:
13906 case BUILT_IN_FPCLASSIFY
:
13907 case BUILT_IN_ISFINITE
:
13908 case BUILT_IN_ISINF_SIGN
:
13909 case BUILT_IN_ISINF
:
13910 case BUILT_IN_ISINFF
:
13911 case BUILT_IN_ISINFL
:
13912 case BUILT_IN_ISINFD32
:
13913 case BUILT_IN_ISINFD64
:
13914 case BUILT_IN_ISINFD128
:
13915 case BUILT_IN_ISNAN
:
13916 case BUILT_IN_ISNANF
:
13917 case BUILT_IN_ISNANL
:
13918 case BUILT_IN_ISNAND32
:
13919 case BUILT_IN_ISNAND64
:
13920 case BUILT_IN_ISNAND128
:
13921 case BUILT_IN_ISNORMAL
:
13922 case BUILT_IN_ISGREATER
:
13923 case BUILT_IN_ISGREATEREQUAL
:
13924 case BUILT_IN_ISLESS
:
13925 case BUILT_IN_ISLESSEQUAL
:
13926 case BUILT_IN_ISLESSGREATER
:
13927 case BUILT_IN_ISUNORDERED
:
13928 case BUILT_IN_VA_ARG_PACK
:
13929 case BUILT_IN_VA_ARG_PACK_LEN
:
13930 case BUILT_IN_VA_COPY
:
13931 case BUILT_IN_TRAP
:
13932 case BUILT_IN_SAVEREGS
:
13933 case BUILT_IN_POPCOUNTL
:
13934 case BUILT_IN_POPCOUNTLL
:
13935 case BUILT_IN_POPCOUNTIMAX
:
13936 case BUILT_IN_POPCOUNT
:
13937 case BUILT_IN_PARITYL
:
13938 case BUILT_IN_PARITYLL
:
13939 case BUILT_IN_PARITYIMAX
:
13940 case BUILT_IN_PARITY
:
13941 case BUILT_IN_LABS
:
13942 case BUILT_IN_LLABS
:
13943 case BUILT_IN_PREFETCH
:
13947 return is_simple_builtin (decl
);