1 /* Expand builtin functions.
2 Copyright (C) 1988-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
28 #include "double-int.h"
35 #include "fold-const.h"
36 #include "stringpool.h"
37 #include "stor-layout.h"
40 #include "tree-object-size.h"
44 #include "hard-reg-set.h"
47 #include "basic-block.h"
48 #include "tree-ssa-alias.h"
49 #include "internal-fn.h"
50 #include "gimple-expr.h"
56 #include "insn-config.h"
57 #include "statistics.h"
59 #include "fixed-value.h"
66 #include "insn-codes.h"
71 #include "typeclass.h"
74 #include "langhooks.h"
75 #include "tree-ssanames.h"
77 #include "value-prof.h"
78 #include "diagnostic-core.h"
83 #include "lto-streamer.h"
85 #include "tree-chkp.h"
89 static tree
do_mpc_arg1 (tree
, tree
, int (*)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
));
91 struct target_builtins default_target_builtins
;
93 struct target_builtins
*this_target_builtins
= &default_target_builtins
;
96 /* Define the names of the builtin function types and codes. */
97 const char *const built_in_class_names
[BUILT_IN_LAST
]
98 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
100 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
101 const char * built_in_names
[(int) END_BUILTINS
] =
103 #include "builtins.def"
107 /* Setup an array of _DECL trees, make sure each element is
108 initialized to NULL_TREE. */
109 builtin_info_type builtin_info
;
111 /* Non-zero if __builtin_constant_p should be folded right away. */
112 bool force_folding_builtin_constant_p
;
114 static rtx
c_readstr (const char *, machine_mode
);
115 static int target_char_cast (tree
, char *);
116 static rtx
get_memory_rtx (tree
, tree
);
117 static int apply_args_size (void);
118 static int apply_result_size (void);
119 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
120 static rtx
result_vector (int, rtx
);
122 static void expand_builtin_update_setjmp_buf (rtx
);
123 static void expand_builtin_prefetch (tree
);
124 static rtx
expand_builtin_apply_args (void);
125 static rtx
expand_builtin_apply_args_1 (void);
126 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
127 static void expand_builtin_return (rtx
);
128 static enum type_class
type_to_class (tree
);
129 static rtx
expand_builtin_classify_type (tree
);
130 static void expand_errno_check (tree
, rtx
);
131 static rtx
expand_builtin_mathfn (tree
, rtx
, rtx
);
132 static rtx
expand_builtin_mathfn_2 (tree
, rtx
, rtx
);
133 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
134 static rtx
expand_builtin_mathfn_ternary (tree
, rtx
, rtx
);
135 static rtx
expand_builtin_interclass_mathfn (tree
, rtx
);
136 static rtx
expand_builtin_sincos (tree
);
137 static rtx
expand_builtin_cexpi (tree
, rtx
);
138 static rtx
expand_builtin_int_roundingfn (tree
, rtx
);
139 static rtx
expand_builtin_int_roundingfn_2 (tree
, rtx
);
140 static rtx
expand_builtin_next_arg (void);
141 static rtx
expand_builtin_va_start (tree
);
142 static rtx
expand_builtin_va_end (tree
);
143 static rtx
expand_builtin_va_copy (tree
);
144 static rtx
expand_builtin_memcmp (tree
, rtx
, machine_mode
);
145 static rtx
expand_builtin_strcmp (tree
, rtx
);
146 static rtx
expand_builtin_strncmp (tree
, rtx
, machine_mode
);
147 static rtx
builtin_memcpy_read_str (void *, HOST_WIDE_INT
, machine_mode
);
148 static rtx
expand_builtin_memcpy (tree
, rtx
);
149 static rtx
expand_builtin_memcpy_with_bounds (tree
, rtx
);
150 static rtx
expand_builtin_memcpy_args (tree
, tree
, tree
, rtx
, tree
);
151 static rtx
expand_builtin_mempcpy (tree
, rtx
, machine_mode
);
152 static rtx
expand_builtin_mempcpy_with_bounds (tree
, rtx
, machine_mode
);
153 static rtx
expand_builtin_mempcpy_args (tree
, tree
, tree
, rtx
,
154 machine_mode
, int, tree
);
155 static rtx
expand_builtin_strcpy (tree
, rtx
);
156 static rtx
expand_builtin_strcpy_args (tree
, tree
, rtx
);
157 static rtx
expand_builtin_stpcpy (tree
, rtx
, machine_mode
);
158 static rtx
expand_builtin_strncpy (tree
, rtx
);
159 static rtx
builtin_memset_gen_str (void *, HOST_WIDE_INT
, machine_mode
);
160 static rtx
expand_builtin_memset (tree
, rtx
, machine_mode
);
161 static rtx
expand_builtin_memset_with_bounds (tree
, rtx
, machine_mode
);
162 static rtx
expand_builtin_memset_args (tree
, tree
, tree
, rtx
, machine_mode
, tree
);
163 static rtx
expand_builtin_bzero (tree
);
164 static rtx
expand_builtin_strlen (tree
, rtx
, machine_mode
);
165 static rtx
expand_builtin_alloca (tree
, bool);
166 static rtx
expand_builtin_unop (machine_mode
, tree
, rtx
, rtx
, optab
);
167 static rtx
expand_builtin_frame_address (tree
, tree
);
168 static tree
stabilize_va_list_loc (location_t
, tree
, int);
169 static rtx
expand_builtin_expect (tree
, rtx
);
170 static tree
fold_builtin_constant_p (tree
);
171 static tree
fold_builtin_classify_type (tree
);
172 static tree
fold_builtin_strlen (location_t
, tree
, tree
);
173 static tree
fold_builtin_inf (location_t
, tree
, int);
174 static tree
fold_builtin_nan (tree
, tree
, int);
175 static tree
rewrite_call_expr (location_t
, tree
, int, tree
, int, ...);
176 static bool validate_arg (const_tree
, enum tree_code code
);
177 static bool integer_valued_real_p (tree
);
178 static tree
fold_trunc_transparent_mathfn (location_t
, tree
, tree
);
179 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
180 static rtx
expand_builtin_signbit (tree
, rtx
);
181 static tree
fold_builtin_sqrt (location_t
, tree
, tree
);
182 static tree
fold_builtin_cbrt (location_t
, tree
, tree
);
183 static tree
fold_builtin_pow (location_t
, tree
, tree
, tree
, tree
);
184 static tree
fold_builtin_powi (location_t
, tree
, tree
, tree
, tree
);
185 static tree
fold_builtin_cos (location_t
, tree
, tree
, tree
);
186 static tree
fold_builtin_cosh (location_t
, tree
, tree
, tree
);
187 static tree
fold_builtin_tan (tree
, tree
);
188 static tree
fold_builtin_trunc (location_t
, tree
, tree
);
189 static tree
fold_builtin_floor (location_t
, tree
, tree
);
190 static tree
fold_builtin_ceil (location_t
, tree
, tree
);
191 static tree
fold_builtin_round (location_t
, tree
, tree
);
192 static tree
fold_builtin_int_roundingfn (location_t
, tree
, tree
);
193 static tree
fold_builtin_bitop (tree
, tree
);
194 static tree
fold_builtin_strchr (location_t
, tree
, tree
, tree
);
195 static tree
fold_builtin_memchr (location_t
, tree
, tree
, tree
, tree
);
196 static tree
fold_builtin_memcmp (location_t
, tree
, tree
, tree
);
197 static tree
fold_builtin_strcmp (location_t
, tree
, tree
);
198 static tree
fold_builtin_strncmp (location_t
, tree
, tree
, tree
);
199 static tree
fold_builtin_signbit (location_t
, tree
, tree
);
200 static tree
fold_builtin_copysign (location_t
, tree
, tree
, tree
, tree
);
201 static tree
fold_builtin_isascii (location_t
, tree
);
202 static tree
fold_builtin_toascii (location_t
, tree
);
203 static tree
fold_builtin_isdigit (location_t
, tree
);
204 static tree
fold_builtin_fabs (location_t
, tree
, tree
);
205 static tree
fold_builtin_abs (location_t
, tree
, tree
);
206 static tree
fold_builtin_unordered_cmp (location_t
, tree
, tree
, tree
, enum tree_code
,
208 static tree
fold_builtin_0 (location_t
, tree
);
209 static tree
fold_builtin_1 (location_t
, tree
, tree
);
210 static tree
fold_builtin_2 (location_t
, tree
, tree
, tree
);
211 static tree
fold_builtin_3 (location_t
, tree
, tree
, tree
, tree
);
212 static tree
fold_builtin_varargs (location_t
, tree
, tree
*, int);
214 static tree
fold_builtin_strpbrk (location_t
, tree
, tree
, tree
);
215 static tree
fold_builtin_strstr (location_t
, tree
, tree
, tree
);
216 static tree
fold_builtin_strrchr (location_t
, tree
, tree
, tree
);
217 static tree
fold_builtin_strspn (location_t
, tree
, tree
);
218 static tree
fold_builtin_strcspn (location_t
, tree
, tree
);
220 static rtx
expand_builtin_object_size (tree
);
221 static rtx
expand_builtin_memory_chk (tree
, rtx
, machine_mode
,
222 enum built_in_function
);
223 static void maybe_emit_chk_warning (tree
, enum built_in_function
);
224 static void maybe_emit_sprintf_chk_warning (tree
, enum built_in_function
);
225 static void maybe_emit_free_warning (tree
);
226 static tree
fold_builtin_object_size (tree
, tree
);
228 unsigned HOST_WIDE_INT target_newline
;
229 unsigned HOST_WIDE_INT target_percent
;
230 static unsigned HOST_WIDE_INT target_c
;
231 static unsigned HOST_WIDE_INT target_s
;
232 char target_percent_c
[3];
233 char target_percent_s
[3];
234 char target_percent_s_newline
[4];
235 static tree
do_mpfr_arg1 (tree
, tree
, int (*)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
236 const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, bool);
237 static tree
do_mpfr_arg2 (tree
, tree
, tree
,
238 int (*)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
));
239 static tree
do_mpfr_arg3 (tree
, tree
, tree
, tree
,
240 int (*)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
));
241 static tree
do_mpfr_sincos (tree
, tree
, tree
);
242 static tree
do_mpfr_bessel_n (tree
, tree
, tree
,
243 int (*)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
244 const REAL_VALUE_TYPE
*, bool);
245 static tree
do_mpfr_remquo (tree
, tree
, tree
);
246 static tree
do_mpfr_lgamma_r (tree
, tree
, tree
);
247 static void expand_builtin_sync_synchronize (void);
249 /* Return true if NAME starts with __builtin_ or __sync_. */
252 is_builtin_name (const char *name
)
254 if (strncmp (name
, "__builtin_", 10) == 0)
256 if (strncmp (name
, "__sync_", 7) == 0)
258 if (strncmp (name
, "__atomic_", 9) == 0)
261 && (!strcmp (name
, "__cilkrts_detach")
262 || !strcmp (name
, "__cilkrts_pop_frame")))
268 /* Return true if DECL is a function symbol representing a built-in. */
271 is_builtin_fn (tree decl
)
273 return TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
);
276 /* Return true if NODE should be considered for inline expansion regardless
277 of the optimization level. This means whenever a function is invoked with
278 its "internal" name, which normally contains the prefix "__builtin". */
281 called_as_built_in (tree node
)
283 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
284 we want the name used to call the function, not the name it
286 const char *name
= IDENTIFIER_POINTER (DECL_NAME (node
));
287 return is_builtin_name (name
);
290 /* Compute values M and N such that M divides (address of EXP - N) and such
291 that N < M. If these numbers can be determined, store M in alignp and N in
292 *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to
293 *alignp and any bit-offset to *bitposp.
295 Note that the address (and thus the alignment) computed here is based
296 on the address to which a symbol resolves, whereas DECL_ALIGN is based
297 on the address at which an object is actually located. These two
298 addresses are not always the same. For example, on ARM targets,
299 the address &foo of a Thumb function foo() has the lowest bit set,
300 whereas foo() itself starts on an even address.
302 If ADDR_P is true we are taking the address of the memory reference EXP
303 and thus cannot rely on the access taking place. */
306 get_object_alignment_2 (tree exp
, unsigned int *alignp
,
307 unsigned HOST_WIDE_INT
*bitposp
, bool addr_p
)
309 HOST_WIDE_INT bitsize
, bitpos
;
312 int unsignedp
, volatilep
;
313 unsigned int align
= BITS_PER_UNIT
;
314 bool known_alignment
= false;
316 /* Get the innermost object and the constant (bitpos) and possibly
317 variable (offset) offset of the access. */
318 exp
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
319 &mode
, &unsignedp
, &volatilep
, true);
321 /* Extract alignment information from the innermost object and
322 possibly adjust bitpos and offset. */
323 if (TREE_CODE (exp
) == FUNCTION_DECL
)
325 /* Function addresses can encode extra information besides their
326 alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
327 allows the low bit to be used as a virtual bit, we know
328 that the address itself must be at least 2-byte aligned. */
329 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
)
330 align
= 2 * BITS_PER_UNIT
;
332 else if (TREE_CODE (exp
) == LABEL_DECL
)
334 else if (TREE_CODE (exp
) == CONST_DECL
)
336 /* The alignment of a CONST_DECL is determined by its initializer. */
337 exp
= DECL_INITIAL (exp
);
338 align
= TYPE_ALIGN (TREE_TYPE (exp
));
339 #ifdef CONSTANT_ALIGNMENT
340 if (CONSTANT_CLASS_P (exp
))
341 align
= (unsigned) CONSTANT_ALIGNMENT (exp
, align
);
343 known_alignment
= true;
345 else if (DECL_P (exp
))
347 align
= DECL_ALIGN (exp
);
348 known_alignment
= true;
350 else if (TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
352 align
= TYPE_ALIGN (TREE_TYPE (exp
));
354 else if (TREE_CODE (exp
) == INDIRECT_REF
355 || TREE_CODE (exp
) == MEM_REF
356 || TREE_CODE (exp
) == TARGET_MEM_REF
)
358 tree addr
= TREE_OPERAND (exp
, 0);
360 unsigned HOST_WIDE_INT ptr_bitpos
;
362 if (TREE_CODE (addr
) == BIT_AND_EXPR
363 && TREE_CODE (TREE_OPERAND (addr
, 1)) == INTEGER_CST
)
365 align
= (TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1))
366 & -TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1)));
367 align
*= BITS_PER_UNIT
;
368 addr
= TREE_OPERAND (addr
, 0);
372 = get_pointer_alignment_1 (addr
, &ptr_align
, &ptr_bitpos
);
373 align
= MAX (ptr_align
, align
);
375 /* The alignment of the pointer operand in a TARGET_MEM_REF
376 has to take the variable offset parts into account. */
377 if (TREE_CODE (exp
) == TARGET_MEM_REF
)
381 unsigned HOST_WIDE_INT step
= 1;
383 step
= TREE_INT_CST_LOW (TMR_STEP (exp
));
384 align
= MIN (align
, (step
& -step
) * BITS_PER_UNIT
);
386 if (TMR_INDEX2 (exp
))
387 align
= BITS_PER_UNIT
;
388 known_alignment
= false;
391 /* When EXP is an actual memory reference then we can use
392 TYPE_ALIGN of a pointer indirection to derive alignment.
393 Do so only if get_pointer_alignment_1 did not reveal absolute
394 alignment knowledge and if using that alignment would
395 improve the situation. */
396 if (!addr_p
&& !known_alignment
397 && TYPE_ALIGN (TREE_TYPE (exp
)) > align
)
398 align
= TYPE_ALIGN (TREE_TYPE (exp
));
401 /* Else adjust bitpos accordingly. */
402 bitpos
+= ptr_bitpos
;
403 if (TREE_CODE (exp
) == MEM_REF
404 || TREE_CODE (exp
) == TARGET_MEM_REF
)
405 bitpos
+= mem_ref_offset (exp
).to_short_addr () * BITS_PER_UNIT
;
408 else if (TREE_CODE (exp
) == STRING_CST
)
410 /* STRING_CST are the only constant objects we allow to be not
411 wrapped inside a CONST_DECL. */
412 align
= TYPE_ALIGN (TREE_TYPE (exp
));
413 #ifdef CONSTANT_ALIGNMENT
414 if (CONSTANT_CLASS_P (exp
))
415 align
= (unsigned) CONSTANT_ALIGNMENT (exp
, align
);
417 known_alignment
= true;
420 /* If there is a non-constant offset part extract the maximum
421 alignment that can prevail. */
424 unsigned int trailing_zeros
= tree_ctz (offset
);
425 if (trailing_zeros
< HOST_BITS_PER_INT
)
427 unsigned int inner
= (1U << trailing_zeros
) * BITS_PER_UNIT
;
429 align
= MIN (align
, inner
);
434 *bitposp
= bitpos
& (*alignp
- 1);
435 return known_alignment
;
438 /* For a memory reference expression EXP compute values M and N such that M
439 divides (&EXP - N) and such that N < M. If these numbers can be determined,
440 store M in alignp and N in *BITPOSP and return true. Otherwise return false
441 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
444 get_object_alignment_1 (tree exp
, unsigned int *alignp
,
445 unsigned HOST_WIDE_INT
*bitposp
)
447 return get_object_alignment_2 (exp
, alignp
, bitposp
, false);
450 /* Return the alignment in bits of EXP, an object. */
453 get_object_alignment (tree exp
)
455 unsigned HOST_WIDE_INT bitpos
= 0;
458 get_object_alignment_1 (exp
, &align
, &bitpos
);
460 /* align and bitpos now specify known low bits of the pointer.
461 ptr & (align - 1) == bitpos. */
464 align
= (bitpos
& -bitpos
);
468 /* For a pointer valued expression EXP compute values M and N such that M
469 divides (EXP - N) and such that N < M. If these numbers can be determined,
470 store M in alignp and N in *BITPOSP and return true. Return false if
471 the results are just a conservative approximation.
473 If EXP is not a pointer, false is returned too. */
476 get_pointer_alignment_1 (tree exp
, unsigned int *alignp
,
477 unsigned HOST_WIDE_INT
*bitposp
)
481 if (TREE_CODE (exp
) == ADDR_EXPR
)
482 return get_object_alignment_2 (TREE_OPERAND (exp
, 0),
483 alignp
, bitposp
, true);
484 else if (TREE_CODE (exp
) == SSA_NAME
485 && POINTER_TYPE_P (TREE_TYPE (exp
)))
487 unsigned int ptr_align
, ptr_misalign
;
488 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (exp
);
490 if (pi
&& get_ptr_info_alignment (pi
, &ptr_align
, &ptr_misalign
))
492 *bitposp
= ptr_misalign
* BITS_PER_UNIT
;
493 *alignp
= ptr_align
* BITS_PER_UNIT
;
494 /* We cannot really tell whether this result is an approximation. */
500 *alignp
= BITS_PER_UNIT
;
504 else if (TREE_CODE (exp
) == INTEGER_CST
)
506 *alignp
= BIGGEST_ALIGNMENT
;
507 *bitposp
= ((TREE_INT_CST_LOW (exp
) * BITS_PER_UNIT
)
508 & (BIGGEST_ALIGNMENT
- 1));
513 *alignp
= BITS_PER_UNIT
;
517 /* Return the alignment in bits of EXP, a pointer valued expression.
518 The alignment returned is, by default, the alignment of the thing that
519 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
521 Otherwise, look at the expression to see if we can do better, i.e., if the
522 expression is actually pointing at an object whose alignment is tighter. */
525 get_pointer_alignment (tree exp
)
527 unsigned HOST_WIDE_INT bitpos
= 0;
530 get_pointer_alignment_1 (exp
, &align
, &bitpos
);
532 /* align and bitpos now specify known low bits of the pointer.
533 ptr & (align - 1) == bitpos. */
536 align
= (bitpos
& -bitpos
);
541 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
542 way, because it could contain a zero byte in the middle.
543 TREE_STRING_LENGTH is the size of the character array, not the string.
545 ONLY_VALUE should be nonzero if the result is not going to be emitted
546 into the instruction stream and zero if it is going to be expanded.
547 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
548 is returned, otherwise NULL, since
549 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
550 evaluate the side-effects.
552 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
553 accesses. Note that this implies the result is not going to be emitted
554 into the instruction stream.
556 The value returned is of type `ssizetype'.
558 Unfortunately, string_constant can't access the values of const char
559 arrays with initializers, so neither can we do so here. */
562 c_strlen (tree src
, int only_value
)
565 HOST_WIDE_INT offset
;
571 if (TREE_CODE (src
) == COND_EXPR
572 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
576 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
577 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
578 if (tree_int_cst_equal (len1
, len2
))
582 if (TREE_CODE (src
) == COMPOUND_EXPR
583 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
584 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
586 loc
= EXPR_LOC_OR_LOC (src
, input_location
);
588 src
= string_constant (src
, &offset_node
);
592 max
= TREE_STRING_LENGTH (src
) - 1;
593 ptr
= TREE_STRING_POINTER (src
);
595 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
597 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
598 compute the offset to the following null if we don't know where to
599 start searching for it. */
602 for (i
= 0; i
< max
; i
++)
606 /* We don't know the starting offset, but we do know that the string
607 has no internal zero bytes. We can assume that the offset falls
608 within the bounds of the string; otherwise, the programmer deserves
609 what he gets. Subtract the offset from the length of the string,
610 and return that. This would perhaps not be valid if we were dealing
611 with named arrays in addition to literal string constants. */
613 return size_diffop_loc (loc
, size_int (max
), offset_node
);
616 /* We have a known offset into the string. Start searching there for
617 a null character if we can represent it as a single HOST_WIDE_INT. */
618 if (offset_node
== 0)
620 else if (! tree_fits_shwi_p (offset_node
))
623 offset
= tree_to_shwi (offset_node
);
625 /* If the offset is known to be out of bounds, warn, and call strlen at
627 if (offset
< 0 || offset
> max
)
629 /* Suppress multiple warnings for propagated constant strings. */
631 && !TREE_NO_WARNING (src
))
633 warning_at (loc
, 0, "offset outside bounds of constant string");
634 TREE_NO_WARNING (src
) = 1;
639 /* Use strlen to search for the first zero byte. Since any strings
640 constructed with build_string will have nulls appended, we win even
641 if we get handed something like (char[4])"abcd".
643 Since OFFSET is our starting index into the string, no further
644 calculation is needed. */
645 return ssize_int (strlen (ptr
+ offset
));
648 /* Return a char pointer for a C string if it is a string constant
649 or sum of string constant and integer constant. */
656 src
= string_constant (src
, &offset_node
);
660 if (offset_node
== 0)
661 return TREE_STRING_POINTER (src
);
662 else if (!tree_fits_uhwi_p (offset_node
)
663 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
666 return TREE_STRING_POINTER (src
) + tree_to_uhwi (offset_node
);
669 /* Return a constant integer corresponding to target reading
670 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
673 c_readstr (const char *str
, machine_mode mode
)
677 HOST_WIDE_INT tmp
[MAX_BITSIZE_MODE_ANY_INT
/ HOST_BITS_PER_WIDE_INT
];
679 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
680 unsigned int len
= (GET_MODE_PRECISION (mode
) + HOST_BITS_PER_WIDE_INT
- 1)
681 / HOST_BITS_PER_WIDE_INT
;
683 gcc_assert (len
<= MAX_BITSIZE_MODE_ANY_INT
/ HOST_BITS_PER_WIDE_INT
);
684 for (i
= 0; i
< len
; i
++)
688 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
691 if (WORDS_BIG_ENDIAN
)
692 j
= GET_MODE_SIZE (mode
) - i
- 1;
693 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
694 && GET_MODE_SIZE (mode
) >= UNITS_PER_WORD
)
695 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
699 ch
= (unsigned char) str
[i
];
700 tmp
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
703 wide_int c
= wide_int::from_array (tmp
, len
, GET_MODE_PRECISION (mode
));
704 return immed_wide_int_const (c
, mode
);
707 /* Cast a target constant CST to target CHAR and if that value fits into
708 host char type, return zero and put that value into variable pointed to by
712 target_char_cast (tree cst
, char *p
)
714 unsigned HOST_WIDE_INT val
, hostval
;
716 if (TREE_CODE (cst
) != INTEGER_CST
717 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
720 /* Do not care if it fits or not right here. */
721 val
= TREE_INT_CST_LOW (cst
);
723 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
724 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
727 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
728 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
737 /* Similar to save_expr, but assumes that arbitrary code is not executed
738 in between the multiple evaluations. In particular, we assume that a
739 non-addressable local variable will not be modified. */
742 builtin_save_expr (tree exp
)
744 if (TREE_CODE (exp
) == SSA_NAME
745 || (TREE_ADDRESSABLE (exp
) == 0
746 && (TREE_CODE (exp
) == PARM_DECL
747 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
)))))
750 return save_expr (exp
);
753 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
754 times to get the address of either a higher stack frame, or a return
755 address located within it (depending on FNDECL_CODE). */
758 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
762 #ifdef INITIAL_FRAME_ADDRESS_RTX
763 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
767 /* For a zero count with __builtin_return_address, we don't care what
768 frame address we return, because target-specific definitions will
769 override us. Therefore frame pointer elimination is OK, and using
770 the soft frame pointer is OK.
772 For a nonzero count, or a zero count with __builtin_frame_address,
773 we require a stable offset from the current frame pointer to the
774 previous one, so we must use the hard frame pointer, and
775 we must disable frame pointer elimination. */
776 if (count
== 0 && fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
777 tem
= frame_pointer_rtx
;
780 tem
= hard_frame_pointer_rtx
;
782 /* Tell reload not to eliminate the frame pointer. */
783 crtl
->accesses_prior_frames
= 1;
787 /* Some machines need special handling before we can access
788 arbitrary frames. For example, on the SPARC, we must first flush
789 all register windows to the stack. */
790 #ifdef SETUP_FRAME_ADDRESSES
792 SETUP_FRAME_ADDRESSES ();
795 /* On the SPARC, the return address is not in the frame, it is in a
796 register. There is no way to access it off of the current frame
797 pointer, but it can be accessed off the previous frame pointer by
798 reading the value from the register window save area. */
799 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
800 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
804 /* Scan back COUNT frames to the specified frame. */
805 for (i
= 0; i
< count
; i
++)
807 /* Assume the dynamic chain pointer is in the word that the
808 frame address points to, unless otherwise specified. */
809 #ifdef DYNAMIC_CHAIN_ADDRESS
810 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
812 tem
= memory_address (Pmode
, tem
);
813 tem
= gen_frame_mem (Pmode
, tem
);
814 tem
= copy_to_reg (tem
);
817 /* For __builtin_frame_address, return what we've got. But, on
818 the SPARC for example, we may have to add a bias. */
819 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
820 #ifdef FRAME_ADDR_RTX
821 return FRAME_ADDR_RTX (tem
);
826 /* For __builtin_return_address, get the return address from that frame. */
827 #ifdef RETURN_ADDR_RTX
828 tem
= RETURN_ADDR_RTX (count
, tem
);
830 tem
= memory_address (Pmode
,
831 plus_constant (Pmode
, tem
, GET_MODE_SIZE (Pmode
)));
832 tem
= gen_frame_mem (Pmode
, tem
);
837 /* Alias set used for setjmp buffer. */
838 static alias_set_type setjmp_alias_set
= -1;
840 /* Construct the leading half of a __builtin_setjmp call. Control will
841 return to RECEIVER_LABEL. This is also called directly by the SJLJ
842 exception handling code. */
845 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
847 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
851 if (setjmp_alias_set
== -1)
852 setjmp_alias_set
= new_alias_set ();
854 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
856 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
858 /* We store the frame pointer and the address of receiver_label in
859 the buffer and use the rest of it for the stack save area, which
860 is machine-dependent. */
862 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
863 set_mem_alias_set (mem
, setjmp_alias_set
);
864 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
866 mem
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
867 GET_MODE_SIZE (Pmode
))),
868 set_mem_alias_set (mem
, setjmp_alias_set
);
870 emit_move_insn (validize_mem (mem
),
871 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
873 stack_save
= gen_rtx_MEM (sa_mode
,
874 plus_constant (Pmode
, buf_addr
,
875 2 * GET_MODE_SIZE (Pmode
)));
876 set_mem_alias_set (stack_save
, setjmp_alias_set
);
877 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
879 /* If there is further processing to do, do it. */
880 #ifdef HAVE_builtin_setjmp_setup
881 if (HAVE_builtin_setjmp_setup
)
882 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
885 /* We have a nonlocal label. */
886 cfun
->has_nonlocal_label
= 1;
889 /* Construct the trailing part of a __builtin_setjmp call. This is
890 also called directly by the SJLJ exception handling code.
891 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
894 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
898 /* Mark the FP as used when we get here, so we have to make sure it's
899 marked as used by this function. */
900 emit_use (hard_frame_pointer_rtx
);
902 /* Mark the static chain as clobbered here so life information
903 doesn't get messed up for it. */
904 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
905 if (chain
&& REG_P (chain
))
906 emit_clobber (chain
);
908 /* Now put in the code to restore the frame pointer, and argument
909 pointer, if needed. */
910 #ifdef HAVE_nonlocal_goto
911 if (! HAVE_nonlocal_goto
)
914 /* First adjust our frame pointer to its actual value. It was
915 previously set to the start of the virtual area corresponding to
916 the stacked variables when we branched here and now needs to be
917 adjusted to the actual hardware fp value.
919 Assignments to virtual registers are converted by
920 instantiate_virtual_regs into the corresponding assignment
921 to the underlying register (fp in this case) that makes
922 the original assignment true.
923 So the following insn will actually be decrementing fp by
924 STARTING_FRAME_OFFSET. */
925 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
927 /* Restoring the frame pointer also modifies the hard frame pointer.
928 Mark it used (so that the previous assignment remains live once
929 the frame pointer is eliminated) and clobbered (to represent the
930 implicit update from the assignment). */
931 emit_use (hard_frame_pointer_rtx
);
932 emit_clobber (hard_frame_pointer_rtx
);
935 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
936 if (fixed_regs
[ARG_POINTER_REGNUM
])
938 #ifdef ELIMINABLE_REGS
939 /* If the argument pointer can be eliminated in favor of the
940 frame pointer, we don't need to restore it. We assume here
941 that if such an elimination is present, it can always be used.
942 This is the case on all known machines; if we don't make this
943 assumption, we do unnecessary saving on many machines. */
945 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
947 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
948 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
949 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
952 if (i
== ARRAY_SIZE (elim_regs
))
955 /* Now restore our arg pointer from the address at which it
956 was saved in our stack frame. */
957 emit_move_insn (crtl
->args
.internal_arg_pointer
,
958 copy_to_reg (get_arg_pointer_save_area ()));
963 #ifdef HAVE_builtin_setjmp_receiver
964 if (receiver_label
!= NULL
&& HAVE_builtin_setjmp_receiver
)
965 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
968 #ifdef HAVE_nonlocal_goto_receiver
969 if (HAVE_nonlocal_goto_receiver
)
970 emit_insn (gen_nonlocal_goto_receiver ());
975 /* We must not allow the code we just generated to be reordered by
976 scheduling. Specifically, the update of the frame pointer must
977 happen immediately, not later. */
978 emit_insn (gen_blockage ());
981 /* __builtin_longjmp is passed a pointer to an array of five words (not
982 all will be used on all machines). It operates similarly to the C
983 library function of the same name, but is more efficient. Much of
984 the code below is copied from the handling of non-local gotos. */
987 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
990 rtx_insn
*insn
, *last
;
991 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
993 /* DRAP is needed for stack realign if longjmp is expanded to current
995 if (SUPPORTS_STACK_ALIGNMENT
)
996 crtl
->need_drap
= true;
998 if (setjmp_alias_set
== -1)
999 setjmp_alias_set
= new_alias_set ();
1001 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
1003 buf_addr
= force_reg (Pmode
, buf_addr
);
1005 /* We require that the user must pass a second argument of 1, because
1006 that is what builtin_setjmp will return. */
1007 gcc_assert (value
== const1_rtx
);
1009 last
= get_last_insn ();
1010 #ifdef HAVE_builtin_longjmp
1011 if (HAVE_builtin_longjmp
)
1012 emit_insn (gen_builtin_longjmp (buf_addr
));
1016 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
1017 lab
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
1018 GET_MODE_SIZE (Pmode
)));
1020 stack
= gen_rtx_MEM (sa_mode
, plus_constant (Pmode
, buf_addr
,
1021 2 * GET_MODE_SIZE (Pmode
)));
1022 set_mem_alias_set (fp
, setjmp_alias_set
);
1023 set_mem_alias_set (lab
, setjmp_alias_set
);
1024 set_mem_alias_set (stack
, setjmp_alias_set
);
1026 /* Pick up FP, label, and SP from the block and jump. This code is
1027 from expand_goto in stmt.c; see there for detailed comments. */
1028 #ifdef HAVE_nonlocal_goto
1029 if (HAVE_nonlocal_goto
)
1030 /* We have to pass a value to the nonlocal_goto pattern that will
1031 get copied into the static_chain pointer, but it does not matter
1032 what that value is, because builtin_setjmp does not use it. */
1033 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
1037 lab
= copy_to_reg (lab
);
1039 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1040 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1042 emit_move_insn (hard_frame_pointer_rtx
, fp
);
1043 emit_stack_restore (SAVE_NONLOCAL
, stack
);
1045 emit_use (hard_frame_pointer_rtx
);
1046 emit_use (stack_pointer_rtx
);
1047 emit_indirect_jump (lab
);
1051 /* Search backwards and mark the jump insn as a non-local goto.
1052 Note that this precludes the use of __builtin_longjmp to a
1053 __builtin_setjmp target in the same function. However, we've
1054 already cautioned the user that these functions are for
1055 internal exception handling use only. */
1056 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1058 gcc_assert (insn
!= last
);
1062 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1065 else if (CALL_P (insn
))
1071 more_const_call_expr_args_p (const const_call_expr_arg_iterator
*iter
)
1073 return (iter
->i
< iter
->n
);
1076 /* This function validates the types of a function call argument list
1077 against a specified list of tree_codes. If the last specifier is a 0,
1078 that represents an ellipses, otherwise the last specifier must be a
1082 validate_arglist (const_tree callexpr
, ...)
1084 enum tree_code code
;
1087 const_call_expr_arg_iterator iter
;
1090 va_start (ap
, callexpr
);
1091 init_const_call_expr_arg_iterator (callexpr
, &iter
);
1095 code
= (enum tree_code
) va_arg (ap
, int);
1099 /* This signifies an ellipses, any further arguments are all ok. */
1103 /* This signifies an endlink, if no arguments remain, return
1104 true, otherwise return false. */
1105 res
= !more_const_call_expr_args_p (&iter
);
1108 /* If no parameters remain or the parameter's code does not
1109 match the specified code, return false. Otherwise continue
1110 checking any remaining arguments. */
1111 arg
= next_const_call_expr_arg (&iter
);
1112 if (!validate_arg (arg
, code
))
1119 /* We need gotos here since we can only have one VA_CLOSE in a
1127 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1128 and the address of the save area. */
1131 expand_builtin_nonlocal_goto (tree exp
)
1133 tree t_label
, t_save_area
;
1134 rtx r_label
, r_save_area
, r_fp
, r_sp
;
1137 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1140 t_label
= CALL_EXPR_ARG (exp
, 0);
1141 t_save_area
= CALL_EXPR_ARG (exp
, 1);
1143 r_label
= expand_normal (t_label
);
1144 r_label
= convert_memory_address (Pmode
, r_label
);
1145 r_save_area
= expand_normal (t_save_area
);
1146 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
1147 /* Copy the address of the save location to a register just in case it was
1148 based on the frame pointer. */
1149 r_save_area
= copy_to_reg (r_save_area
);
1150 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
1151 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
1152 plus_constant (Pmode
, r_save_area
,
1153 GET_MODE_SIZE (Pmode
)));
1155 crtl
->has_nonlocal_goto
= 1;
1157 #ifdef HAVE_nonlocal_goto
1158 /* ??? We no longer need to pass the static chain value, afaik. */
1159 if (HAVE_nonlocal_goto
)
1160 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
1164 r_label
= copy_to_reg (r_label
);
1166 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1167 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1169 /* Restore frame pointer for containing function. */
1170 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
1171 emit_stack_restore (SAVE_NONLOCAL
, r_sp
);
1173 /* USE of hard_frame_pointer_rtx added for consistency;
1174 not clear if really needed. */
1175 emit_use (hard_frame_pointer_rtx
);
1176 emit_use (stack_pointer_rtx
);
1178 /* If the architecture is using a GP register, we must
1179 conservatively assume that the target function makes use of it.
1180 The prologue of functions with nonlocal gotos must therefore
1181 initialize the GP register to the appropriate value, and we
1182 must then make sure that this value is live at the point
1183 of the jump. (Note that this doesn't necessarily apply
1184 to targets with a nonlocal_goto pattern; they are free
1185 to implement it in their own way. Note also that this is
1186 a no-op if the GP register is a global invariant.) */
1187 if ((unsigned) PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
1188 && fixed_regs
[PIC_OFFSET_TABLE_REGNUM
])
1189 emit_use (pic_offset_table_rtx
);
1191 emit_indirect_jump (r_label
);
1194 /* Search backwards to the jump insn and mark it as a
1196 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1200 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1203 else if (CALL_P (insn
))
1210 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1211 (not all will be used on all machines) that was passed to __builtin_setjmp.
1212 It updates the stack pointer in that block to correspond to the current
1216 expand_builtin_update_setjmp_buf (rtx buf_addr
)
1218 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
1220 = gen_rtx_MEM (sa_mode
,
1223 plus_constant (Pmode
, buf_addr
,
1224 2 * GET_MODE_SIZE (Pmode
))));
1226 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
1229 /* Expand a call to __builtin_prefetch. For a target that does not support
1230 data prefetch, evaluate the memory address argument in case it has side
1234 expand_builtin_prefetch (tree exp
)
1236 tree arg0
, arg1
, arg2
;
1240 if (!validate_arglist (exp
, POINTER_TYPE
, 0))
1243 arg0
= CALL_EXPR_ARG (exp
, 0);
1245 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1246 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1248 nargs
= call_expr_nargs (exp
);
1250 arg1
= CALL_EXPR_ARG (exp
, 1);
1252 arg1
= integer_zero_node
;
1254 arg2
= CALL_EXPR_ARG (exp
, 2);
1256 arg2
= integer_three_node
;
1258 /* Argument 0 is an address. */
1259 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
1261 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1262 if (TREE_CODE (arg1
) != INTEGER_CST
)
1264 error ("second argument to %<__builtin_prefetch%> must be a constant");
1265 arg1
= integer_zero_node
;
1267 op1
= expand_normal (arg1
);
1268 /* Argument 1 must be either zero or one. */
1269 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
1271 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1276 /* Argument 2 (locality) must be a compile-time constant int. */
1277 if (TREE_CODE (arg2
) != INTEGER_CST
)
1279 error ("third argument to %<__builtin_prefetch%> must be a constant");
1280 arg2
= integer_zero_node
;
1282 op2
= expand_normal (arg2
);
1283 /* Argument 2 must be 0, 1, 2, or 3. */
1284 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
1286 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1290 #ifdef HAVE_prefetch
1293 struct expand_operand ops
[3];
1295 create_address_operand (&ops
[0], op0
);
1296 create_integer_operand (&ops
[1], INTVAL (op1
));
1297 create_integer_operand (&ops
[2], INTVAL (op2
));
1298 if (maybe_expand_insn (CODE_FOR_prefetch
, 3, ops
))
1303 /* Don't do anything with direct references to volatile memory, but
1304 generate code to handle other side effects. */
1305 if (!MEM_P (op0
) && side_effects_p (op0
))
1309 /* Get a MEM rtx for expression EXP which is the address of an operand
1310 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1311 the maximum length of the block of memory that might be accessed or
1315 get_memory_rtx (tree exp
, tree len
)
1317 tree orig_exp
= exp
;
1320 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1321 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1322 if (TREE_CODE (exp
) == SAVE_EXPR
&& !SAVE_EXPR_RESOLVED_P (exp
))
1323 exp
= TREE_OPERAND (exp
, 0);
1325 addr
= expand_expr (orig_exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1326 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1328 /* Get an expression we can use to find the attributes to assign to MEM.
1329 First remove any nops. */
1330 while (CONVERT_EXPR_P (exp
)
1331 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1332 exp
= TREE_OPERAND (exp
, 0);
1334 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1335 (as builtin stringops may alias with anything). */
1336 exp
= fold_build2 (MEM_REF
,
1337 build_array_type (char_type_node
,
1338 build_range_type (sizetype
,
1339 size_one_node
, len
)),
1340 exp
, build_int_cst (ptr_type_node
, 0));
1342 /* If the MEM_REF has no acceptable address, try to get the base object
1343 from the original address we got, and build an all-aliasing
1344 unknown-sized access to that one. */
1345 if (is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
1346 set_mem_attributes (mem
, exp
, 0);
1347 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
1348 && (exp
= get_base_address (TREE_OPERAND (TREE_OPERAND (exp
, 0),
1351 exp
= build_fold_addr_expr (exp
);
1352 exp
= fold_build2 (MEM_REF
,
1353 build_array_type (char_type_node
,
1354 build_range_type (sizetype
,
1357 exp
, build_int_cst (ptr_type_node
, 0));
1358 set_mem_attributes (mem
, exp
, 0);
1360 set_mem_alias_set (mem
, 0);
1364 /* Built-in functions to perform an untyped call and return. */
1366 #define apply_args_mode \
1367 (this_target_builtins->x_apply_args_mode)
1368 #define apply_result_mode \
1369 (this_target_builtins->x_apply_result_mode)
1371 /* Return the size required for the block returned by __builtin_apply_args,
1372 and initialize apply_args_mode. */
1375 apply_args_size (void)
1377 static int size
= -1;
1382 /* The values computed by this function never change. */
1385 /* The first value is the incoming arg-pointer. */
1386 size
= GET_MODE_SIZE (Pmode
);
1388 /* The second value is the structure value address unless this is
1389 passed as an "invisible" first argument. */
1390 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1391 size
+= GET_MODE_SIZE (Pmode
);
1393 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1394 if (FUNCTION_ARG_REGNO_P (regno
))
1396 mode
= targetm
.calls
.get_raw_arg_mode (regno
);
1398 gcc_assert (mode
!= VOIDmode
);
1400 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1401 if (size
% align
!= 0)
1402 size
= CEIL (size
, align
) * align
;
1403 size
+= GET_MODE_SIZE (mode
);
1404 apply_args_mode
[regno
] = mode
;
1408 apply_args_mode
[regno
] = VOIDmode
;
1414 /* Return the size required for the block returned by __builtin_apply,
1415 and initialize apply_result_mode. */
1418 apply_result_size (void)
1420 static int size
= -1;
1424 /* The values computed by this function never change. */
1429 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1430 if (targetm
.calls
.function_value_regno_p (regno
))
1432 mode
= targetm
.calls
.get_raw_result_mode (regno
);
1434 gcc_assert (mode
!= VOIDmode
);
1436 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1437 if (size
% align
!= 0)
1438 size
= CEIL (size
, align
) * align
;
1439 size
+= GET_MODE_SIZE (mode
);
1440 apply_result_mode
[regno
] = mode
;
1443 apply_result_mode
[regno
] = VOIDmode
;
1445 /* Allow targets that use untyped_call and untyped_return to override
1446 the size so that machine-specific information can be stored here. */
1447 #ifdef APPLY_RESULT_SIZE
1448 size
= APPLY_RESULT_SIZE
;
1454 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1455 /* Create a vector describing the result block RESULT. If SAVEP is true,
1456 the result block is used to save the values; otherwise it is used to
1457 restore the values. */
1460 result_vector (int savep
, rtx result
)
1462 int regno
, size
, align
, nelts
;
1465 rtx
*savevec
= XALLOCAVEC (rtx
, FIRST_PSEUDO_REGISTER
);
1468 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1469 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1471 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1472 if (size
% align
!= 0)
1473 size
= CEIL (size
, align
) * align
;
1474 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1475 mem
= adjust_address (result
, mode
, size
);
1476 savevec
[nelts
++] = (savep
1477 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1478 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1479 size
+= GET_MODE_SIZE (mode
);
1481 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1483 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1485 /* Save the state required to perform an untyped call with the same
1486 arguments as were passed to the current function. */
1489 expand_builtin_apply_args_1 (void)
1492 int size
, align
, regno
;
1494 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1496 /* Create a block where the arg-pointer, structure value address,
1497 and argument registers can be saved. */
1498 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1500 /* Walk past the arg-pointer and structure value address. */
1501 size
= GET_MODE_SIZE (Pmode
);
1502 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1503 size
+= GET_MODE_SIZE (Pmode
);
1505 /* Save each register used in calling a function to the block. */
1506 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1507 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1509 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1510 if (size
% align
!= 0)
1511 size
= CEIL (size
, align
) * align
;
1513 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1515 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1516 size
+= GET_MODE_SIZE (mode
);
1519 /* Save the arg pointer to the block. */
1520 tem
= copy_to_reg (crtl
->args
.internal_arg_pointer
);
1521 #ifdef STACK_GROWS_DOWNWARD
1522 /* We need the pointer as the caller actually passed them to us, not
1523 as we might have pretended they were passed. Make sure it's a valid
1524 operand, as emit_move_insn isn't expected to handle a PLUS. */
1526 = force_operand (plus_constant (Pmode
, tem
, crtl
->args
.pretend_args_size
),
1529 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1531 size
= GET_MODE_SIZE (Pmode
);
1533 /* Save the structure value address unless this is passed as an
1534 "invisible" first argument. */
1535 if (struct_incoming_value
)
1537 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1538 copy_to_reg (struct_incoming_value
));
1539 size
+= GET_MODE_SIZE (Pmode
);
1542 /* Return the address of the block. */
1543 return copy_addr_to_reg (XEXP (registers
, 0));
1546 /* __builtin_apply_args returns block of memory allocated on
1547 the stack into which is stored the arg pointer, structure
1548 value address, static chain, and all the registers that might
1549 possibly be used in performing a function call. The code is
1550 moved to the start of the function so the incoming values are
1554 expand_builtin_apply_args (void)
1556 /* Don't do __builtin_apply_args more than once in a function.
1557 Save the result of the first call and reuse it. */
1558 if (apply_args_value
!= 0)
1559 return apply_args_value
;
1561 /* When this function is called, it means that registers must be
1562 saved on entry to this function. So we migrate the
1563 call to the first insn of this function. */
1568 temp
= expand_builtin_apply_args_1 ();
1572 apply_args_value
= temp
;
1574 /* Put the insns after the NOTE that starts the function.
1575 If this is inside a start_sequence, make the outer-level insn
1576 chain current, so the code is placed at the start of the
1577 function. If internal_arg_pointer is a non-virtual pseudo,
1578 it needs to be placed after the function that initializes
1580 push_topmost_sequence ();
1581 if (REG_P (crtl
->args
.internal_arg_pointer
)
1582 && REGNO (crtl
->args
.internal_arg_pointer
) > LAST_VIRTUAL_REGISTER
)
1583 emit_insn_before (seq
, parm_birth_insn
);
1585 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1586 pop_topmost_sequence ();
1591 /* Perform an untyped call and save the state required to perform an
1592 untyped return of whatever value was returned by the given function. */
1595 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1597 int size
, align
, regno
;
1599 rtx incoming_args
, result
, reg
, dest
, src
;
1600 rtx_call_insn
*call_insn
;
1601 rtx old_stack_level
= 0;
1602 rtx call_fusage
= 0;
1603 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1605 arguments
= convert_memory_address (Pmode
, arguments
);
1607 /* Create a block where the return registers can be saved. */
1608 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1610 /* Fetch the arg pointer from the ARGUMENTS block. */
1611 incoming_args
= gen_reg_rtx (Pmode
);
1612 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1613 #ifndef STACK_GROWS_DOWNWARD
1614 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1615 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1618 /* Push a new argument block and copy the arguments. Do not allow
1619 the (potential) memcpy call below to interfere with our stack
1621 do_pending_stack_adjust ();
1624 /* Save the stack with nonlocal if available. */
1625 #ifdef HAVE_save_stack_nonlocal
1626 if (HAVE_save_stack_nonlocal
)
1627 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
);
1630 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
1632 /* Allocate a block of memory onto the stack and copy the memory
1633 arguments to the outgoing arguments address. We can pass TRUE
1634 as the 4th argument because we just saved the stack pointer
1635 and will restore it right after the call. */
1636 allocate_dynamic_stack_space (argsize
, 0, BIGGEST_ALIGNMENT
, true);
1638 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1639 may have already set current_function_calls_alloca to true.
1640 current_function_calls_alloca won't be set if argsize is zero,
1641 so we have to guarantee need_drap is true here. */
1642 if (SUPPORTS_STACK_ALIGNMENT
)
1643 crtl
->need_drap
= true;
1645 dest
= virtual_outgoing_args_rtx
;
1646 #ifndef STACK_GROWS_DOWNWARD
1647 if (CONST_INT_P (argsize
))
1648 dest
= plus_constant (Pmode
, dest
, -INTVAL (argsize
));
1650 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1652 dest
= gen_rtx_MEM (BLKmode
, dest
);
1653 set_mem_align (dest
, PARM_BOUNDARY
);
1654 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1655 set_mem_align (src
, PARM_BOUNDARY
);
1656 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1658 /* Refer to the argument block. */
1660 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1661 set_mem_align (arguments
, PARM_BOUNDARY
);
1663 /* Walk past the arg-pointer and structure value address. */
1664 size
= GET_MODE_SIZE (Pmode
);
1666 size
+= GET_MODE_SIZE (Pmode
);
1668 /* Restore each of the registers previously saved. Make USE insns
1669 for each of these registers for use in making the call. */
1670 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1671 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1673 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1674 if (size
% align
!= 0)
1675 size
= CEIL (size
, align
) * align
;
1676 reg
= gen_rtx_REG (mode
, regno
);
1677 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1678 use_reg (&call_fusage
, reg
);
1679 size
+= GET_MODE_SIZE (mode
);
1682 /* Restore the structure value address unless this is passed as an
1683 "invisible" first argument. */
1684 size
= GET_MODE_SIZE (Pmode
);
1687 rtx value
= gen_reg_rtx (Pmode
);
1688 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1689 emit_move_insn (struct_value
, value
);
1690 if (REG_P (struct_value
))
1691 use_reg (&call_fusage
, struct_value
);
1692 size
+= GET_MODE_SIZE (Pmode
);
1695 /* All arguments and registers used for the call are set up by now! */
1696 function
= prepare_call_address (NULL
, function
, NULL
, &call_fusage
, 0, 0);
1698 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1699 and we don't want to load it into a register as an optimization,
1700 because prepare_call_address already did it if it should be done. */
1701 if (GET_CODE (function
) != SYMBOL_REF
)
1702 function
= memory_address (FUNCTION_MODE
, function
);
1704 /* Generate the actual call instruction and save the return value. */
1705 #ifdef HAVE_untyped_call
1706 if (HAVE_untyped_call
)
1707 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1708 result
, result_vector (1, result
)));
1711 #ifdef HAVE_call_value
1712 if (HAVE_call_value
)
1716 /* Locate the unique return register. It is not possible to
1717 express a call that sets more than one return register using
1718 call_value; use untyped_call for that. In fact, untyped_call
1719 only needs to save the return registers in the given block. */
1720 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1721 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1723 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1725 valreg
= gen_rtx_REG (mode
, regno
);
1728 emit_call_insn (GEN_CALL_VALUE (valreg
,
1729 gen_rtx_MEM (FUNCTION_MODE
, function
),
1730 const0_rtx
, NULL_RTX
, const0_rtx
));
1732 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1738 /* Find the CALL insn we just emitted, and attach the register usage
1740 call_insn
= last_call_insn ();
1741 add_function_usage_to (call_insn
, call_fusage
);
1743 /* Restore the stack. */
1744 #ifdef HAVE_save_stack_nonlocal
1745 if (HAVE_save_stack_nonlocal
)
1746 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
);
1749 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
1750 fixup_args_size_notes (call_insn
, get_last_insn (), 0);
1754 /* Return the address of the result block. */
1755 result
= copy_addr_to_reg (XEXP (result
, 0));
1756 return convert_memory_address (ptr_mode
, result
);
1759 /* Perform an untyped return. */
1762 expand_builtin_return (rtx result
)
1764 int size
, align
, regno
;
1767 rtx_insn
*call_fusage
= 0;
1769 result
= convert_memory_address (Pmode
, result
);
1771 apply_result_size ();
1772 result
= gen_rtx_MEM (BLKmode
, result
);
1774 #ifdef HAVE_untyped_return
1775 if (HAVE_untyped_return
)
1777 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1783 /* Restore the return value and note that each value is used. */
1785 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1786 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1788 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1789 if (size
% align
!= 0)
1790 size
= CEIL (size
, align
) * align
;
1791 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1792 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1794 push_to_sequence (call_fusage
);
1796 call_fusage
= get_insns ();
1798 size
+= GET_MODE_SIZE (mode
);
1801 /* Put the USE insns before the return. */
1802 emit_insn (call_fusage
);
1804 /* Return whatever values was restored by jumping directly to the end
1806 expand_naked_return ();
1809 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1811 static enum type_class
1812 type_to_class (tree type
)
1814 switch (TREE_CODE (type
))
1816 case VOID_TYPE
: return void_type_class
;
1817 case INTEGER_TYPE
: return integer_type_class
;
1818 case ENUMERAL_TYPE
: return enumeral_type_class
;
1819 case BOOLEAN_TYPE
: return boolean_type_class
;
1820 case POINTER_TYPE
: return pointer_type_class
;
1821 case REFERENCE_TYPE
: return reference_type_class
;
1822 case OFFSET_TYPE
: return offset_type_class
;
1823 case REAL_TYPE
: return real_type_class
;
1824 case COMPLEX_TYPE
: return complex_type_class
;
1825 case FUNCTION_TYPE
: return function_type_class
;
1826 case METHOD_TYPE
: return method_type_class
;
1827 case RECORD_TYPE
: return record_type_class
;
1829 case QUAL_UNION_TYPE
: return union_type_class
;
1830 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1831 ? string_type_class
: array_type_class
);
1832 case LANG_TYPE
: return lang_type_class
;
1833 default: return no_type_class
;
1837 /* Expand a call EXP to __builtin_classify_type. */
1840 expand_builtin_classify_type (tree exp
)
1842 if (call_expr_nargs (exp
))
1843 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))));
1844 return GEN_INT (no_type_class
);
1847 /* This helper macro, meant to be used in mathfn_built_in below,
1848 determines which among a set of three builtin math functions is
1849 appropriate for a given type mode. The `F' and `L' cases are
1850 automatically generated from the `double' case. */
1851 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1852 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1853 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1854 fcodel = BUILT_IN_MATHFN##L ; break;
1855 /* Similar to above, but appends _R after any F/L suffix. */
1856 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1857 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1858 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1859 fcodel = BUILT_IN_MATHFN##L_R ; break;
1861 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1862 if available. If IMPLICIT is true use the implicit builtin declaration,
1863 otherwise use the explicit declaration. If we can't do the conversion,
1867 mathfn_built_in_1 (tree type
, enum built_in_function fn
, bool implicit_p
)
1869 enum built_in_function fcode
, fcodef
, fcodel
, fcode2
;
1873 CASE_MATHFN (BUILT_IN_ACOS
)
1874 CASE_MATHFN (BUILT_IN_ACOSH
)
1875 CASE_MATHFN (BUILT_IN_ASIN
)
1876 CASE_MATHFN (BUILT_IN_ASINH
)
1877 CASE_MATHFN (BUILT_IN_ATAN
)
1878 CASE_MATHFN (BUILT_IN_ATAN2
)
1879 CASE_MATHFN (BUILT_IN_ATANH
)
1880 CASE_MATHFN (BUILT_IN_CBRT
)
1881 CASE_MATHFN (BUILT_IN_CEIL
)
1882 CASE_MATHFN (BUILT_IN_CEXPI
)
1883 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1884 CASE_MATHFN (BUILT_IN_COS
)
1885 CASE_MATHFN (BUILT_IN_COSH
)
1886 CASE_MATHFN (BUILT_IN_DREM
)
1887 CASE_MATHFN (BUILT_IN_ERF
)
1888 CASE_MATHFN (BUILT_IN_ERFC
)
1889 CASE_MATHFN (BUILT_IN_EXP
)
1890 CASE_MATHFN (BUILT_IN_EXP10
)
1891 CASE_MATHFN (BUILT_IN_EXP2
)
1892 CASE_MATHFN (BUILT_IN_EXPM1
)
1893 CASE_MATHFN (BUILT_IN_FABS
)
1894 CASE_MATHFN (BUILT_IN_FDIM
)
1895 CASE_MATHFN (BUILT_IN_FLOOR
)
1896 CASE_MATHFN (BUILT_IN_FMA
)
1897 CASE_MATHFN (BUILT_IN_FMAX
)
1898 CASE_MATHFN (BUILT_IN_FMIN
)
1899 CASE_MATHFN (BUILT_IN_FMOD
)
1900 CASE_MATHFN (BUILT_IN_FREXP
)
1901 CASE_MATHFN (BUILT_IN_GAMMA
)
1902 CASE_MATHFN_REENT (BUILT_IN_GAMMA
) /* GAMMA_R */
1903 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1904 CASE_MATHFN (BUILT_IN_HYPOT
)
1905 CASE_MATHFN (BUILT_IN_ILOGB
)
1906 CASE_MATHFN (BUILT_IN_ICEIL
)
1907 CASE_MATHFN (BUILT_IN_IFLOOR
)
1908 CASE_MATHFN (BUILT_IN_INF
)
1909 CASE_MATHFN (BUILT_IN_IRINT
)
1910 CASE_MATHFN (BUILT_IN_IROUND
)
1911 CASE_MATHFN (BUILT_IN_ISINF
)
1912 CASE_MATHFN (BUILT_IN_J0
)
1913 CASE_MATHFN (BUILT_IN_J1
)
1914 CASE_MATHFN (BUILT_IN_JN
)
1915 CASE_MATHFN (BUILT_IN_LCEIL
)
1916 CASE_MATHFN (BUILT_IN_LDEXP
)
1917 CASE_MATHFN (BUILT_IN_LFLOOR
)
1918 CASE_MATHFN (BUILT_IN_LGAMMA
)
1919 CASE_MATHFN_REENT (BUILT_IN_LGAMMA
) /* LGAMMA_R */
1920 CASE_MATHFN (BUILT_IN_LLCEIL
)
1921 CASE_MATHFN (BUILT_IN_LLFLOOR
)
1922 CASE_MATHFN (BUILT_IN_LLRINT
)
1923 CASE_MATHFN (BUILT_IN_LLROUND
)
1924 CASE_MATHFN (BUILT_IN_LOG
)
1925 CASE_MATHFN (BUILT_IN_LOG10
)
1926 CASE_MATHFN (BUILT_IN_LOG1P
)
1927 CASE_MATHFN (BUILT_IN_LOG2
)
1928 CASE_MATHFN (BUILT_IN_LOGB
)
1929 CASE_MATHFN (BUILT_IN_LRINT
)
1930 CASE_MATHFN (BUILT_IN_LROUND
)
1931 CASE_MATHFN (BUILT_IN_MODF
)
1932 CASE_MATHFN (BUILT_IN_NAN
)
1933 CASE_MATHFN (BUILT_IN_NANS
)
1934 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1935 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1936 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1937 CASE_MATHFN (BUILT_IN_POW
)
1938 CASE_MATHFN (BUILT_IN_POWI
)
1939 CASE_MATHFN (BUILT_IN_POW10
)
1940 CASE_MATHFN (BUILT_IN_REMAINDER
)
1941 CASE_MATHFN (BUILT_IN_REMQUO
)
1942 CASE_MATHFN (BUILT_IN_RINT
)
1943 CASE_MATHFN (BUILT_IN_ROUND
)
1944 CASE_MATHFN (BUILT_IN_SCALB
)
1945 CASE_MATHFN (BUILT_IN_SCALBLN
)
1946 CASE_MATHFN (BUILT_IN_SCALBN
)
1947 CASE_MATHFN (BUILT_IN_SIGNBIT
)
1948 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1949 CASE_MATHFN (BUILT_IN_SIN
)
1950 CASE_MATHFN (BUILT_IN_SINCOS
)
1951 CASE_MATHFN (BUILT_IN_SINH
)
1952 CASE_MATHFN (BUILT_IN_SQRT
)
1953 CASE_MATHFN (BUILT_IN_TAN
)
1954 CASE_MATHFN (BUILT_IN_TANH
)
1955 CASE_MATHFN (BUILT_IN_TGAMMA
)
1956 CASE_MATHFN (BUILT_IN_TRUNC
)
1957 CASE_MATHFN (BUILT_IN_Y0
)
1958 CASE_MATHFN (BUILT_IN_Y1
)
1959 CASE_MATHFN (BUILT_IN_YN
)
1965 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1967 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1969 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1974 if (implicit_p
&& !builtin_decl_implicit_p (fcode2
))
1977 return builtin_decl_explicit (fcode2
);
1980 /* Like mathfn_built_in_1(), but always use the implicit array. */
1983 mathfn_built_in (tree type
, enum built_in_function fn
)
1985 return mathfn_built_in_1 (type
, fn
, /*implicit=*/ 1);
1988 /* If errno must be maintained, expand the RTL to check if the result,
1989 TARGET, of a built-in function call, EXP, is NaN, and if so set
1993 expand_errno_check (tree exp
, rtx target
)
1995 rtx_code_label
*lab
= gen_label_rtx ();
1997 /* Test the result; if it is NaN, set errno=EDOM because
1998 the argument was not in the domain. */
1999 do_compare_rtx_and_jump (target
, target
, EQ
, 0, GET_MODE (target
),
2000 NULL_RTX
, NULL_RTX
, lab
,
2001 /* The jump is very likely. */
2002 REG_BR_PROB_BASE
- (REG_BR_PROB_BASE
/ 2000 - 1));
2005 /* If this built-in doesn't throw an exception, set errno directly. */
2006 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp
), 0)))
2008 #ifdef GEN_ERRNO_RTX
2009 rtx errno_rtx
= GEN_ERRNO_RTX
;
2012 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
2014 emit_move_insn (errno_rtx
,
2015 gen_int_mode (TARGET_EDOM
, GET_MODE (errno_rtx
)));
2021 /* Make sure the library call isn't expanded as a tail call. */
2022 CALL_EXPR_TAILCALL (exp
) = 0;
2024 /* We can't set errno=EDOM directly; let the library call do it.
2025 Pop the arguments right away in case the call gets deleted. */
2027 expand_call (exp
, target
, 0);
2032 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
2033 Return NULL_RTX if a normal call should be emitted rather than expanding
2034 the function in-line. EXP is the expression that is a call to the builtin
2035 function; if convenient, the result should be placed in TARGET.
2036 SUBTARGET may be used as the target for computing one of EXP's operands. */
2039 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
2041 optab builtin_optab
;
2044 tree fndecl
= get_callee_fndecl (exp
);
2046 bool errno_set
= false;
2047 bool try_widening
= false;
2050 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2053 arg
= CALL_EXPR_ARG (exp
, 0);
2055 switch (DECL_FUNCTION_CODE (fndecl
))
2057 CASE_FLT_FN (BUILT_IN_SQRT
):
2058 errno_set
= ! tree_expr_nonnegative_p (arg
);
2059 try_widening
= true;
2060 builtin_optab
= sqrt_optab
;
2062 CASE_FLT_FN (BUILT_IN_EXP
):
2063 errno_set
= true; builtin_optab
= exp_optab
; break;
2064 CASE_FLT_FN (BUILT_IN_EXP10
):
2065 CASE_FLT_FN (BUILT_IN_POW10
):
2066 errno_set
= true; builtin_optab
= exp10_optab
; break;
2067 CASE_FLT_FN (BUILT_IN_EXP2
):
2068 errno_set
= true; builtin_optab
= exp2_optab
; break;
2069 CASE_FLT_FN (BUILT_IN_EXPM1
):
2070 errno_set
= true; builtin_optab
= expm1_optab
; break;
2071 CASE_FLT_FN (BUILT_IN_LOGB
):
2072 errno_set
= true; builtin_optab
= logb_optab
; break;
2073 CASE_FLT_FN (BUILT_IN_LOG
):
2074 errno_set
= true; builtin_optab
= log_optab
; break;
2075 CASE_FLT_FN (BUILT_IN_LOG10
):
2076 errno_set
= true; builtin_optab
= log10_optab
; break;
2077 CASE_FLT_FN (BUILT_IN_LOG2
):
2078 errno_set
= true; builtin_optab
= log2_optab
; break;
2079 CASE_FLT_FN (BUILT_IN_LOG1P
):
2080 errno_set
= true; builtin_optab
= log1p_optab
; break;
2081 CASE_FLT_FN (BUILT_IN_ASIN
):
2082 builtin_optab
= asin_optab
; break;
2083 CASE_FLT_FN (BUILT_IN_ACOS
):
2084 builtin_optab
= acos_optab
; break;
2085 CASE_FLT_FN (BUILT_IN_TAN
):
2086 builtin_optab
= tan_optab
; break;
2087 CASE_FLT_FN (BUILT_IN_ATAN
):
2088 builtin_optab
= atan_optab
; break;
2089 CASE_FLT_FN (BUILT_IN_FLOOR
):
2090 builtin_optab
= floor_optab
; break;
2091 CASE_FLT_FN (BUILT_IN_CEIL
):
2092 builtin_optab
= ceil_optab
; break;
2093 CASE_FLT_FN (BUILT_IN_TRUNC
):
2094 builtin_optab
= btrunc_optab
; break;
2095 CASE_FLT_FN (BUILT_IN_ROUND
):
2096 builtin_optab
= round_optab
; break;
2097 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
2098 builtin_optab
= nearbyint_optab
;
2099 if (flag_trapping_math
)
2101 /* Else fallthrough and expand as rint. */
2102 CASE_FLT_FN (BUILT_IN_RINT
):
2103 builtin_optab
= rint_optab
; break;
2104 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
2105 builtin_optab
= significand_optab
; break;
2110 /* Make a suitable register to place result in. */
2111 mode
= TYPE_MODE (TREE_TYPE (exp
));
2113 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2116 /* Before working hard, check whether the instruction is available, but try
2117 to widen the mode for specific operations. */
2118 if ((optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
2119 || (try_widening
&& !excess_precision_type (TREE_TYPE (exp
))))
2120 && (!errno_set
|| !optimize_insn_for_size_p ()))
2122 rtx result
= gen_reg_rtx (mode
);
2124 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2125 need to expand the argument again. This way, we will not perform
2126 side-effects more the once. */
2127 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2129 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2133 /* Compute into RESULT.
2134 Set RESULT to wherever the result comes back. */
2135 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2140 expand_errno_check (exp
, result
);
2142 /* Output the entire sequence. */
2143 insns
= get_insns ();
2149 /* If we were unable to expand via the builtin, stop the sequence
2150 (without outputting the insns) and call to the library function
2151 with the stabilized argument list. */
2155 return expand_call (exp
, target
, target
== const0_rtx
);
2158 /* Expand a call to the builtin binary math functions (pow and atan2).
2159 Return NULL_RTX if a normal call should be emitted rather than expanding the
2160 function in-line. EXP is the expression that is a call to the builtin
2161 function; if convenient, the result should be placed in TARGET.
2162 SUBTARGET may be used as the target for computing one of EXP's
2166 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
2168 optab builtin_optab
;
2169 rtx op0
, op1
, result
;
2171 int op1_type
= REAL_TYPE
;
2172 tree fndecl
= get_callee_fndecl (exp
);
2175 bool errno_set
= true;
2177 switch (DECL_FUNCTION_CODE (fndecl
))
2179 CASE_FLT_FN (BUILT_IN_SCALBN
):
2180 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2181 CASE_FLT_FN (BUILT_IN_LDEXP
):
2182 op1_type
= INTEGER_TYPE
;
2187 if (!validate_arglist (exp
, REAL_TYPE
, op1_type
, VOID_TYPE
))
2190 arg0
= CALL_EXPR_ARG (exp
, 0);
2191 arg1
= CALL_EXPR_ARG (exp
, 1);
2193 switch (DECL_FUNCTION_CODE (fndecl
))
2195 CASE_FLT_FN (BUILT_IN_POW
):
2196 builtin_optab
= pow_optab
; break;
2197 CASE_FLT_FN (BUILT_IN_ATAN2
):
2198 builtin_optab
= atan2_optab
; break;
2199 CASE_FLT_FN (BUILT_IN_SCALB
):
2200 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2202 builtin_optab
= scalb_optab
; break;
2203 CASE_FLT_FN (BUILT_IN_SCALBN
):
2204 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2205 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2207 /* Fall through... */
2208 CASE_FLT_FN (BUILT_IN_LDEXP
):
2209 builtin_optab
= ldexp_optab
; break;
2210 CASE_FLT_FN (BUILT_IN_FMOD
):
2211 builtin_optab
= fmod_optab
; break;
2212 CASE_FLT_FN (BUILT_IN_REMAINDER
):
2213 CASE_FLT_FN (BUILT_IN_DREM
):
2214 builtin_optab
= remainder_optab
; break;
2219 /* Make a suitable register to place result in. */
2220 mode
= TYPE_MODE (TREE_TYPE (exp
));
2222 /* Before working hard, check whether the instruction is available. */
2223 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2226 result
= gen_reg_rtx (mode
);
2228 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2231 if (errno_set
&& optimize_insn_for_size_p ())
2234 /* Always stabilize the argument list. */
2235 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2236 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2238 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2239 op1
= expand_normal (arg1
);
2243 /* Compute into RESULT.
2244 Set RESULT to wherever the result comes back. */
2245 result
= expand_binop (mode
, builtin_optab
, op0
, op1
,
2246 result
, 0, OPTAB_DIRECT
);
2248 /* If we were unable to expand via the builtin, stop the sequence
2249 (without outputting the insns) and call to the library function
2250 with the stabilized argument list. */
2254 return expand_call (exp
, target
, target
== const0_rtx
);
2258 expand_errno_check (exp
, result
);
2260 /* Output the entire sequence. */
2261 insns
= get_insns ();
2268 /* Expand a call to the builtin trinary math functions (fma).
2269 Return NULL_RTX if a normal call should be emitted rather than expanding the
2270 function in-line. EXP is the expression that is a call to the builtin
2271 function; if convenient, the result should be placed in TARGET.
2272 SUBTARGET may be used as the target for computing one of EXP's
2276 expand_builtin_mathfn_ternary (tree exp
, rtx target
, rtx subtarget
)
2278 optab builtin_optab
;
2279 rtx op0
, op1
, op2
, result
;
2281 tree fndecl
= get_callee_fndecl (exp
);
2282 tree arg0
, arg1
, arg2
;
2285 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2288 arg0
= CALL_EXPR_ARG (exp
, 0);
2289 arg1
= CALL_EXPR_ARG (exp
, 1);
2290 arg2
= CALL_EXPR_ARG (exp
, 2);
2292 switch (DECL_FUNCTION_CODE (fndecl
))
2294 CASE_FLT_FN (BUILT_IN_FMA
):
2295 builtin_optab
= fma_optab
; break;
2300 /* Make a suitable register to place result in. */
2301 mode
= TYPE_MODE (TREE_TYPE (exp
));
2303 /* Before working hard, check whether the instruction is available. */
2304 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2307 result
= gen_reg_rtx (mode
);
2309 /* Always stabilize the argument list. */
2310 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2311 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2312 CALL_EXPR_ARG (exp
, 2) = arg2
= builtin_save_expr (arg2
);
2314 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2315 op1
= expand_normal (arg1
);
2316 op2
= expand_normal (arg2
);
2320 /* Compute into RESULT.
2321 Set RESULT to wherever the result comes back. */
2322 result
= expand_ternary_op (mode
, builtin_optab
, op0
, op1
, op2
,
2325 /* If we were unable to expand via the builtin, stop the sequence
2326 (without outputting the insns) and call to the library function
2327 with the stabilized argument list. */
2331 return expand_call (exp
, target
, target
== const0_rtx
);
2334 /* Output the entire sequence. */
2335 insns
= get_insns ();
2342 /* Expand a call to the builtin sin and cos math functions.
2343 Return NULL_RTX if a normal call should be emitted rather than expanding the
2344 function in-line. EXP is the expression that is a call to the builtin
2345 function; if convenient, the result should be placed in TARGET.
2346 SUBTARGET may be used as the target for computing one of EXP's
2350 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2352 optab builtin_optab
;
2355 tree fndecl
= get_callee_fndecl (exp
);
2359 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2362 arg
= CALL_EXPR_ARG (exp
, 0);
2364 switch (DECL_FUNCTION_CODE (fndecl
))
2366 CASE_FLT_FN (BUILT_IN_SIN
):
2367 CASE_FLT_FN (BUILT_IN_COS
):
2368 builtin_optab
= sincos_optab
; break;
2373 /* Make a suitable register to place result in. */
2374 mode
= TYPE_MODE (TREE_TYPE (exp
));
2376 /* Check if sincos insn is available, otherwise fallback
2377 to sin or cos insn. */
2378 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2379 switch (DECL_FUNCTION_CODE (fndecl
))
2381 CASE_FLT_FN (BUILT_IN_SIN
):
2382 builtin_optab
= sin_optab
; break;
2383 CASE_FLT_FN (BUILT_IN_COS
):
2384 builtin_optab
= cos_optab
; break;
2389 /* Before working hard, check whether the instruction is available. */
2390 if (optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
)
2392 rtx result
= gen_reg_rtx (mode
);
2394 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2395 need to expand the argument again. This way, we will not perform
2396 side-effects more the once. */
2397 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2399 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2403 /* Compute into RESULT.
2404 Set RESULT to wherever the result comes back. */
2405 if (builtin_optab
== sincos_optab
)
2409 switch (DECL_FUNCTION_CODE (fndecl
))
2411 CASE_FLT_FN (BUILT_IN_SIN
):
2412 ok
= expand_twoval_unop (builtin_optab
, op0
, 0, result
, 0);
2414 CASE_FLT_FN (BUILT_IN_COS
):
2415 ok
= expand_twoval_unop (builtin_optab
, op0
, result
, 0, 0);
2423 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2427 /* Output the entire sequence. */
2428 insns
= get_insns ();
2434 /* If we were unable to expand via the builtin, stop the sequence
2435 (without outputting the insns) and call to the library function
2436 with the stabilized argument list. */
2440 return expand_call (exp
, target
, target
== const0_rtx
);
2443 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2444 return an RTL instruction code that implements the functionality.
2445 If that isn't possible or available return CODE_FOR_nothing. */
2447 static enum insn_code
2448 interclass_mathfn_icode (tree arg
, tree fndecl
)
2450 bool errno_set
= false;
2451 optab builtin_optab
= unknown_optab
;
2454 switch (DECL_FUNCTION_CODE (fndecl
))
2456 CASE_FLT_FN (BUILT_IN_ILOGB
):
2457 errno_set
= true; builtin_optab
= ilogb_optab
; break;
2458 CASE_FLT_FN (BUILT_IN_ISINF
):
2459 builtin_optab
= isinf_optab
; break;
2460 case BUILT_IN_ISNORMAL
:
2461 case BUILT_IN_ISFINITE
:
2462 CASE_FLT_FN (BUILT_IN_FINITE
):
2463 case BUILT_IN_FINITED32
:
2464 case BUILT_IN_FINITED64
:
2465 case BUILT_IN_FINITED128
:
2466 case BUILT_IN_ISINFD32
:
2467 case BUILT_IN_ISINFD64
:
2468 case BUILT_IN_ISINFD128
:
2469 /* These builtins have no optabs (yet). */
2475 /* There's no easy way to detect the case we need to set EDOM. */
2476 if (flag_errno_math
&& errno_set
)
2477 return CODE_FOR_nothing
;
2479 /* Optab mode depends on the mode of the input argument. */
2480 mode
= TYPE_MODE (TREE_TYPE (arg
));
2483 return optab_handler (builtin_optab
, mode
);
2484 return CODE_FOR_nothing
;
2487 /* Expand a call to one of the builtin math functions that operate on
2488 floating point argument and output an integer result (ilogb, isinf,
2490 Return 0 if a normal call should be emitted rather than expanding the
2491 function in-line. EXP is the expression that is a call to the builtin
2492 function; if convenient, the result should be placed in TARGET. */
2495 expand_builtin_interclass_mathfn (tree exp
, rtx target
)
2497 enum insn_code icode
= CODE_FOR_nothing
;
2499 tree fndecl
= get_callee_fndecl (exp
);
2503 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2506 arg
= CALL_EXPR_ARG (exp
, 0);
2507 icode
= interclass_mathfn_icode (arg
, fndecl
);
2508 mode
= TYPE_MODE (TREE_TYPE (arg
));
2510 if (icode
!= CODE_FOR_nothing
)
2512 struct expand_operand ops
[1];
2513 rtx_insn
*last
= get_last_insn ();
2514 tree orig_arg
= arg
;
2516 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2517 need to expand the argument again. This way, we will not perform
2518 side-effects more the once. */
2519 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2521 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2523 if (mode
!= GET_MODE (op0
))
2524 op0
= convert_to_mode (mode
, op0
, 0);
2526 create_output_operand (&ops
[0], target
, TYPE_MODE (TREE_TYPE (exp
)));
2527 if (maybe_legitimize_operands (icode
, 0, 1, ops
)
2528 && maybe_emit_unop_insn (icode
, ops
[0].value
, op0
, UNKNOWN
))
2529 return ops
[0].value
;
2531 delete_insns_since (last
);
2532 CALL_EXPR_ARG (exp
, 0) = orig_arg
;
2538 /* Expand a call to the builtin sincos math function.
2539 Return NULL_RTX if a normal call should be emitted rather than expanding the
2540 function in-line. EXP is the expression that is a call to the builtin
2544 expand_builtin_sincos (tree exp
)
2546 rtx op0
, op1
, op2
, target1
, target2
;
2548 tree arg
, sinp
, cosp
;
2550 location_t loc
= EXPR_LOCATION (exp
);
2551 tree alias_type
, alias_off
;
2553 if (!validate_arglist (exp
, REAL_TYPE
,
2554 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2557 arg
= CALL_EXPR_ARG (exp
, 0);
2558 sinp
= CALL_EXPR_ARG (exp
, 1);
2559 cosp
= CALL_EXPR_ARG (exp
, 2);
2561 /* Make a suitable register to place result in. */
2562 mode
= TYPE_MODE (TREE_TYPE (arg
));
2564 /* Check if sincos insn is available, otherwise emit the call. */
2565 if (optab_handler (sincos_optab
, mode
) == CODE_FOR_nothing
)
2568 target1
= gen_reg_rtx (mode
);
2569 target2
= gen_reg_rtx (mode
);
2571 op0
= expand_normal (arg
);
2572 alias_type
= build_pointer_type_for_mode (TREE_TYPE (arg
), ptr_mode
, true);
2573 alias_off
= build_int_cst (alias_type
, 0);
2574 op1
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2576 op2
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2579 /* Compute into target1 and target2.
2580 Set TARGET to wherever the result comes back. */
2581 result
= expand_twoval_unop (sincos_optab
, op0
, target2
, target1
, 0);
2582 gcc_assert (result
);
2584 /* Move target1 and target2 to the memory locations indicated
2586 emit_move_insn (op1
, target1
);
2587 emit_move_insn (op2
, target2
);
2592 /* Expand a call to the internal cexpi builtin to the sincos math function.
2593 EXP is the expression that is a call to the builtin function; if convenient,
2594 the result should be placed in TARGET. */
2597 expand_builtin_cexpi (tree exp
, rtx target
)
2599 tree fndecl
= get_callee_fndecl (exp
);
2603 location_t loc
= EXPR_LOCATION (exp
);
2605 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2608 arg
= CALL_EXPR_ARG (exp
, 0);
2609 type
= TREE_TYPE (arg
);
2610 mode
= TYPE_MODE (TREE_TYPE (arg
));
2612 /* Try expanding via a sincos optab, fall back to emitting a libcall
2613 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2614 is only generated from sincos, cexp or if we have either of them. */
2615 if (optab_handler (sincos_optab
, mode
) != CODE_FOR_nothing
)
2617 op1
= gen_reg_rtx (mode
);
2618 op2
= gen_reg_rtx (mode
);
2620 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2622 /* Compute into op1 and op2. */
2623 expand_twoval_unop (sincos_optab
, op0
, op2
, op1
, 0);
2625 else if (targetm
.libc_has_function (function_sincos
))
2627 tree call
, fn
= NULL_TREE
;
2631 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2632 fn
= builtin_decl_explicit (BUILT_IN_SINCOSF
);
2633 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2634 fn
= builtin_decl_explicit (BUILT_IN_SINCOS
);
2635 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2636 fn
= builtin_decl_explicit (BUILT_IN_SINCOSL
);
2640 op1
= assign_temp (TREE_TYPE (arg
), 1, 1);
2641 op2
= assign_temp (TREE_TYPE (arg
), 1, 1);
2642 op1a
= copy_addr_to_reg (XEXP (op1
, 0));
2643 op2a
= copy_addr_to_reg (XEXP (op2
, 0));
2644 top1
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op1a
);
2645 top2
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op2a
);
2647 /* Make sure not to fold the sincos call again. */
2648 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2649 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn
)),
2650 call
, 3, arg
, top1
, top2
));
2654 tree call
, fn
= NULL_TREE
, narg
;
2655 tree ctype
= build_complex_type (type
);
2657 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2658 fn
= builtin_decl_explicit (BUILT_IN_CEXPF
);
2659 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2660 fn
= builtin_decl_explicit (BUILT_IN_CEXP
);
2661 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2662 fn
= builtin_decl_explicit (BUILT_IN_CEXPL
);
2666 /* If we don't have a decl for cexp create one. This is the
2667 friendliest fallback if the user calls __builtin_cexpi
2668 without full target C99 function support. */
2669 if (fn
== NULL_TREE
)
2672 const char *name
= NULL
;
2674 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2676 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2678 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2681 fntype
= build_function_type_list (ctype
, ctype
, NULL_TREE
);
2682 fn
= build_fn_decl (name
, fntype
);
2685 narg
= fold_build2_loc (loc
, COMPLEX_EXPR
, ctype
,
2686 build_real (type
, dconst0
), arg
);
2688 /* Make sure not to fold the cexp call again. */
2689 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2690 return expand_expr (build_call_nary (ctype
, call
, 1, narg
),
2691 target
, VOIDmode
, EXPAND_NORMAL
);
2694 /* Now build the proper return type. */
2695 return expand_expr (build2 (COMPLEX_EXPR
, build_complex_type (type
),
2696 make_tree (TREE_TYPE (arg
), op2
),
2697 make_tree (TREE_TYPE (arg
), op1
)),
2698 target
, VOIDmode
, EXPAND_NORMAL
);
2701 /* Conveniently construct a function call expression. FNDECL names the
2702 function to be called, N is the number of arguments, and the "..."
2703 parameters are the argument expressions. Unlike build_call_exr
2704 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2707 build_call_nofold_loc (location_t loc
, tree fndecl
, int n
, ...)
2710 tree fntype
= TREE_TYPE (fndecl
);
2711 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
2714 fn
= build_call_valist (TREE_TYPE (fntype
), fn
, n
, ap
);
2716 SET_EXPR_LOCATION (fn
, loc
);
2720 /* Expand a call to one of the builtin rounding functions gcc defines
2721 as an extension (lfloor and lceil). As these are gcc extensions we
2722 do not need to worry about setting errno to EDOM.
2723 If expanding via optab fails, lower expression to (int)(floor(x)).
2724 EXP is the expression that is a call to the builtin function;
2725 if convenient, the result should be placed in TARGET. */
2728 expand_builtin_int_roundingfn (tree exp
, rtx target
)
2730 convert_optab builtin_optab
;
2733 tree fndecl
= get_callee_fndecl (exp
);
2734 enum built_in_function fallback_fn
;
2735 tree fallback_fndecl
;
2739 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2742 arg
= CALL_EXPR_ARG (exp
, 0);
2744 switch (DECL_FUNCTION_CODE (fndecl
))
2746 CASE_FLT_FN (BUILT_IN_ICEIL
):
2747 CASE_FLT_FN (BUILT_IN_LCEIL
):
2748 CASE_FLT_FN (BUILT_IN_LLCEIL
):
2749 builtin_optab
= lceil_optab
;
2750 fallback_fn
= BUILT_IN_CEIL
;
2753 CASE_FLT_FN (BUILT_IN_IFLOOR
):
2754 CASE_FLT_FN (BUILT_IN_LFLOOR
):
2755 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
2756 builtin_optab
= lfloor_optab
;
2757 fallback_fn
= BUILT_IN_FLOOR
;
2764 /* Make a suitable register to place result in. */
2765 mode
= TYPE_MODE (TREE_TYPE (exp
));
2767 target
= gen_reg_rtx (mode
);
2769 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2770 need to expand the argument again. This way, we will not perform
2771 side-effects more the once. */
2772 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2774 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2778 /* Compute into TARGET. */
2779 if (expand_sfix_optab (target
, op0
, builtin_optab
))
2781 /* Output the entire sequence. */
2782 insns
= get_insns ();
2788 /* If we were unable to expand via the builtin, stop the sequence
2789 (without outputting the insns). */
2792 /* Fall back to floating point rounding optab. */
2793 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
2795 /* For non-C99 targets we may end up without a fallback fndecl here
2796 if the user called __builtin_lfloor directly. In this case emit
2797 a call to the floor/ceil variants nevertheless. This should result
2798 in the best user experience for not full C99 targets. */
2799 if (fallback_fndecl
== NULL_TREE
)
2802 const char *name
= NULL
;
2804 switch (DECL_FUNCTION_CODE (fndecl
))
2806 case BUILT_IN_ICEIL
:
2807 case BUILT_IN_LCEIL
:
2808 case BUILT_IN_LLCEIL
:
2811 case BUILT_IN_ICEILF
:
2812 case BUILT_IN_LCEILF
:
2813 case BUILT_IN_LLCEILF
:
2816 case BUILT_IN_ICEILL
:
2817 case BUILT_IN_LCEILL
:
2818 case BUILT_IN_LLCEILL
:
2821 case BUILT_IN_IFLOOR
:
2822 case BUILT_IN_LFLOOR
:
2823 case BUILT_IN_LLFLOOR
:
2826 case BUILT_IN_IFLOORF
:
2827 case BUILT_IN_LFLOORF
:
2828 case BUILT_IN_LLFLOORF
:
2831 case BUILT_IN_IFLOORL
:
2832 case BUILT_IN_LFLOORL
:
2833 case BUILT_IN_LLFLOORL
:
2840 fntype
= build_function_type_list (TREE_TYPE (arg
),
2841 TREE_TYPE (arg
), NULL_TREE
);
2842 fallback_fndecl
= build_fn_decl (name
, fntype
);
2845 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
), fallback_fndecl
, 1, arg
);
2847 tmp
= expand_normal (exp
);
2848 tmp
= maybe_emit_group_store (tmp
, TREE_TYPE (exp
));
2850 /* Truncate the result of floating point optab to integer
2851 via expand_fix (). */
2852 target
= gen_reg_rtx (mode
);
2853 expand_fix (target
, tmp
, 0);
2858 /* Expand a call to one of the builtin math functions doing integer
2860 Return 0 if a normal call should be emitted rather than expanding the
2861 function in-line. EXP is the expression that is a call to the builtin
2862 function; if convenient, the result should be placed in TARGET. */
2865 expand_builtin_int_roundingfn_2 (tree exp
, rtx target
)
2867 convert_optab builtin_optab
;
2870 tree fndecl
= get_callee_fndecl (exp
);
2873 enum built_in_function fallback_fn
= BUILT_IN_NONE
;
2875 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2878 arg
= CALL_EXPR_ARG (exp
, 0);
2880 switch (DECL_FUNCTION_CODE (fndecl
))
2882 CASE_FLT_FN (BUILT_IN_IRINT
):
2883 fallback_fn
= BUILT_IN_LRINT
;
2885 CASE_FLT_FN (BUILT_IN_LRINT
):
2886 CASE_FLT_FN (BUILT_IN_LLRINT
):
2887 builtin_optab
= lrint_optab
;
2890 CASE_FLT_FN (BUILT_IN_IROUND
):
2891 fallback_fn
= BUILT_IN_LROUND
;
2893 CASE_FLT_FN (BUILT_IN_LROUND
):
2894 CASE_FLT_FN (BUILT_IN_LLROUND
):
2895 builtin_optab
= lround_optab
;
2902 /* There's no easy way to detect the case we need to set EDOM. */
2903 if (flag_errno_math
&& fallback_fn
== BUILT_IN_NONE
)
2906 /* Make a suitable register to place result in. */
2907 mode
= TYPE_MODE (TREE_TYPE (exp
));
2909 /* There's no easy way to detect the case we need to set EDOM. */
2910 if (!flag_errno_math
)
2912 rtx result
= gen_reg_rtx (mode
);
2914 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2915 need to expand the argument again. This way, we will not perform
2916 side-effects more the once. */
2917 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2919 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2923 if (expand_sfix_optab (result
, op0
, builtin_optab
))
2925 /* Output the entire sequence. */
2926 insns
= get_insns ();
2932 /* If we were unable to expand via the builtin, stop the sequence
2933 (without outputting the insns) and call to the library function
2934 with the stabilized argument list. */
2938 if (fallback_fn
!= BUILT_IN_NONE
)
2940 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2941 targets, (int) round (x) should never be transformed into
2942 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2943 a call to lround in the hope that the target provides at least some
2944 C99 functions. This should result in the best user experience for
2945 not full C99 targets. */
2946 tree fallback_fndecl
= mathfn_built_in_1 (TREE_TYPE (arg
),
2949 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
),
2950 fallback_fndecl
, 1, arg
);
2952 target
= expand_call (exp
, NULL_RTX
, target
== const0_rtx
);
2953 target
= maybe_emit_group_store (target
, TREE_TYPE (exp
));
2954 return convert_to_mode (mode
, target
, 0);
2957 return expand_call (exp
, target
, target
== const0_rtx
);
2960 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2961 a normal call should be emitted rather than expanding the function
2962 in-line. EXP is the expression that is a call to the builtin
2963 function; if convenient, the result should be placed in TARGET. */
2966 expand_builtin_powi (tree exp
, rtx target
)
2973 if (! validate_arglist (exp
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2976 arg0
= CALL_EXPR_ARG (exp
, 0);
2977 arg1
= CALL_EXPR_ARG (exp
, 1);
2978 mode
= TYPE_MODE (TREE_TYPE (exp
));
2980 /* Emit a libcall to libgcc. */
2982 /* Mode of the 2nd argument must match that of an int. */
2983 mode2
= mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0);
2985 if (target
== NULL_RTX
)
2986 target
= gen_reg_rtx (mode
);
2988 op0
= expand_expr (arg0
, NULL_RTX
, mode
, EXPAND_NORMAL
);
2989 if (GET_MODE (op0
) != mode
)
2990 op0
= convert_to_mode (mode
, op0
, 0);
2991 op1
= expand_expr (arg1
, NULL_RTX
, mode2
, EXPAND_NORMAL
);
2992 if (GET_MODE (op1
) != mode2
)
2993 op1
= convert_to_mode (mode2
, op1
, 0);
2995 target
= emit_library_call_value (optab_libfunc (powi_optab
, mode
),
2996 target
, LCT_CONST
, mode
, 2,
2997 op0
, mode
, op1
, mode2
);
3002 /* Expand expression EXP which is a call to the strlen builtin. Return
3003 NULL_RTX if we failed the caller should emit a normal call, otherwise
3004 try to get the result in TARGET, if convenient. */
3007 expand_builtin_strlen (tree exp
, rtx target
,
3008 machine_mode target_mode
)
3010 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
3014 struct expand_operand ops
[4];
3017 tree src
= CALL_EXPR_ARG (exp
, 0);
3019 rtx_insn
*before_strlen
;
3020 machine_mode insn_mode
= target_mode
;
3021 enum insn_code icode
= CODE_FOR_nothing
;
3024 /* If the length can be computed at compile-time, return it. */
3025 len
= c_strlen (src
, 0);
3027 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3029 /* If the length can be computed at compile-time and is constant
3030 integer, but there are side-effects in src, evaluate
3031 src for side-effects, then return len.
3032 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3033 can be optimized into: i++; x = 3; */
3034 len
= c_strlen (src
, 1);
3035 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
3037 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3038 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3041 align
= get_pointer_alignment (src
) / BITS_PER_UNIT
;
3043 /* If SRC is not a pointer type, don't do this operation inline. */
3047 /* Bail out if we can't compute strlen in the right mode. */
3048 while (insn_mode
!= VOIDmode
)
3050 icode
= optab_handler (strlen_optab
, insn_mode
);
3051 if (icode
!= CODE_FOR_nothing
)
3054 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
3056 if (insn_mode
== VOIDmode
)
3059 /* Make a place to hold the source address. We will not expand
3060 the actual source until we are sure that the expansion will
3061 not fail -- there are trees that cannot be expanded twice. */
3062 src_reg
= gen_reg_rtx (Pmode
);
3064 /* Mark the beginning of the strlen sequence so we can emit the
3065 source operand later. */
3066 before_strlen
= get_last_insn ();
3068 create_output_operand (&ops
[0], target
, insn_mode
);
3069 create_fixed_operand (&ops
[1], gen_rtx_MEM (BLKmode
, src_reg
));
3070 create_integer_operand (&ops
[2], 0);
3071 create_integer_operand (&ops
[3], align
);
3072 if (!maybe_expand_insn (icode
, 4, ops
))
3075 /* Now that we are assured of success, expand the source. */
3077 pat
= expand_expr (src
, src_reg
, Pmode
, EXPAND_NORMAL
);
3080 #ifdef POINTERS_EXTEND_UNSIGNED
3081 if (GET_MODE (pat
) != Pmode
)
3082 pat
= convert_to_mode (Pmode
, pat
,
3083 POINTERS_EXTEND_UNSIGNED
);
3085 emit_move_insn (src_reg
, pat
);
3091 emit_insn_after (pat
, before_strlen
);
3093 emit_insn_before (pat
, get_insns ());
3095 /* Return the value in the proper mode for this function. */
3096 if (GET_MODE (ops
[0].value
) == target_mode
)
3097 target
= ops
[0].value
;
3098 else if (target
!= 0)
3099 convert_move (target
, ops
[0].value
, 0);
3101 target
= convert_to_mode (target_mode
, ops
[0].value
, 0);
3107 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3108 bytes from constant string DATA + OFFSET and return it as target
3112 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
3115 const char *str
= (const char *) data
;
3117 gcc_assert (offset
>= 0
3118 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
3119 <= strlen (str
) + 1));
3121 return c_readstr (str
+ offset
, mode
);
3124 /* LEN specify length of the block of memcpy/memset operation.
3125 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
3126 In some cases we can make very likely guess on max size, then we
3127 set it into PROBABLE_MAX_SIZE. */
3130 determine_block_size (tree len
, rtx len_rtx
,
3131 unsigned HOST_WIDE_INT
*min_size
,
3132 unsigned HOST_WIDE_INT
*max_size
,
3133 unsigned HOST_WIDE_INT
*probable_max_size
)
3135 if (CONST_INT_P (len_rtx
))
3137 *min_size
= *max_size
= *probable_max_size
= UINTVAL (len_rtx
);
3143 enum value_range_type range_type
= VR_UNDEFINED
;
3145 /* Determine bounds from the type. */
3146 if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len
))))
3147 *min_size
= tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len
)));
3150 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len
))))
3151 *probable_max_size
= *max_size
3152 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len
)));
3154 *probable_max_size
= *max_size
= GET_MODE_MASK (GET_MODE (len_rtx
));
3156 if (TREE_CODE (len
) == SSA_NAME
)
3157 range_type
= get_range_info (len
, &min
, &max
);
3158 if (range_type
== VR_RANGE
)
3160 if (wi::fits_uhwi_p (min
) && *min_size
< min
.to_uhwi ())
3161 *min_size
= min
.to_uhwi ();
3162 if (wi::fits_uhwi_p (max
) && *max_size
> max
.to_uhwi ())
3163 *probable_max_size
= *max_size
= max
.to_uhwi ();
3165 else if (range_type
== VR_ANTI_RANGE
)
3167 /* Anti range 0...N lets us to determine minimal size to N+1. */
3170 if (wi::fits_uhwi_p (max
) && max
.to_uhwi () + 1 != 0)
3171 *min_size
= max
.to_uhwi () + 1;
3179 Produce anti range allowing negative values of N. We still
3180 can use the information and make a guess that N is not negative.
3182 else if (!wi::leu_p (max
, 1 << 30) && wi::fits_uhwi_p (min
))
3183 *probable_max_size
= min
.to_uhwi () - 1;
3186 gcc_checking_assert (*max_size
<=
3187 (unsigned HOST_WIDE_INT
)
3188 GET_MODE_MASK (GET_MODE (len_rtx
)));
3191 /* Helper function to do the actual work for expand_builtin_memcpy. */
3194 expand_builtin_memcpy_args (tree dest
, tree src
, tree len
, rtx target
, tree exp
)
3196 const char *src_str
;
3197 unsigned int src_align
= get_pointer_alignment (src
);
3198 unsigned int dest_align
= get_pointer_alignment (dest
);
3199 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
3200 HOST_WIDE_INT expected_size
= -1;
3201 unsigned int expected_align
= 0;
3202 unsigned HOST_WIDE_INT min_size
;
3203 unsigned HOST_WIDE_INT max_size
;
3204 unsigned HOST_WIDE_INT probable_max_size
;
3206 /* If DEST is not a pointer type, call the normal function. */
3207 if (dest_align
== 0)
3210 /* If either SRC is not a pointer type, don't do this
3211 operation in-line. */
3215 if (currently_expanding_gimple_stmt
)
3216 stringop_block_profile (currently_expanding_gimple_stmt
,
3217 &expected_align
, &expected_size
);
3219 if (expected_align
< dest_align
)
3220 expected_align
= dest_align
;
3221 dest_mem
= get_memory_rtx (dest
, len
);
3222 set_mem_align (dest_mem
, dest_align
);
3223 len_rtx
= expand_normal (len
);
3224 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3225 &probable_max_size
);
3226 src_str
= c_getstr (src
);
3228 /* If SRC is a string constant and block move would be done
3229 by pieces, we can avoid loading the string from memory
3230 and only stored the computed constants. */
3232 && CONST_INT_P (len_rtx
)
3233 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3234 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3235 CONST_CAST (char *, src_str
),
3238 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3239 builtin_memcpy_read_str
,
3240 CONST_CAST (char *, src_str
),
3241 dest_align
, false, 0);
3242 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3243 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3247 src_mem
= get_memory_rtx (src
, len
);
3248 set_mem_align (src_mem
, src_align
);
3250 /* Copy word part most expediently. */
3251 dest_addr
= emit_block_move_hints (dest_mem
, src_mem
, len_rtx
,
3252 CALL_EXPR_TAILCALL (exp
)
3253 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3254 expected_align
, expected_size
,
3255 min_size
, max_size
, probable_max_size
);
3259 dest_addr
= force_operand (XEXP (dest_mem
, 0), target
);
3260 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3266 /* Expand a call EXP to the memcpy builtin.
3267 Return NULL_RTX if we failed, the caller should emit a normal call,
3268 otherwise try to get the result in TARGET, if convenient (and in
3269 mode MODE if that's convenient). */
3272 expand_builtin_memcpy (tree exp
, rtx target
)
3274 if (!validate_arglist (exp
,
3275 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3279 tree dest
= CALL_EXPR_ARG (exp
, 0);
3280 tree src
= CALL_EXPR_ARG (exp
, 1);
3281 tree len
= CALL_EXPR_ARG (exp
, 2);
3282 return expand_builtin_memcpy_args (dest
, src
, len
, target
, exp
);
3286 /* Expand an instrumented call EXP to the memcpy builtin.
3287 Return NULL_RTX if we failed, the caller should emit a normal call,
3288 otherwise try to get the result in TARGET, if convenient (and in
3289 mode MODE if that's convenient). */
3292 expand_builtin_memcpy_with_bounds (tree exp
, rtx target
)
3294 if (!validate_arglist (exp
,
3295 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3296 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3297 INTEGER_TYPE
, VOID_TYPE
))
3301 tree dest
= CALL_EXPR_ARG (exp
, 0);
3302 tree src
= CALL_EXPR_ARG (exp
, 2);
3303 tree len
= CALL_EXPR_ARG (exp
, 4);
3304 rtx res
= expand_builtin_memcpy_args (dest
, src
, len
, target
, exp
);
3306 /* Return src bounds with the result. */
3309 rtx bnd
= force_reg (targetm
.chkp_bound_mode (),
3310 expand_normal (CALL_EXPR_ARG (exp
, 1)));
3311 res
= chkp_join_splitted_slot (res
, bnd
);
3317 /* Expand a call EXP to the mempcpy builtin.
3318 Return NULL_RTX if we failed; the caller should emit a normal call,
3319 otherwise try to get the result in TARGET, if convenient (and in
3320 mode MODE if that's convenient). If ENDP is 0 return the
3321 destination pointer, if ENDP is 1 return the end pointer ala
3322 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3326 expand_builtin_mempcpy (tree exp
, rtx target
, machine_mode mode
)
3328 if (!validate_arglist (exp
,
3329 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3333 tree dest
= CALL_EXPR_ARG (exp
, 0);
3334 tree src
= CALL_EXPR_ARG (exp
, 1);
3335 tree len
= CALL_EXPR_ARG (exp
, 2);
3336 return expand_builtin_mempcpy_args (dest
, src
, len
,
3337 target
, mode
, /*endp=*/ 1,
3342 /* Expand an instrumented call EXP to the mempcpy builtin.
3343 Return NULL_RTX if we failed, the caller should emit a normal call,
3344 otherwise try to get the result in TARGET, if convenient (and in
3345 mode MODE if that's convenient). */
3348 expand_builtin_mempcpy_with_bounds (tree exp
, rtx target
, machine_mode mode
)
3350 if (!validate_arglist (exp
,
3351 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3352 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3353 INTEGER_TYPE
, VOID_TYPE
))
3357 tree dest
= CALL_EXPR_ARG (exp
, 0);
3358 tree src
= CALL_EXPR_ARG (exp
, 2);
3359 tree len
= CALL_EXPR_ARG (exp
, 4);
3360 rtx res
= expand_builtin_mempcpy_args (dest
, src
, len
, target
,
3363 /* Return src bounds with the result. */
3366 rtx bnd
= force_reg (targetm
.chkp_bound_mode (),
3367 expand_normal (CALL_EXPR_ARG (exp
, 1)));
3368 res
= chkp_join_splitted_slot (res
, bnd
);
3374 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3375 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3376 so that this can also be called without constructing an actual CALL_EXPR.
3377 The other arguments and return value are the same as for
3378 expand_builtin_mempcpy. */
3381 expand_builtin_mempcpy_args (tree dest
, tree src
, tree len
,
3382 rtx target
, machine_mode mode
, int endp
,
3385 tree fndecl
= get_callee_fndecl (orig_exp
);
3387 /* If return value is ignored, transform mempcpy into memcpy. */
3388 if (target
== const0_rtx
3389 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP
3390 && builtin_decl_implicit_p (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP
))
3392 tree fn
= builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP
);
3393 tree result
= build_call_nofold_loc (UNKNOWN_LOCATION
, fn
, 3,
3395 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3397 else if (target
== const0_rtx
3398 && builtin_decl_implicit_p (BUILT_IN_MEMCPY
))
3400 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3401 tree result
= build_call_nofold_loc (UNKNOWN_LOCATION
, fn
, 3,
3403 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3407 const char *src_str
;
3408 unsigned int src_align
= get_pointer_alignment (src
);
3409 unsigned int dest_align
= get_pointer_alignment (dest
);
3410 rtx dest_mem
, src_mem
, len_rtx
;
3412 /* If either SRC or DEST is not a pointer type, don't do this
3413 operation in-line. */
3414 if (dest_align
== 0 || src_align
== 0)
3417 /* If LEN is not constant, call the normal function. */
3418 if (! tree_fits_uhwi_p (len
))
3421 len_rtx
= expand_normal (len
);
3422 src_str
= c_getstr (src
);
3424 /* If SRC is a string constant and block move would be done
3425 by pieces, we can avoid loading the string from memory
3426 and only stored the computed constants. */
3428 && CONST_INT_P (len_rtx
)
3429 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3430 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3431 CONST_CAST (char *, src_str
),
3434 dest_mem
= get_memory_rtx (dest
, len
);
3435 set_mem_align (dest_mem
, dest_align
);
3436 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3437 builtin_memcpy_read_str
,
3438 CONST_CAST (char *, src_str
),
3439 dest_align
, false, endp
);
3440 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3441 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3445 if (CONST_INT_P (len_rtx
)
3446 && can_move_by_pieces (INTVAL (len_rtx
),
3447 MIN (dest_align
, src_align
)))
3449 dest_mem
= get_memory_rtx (dest
, len
);
3450 set_mem_align (dest_mem
, dest_align
);
3451 src_mem
= get_memory_rtx (src
, len
);
3452 set_mem_align (src_mem
, src_align
);
3453 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
3454 MIN (dest_align
, src_align
), endp
);
3455 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3456 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3465 # define HAVE_movstr 0
3466 # define CODE_FOR_movstr CODE_FOR_nothing
3469 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3470 we failed, the caller should emit a normal call, otherwise try to
3471 get the result in TARGET, if convenient. If ENDP is 0 return the
3472 destination pointer, if ENDP is 1 return the end pointer ala
3473 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3477 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3479 struct expand_operand ops
[3];
3486 dest_mem
= get_memory_rtx (dest
, NULL
);
3487 src_mem
= get_memory_rtx (src
, NULL
);
3490 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3491 dest_mem
= replace_equiv_address (dest_mem
, target
);
3494 create_output_operand (&ops
[0], endp
? target
: NULL_RTX
, Pmode
);
3495 create_fixed_operand (&ops
[1], dest_mem
);
3496 create_fixed_operand (&ops
[2], src_mem
);
3497 if (!maybe_expand_insn (CODE_FOR_movstr
, 3, ops
))
3500 if (endp
&& target
!= const0_rtx
)
3502 target
= ops
[0].value
;
3503 /* movstr is supposed to set end to the address of the NUL
3504 terminator. If the caller requested a mempcpy-like return value,
3508 rtx tem
= plus_constant (GET_MODE (target
),
3509 gen_lowpart (GET_MODE (target
), target
), 1);
3510 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3516 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3517 NULL_RTX if we failed the caller should emit a normal call, otherwise
3518 try to get the result in TARGET, if convenient (and in mode MODE if that's
3522 expand_builtin_strcpy (tree exp
, rtx target
)
3524 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3526 tree dest
= CALL_EXPR_ARG (exp
, 0);
3527 tree src
= CALL_EXPR_ARG (exp
, 1);
3528 return expand_builtin_strcpy_args (dest
, src
, target
);
3533 /* Helper function to do the actual work for expand_builtin_strcpy. The
3534 arguments to the builtin_strcpy call DEST and SRC are broken out
3535 so that this can also be called without constructing an actual CALL_EXPR.
3536 The other arguments and return value are the same as for
3537 expand_builtin_strcpy. */
3540 expand_builtin_strcpy_args (tree dest
, tree src
, rtx target
)
3542 return expand_movstr (dest
, src
, target
, /*endp=*/0);
3545 /* Expand a call EXP to the stpcpy builtin.
3546 Return NULL_RTX if we failed the caller should emit a normal call,
3547 otherwise try to get the result in TARGET, if convenient (and in
3548 mode MODE if that's convenient). */
3551 expand_builtin_stpcpy (tree exp
, rtx target
, machine_mode mode
)
3554 location_t loc
= EXPR_LOCATION (exp
);
3556 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3559 dst
= CALL_EXPR_ARG (exp
, 0);
3560 src
= CALL_EXPR_ARG (exp
, 1);
3562 /* If return value is ignored, transform stpcpy into strcpy. */
3563 if (target
== const0_rtx
&& builtin_decl_implicit (BUILT_IN_STRCPY
))
3565 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3566 tree result
= build_call_nofold_loc (loc
, fn
, 2, dst
, src
);
3567 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3574 /* Ensure we get an actual string whose length can be evaluated at
3575 compile-time, not an expression containing a string. This is
3576 because the latter will potentially produce pessimized code
3577 when used to produce the return value. */
3578 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3579 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3581 lenp1
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
3582 ret
= expand_builtin_mempcpy_args (dst
, src
, lenp1
,
3583 target
, mode
, /*endp=*/2,
3589 if (TREE_CODE (len
) == INTEGER_CST
)
3591 rtx len_rtx
= expand_normal (len
);
3593 if (CONST_INT_P (len_rtx
))
3595 ret
= expand_builtin_strcpy_args (dst
, src
, target
);
3601 if (mode
!= VOIDmode
)
3602 target
= gen_reg_rtx (mode
);
3604 target
= gen_reg_rtx (GET_MODE (ret
));
3606 if (GET_MODE (target
) != GET_MODE (ret
))
3607 ret
= gen_lowpart (GET_MODE (target
), ret
);
3609 ret
= plus_constant (GET_MODE (ret
), ret
, INTVAL (len_rtx
));
3610 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3618 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3622 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3623 bytes from constant string DATA + OFFSET and return it as target
3627 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3630 const char *str
= (const char *) data
;
3632 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3635 return c_readstr (str
+ offset
, mode
);
3638 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3639 NULL_RTX if we failed the caller should emit a normal call. */
3642 expand_builtin_strncpy (tree exp
, rtx target
)
3644 location_t loc
= EXPR_LOCATION (exp
);
3646 if (validate_arglist (exp
,
3647 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3649 tree dest
= CALL_EXPR_ARG (exp
, 0);
3650 tree src
= CALL_EXPR_ARG (exp
, 1);
3651 tree len
= CALL_EXPR_ARG (exp
, 2);
3652 tree slen
= c_strlen (src
, 1);
3654 /* We must be passed a constant len and src parameter. */
3655 if (!tree_fits_uhwi_p (len
) || !slen
|| !tree_fits_uhwi_p (slen
))
3658 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
3660 /* We're required to pad with trailing zeros if the requested
3661 len is greater than strlen(s2)+1. In that case try to
3662 use store_by_pieces, if it fails, punt. */
3663 if (tree_int_cst_lt (slen
, len
))
3665 unsigned int dest_align
= get_pointer_alignment (dest
);
3666 const char *p
= c_getstr (src
);
3669 if (!p
|| dest_align
== 0 || !tree_fits_uhwi_p (len
)
3670 || !can_store_by_pieces (tree_to_uhwi (len
),
3671 builtin_strncpy_read_str
,
3672 CONST_CAST (char *, p
),
3676 dest_mem
= get_memory_rtx (dest
, len
);
3677 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3678 builtin_strncpy_read_str
,
3679 CONST_CAST (char *, p
), dest_align
, false, 0);
3680 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3681 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3688 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3689 bytes from constant string DATA + OFFSET and return it as target
3693 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3696 const char *c
= (const char *) data
;
3697 char *p
= XALLOCAVEC (char, GET_MODE_SIZE (mode
));
3699 memset (p
, *c
, GET_MODE_SIZE (mode
));
3701 return c_readstr (p
, mode
);
3704 /* Callback routine for store_by_pieces. Return the RTL of a register
3705 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3706 char value given in the RTL register data. For example, if mode is
3707 4 bytes wide, return the RTL for 0x01010101*data. */
3710 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3717 size
= GET_MODE_SIZE (mode
);
3721 p
= XALLOCAVEC (char, size
);
3722 memset (p
, 1, size
);
3723 coeff
= c_readstr (p
, mode
);
3725 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3726 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3727 return force_reg (mode
, target
);
3730 /* Expand expression EXP, which is a call to the memset builtin. Return
3731 NULL_RTX if we failed the caller should emit a normal call, otherwise
3732 try to get the result in TARGET, if convenient (and in mode MODE if that's
3736 expand_builtin_memset (tree exp
, rtx target
, machine_mode mode
)
3738 if (!validate_arglist (exp
,
3739 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3743 tree dest
= CALL_EXPR_ARG (exp
, 0);
3744 tree val
= CALL_EXPR_ARG (exp
, 1);
3745 tree len
= CALL_EXPR_ARG (exp
, 2);
3746 return expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
3750 /* Expand expression EXP, which is an instrumented call to the memset builtin.
3751 Return NULL_RTX if we failed the caller should emit a normal call, otherwise
3752 try to get the result in TARGET, if convenient (and in mode MODE if that's
3756 expand_builtin_memset_with_bounds (tree exp
, rtx target
, machine_mode mode
)
3758 if (!validate_arglist (exp
,
3759 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3760 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3764 tree dest
= CALL_EXPR_ARG (exp
, 0);
3765 tree val
= CALL_EXPR_ARG (exp
, 2);
3766 tree len
= CALL_EXPR_ARG (exp
, 3);
3767 rtx res
= expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
3769 /* Return src bounds with the result. */
3772 rtx bnd
= force_reg (targetm
.chkp_bound_mode (),
3773 expand_normal (CALL_EXPR_ARG (exp
, 1)));
3774 res
= chkp_join_splitted_slot (res
, bnd
);
3780 /* Helper function to do the actual work for expand_builtin_memset. The
3781 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3782 so that this can also be called without constructing an actual CALL_EXPR.
3783 The other arguments and return value are the same as for
3784 expand_builtin_memset. */
3787 expand_builtin_memset_args (tree dest
, tree val
, tree len
,
3788 rtx target
, machine_mode mode
, tree orig_exp
)
3791 enum built_in_function fcode
;
3792 machine_mode val_mode
;
3794 unsigned int dest_align
;
3795 rtx dest_mem
, dest_addr
, len_rtx
;
3796 HOST_WIDE_INT expected_size
= -1;
3797 unsigned int expected_align
= 0;
3798 unsigned HOST_WIDE_INT min_size
;
3799 unsigned HOST_WIDE_INT max_size
;
3800 unsigned HOST_WIDE_INT probable_max_size
;
3802 dest_align
= get_pointer_alignment (dest
);
3804 /* If DEST is not a pointer type, don't do this operation in-line. */
3805 if (dest_align
== 0)
3808 if (currently_expanding_gimple_stmt
)
3809 stringop_block_profile (currently_expanding_gimple_stmt
,
3810 &expected_align
, &expected_size
);
3812 if (expected_align
< dest_align
)
3813 expected_align
= dest_align
;
3815 /* If the LEN parameter is zero, return DEST. */
3816 if (integer_zerop (len
))
3818 /* Evaluate and ignore VAL in case it has side-effects. */
3819 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3820 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3823 /* Stabilize the arguments in case we fail. */
3824 dest
= builtin_save_expr (dest
);
3825 val
= builtin_save_expr (val
);
3826 len
= builtin_save_expr (len
);
3828 len_rtx
= expand_normal (len
);
3829 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3830 &probable_max_size
);
3831 dest_mem
= get_memory_rtx (dest
, len
);
3832 val_mode
= TYPE_MODE (unsigned_char_type_node
);
3834 if (TREE_CODE (val
) != INTEGER_CST
)
3838 val_rtx
= expand_normal (val
);
3839 val_rtx
= convert_to_mode (val_mode
, val_rtx
, 0);
3841 /* Assume that we can memset by pieces if we can store
3842 * the coefficients by pieces (in the required modes).
3843 * We can't pass builtin_memset_gen_str as that emits RTL. */
3845 if (tree_fits_uhwi_p (len
)
3846 && can_store_by_pieces (tree_to_uhwi (len
),
3847 builtin_memset_read_str
, &c
, dest_align
,
3850 val_rtx
= force_reg (val_mode
, val_rtx
);
3851 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3852 builtin_memset_gen_str
, val_rtx
, dest_align
,
3855 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, val_rtx
,
3856 dest_align
, expected_align
,
3857 expected_size
, min_size
, max_size
,
3861 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3862 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3866 if (target_char_cast (val
, &c
))
3871 if (tree_fits_uhwi_p (len
)
3872 && can_store_by_pieces (tree_to_uhwi (len
),
3873 builtin_memset_read_str
, &c
, dest_align
,
3875 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3876 builtin_memset_read_str
, &c
, dest_align
, true, 0);
3877 else if (!set_storage_via_setmem (dest_mem
, len_rtx
,
3878 gen_int_mode (c
, val_mode
),
3879 dest_align
, expected_align
,
3880 expected_size
, min_size
, max_size
,
3884 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3885 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3889 set_mem_align (dest_mem
, dest_align
);
3890 dest_addr
= clear_storage_hints (dest_mem
, len_rtx
,
3891 CALL_EXPR_TAILCALL (orig_exp
)
3892 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3893 expected_align
, expected_size
,
3899 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3900 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3906 fndecl
= get_callee_fndecl (orig_exp
);
3907 fcode
= DECL_FUNCTION_CODE (fndecl
);
3908 if (fcode
== BUILT_IN_MEMSET
3909 || fcode
== BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP
)
3910 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 3,
3912 else if (fcode
== BUILT_IN_BZERO
)
3913 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 2,
3917 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
3918 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
3919 return expand_call (fn
, target
, target
== const0_rtx
);
3922 /* Expand expression EXP, which is a call to the bzero builtin. Return
3923 NULL_RTX if we failed the caller should emit a normal call. */
3926 expand_builtin_bzero (tree exp
)
3929 location_t loc
= EXPR_LOCATION (exp
);
3931 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3934 dest
= CALL_EXPR_ARG (exp
, 0);
3935 size
= CALL_EXPR_ARG (exp
, 1);
3937 /* New argument list transforming bzero(ptr x, int y) to
3938 memset(ptr x, int 0, size_t y). This is done this way
3939 so that if it isn't expanded inline, we fallback to
3940 calling bzero instead of memset. */
3942 return expand_builtin_memset_args (dest
, integer_zero_node
,
3943 fold_convert_loc (loc
,
3944 size_type_node
, size
),
3945 const0_rtx
, VOIDmode
, exp
);
3948 /* Expand expression EXP, which is a call to the memcmp built-in function.
3949 Return NULL_RTX if we failed and the caller should emit a normal call,
3950 otherwise try to get the result in TARGET, if convenient (and in mode
3951 MODE, if that's convenient). */
3954 expand_builtin_memcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
3955 ATTRIBUTE_UNUSED machine_mode mode
)
3957 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
3959 if (!validate_arglist (exp
,
3960 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3963 /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3964 implementing memcmp because it will stop if it encounters two
3966 #if defined HAVE_cmpmemsi
3968 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3971 tree arg1
= CALL_EXPR_ARG (exp
, 0);
3972 tree arg2
= CALL_EXPR_ARG (exp
, 1);
3973 tree len
= CALL_EXPR_ARG (exp
, 2);
3975 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
3976 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
3977 machine_mode insn_mode
;
3980 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3984 /* If we don't have POINTER_TYPE, call the function. */
3985 if (arg1_align
== 0 || arg2_align
== 0)
3988 /* Make a place to write the result of the instruction. */
3991 && REG_P (result
) && GET_MODE (result
) == insn_mode
3992 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3993 result
= gen_reg_rtx (insn_mode
);
3995 arg1_rtx
= get_memory_rtx (arg1
, len
);
3996 arg2_rtx
= get_memory_rtx (arg2
, len
);
3997 arg3_rtx
= expand_normal (fold_convert_loc (loc
, sizetype
, len
));
3999 /* Set MEM_SIZE as appropriate. */
4000 if (CONST_INT_P (arg3_rtx
))
4002 set_mem_size (arg1_rtx
, INTVAL (arg3_rtx
));
4003 set_mem_size (arg2_rtx
, INTVAL (arg3_rtx
));
4007 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4008 GEN_INT (MIN (arg1_align
, arg2_align
)));
4015 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE
,
4016 TYPE_MODE (integer_type_node
), 3,
4017 XEXP (arg1_rtx
, 0), Pmode
,
4018 XEXP (arg2_rtx
, 0), Pmode
,
4019 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
4020 TYPE_UNSIGNED (sizetype
)),
4021 TYPE_MODE (sizetype
));
4023 /* Return the value in the proper mode for this function. */
4024 mode
= TYPE_MODE (TREE_TYPE (exp
));
4025 if (GET_MODE (result
) == mode
)
4027 else if (target
!= 0)
4029 convert_move (target
, result
, 0);
4033 return convert_to_mode (mode
, result
, 0);
4035 #endif /* HAVE_cmpmemsi. */
4040 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4041 if we failed the caller should emit a normal call, otherwise try to get
4042 the result in TARGET, if convenient. */
4045 expand_builtin_strcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
)
4047 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4050 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4051 if (direct_optab_handler (cmpstr_optab
, SImode
) != CODE_FOR_nothing
4052 || direct_optab_handler (cmpstrn_optab
, SImode
) != CODE_FOR_nothing
)
4054 rtx arg1_rtx
, arg2_rtx
;
4055 rtx result
, insn
= NULL_RTX
;
4057 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4058 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4060 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4061 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4063 /* If we don't have POINTER_TYPE, call the function. */
4064 if (arg1_align
== 0 || arg2_align
== 0)
4067 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4068 arg1
= builtin_save_expr (arg1
);
4069 arg2
= builtin_save_expr (arg2
);
4071 arg1_rtx
= get_memory_rtx (arg1
, NULL
);
4072 arg2_rtx
= get_memory_rtx (arg2
, NULL
);
4074 #ifdef HAVE_cmpstrsi
4075 /* Try to call cmpstrsi. */
4078 machine_mode insn_mode
4079 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
4081 /* Make a place to write the result of the instruction. */
4084 && REG_P (result
) && GET_MODE (result
) == insn_mode
4085 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4086 result
= gen_reg_rtx (insn_mode
);
4088 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
,
4089 GEN_INT (MIN (arg1_align
, arg2_align
)));
4092 #ifdef HAVE_cmpstrnsi
4093 /* Try to determine at least one length and call cmpstrnsi. */
4094 if (!insn
&& HAVE_cmpstrnsi
)
4099 machine_mode insn_mode
4100 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4101 tree len1
= c_strlen (arg1
, 1);
4102 tree len2
= c_strlen (arg2
, 1);
4105 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
4107 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
4109 /* If we don't have a constant length for the first, use the length
4110 of the second, if we know it. We don't require a constant for
4111 this case; some cost analysis could be done if both are available
4112 but neither is constant. For now, assume they're equally cheap,
4113 unless one has side effects. If both strings have constant lengths,
4120 else if (TREE_SIDE_EFFECTS (len1
))
4122 else if (TREE_SIDE_EFFECTS (len2
))
4124 else if (TREE_CODE (len1
) != INTEGER_CST
)
4126 else if (TREE_CODE (len2
) != INTEGER_CST
)
4128 else if (tree_int_cst_lt (len1
, len2
))
4133 /* If both arguments have side effects, we cannot optimize. */
4134 if (!len
|| TREE_SIDE_EFFECTS (len
))
4137 arg3_rtx
= expand_normal (len
);
4139 /* Make a place to write the result of the instruction. */
4142 && REG_P (result
) && GET_MODE (result
) == insn_mode
4143 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4144 result
= gen_reg_rtx (insn_mode
);
4146 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4147 GEN_INT (MIN (arg1_align
, arg2_align
)));
4156 /* Return the value in the proper mode for this function. */
4157 mode
= TYPE_MODE (TREE_TYPE (exp
));
4158 if (GET_MODE (result
) == mode
)
4161 return convert_to_mode (mode
, result
, 0);
4162 convert_move (target
, result
, 0);
4166 /* Expand the library call ourselves using a stabilized argument
4167 list to avoid re-evaluating the function's arguments twice. */
4168 #ifdef HAVE_cmpstrnsi
4171 fndecl
= get_callee_fndecl (exp
);
4172 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 2, arg1
, arg2
);
4173 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4174 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4175 return expand_call (fn
, target
, target
== const0_rtx
);
4181 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4182 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4183 the result in TARGET, if convenient. */
4186 expand_builtin_strncmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
4187 ATTRIBUTE_UNUSED machine_mode mode
)
4189 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
4191 if (!validate_arglist (exp
,
4192 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4195 /* If c_strlen can determine an expression for one of the string
4196 lengths, and it doesn't have side effects, then emit cmpstrnsi
4197 using length MIN(strlen(string)+1, arg3). */
4198 #ifdef HAVE_cmpstrnsi
4201 tree len
, len1
, len2
;
4202 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
4205 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4206 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4207 tree arg3
= CALL_EXPR_ARG (exp
, 2);
4209 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4210 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4211 machine_mode insn_mode
4212 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4214 len1
= c_strlen (arg1
, 1);
4215 len2
= c_strlen (arg2
, 1);
4218 len1
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len1
);
4220 len2
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len2
);
4222 /* If we don't have a constant length for the first, use the length
4223 of the second, if we know it. We don't require a constant for
4224 this case; some cost analysis could be done if both are available
4225 but neither is constant. For now, assume they're equally cheap,
4226 unless one has side effects. If both strings have constant lengths,
4233 else if (TREE_SIDE_EFFECTS (len1
))
4235 else if (TREE_SIDE_EFFECTS (len2
))
4237 else if (TREE_CODE (len1
) != INTEGER_CST
)
4239 else if (TREE_CODE (len2
) != INTEGER_CST
)
4241 else if (tree_int_cst_lt (len1
, len2
))
4246 /* If both arguments have side effects, we cannot optimize. */
4247 if (!len
|| TREE_SIDE_EFFECTS (len
))
4250 /* The actual new length parameter is MIN(len,arg3). */
4251 len
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (len
), len
,
4252 fold_convert_loc (loc
, TREE_TYPE (len
), arg3
));
4254 /* If we don't have POINTER_TYPE, call the function. */
4255 if (arg1_align
== 0 || arg2_align
== 0)
4258 /* Make a place to write the result of the instruction. */
4261 && REG_P (result
) && GET_MODE (result
) == insn_mode
4262 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4263 result
= gen_reg_rtx (insn_mode
);
4265 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4266 arg1
= builtin_save_expr (arg1
);
4267 arg2
= builtin_save_expr (arg2
);
4268 len
= builtin_save_expr (len
);
4270 arg1_rtx
= get_memory_rtx (arg1
, len
);
4271 arg2_rtx
= get_memory_rtx (arg2
, len
);
4272 arg3_rtx
= expand_normal (len
);
4273 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4274 GEN_INT (MIN (arg1_align
, arg2_align
)));
4279 /* Return the value in the proper mode for this function. */
4280 mode
= TYPE_MODE (TREE_TYPE (exp
));
4281 if (GET_MODE (result
) == mode
)
4284 return convert_to_mode (mode
, result
, 0);
4285 convert_move (target
, result
, 0);
4289 /* Expand the library call ourselves using a stabilized argument
4290 list to avoid re-evaluating the function's arguments twice. */
4291 fndecl
= get_callee_fndecl (exp
);
4292 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 3,
4294 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4295 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4296 return expand_call (fn
, target
, target
== const0_rtx
);
4302 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4303 if that's convenient. */
4306 expand_builtin_saveregs (void)
4311 /* Don't do __builtin_saveregs more than once in a function.
4312 Save the result of the first call and reuse it. */
4313 if (saveregs_value
!= 0)
4314 return saveregs_value
;
4316 /* When this function is called, it means that registers must be
4317 saved on entry to this function. So we migrate the call to the
4318 first insn of this function. */
4322 /* Do whatever the machine needs done in this case. */
4323 val
= targetm
.calls
.expand_builtin_saveregs ();
4328 saveregs_value
= val
;
4330 /* Put the insns after the NOTE that starts the function. If this
4331 is inside a start_sequence, make the outer-level insn chain current, so
4332 the code is placed at the start of the function. */
4333 push_topmost_sequence ();
4334 emit_insn_after (seq
, entry_of_function ());
4335 pop_topmost_sequence ();
4340 /* Expand a call to __builtin_next_arg. */
4343 expand_builtin_next_arg (void)
4345 /* Checking arguments is already done in fold_builtin_next_arg
4346 that must be called before this function. */
4347 return expand_binop (ptr_mode
, add_optab
,
4348 crtl
->args
.internal_arg_pointer
,
4349 crtl
->args
.arg_offset_rtx
,
4350 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4353 /* Make it easier for the backends by protecting the valist argument
4354 from multiple evaluations. */
4357 stabilize_va_list_loc (location_t loc
, tree valist
, int needs_lvalue
)
4359 tree vatype
= targetm
.canonical_va_list_type (TREE_TYPE (valist
));
4361 /* The current way of determining the type of valist is completely
4362 bogus. We should have the information on the va builtin instead. */
4364 vatype
= targetm
.fn_abi_va_list (cfun
->decl
);
4366 if (TREE_CODE (vatype
) == ARRAY_TYPE
)
4368 if (TREE_SIDE_EFFECTS (valist
))
4369 valist
= save_expr (valist
);
4371 /* For this case, the backends will be expecting a pointer to
4372 vatype, but it's possible we've actually been given an array
4373 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4375 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4377 tree p1
= build_pointer_type (TREE_TYPE (vatype
));
4378 valist
= build_fold_addr_expr_with_type_loc (loc
, valist
, p1
);
4383 tree pt
= build_pointer_type (vatype
);
4387 if (! TREE_SIDE_EFFECTS (valist
))
4390 valist
= fold_build1_loc (loc
, ADDR_EXPR
, pt
, valist
);
4391 TREE_SIDE_EFFECTS (valist
) = 1;
4394 if (TREE_SIDE_EFFECTS (valist
))
4395 valist
= save_expr (valist
);
4396 valist
= fold_build2_loc (loc
, MEM_REF
,
4397 vatype
, valist
, build_int_cst (pt
, 0));
4403 /* The "standard" definition of va_list is void*. */
4406 std_build_builtin_va_list (void)
4408 return ptr_type_node
;
4411 /* The "standard" abi va_list is va_list_type_node. */
4414 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED
)
4416 return va_list_type_node
;
4419 /* The "standard" type of va_list is va_list_type_node. */
4422 std_canonical_va_list_type (tree type
)
4426 if (INDIRECT_REF_P (type
))
4427 type
= TREE_TYPE (type
);
4428 else if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (TREE_TYPE (type
)))
4429 type
= TREE_TYPE (type
);
4430 wtype
= va_list_type_node
;
4432 /* Treat structure va_list types. */
4433 if (TREE_CODE (wtype
) == RECORD_TYPE
&& POINTER_TYPE_P (htype
))
4434 htype
= TREE_TYPE (htype
);
4435 else if (TREE_CODE (wtype
) == ARRAY_TYPE
)
4437 /* If va_list is an array type, the argument may have decayed
4438 to a pointer type, e.g. by being passed to another function.
4439 In that case, unwrap both types so that we can compare the
4440 underlying records. */
4441 if (TREE_CODE (htype
) == ARRAY_TYPE
4442 || POINTER_TYPE_P (htype
))
4444 wtype
= TREE_TYPE (wtype
);
4445 htype
= TREE_TYPE (htype
);
4448 if (TYPE_MAIN_VARIANT (wtype
) == TYPE_MAIN_VARIANT (htype
))
4449 return va_list_type_node
;
4454 /* The "standard" implementation of va_start: just assign `nextarg' to
4458 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4460 rtx va_r
= expand_expr (valist
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4461 convert_move (va_r
, nextarg
, 0);
4463 /* We do not have any valid bounds for the pointer, so
4464 just store zero bounds for it. */
4465 if (chkp_function_instrumented_p (current_function_decl
))
4466 chkp_expand_bounds_reset_for_mem (valist
,
4467 make_tree (TREE_TYPE (valist
),
4471 /* Expand EXP, a call to __builtin_va_start. */
4474 expand_builtin_va_start (tree exp
)
4478 location_t loc
= EXPR_LOCATION (exp
);
4480 if (call_expr_nargs (exp
) < 2)
4482 error_at (loc
, "too few arguments to function %<va_start%>");
4486 if (fold_builtin_next_arg (exp
, true))
4489 nextarg
= expand_builtin_next_arg ();
4490 valist
= stabilize_va_list_loc (loc
, CALL_EXPR_ARG (exp
, 0), 1);
4492 if (targetm
.expand_builtin_va_start
)
4493 targetm
.expand_builtin_va_start (valist
, nextarg
);
4495 std_expand_builtin_va_start (valist
, nextarg
);
4500 /* Expand EXP, a call to __builtin_va_end. */
4503 expand_builtin_va_end (tree exp
)
4505 tree valist
= CALL_EXPR_ARG (exp
, 0);
4507 /* Evaluate for side effects, if needed. I hate macros that don't
4509 if (TREE_SIDE_EFFECTS (valist
))
4510 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4515 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4516 builtin rather than just as an assignment in stdarg.h because of the
4517 nastiness of array-type va_list types. */
4520 expand_builtin_va_copy (tree exp
)
4523 location_t loc
= EXPR_LOCATION (exp
);
4525 dst
= CALL_EXPR_ARG (exp
, 0);
4526 src
= CALL_EXPR_ARG (exp
, 1);
4528 dst
= stabilize_va_list_loc (loc
, dst
, 1);
4529 src
= stabilize_va_list_loc (loc
, src
, 0);
4531 gcc_assert (cfun
!= NULL
&& cfun
->decl
!= NULL_TREE
);
4533 if (TREE_CODE (targetm
.fn_abi_va_list (cfun
->decl
)) != ARRAY_TYPE
)
4535 t
= build2 (MODIFY_EXPR
, targetm
.fn_abi_va_list (cfun
->decl
), dst
, src
);
4536 TREE_SIDE_EFFECTS (t
) = 1;
4537 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4541 rtx dstb
, srcb
, size
;
4543 /* Evaluate to pointers. */
4544 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4545 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4546 size
= expand_expr (TYPE_SIZE_UNIT (targetm
.fn_abi_va_list (cfun
->decl
)),
4547 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
4549 dstb
= convert_memory_address (Pmode
, dstb
);
4550 srcb
= convert_memory_address (Pmode
, srcb
);
4552 /* "Dereference" to BLKmode memories. */
4553 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4554 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4555 set_mem_align (dstb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4556 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4557 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4558 set_mem_align (srcb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4561 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4567 /* Expand a call to one of the builtin functions __builtin_frame_address or
4568 __builtin_return_address. */
4571 expand_builtin_frame_address (tree fndecl
, tree exp
)
4573 /* The argument must be a nonnegative integer constant.
4574 It counts the number of frames to scan up the stack.
4575 The value is the return address saved in that frame. */
4576 if (call_expr_nargs (exp
) == 0)
4577 /* Warning about missing arg was already issued. */
4579 else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp
, 0)))
4581 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4582 error ("invalid argument to %<__builtin_frame_address%>");
4584 error ("invalid argument to %<__builtin_return_address%>");
4590 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4591 tree_to_uhwi (CALL_EXPR_ARG (exp
, 0)));
4593 /* Some ports cannot access arbitrary stack frames. */
4596 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4597 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4599 warning (0, "unsupported argument to %<__builtin_return_address%>");
4603 /* For __builtin_frame_address, return what we've got. */
4604 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4608 && ! CONSTANT_P (tem
))
4609 tem
= copy_addr_to_reg (tem
);
4614 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4615 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4616 is the same as for allocate_dynamic_stack_space. */
4619 expand_builtin_alloca (tree exp
, bool cannot_accumulate
)
4625 bool alloca_with_align
= (DECL_FUNCTION_CODE (get_callee_fndecl (exp
))
4626 == BUILT_IN_ALLOCA_WITH_ALIGN
);
4629 = (alloca_with_align
4630 ? validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
4631 : validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
));
4636 /* Compute the argument. */
4637 op0
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4639 /* Compute the alignment. */
4640 align
= (alloca_with_align
4641 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp
, 1))
4642 : BIGGEST_ALIGNMENT
);
4644 /* Allocate the desired space. */
4645 result
= allocate_dynamic_stack_space (op0
, 0, align
, cannot_accumulate
);
4646 result
= convert_memory_address (ptr_mode
, result
);
4651 /* Expand a call to bswap builtin in EXP.
4652 Return NULL_RTX if a normal call should be emitted rather than expanding the
4653 function in-line. If convenient, the result should be placed in TARGET.
4654 SUBTARGET may be used as the target for computing one of EXP's operands. */
4657 expand_builtin_bswap (machine_mode target_mode
, tree exp
, rtx target
,
4663 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4666 arg
= CALL_EXPR_ARG (exp
, 0);
4667 op0
= expand_expr (arg
,
4668 subtarget
&& GET_MODE (subtarget
) == target_mode
4669 ? subtarget
: NULL_RTX
,
4670 target_mode
, EXPAND_NORMAL
);
4671 if (GET_MODE (op0
) != target_mode
)
4672 op0
= convert_to_mode (target_mode
, op0
, 1);
4674 target
= expand_unop (target_mode
, bswap_optab
, op0
, target
, 1);
4676 gcc_assert (target
);
4678 return convert_to_mode (target_mode
, target
, 1);
4681 /* Expand a call to a unary builtin in EXP.
4682 Return NULL_RTX if a normal call should be emitted rather than expanding the
4683 function in-line. If convenient, the result should be placed in TARGET.
4684 SUBTARGET may be used as the target for computing one of EXP's operands. */
4687 expand_builtin_unop (machine_mode target_mode
, tree exp
, rtx target
,
4688 rtx subtarget
, optab op_optab
)
4692 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4695 /* Compute the argument. */
4696 op0
= expand_expr (CALL_EXPR_ARG (exp
, 0),
4698 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0)))
4699 == GET_MODE (subtarget
))) ? subtarget
: NULL_RTX
,
4700 VOIDmode
, EXPAND_NORMAL
);
4701 /* Compute op, into TARGET if possible.
4702 Set TARGET to wherever the result comes back. */
4703 target
= expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))),
4704 op_optab
, op0
, target
, op_optab
!= clrsb_optab
);
4705 gcc_assert (target
);
4707 return convert_to_mode (target_mode
, target
, 0);
4710 /* Expand a call to __builtin_expect. We just return our argument
4711 as the builtin_expect semantic should've been already executed by
4712 tree branch prediction pass. */
4715 expand_builtin_expect (tree exp
, rtx target
)
4719 if (call_expr_nargs (exp
) < 2)
4721 arg
= CALL_EXPR_ARG (exp
, 0);
4723 target
= expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
4724 /* When guessing was done, the hints should be already stripped away. */
4725 gcc_assert (!flag_guess_branch_prob
4726 || optimize
== 0 || seen_error ());
4730 /* Expand a call to __builtin_assume_aligned. We just return our first
4731 argument as the builtin_assume_aligned semantic should've been already
4735 expand_builtin_assume_aligned (tree exp
, rtx target
)
4737 if (call_expr_nargs (exp
) < 2)
4739 target
= expand_expr (CALL_EXPR_ARG (exp
, 0), target
, VOIDmode
,
4741 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 1))
4742 && (call_expr_nargs (exp
) < 3
4743 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 2))));
4748 expand_builtin_trap (void)
4753 rtx insn
= emit_insn (gen_trap ());
4754 /* For trap insns when not accumulating outgoing args force
4755 REG_ARGS_SIZE note to prevent crossjumping of calls with
4756 different args sizes. */
4757 if (!ACCUMULATE_OUTGOING_ARGS
)
4758 add_reg_note (insn
, REG_ARGS_SIZE
, GEN_INT (stack_pointer_delta
));
4762 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4766 /* Expand a call to __builtin_unreachable. We do nothing except emit
4767 a barrier saying that control flow will not pass here.
4769 It is the responsibility of the program being compiled to ensure
4770 that control flow does never reach __builtin_unreachable. */
4772 expand_builtin_unreachable (void)
4777 /* Expand EXP, a call to fabs, fabsf or fabsl.
4778 Return NULL_RTX if a normal call should be emitted rather than expanding
4779 the function inline. If convenient, the result should be placed
4780 in TARGET. SUBTARGET may be used as the target for computing
4784 expand_builtin_fabs (tree exp
, rtx target
, rtx subtarget
)
4790 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
4793 arg
= CALL_EXPR_ARG (exp
, 0);
4794 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
4795 mode
= TYPE_MODE (TREE_TYPE (arg
));
4796 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
4797 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4800 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4801 Return NULL is a normal call should be emitted rather than expanding the
4802 function inline. If convenient, the result should be placed in TARGET.
4803 SUBTARGET may be used as the target for computing the operand. */
4806 expand_builtin_copysign (tree exp
, rtx target
, rtx subtarget
)
4811 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
4814 arg
= CALL_EXPR_ARG (exp
, 0);
4815 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
4817 arg
= CALL_EXPR_ARG (exp
, 1);
4818 op1
= expand_normal (arg
);
4820 return expand_copysign (op0
, op1
, target
);
4823 /* Expand a call to __builtin___clear_cache. */
4826 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED
)
4828 #ifndef HAVE_clear_cache
4829 #ifdef CLEAR_INSN_CACHE
4830 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4831 does something. Just do the default expansion to a call to
4835 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4836 does nothing. There is no need to call it. Do nothing. */
4838 #endif /* CLEAR_INSN_CACHE */
4840 /* We have a "clear_cache" insn, and it will handle everything. */
4842 rtx begin_rtx
, end_rtx
;
4844 /* We must not expand to a library call. If we did, any
4845 fallback library function in libgcc that might contain a call to
4846 __builtin___clear_cache() would recurse infinitely. */
4847 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4849 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4853 if (HAVE_clear_cache
)
4855 struct expand_operand ops
[2];
4857 begin
= CALL_EXPR_ARG (exp
, 0);
4858 begin_rtx
= expand_expr (begin
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4860 end
= CALL_EXPR_ARG (exp
, 1);
4861 end_rtx
= expand_expr (end
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4863 create_address_operand (&ops
[0], begin_rtx
);
4864 create_address_operand (&ops
[1], end_rtx
);
4865 if (maybe_expand_insn (CODE_FOR_clear_cache
, 2, ops
))
4869 #endif /* HAVE_clear_cache */
4872 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
4875 round_trampoline_addr (rtx tramp
)
4877 rtx temp
, addend
, mask
;
4879 /* If we don't need too much alignment, we'll have been guaranteed
4880 proper alignment by get_trampoline_type. */
4881 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
4884 /* Round address up to desired boundary. */
4885 temp
= gen_reg_rtx (Pmode
);
4886 addend
= gen_int_mode (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1, Pmode
);
4887 mask
= gen_int_mode (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
, Pmode
);
4889 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
4890 temp
, 0, OPTAB_LIB_WIDEN
);
4891 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
4892 temp
, 0, OPTAB_LIB_WIDEN
);
4898 expand_builtin_init_trampoline (tree exp
, bool onstack
)
4900 tree t_tramp
, t_func
, t_chain
;
4901 rtx m_tramp
, r_tramp
, r_chain
, tmp
;
4903 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
,
4904 POINTER_TYPE
, VOID_TYPE
))
4907 t_tramp
= CALL_EXPR_ARG (exp
, 0);
4908 t_func
= CALL_EXPR_ARG (exp
, 1);
4909 t_chain
= CALL_EXPR_ARG (exp
, 2);
4911 r_tramp
= expand_normal (t_tramp
);
4912 m_tramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
4913 MEM_NOTRAP_P (m_tramp
) = 1;
4915 /* If ONSTACK, the TRAMP argument should be the address of a field
4916 within the local function's FRAME decl. Either way, let's see if
4917 we can fill in the MEM_ATTRs for this memory. */
4918 if (TREE_CODE (t_tramp
) == ADDR_EXPR
)
4919 set_mem_attributes (m_tramp
, TREE_OPERAND (t_tramp
, 0), true);
4921 /* Creator of a heap trampoline is responsible for making sure the
4922 address is aligned to at least STACK_BOUNDARY. Normally malloc
4923 will ensure this anyhow. */
4924 tmp
= round_trampoline_addr (r_tramp
);
4927 m_tramp
= change_address (m_tramp
, BLKmode
, tmp
);
4928 set_mem_align (m_tramp
, TRAMPOLINE_ALIGNMENT
);
4929 set_mem_size (m_tramp
, TRAMPOLINE_SIZE
);
4932 /* The FUNC argument should be the address of the nested function.
4933 Extract the actual function decl to pass to the hook. */
4934 gcc_assert (TREE_CODE (t_func
) == ADDR_EXPR
);
4935 t_func
= TREE_OPERAND (t_func
, 0);
4936 gcc_assert (TREE_CODE (t_func
) == FUNCTION_DECL
);
4938 r_chain
= expand_normal (t_chain
);
4940 /* Generate insns to initialize the trampoline. */
4941 targetm
.calls
.trampoline_init (m_tramp
, t_func
, r_chain
);
4945 trampolines_created
= 1;
4947 warning_at (DECL_SOURCE_LOCATION (t_func
), OPT_Wtrampolines
,
4948 "trampoline generated for nested function %qD", t_func
);
4955 expand_builtin_adjust_trampoline (tree exp
)
4959 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
4962 tramp
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4963 tramp
= round_trampoline_addr (tramp
);
4964 if (targetm
.calls
.trampoline_adjust_address
)
4965 tramp
= targetm
.calls
.trampoline_adjust_address (tramp
);
4970 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4971 function. The function first checks whether the back end provides
4972 an insn to implement signbit for the respective mode. If not, it
4973 checks whether the floating point format of the value is such that
4974 the sign bit can be extracted. If that is not the case, the
4975 function returns NULL_RTX to indicate that a normal call should be
4976 emitted rather than expanding the function in-line. EXP is the
4977 expression that is a call to the builtin function; if convenient,
4978 the result should be placed in TARGET. */
4980 expand_builtin_signbit (tree exp
, rtx target
)
4982 const struct real_format
*fmt
;
4983 machine_mode fmode
, imode
, rmode
;
4986 enum insn_code icode
;
4988 location_t loc
= EXPR_LOCATION (exp
);
4990 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
4993 arg
= CALL_EXPR_ARG (exp
, 0);
4994 fmode
= TYPE_MODE (TREE_TYPE (arg
));
4995 rmode
= TYPE_MODE (TREE_TYPE (exp
));
4996 fmt
= REAL_MODE_FORMAT (fmode
);
4998 arg
= builtin_save_expr (arg
);
5000 /* Expand the argument yielding a RTX expression. */
5001 temp
= expand_normal (arg
);
5003 /* Check if the back end provides an insn that handles signbit for the
5005 icode
= optab_handler (signbit_optab
, fmode
);
5006 if (icode
!= CODE_FOR_nothing
)
5008 rtx_insn
*last
= get_last_insn ();
5009 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
5010 if (maybe_emit_unop_insn (icode
, target
, temp
, UNKNOWN
))
5012 delete_insns_since (last
);
5015 /* For floating point formats without a sign bit, implement signbit
5017 bitpos
= fmt
->signbit_ro
;
5020 /* But we can't do this if the format supports signed zero. */
5021 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5024 arg
= fold_build2_loc (loc
, LT_EXPR
, TREE_TYPE (exp
), arg
,
5025 build_real (TREE_TYPE (arg
), dconst0
));
5026 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5029 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
5031 imode
= int_mode_for_mode (fmode
);
5032 if (imode
== BLKmode
)
5034 temp
= gen_lowpart (imode
, temp
);
5039 /* Handle targets with different FP word orders. */
5040 if (FLOAT_WORDS_BIG_ENDIAN
)
5041 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
5043 word
= bitpos
/ BITS_PER_WORD
;
5044 temp
= operand_subword_force (temp
, word
, fmode
);
5045 bitpos
= bitpos
% BITS_PER_WORD
;
5048 /* Force the intermediate word_mode (or narrower) result into a
5049 register. This avoids attempting to create paradoxical SUBREGs
5050 of floating point modes below. */
5051 temp
= force_reg (imode
, temp
);
5053 /* If the bitpos is within the "result mode" lowpart, the operation
5054 can be implement with a single bitwise AND. Otherwise, we need
5055 a right shift and an AND. */
5057 if (bitpos
< GET_MODE_BITSIZE (rmode
))
5059 wide_int mask
= wi::set_bit_in_zero (bitpos
, GET_MODE_PRECISION (rmode
));
5061 if (GET_MODE_SIZE (imode
) > GET_MODE_SIZE (rmode
))
5062 temp
= gen_lowpart (rmode
, temp
);
5063 temp
= expand_binop (rmode
, and_optab
, temp
,
5064 immed_wide_int_const (mask
, rmode
),
5065 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5069 /* Perform a logical right shift to place the signbit in the least
5070 significant bit, then truncate the result to the desired mode
5071 and mask just this bit. */
5072 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
, bitpos
, NULL_RTX
, 1);
5073 temp
= gen_lowpart (rmode
, temp
);
5074 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
5075 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5081 /* Expand fork or exec calls. TARGET is the desired target of the
5082 call. EXP is the call. FN is the
5083 identificator of the actual function. IGNORE is nonzero if the
5084 value is to be ignored. */
5087 expand_builtin_fork_or_exec (tree fn
, tree exp
, rtx target
, int ignore
)
5092 /* If we are not profiling, just call the function. */
5093 if (!profile_arc_flag
)
5096 /* Otherwise call the wrapper. This should be equivalent for the rest of
5097 compiler, so the code does not diverge, and the wrapper may run the
5098 code necessary for keeping the profiling sane. */
5100 switch (DECL_FUNCTION_CODE (fn
))
5103 id
= get_identifier ("__gcov_fork");
5106 case BUILT_IN_EXECL
:
5107 id
= get_identifier ("__gcov_execl");
5110 case BUILT_IN_EXECV
:
5111 id
= get_identifier ("__gcov_execv");
5114 case BUILT_IN_EXECLP
:
5115 id
= get_identifier ("__gcov_execlp");
5118 case BUILT_IN_EXECLE
:
5119 id
= get_identifier ("__gcov_execle");
5122 case BUILT_IN_EXECVP
:
5123 id
= get_identifier ("__gcov_execvp");
5126 case BUILT_IN_EXECVE
:
5127 id
= get_identifier ("__gcov_execve");
5134 decl
= build_decl (DECL_SOURCE_LOCATION (fn
),
5135 FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5136 DECL_EXTERNAL (decl
) = 1;
5137 TREE_PUBLIC (decl
) = 1;
5138 DECL_ARTIFICIAL (decl
) = 1;
5139 TREE_NOTHROW (decl
) = 1;
5140 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5141 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5142 call
= rewrite_call_expr (EXPR_LOCATION (exp
), exp
, 0, decl
, 0);
5143 return expand_call (call
, target
, ignore
);
5148 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5149 the pointer in these functions is void*, the tree optimizers may remove
5150 casts. The mode computed in expand_builtin isn't reliable either, due
5151 to __sync_bool_compare_and_swap.
5153 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5154 group of builtins. This gives us log2 of the mode size. */
5156 static inline machine_mode
5157 get_builtin_sync_mode (int fcode_diff
)
5159 /* The size is not negotiable, so ask not to get BLKmode in return
5160 if the target indicates that a smaller size would be better. */
5161 return mode_for_size (BITS_PER_UNIT
<< fcode_diff
, MODE_INT
, 0);
5164 /* Expand the memory expression LOC and return the appropriate memory operand
5165 for the builtin_sync operations. */
5168 get_builtin_sync_mem (tree loc
, machine_mode mode
)
5172 addr
= expand_expr (loc
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
5173 addr
= convert_memory_address (Pmode
, addr
);
5175 /* Note that we explicitly do not want any alias information for this
5176 memory, so that we kill all other live memories. Otherwise we don't
5177 satisfy the full barrier semantics of the intrinsic. */
5178 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5180 /* The alignment needs to be at least according to that of the mode. */
5181 set_mem_align (mem
, MAX (GET_MODE_ALIGNMENT (mode
),
5182 get_pointer_alignment (loc
)));
5183 set_mem_alias_set (mem
, ALIAS_SET_MEMORY_BARRIER
);
5184 MEM_VOLATILE_P (mem
) = 1;
5189 /* Make sure an argument is in the right mode.
5190 EXP is the tree argument.
5191 MODE is the mode it should be in. */
5194 expand_expr_force_mode (tree exp
, machine_mode mode
)
5197 machine_mode old_mode
;
5199 val
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_NORMAL
);
5200 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5201 of CONST_INTs, where we know the old_mode only from the call argument. */
5203 old_mode
= GET_MODE (val
);
5204 if (old_mode
== VOIDmode
)
5205 old_mode
= TYPE_MODE (TREE_TYPE (exp
));
5206 val
= convert_modes (mode
, old_mode
, val
, 1);
5211 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5212 EXP is the CALL_EXPR. CODE is the rtx code
5213 that corresponds to the arithmetic or logical operation from the name;
5214 an exception here is that NOT actually means NAND. TARGET is an optional
5215 place for us to store the results; AFTER is true if this is the
5216 fetch_and_xxx form. */
5219 expand_builtin_sync_operation (machine_mode mode
, tree exp
,
5220 enum rtx_code code
, bool after
,
5224 location_t loc
= EXPR_LOCATION (exp
);
5226 if (code
== NOT
&& warn_sync_nand
)
5228 tree fndecl
= get_callee_fndecl (exp
);
5229 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5231 static bool warned_f_a_n
, warned_n_a_f
;
5235 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
5236 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
5237 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
5238 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
5239 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
5243 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N
);
5244 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5245 warned_f_a_n
= true;
5248 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
5249 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
5250 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
5251 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
5252 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
5256 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N
);
5257 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5258 warned_n_a_f
= true;
5266 /* Expand the operands. */
5267 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5268 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5270 return expand_atomic_fetch_op (target
, mem
, val
, code
, MEMMODEL_SEQ_CST
,
5274 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5275 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5276 true if this is the boolean form. TARGET is a place for us to store the
5277 results; this is NOT optional if IS_BOOL is true. */
5280 expand_builtin_compare_and_swap (machine_mode mode
, tree exp
,
5281 bool is_bool
, rtx target
)
5283 rtx old_val
, new_val
, mem
;
5286 /* Expand the operands. */
5287 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5288 old_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5289 new_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
5291 pbool
= poval
= NULL
;
5292 if (target
!= const0_rtx
)
5299 if (!expand_atomic_compare_and_swap (pbool
, poval
, mem
, old_val
, new_val
,
5300 false, MEMMODEL_SEQ_CST
,
5307 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5308 general form is actually an atomic exchange, and some targets only
5309 support a reduced form with the second argument being a constant 1.
5310 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5314 expand_builtin_sync_lock_test_and_set (machine_mode mode
, tree exp
,
5319 /* Expand the operands. */
5320 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5321 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5323 return expand_sync_lock_test_and_set (target
, mem
, val
);
5326 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5329 expand_builtin_sync_lock_release (machine_mode mode
, tree exp
)
5333 /* Expand the operands. */
5334 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5336 expand_atomic_store (mem
, const0_rtx
, MEMMODEL_RELEASE
, true);
5339 /* Given an integer representing an ``enum memmodel'', verify its
5340 correctness and return the memory model enum. */
5342 static enum memmodel
5343 get_memmodel (tree exp
)
5346 unsigned HOST_WIDE_INT val
;
5348 /* If the parameter is not a constant, it's a run time value so we'll just
5349 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5350 if (TREE_CODE (exp
) != INTEGER_CST
)
5351 return MEMMODEL_SEQ_CST
;
5353 op
= expand_normal (exp
);
5356 if (targetm
.memmodel_check
)
5357 val
= targetm
.memmodel_check (val
);
5358 else if (val
& ~MEMMODEL_MASK
)
5360 warning (OPT_Winvalid_memory_model
,
5361 "Unknown architecture specifier in memory model to builtin.");
5362 return MEMMODEL_SEQ_CST
;
5365 if ((INTVAL (op
) & MEMMODEL_MASK
) >= MEMMODEL_LAST
)
5367 warning (OPT_Winvalid_memory_model
,
5368 "invalid memory model argument to builtin");
5369 return MEMMODEL_SEQ_CST
;
5372 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
5373 be conservative and promote consume to acquire. */
5374 if (val
== MEMMODEL_CONSUME
)
5375 val
= MEMMODEL_ACQUIRE
;
5377 return (enum memmodel
) val
;
5380 /* Expand the __atomic_exchange intrinsic:
5381 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5382 EXP is the CALL_EXPR.
5383 TARGET is an optional place for us to store the results. */
5386 expand_builtin_atomic_exchange (machine_mode mode
, tree exp
, rtx target
)
5389 enum memmodel model
;
5391 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5393 if (!flag_inline_atomics
)
5396 /* Expand the operands. */
5397 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5398 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5400 return expand_atomic_exchange (target
, mem
, val
, model
);
5403 /* Expand the __atomic_compare_exchange intrinsic:
5404 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5405 TYPE desired, BOOL weak,
5406 enum memmodel success,
5407 enum memmodel failure)
5408 EXP is the CALL_EXPR.
5409 TARGET is an optional place for us to store the results. */
5412 expand_builtin_atomic_compare_exchange (machine_mode mode
, tree exp
,
5415 rtx expect
, desired
, mem
, oldval
;
5416 rtx_code_label
*label
;
5417 enum memmodel success
, failure
;
5421 success
= get_memmodel (CALL_EXPR_ARG (exp
, 4));
5422 failure
= get_memmodel (CALL_EXPR_ARG (exp
, 5));
5424 if (failure
> success
)
5426 warning (OPT_Winvalid_memory_model
,
5427 "failure memory model cannot be stronger than success memory "
5428 "model for %<__atomic_compare_exchange%>");
5429 success
= MEMMODEL_SEQ_CST
;
5432 if ((failure
& MEMMODEL_MASK
) == MEMMODEL_RELEASE
5433 || (failure
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
5435 warning (OPT_Winvalid_memory_model
,
5436 "invalid failure memory model for "
5437 "%<__atomic_compare_exchange%>");
5438 failure
= MEMMODEL_SEQ_CST
;
5439 success
= MEMMODEL_SEQ_CST
;
5443 if (!flag_inline_atomics
)
5446 /* Expand the operands. */
5447 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5449 expect
= expand_normal (CALL_EXPR_ARG (exp
, 1));
5450 expect
= convert_memory_address (Pmode
, expect
);
5451 expect
= gen_rtx_MEM (mode
, expect
);
5452 desired
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
5454 weak
= CALL_EXPR_ARG (exp
, 3);
5456 if (tree_fits_shwi_p (weak
) && tree_to_shwi (weak
) != 0)
5459 if (target
== const0_rtx
)
5462 /* Lest the rtl backend create a race condition with an imporoper store
5463 to memory, always create a new pseudo for OLDVAL. */
5466 if (!expand_atomic_compare_and_swap (&target
, &oldval
, mem
, expect
, desired
,
5467 is_weak
, success
, failure
))
5470 /* Conditionally store back to EXPECT, lest we create a race condition
5471 with an improper store to memory. */
5472 /* ??? With a rearrangement of atomics at the gimple level, we can handle
5473 the normal case where EXPECT is totally private, i.e. a register. At
5474 which point the store can be unconditional. */
5475 label
= gen_label_rtx ();
5476 emit_cmp_and_jump_insns (target
, const0_rtx
, NE
, NULL
, VOIDmode
, 1, label
);
5477 emit_move_insn (expect
, oldval
);
5483 /* Expand the __atomic_load intrinsic:
5484 TYPE __atomic_load (TYPE *object, enum memmodel)
5485 EXP is the CALL_EXPR.
5486 TARGET is an optional place for us to store the results. */
5489 expand_builtin_atomic_load (machine_mode mode
, tree exp
, rtx target
)
5492 enum memmodel model
;
5494 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5495 if ((model
& MEMMODEL_MASK
) == MEMMODEL_RELEASE
5496 || (model
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
5498 warning (OPT_Winvalid_memory_model
,
5499 "invalid memory model for %<__atomic_load%>");
5500 model
= MEMMODEL_SEQ_CST
;
5503 if (!flag_inline_atomics
)
5506 /* Expand the operand. */
5507 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5509 return expand_atomic_load (target
, mem
, model
);
5513 /* Expand the __atomic_store intrinsic:
5514 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5515 EXP is the CALL_EXPR.
5516 TARGET is an optional place for us to store the results. */
5519 expand_builtin_atomic_store (machine_mode mode
, tree exp
)
5522 enum memmodel model
;
5524 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5525 if ((model
& MEMMODEL_MASK
) != MEMMODEL_RELAXED
5526 && (model
& MEMMODEL_MASK
) != MEMMODEL_SEQ_CST
5527 && (model
& MEMMODEL_MASK
) != MEMMODEL_RELEASE
)
5529 warning (OPT_Winvalid_memory_model
,
5530 "invalid memory model for %<__atomic_store%>");
5531 model
= MEMMODEL_SEQ_CST
;
5534 if (!flag_inline_atomics
)
5537 /* Expand the operands. */
5538 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5539 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5541 return expand_atomic_store (mem
, val
, model
, false);
5544 /* Expand the __atomic_fetch_XXX intrinsic:
5545 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5546 EXP is the CALL_EXPR.
5547 TARGET is an optional place for us to store the results.
5548 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5549 FETCH_AFTER is true if returning the result of the operation.
5550 FETCH_AFTER is false if returning the value before the operation.
5551 IGNORE is true if the result is not used.
5552 EXT_CALL is the correct builtin for an external call if this cannot be
5553 resolved to an instruction sequence. */
5556 expand_builtin_atomic_fetch_op (machine_mode mode
, tree exp
, rtx target
,
5557 enum rtx_code code
, bool fetch_after
,
5558 bool ignore
, enum built_in_function ext_call
)
5561 enum memmodel model
;
5565 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5567 /* Expand the operands. */
5568 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5569 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5571 /* Only try generating instructions if inlining is turned on. */
5572 if (flag_inline_atomics
)
5574 ret
= expand_atomic_fetch_op (target
, mem
, val
, code
, model
, fetch_after
);
5579 /* Return if a different routine isn't needed for the library call. */
5580 if (ext_call
== BUILT_IN_NONE
)
5583 /* Change the call to the specified function. */
5584 fndecl
= get_callee_fndecl (exp
);
5585 addr
= CALL_EXPR_FN (exp
);
5588 gcc_assert (TREE_OPERAND (addr
, 0) == fndecl
);
5589 TREE_OPERAND (addr
, 0) = builtin_decl_explicit (ext_call
);
5591 /* Expand the call here so we can emit trailing code. */
5592 ret
= expand_call (exp
, target
, ignore
);
5594 /* Replace the original function just in case it matters. */
5595 TREE_OPERAND (addr
, 0) = fndecl
;
5597 /* Then issue the arithmetic correction to return the right result. */
5602 ret
= expand_simple_binop (mode
, AND
, ret
, val
, NULL_RTX
, true,
5604 ret
= expand_simple_unop (mode
, NOT
, ret
, target
, true);
5607 ret
= expand_simple_binop (mode
, code
, ret
, val
, target
, true,
5614 #ifndef HAVE_atomic_clear
5615 # define HAVE_atomic_clear 0
5616 # define gen_atomic_clear(x,y) (gcc_unreachable (), NULL_RTX)
5619 /* Expand an atomic clear operation.
5620 void _atomic_clear (BOOL *obj, enum memmodel)
5621 EXP is the call expression. */
5624 expand_builtin_atomic_clear (tree exp
)
5628 enum memmodel model
;
5630 mode
= mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0);
5631 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5632 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5634 if ((model
& MEMMODEL_MASK
) == MEMMODEL_CONSUME
5635 || (model
& MEMMODEL_MASK
) == MEMMODEL_ACQUIRE
5636 || (model
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
5638 warning (OPT_Winvalid_memory_model
,
5639 "invalid memory model for %<__atomic_store%>");
5640 model
= MEMMODEL_SEQ_CST
;
5643 if (HAVE_atomic_clear
)
5645 emit_insn (gen_atomic_clear (mem
, model
));
5649 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5650 Failing that, a store is issued by __atomic_store. The only way this can
5651 fail is if the bool type is larger than a word size. Unlikely, but
5652 handle it anyway for completeness. Assume a single threaded model since
5653 there is no atomic support in this case, and no barriers are required. */
5654 ret
= expand_atomic_store (mem
, const0_rtx
, model
, true);
5656 emit_move_insn (mem
, const0_rtx
);
5660 /* Expand an atomic test_and_set operation.
5661 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5662 EXP is the call expression. */
5665 expand_builtin_atomic_test_and_set (tree exp
, rtx target
)
5668 enum memmodel model
;
5671 mode
= mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0);
5672 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5673 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5675 return expand_atomic_test_and_set (target
, mem
, model
);
5679 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5680 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
5683 fold_builtin_atomic_always_lock_free (tree arg0
, tree arg1
)
5687 unsigned int mode_align
, type_align
;
5689 if (TREE_CODE (arg0
) != INTEGER_CST
)
5692 size
= INTVAL (expand_normal (arg0
)) * BITS_PER_UNIT
;
5693 mode
= mode_for_size (size
, MODE_INT
, 0);
5694 mode_align
= GET_MODE_ALIGNMENT (mode
);
5696 if (TREE_CODE (arg1
) == INTEGER_CST
&& INTVAL (expand_normal (arg1
)) == 0)
5697 type_align
= mode_align
;
5700 tree ttype
= TREE_TYPE (arg1
);
5702 /* This function is usually invoked and folded immediately by the front
5703 end before anything else has a chance to look at it. The pointer
5704 parameter at this point is usually cast to a void *, so check for that
5705 and look past the cast. */
5706 if (CONVERT_EXPR_P (arg1
) && POINTER_TYPE_P (ttype
)
5707 && VOID_TYPE_P (TREE_TYPE (ttype
)))
5708 arg1
= TREE_OPERAND (arg1
, 0);
5710 ttype
= TREE_TYPE (arg1
);
5711 gcc_assert (POINTER_TYPE_P (ttype
));
5713 /* Get the underlying type of the object. */
5714 ttype
= TREE_TYPE (ttype
);
5715 type_align
= TYPE_ALIGN (ttype
);
5718 /* If the object has smaller alignment, the the lock free routines cannot
5720 if (type_align
< mode_align
)
5721 return boolean_false_node
;
5723 /* Check if a compare_and_swap pattern exists for the mode which represents
5724 the required size. The pattern is not allowed to fail, so the existence
5725 of the pattern indicates support is present. */
5726 if (can_compare_and_swap_p (mode
, true))
5727 return boolean_true_node
;
5729 return boolean_false_node
;
5732 /* Return true if the parameters to call EXP represent an object which will
5733 always generate lock free instructions. The first argument represents the
5734 size of the object, and the second parameter is a pointer to the object
5735 itself. If NULL is passed for the object, then the result is based on
5736 typical alignment for an object of the specified size. Otherwise return
5740 expand_builtin_atomic_always_lock_free (tree exp
)
5743 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5744 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5746 if (TREE_CODE (arg0
) != INTEGER_CST
)
5748 error ("non-constant argument 1 to __atomic_always_lock_free");
5752 size
= fold_builtin_atomic_always_lock_free (arg0
, arg1
);
5753 if (size
== boolean_true_node
)
5758 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5759 is lock free on this architecture. */
5762 fold_builtin_atomic_is_lock_free (tree arg0
, tree arg1
)
5764 if (!flag_inline_atomics
)
5767 /* If it isn't always lock free, don't generate a result. */
5768 if (fold_builtin_atomic_always_lock_free (arg0
, arg1
) == boolean_true_node
)
5769 return boolean_true_node
;
5774 /* Return true if the parameters to call EXP represent an object which will
5775 always generate lock free instructions. The first argument represents the
5776 size of the object, and the second parameter is a pointer to the object
5777 itself. If NULL is passed for the object, then the result is based on
5778 typical alignment for an object of the specified size. Otherwise return
5782 expand_builtin_atomic_is_lock_free (tree exp
)
5785 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5786 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5788 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
5790 error ("non-integer argument 1 to __atomic_is_lock_free");
5794 if (!flag_inline_atomics
)
5797 /* If the value is known at compile time, return the RTX for it. */
5798 size
= fold_builtin_atomic_is_lock_free (arg0
, arg1
);
5799 if (size
== boolean_true_node
)
5805 /* Expand the __atomic_thread_fence intrinsic:
5806 void __atomic_thread_fence (enum memmodel)
5807 EXP is the CALL_EXPR. */
5810 expand_builtin_atomic_thread_fence (tree exp
)
5812 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
5813 expand_mem_thread_fence (model
);
5816 /* Expand the __atomic_signal_fence intrinsic:
5817 void __atomic_signal_fence (enum memmodel)
5818 EXP is the CALL_EXPR. */
5821 expand_builtin_atomic_signal_fence (tree exp
)
5823 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
5824 expand_mem_signal_fence (model
);
5827 /* Expand the __sync_synchronize intrinsic. */
5830 expand_builtin_sync_synchronize (void)
5832 expand_mem_thread_fence (MEMMODEL_SEQ_CST
);
5836 expand_builtin_thread_pointer (tree exp
, rtx target
)
5838 enum insn_code icode
;
5839 if (!validate_arglist (exp
, VOID_TYPE
))
5841 icode
= direct_optab_handler (get_thread_pointer_optab
, Pmode
);
5842 if (icode
!= CODE_FOR_nothing
)
5844 struct expand_operand op
;
5845 /* If the target is not sutitable then create a new target. */
5846 if (target
== NULL_RTX
5848 || GET_MODE (target
) != Pmode
)
5849 target
= gen_reg_rtx (Pmode
);
5850 create_output_operand (&op
, target
, Pmode
);
5851 expand_insn (icode
, 1, &op
);
5854 error ("__builtin_thread_pointer is not supported on this target");
5859 expand_builtin_set_thread_pointer (tree exp
)
5861 enum insn_code icode
;
5862 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5864 icode
= direct_optab_handler (set_thread_pointer_optab
, Pmode
);
5865 if (icode
!= CODE_FOR_nothing
)
5867 struct expand_operand op
;
5868 rtx val
= expand_expr (CALL_EXPR_ARG (exp
, 0), NULL_RTX
,
5869 Pmode
, EXPAND_NORMAL
);
5870 create_input_operand (&op
, val
, Pmode
);
5871 expand_insn (icode
, 1, &op
);
5874 error ("__builtin_set_thread_pointer is not supported on this target");
5878 /* Emit code to restore the current value of stack. */
5881 expand_stack_restore (tree var
)
5884 rtx sa
= expand_normal (var
);
5886 sa
= convert_memory_address (Pmode
, sa
);
5888 prev
= get_last_insn ();
5889 emit_stack_restore (SAVE_BLOCK
, sa
);
5890 fixup_args_size_notes (prev
, get_last_insn (), 0);
5894 /* Emit code to save the current value of stack. */
5897 expand_stack_save (void)
5901 do_pending_stack_adjust ();
5902 emit_stack_save (SAVE_BLOCK
, &ret
);
5906 /* Expand an expression EXP that calls a built-in function,
5907 with result going to TARGET if that's convenient
5908 (and in mode MODE if that's convenient).
5909 SUBTARGET may be used as the target for computing one of EXP's operands.
5910 IGNORE is nonzero if the value is to be ignored. */
5913 expand_builtin (tree exp
, rtx target
, rtx subtarget
, machine_mode mode
,
5916 tree fndecl
= get_callee_fndecl (exp
);
5917 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5918 machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5921 /* When ASan is enabled, we don't want to expand some memory/string
5922 builtins and rely on libsanitizer's hooks. This allows us to avoid
5923 redundant checks and be sure, that possible overflow will be detected
5926 if ((flag_sanitize
& SANITIZE_ADDRESS
) && asan_intercepted_p (fcode
))
5927 return expand_call (exp
, target
, ignore
);
5929 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5930 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5932 /* When not optimizing, generate calls to library functions for a certain
5935 && !called_as_built_in (fndecl
)
5936 && fcode
!= BUILT_IN_FORK
5937 && fcode
!= BUILT_IN_EXECL
5938 && fcode
!= BUILT_IN_EXECV
5939 && fcode
!= BUILT_IN_EXECLP
5940 && fcode
!= BUILT_IN_EXECLE
5941 && fcode
!= BUILT_IN_EXECVP
5942 && fcode
!= BUILT_IN_EXECVE
5943 && fcode
!= BUILT_IN_ALLOCA
5944 && fcode
!= BUILT_IN_ALLOCA_WITH_ALIGN
5945 && fcode
!= BUILT_IN_FREE
5946 && fcode
!= BUILT_IN_CHKP_SET_PTR_BOUNDS
5947 && fcode
!= BUILT_IN_CHKP_INIT_PTR_BOUNDS
5948 && fcode
!= BUILT_IN_CHKP_NULL_PTR_BOUNDS
5949 && fcode
!= BUILT_IN_CHKP_COPY_PTR_BOUNDS
5950 && fcode
!= BUILT_IN_CHKP_NARROW_PTR_BOUNDS
5951 && fcode
!= BUILT_IN_CHKP_STORE_PTR_BOUNDS
5952 && fcode
!= BUILT_IN_CHKP_CHECK_PTR_LBOUNDS
5953 && fcode
!= BUILT_IN_CHKP_CHECK_PTR_UBOUNDS
5954 && fcode
!= BUILT_IN_CHKP_CHECK_PTR_BOUNDS
5955 && fcode
!= BUILT_IN_CHKP_GET_PTR_LBOUND
5956 && fcode
!= BUILT_IN_CHKP_GET_PTR_UBOUND
5957 && fcode
!= BUILT_IN_CHKP_BNDRET
)
5958 return expand_call (exp
, target
, ignore
);
5960 /* The built-in function expanders test for target == const0_rtx
5961 to determine whether the function's result will be ignored. */
5963 target
= const0_rtx
;
5965 /* If the result of a pure or const built-in function is ignored, and
5966 none of its arguments are volatile, we can avoid expanding the
5967 built-in call and just evaluate the arguments for side-effects. */
5968 if (target
== const0_rtx
5969 && ((flags
= flags_from_decl_or_type (fndecl
)) & (ECF_CONST
| ECF_PURE
))
5970 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
5972 bool volatilep
= false;
5974 call_expr_arg_iterator iter
;
5976 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
5977 if (TREE_THIS_VOLATILE (arg
))
5985 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
5986 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5991 /* expand_builtin_with_bounds is supposed to be used for
5992 instrumented builtin calls. */
5993 gcc_assert (!CALL_WITH_BOUNDS_P (exp
));
5997 CASE_FLT_FN (BUILT_IN_FABS
):
5998 case BUILT_IN_FABSD32
:
5999 case BUILT_IN_FABSD64
:
6000 case BUILT_IN_FABSD128
:
6001 target
= expand_builtin_fabs (exp
, target
, subtarget
);
6006 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
6007 target
= expand_builtin_copysign (exp
, target
, subtarget
);
6012 /* Just do a normal library call if we were unable to fold
6014 CASE_FLT_FN (BUILT_IN_CABS
):
6017 CASE_FLT_FN (BUILT_IN_EXP
):
6018 CASE_FLT_FN (BUILT_IN_EXP10
):
6019 CASE_FLT_FN (BUILT_IN_POW10
):
6020 CASE_FLT_FN (BUILT_IN_EXP2
):
6021 CASE_FLT_FN (BUILT_IN_EXPM1
):
6022 CASE_FLT_FN (BUILT_IN_LOGB
):
6023 CASE_FLT_FN (BUILT_IN_LOG
):
6024 CASE_FLT_FN (BUILT_IN_LOG10
):
6025 CASE_FLT_FN (BUILT_IN_LOG2
):
6026 CASE_FLT_FN (BUILT_IN_LOG1P
):
6027 CASE_FLT_FN (BUILT_IN_TAN
):
6028 CASE_FLT_FN (BUILT_IN_ASIN
):
6029 CASE_FLT_FN (BUILT_IN_ACOS
):
6030 CASE_FLT_FN (BUILT_IN_ATAN
):
6031 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
6032 /* Treat these like sqrt only if unsafe math optimizations are allowed,
6033 because of possible accuracy problems. */
6034 if (! flag_unsafe_math_optimizations
)
6036 CASE_FLT_FN (BUILT_IN_SQRT
):
6037 CASE_FLT_FN (BUILT_IN_FLOOR
):
6038 CASE_FLT_FN (BUILT_IN_CEIL
):
6039 CASE_FLT_FN (BUILT_IN_TRUNC
):
6040 CASE_FLT_FN (BUILT_IN_ROUND
):
6041 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
6042 CASE_FLT_FN (BUILT_IN_RINT
):
6043 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
6048 CASE_FLT_FN (BUILT_IN_FMA
):
6049 target
= expand_builtin_mathfn_ternary (exp
, target
, subtarget
);
6054 CASE_FLT_FN (BUILT_IN_ILOGB
):
6055 if (! flag_unsafe_math_optimizations
)
6057 CASE_FLT_FN (BUILT_IN_ISINF
):
6058 CASE_FLT_FN (BUILT_IN_FINITE
):
6059 case BUILT_IN_ISFINITE
:
6060 case BUILT_IN_ISNORMAL
:
6061 target
= expand_builtin_interclass_mathfn (exp
, target
);
6066 CASE_FLT_FN (BUILT_IN_ICEIL
):
6067 CASE_FLT_FN (BUILT_IN_LCEIL
):
6068 CASE_FLT_FN (BUILT_IN_LLCEIL
):
6069 CASE_FLT_FN (BUILT_IN_LFLOOR
):
6070 CASE_FLT_FN (BUILT_IN_IFLOOR
):
6071 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
6072 target
= expand_builtin_int_roundingfn (exp
, target
);
6077 CASE_FLT_FN (BUILT_IN_IRINT
):
6078 CASE_FLT_FN (BUILT_IN_LRINT
):
6079 CASE_FLT_FN (BUILT_IN_LLRINT
):
6080 CASE_FLT_FN (BUILT_IN_IROUND
):
6081 CASE_FLT_FN (BUILT_IN_LROUND
):
6082 CASE_FLT_FN (BUILT_IN_LLROUND
):
6083 target
= expand_builtin_int_roundingfn_2 (exp
, target
);
6088 CASE_FLT_FN (BUILT_IN_POWI
):
6089 target
= expand_builtin_powi (exp
, target
);
6094 CASE_FLT_FN (BUILT_IN_ATAN2
):
6095 CASE_FLT_FN (BUILT_IN_LDEXP
):
6096 CASE_FLT_FN (BUILT_IN_SCALB
):
6097 CASE_FLT_FN (BUILT_IN_SCALBN
):
6098 CASE_FLT_FN (BUILT_IN_SCALBLN
):
6099 if (! flag_unsafe_math_optimizations
)
6102 CASE_FLT_FN (BUILT_IN_FMOD
):
6103 CASE_FLT_FN (BUILT_IN_REMAINDER
):
6104 CASE_FLT_FN (BUILT_IN_DREM
):
6105 CASE_FLT_FN (BUILT_IN_POW
):
6106 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
6111 CASE_FLT_FN (BUILT_IN_CEXPI
):
6112 target
= expand_builtin_cexpi (exp
, target
);
6113 gcc_assert (target
);
6116 CASE_FLT_FN (BUILT_IN_SIN
):
6117 CASE_FLT_FN (BUILT_IN_COS
):
6118 if (! flag_unsafe_math_optimizations
)
6120 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
6125 CASE_FLT_FN (BUILT_IN_SINCOS
):
6126 if (! flag_unsafe_math_optimizations
)
6128 target
= expand_builtin_sincos (exp
);
6133 case BUILT_IN_APPLY_ARGS
:
6134 return expand_builtin_apply_args ();
6136 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6137 FUNCTION with a copy of the parameters described by
6138 ARGUMENTS, and ARGSIZE. It returns a block of memory
6139 allocated on the stack into which is stored all the registers
6140 that might possibly be used for returning the result of a
6141 function. ARGUMENTS is the value returned by
6142 __builtin_apply_args. ARGSIZE is the number of bytes of
6143 arguments that must be copied. ??? How should this value be
6144 computed? We'll also need a safe worst case value for varargs
6146 case BUILT_IN_APPLY
:
6147 if (!validate_arglist (exp
, POINTER_TYPE
,
6148 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
6149 && !validate_arglist (exp
, REFERENCE_TYPE
,
6150 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6156 ops
[0] = expand_normal (CALL_EXPR_ARG (exp
, 0));
6157 ops
[1] = expand_normal (CALL_EXPR_ARG (exp
, 1));
6158 ops
[2] = expand_normal (CALL_EXPR_ARG (exp
, 2));
6160 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
6163 /* __builtin_return (RESULT) causes the function to return the
6164 value described by RESULT. RESULT is address of the block of
6165 memory returned by __builtin_apply. */
6166 case BUILT_IN_RETURN
:
6167 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6168 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp
, 0)));
6171 case BUILT_IN_SAVEREGS
:
6172 return expand_builtin_saveregs ();
6174 case BUILT_IN_VA_ARG_PACK
:
6175 /* All valid uses of __builtin_va_arg_pack () are removed during
6177 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp
);
6180 case BUILT_IN_VA_ARG_PACK_LEN
:
6181 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6183 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp
);
6186 /* Return the address of the first anonymous stack arg. */
6187 case BUILT_IN_NEXT_ARG
:
6188 if (fold_builtin_next_arg (exp
, false))
6190 return expand_builtin_next_arg ();
6192 case BUILT_IN_CLEAR_CACHE
:
6193 target
= expand_builtin___clear_cache (exp
);
6198 case BUILT_IN_CLASSIFY_TYPE
:
6199 return expand_builtin_classify_type (exp
);
6201 case BUILT_IN_CONSTANT_P
:
6204 case BUILT_IN_FRAME_ADDRESS
:
6205 case BUILT_IN_RETURN_ADDRESS
:
6206 return expand_builtin_frame_address (fndecl
, exp
);
6208 /* Returns the address of the area where the structure is returned.
6210 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
6211 if (call_expr_nargs (exp
) != 0
6212 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
6213 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
6216 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
6218 case BUILT_IN_ALLOCA
:
6219 case BUILT_IN_ALLOCA_WITH_ALIGN
:
6220 /* If the allocation stems from the declaration of a variable-sized
6221 object, it cannot accumulate. */
6222 target
= expand_builtin_alloca (exp
, CALL_ALLOCA_FOR_VAR_P (exp
));
6227 case BUILT_IN_STACK_SAVE
:
6228 return expand_stack_save ();
6230 case BUILT_IN_STACK_RESTORE
:
6231 expand_stack_restore (CALL_EXPR_ARG (exp
, 0));
6234 case BUILT_IN_BSWAP16
:
6235 case BUILT_IN_BSWAP32
:
6236 case BUILT_IN_BSWAP64
:
6237 target
= expand_builtin_bswap (target_mode
, exp
, target
, subtarget
);
6242 CASE_INT_FN (BUILT_IN_FFS
):
6243 target
= expand_builtin_unop (target_mode
, exp
, target
,
6244 subtarget
, ffs_optab
);
6249 CASE_INT_FN (BUILT_IN_CLZ
):
6250 target
= expand_builtin_unop (target_mode
, exp
, target
,
6251 subtarget
, clz_optab
);
6256 CASE_INT_FN (BUILT_IN_CTZ
):
6257 target
= expand_builtin_unop (target_mode
, exp
, target
,
6258 subtarget
, ctz_optab
);
6263 CASE_INT_FN (BUILT_IN_CLRSB
):
6264 target
= expand_builtin_unop (target_mode
, exp
, target
,
6265 subtarget
, clrsb_optab
);
6270 CASE_INT_FN (BUILT_IN_POPCOUNT
):
6271 target
= expand_builtin_unop (target_mode
, exp
, target
,
6272 subtarget
, popcount_optab
);
6277 CASE_INT_FN (BUILT_IN_PARITY
):
6278 target
= expand_builtin_unop (target_mode
, exp
, target
,
6279 subtarget
, parity_optab
);
6284 case BUILT_IN_STRLEN
:
6285 target
= expand_builtin_strlen (exp
, target
, target_mode
);
6290 case BUILT_IN_STRCPY
:
6291 target
= expand_builtin_strcpy (exp
, target
);
6296 case BUILT_IN_STRNCPY
:
6297 target
= expand_builtin_strncpy (exp
, target
);
6302 case BUILT_IN_STPCPY
:
6303 target
= expand_builtin_stpcpy (exp
, target
, mode
);
6308 case BUILT_IN_MEMCPY
:
6309 target
= expand_builtin_memcpy (exp
, target
);
6314 case BUILT_IN_MEMPCPY
:
6315 target
= expand_builtin_mempcpy (exp
, target
, mode
);
6320 case BUILT_IN_MEMSET
:
6321 target
= expand_builtin_memset (exp
, target
, mode
);
6326 case BUILT_IN_BZERO
:
6327 target
= expand_builtin_bzero (exp
);
6332 case BUILT_IN_STRCMP
:
6333 target
= expand_builtin_strcmp (exp
, target
);
6338 case BUILT_IN_STRNCMP
:
6339 target
= expand_builtin_strncmp (exp
, target
, mode
);
6345 case BUILT_IN_MEMCMP
:
6346 target
= expand_builtin_memcmp (exp
, target
, mode
);
6351 case BUILT_IN_SETJMP
:
6352 /* This should have been lowered to the builtins below. */
6355 case BUILT_IN_SETJMP_SETUP
:
6356 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6357 and the receiver label. */
6358 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
6360 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6361 VOIDmode
, EXPAND_NORMAL
);
6362 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 1), 0);
6363 rtx label_r
= label_rtx (label
);
6365 /* This is copied from the handling of non-local gotos. */
6366 expand_builtin_setjmp_setup (buf_addr
, label_r
);
6367 nonlocal_goto_handler_labels
6368 = gen_rtx_INSN_LIST (VOIDmode
, label_r
,
6369 nonlocal_goto_handler_labels
);
6370 /* ??? Do not let expand_label treat us as such since we would
6371 not want to be both on the list of non-local labels and on
6372 the list of forced labels. */
6373 FORCED_LABEL (label
) = 0;
6378 case BUILT_IN_SETJMP_RECEIVER
:
6379 /* __builtin_setjmp_receiver is passed the receiver label. */
6380 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6382 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 0), 0);
6383 rtx label_r
= label_rtx (label
);
6385 expand_builtin_setjmp_receiver (label_r
);
6390 /* __builtin_longjmp is passed a pointer to an array of five words.
6391 It's similar to the C library longjmp function but works with
6392 __builtin_setjmp above. */
6393 case BUILT_IN_LONGJMP
:
6394 if (validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6396 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6397 VOIDmode
, EXPAND_NORMAL
);
6398 rtx value
= expand_normal (CALL_EXPR_ARG (exp
, 1));
6400 if (value
!= const1_rtx
)
6402 error ("%<__builtin_longjmp%> second argument must be 1");
6406 expand_builtin_longjmp (buf_addr
, value
);
6411 case BUILT_IN_NONLOCAL_GOTO
:
6412 target
= expand_builtin_nonlocal_goto (exp
);
6417 /* This updates the setjmp buffer that is its argument with the value
6418 of the current stack pointer. */
6419 case BUILT_IN_UPDATE_SETJMP_BUF
:
6420 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6423 = expand_normal (CALL_EXPR_ARG (exp
, 0));
6425 expand_builtin_update_setjmp_buf (buf_addr
);
6431 expand_builtin_trap ();
6434 case BUILT_IN_UNREACHABLE
:
6435 expand_builtin_unreachable ();
6438 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
6439 case BUILT_IN_SIGNBITD32
:
6440 case BUILT_IN_SIGNBITD64
:
6441 case BUILT_IN_SIGNBITD128
:
6442 target
= expand_builtin_signbit (exp
, target
);
6447 /* Various hooks for the DWARF 2 __throw routine. */
6448 case BUILT_IN_UNWIND_INIT
:
6449 expand_builtin_unwind_init ();
6451 case BUILT_IN_DWARF_CFA
:
6452 return virtual_cfa_rtx
;
6453 #ifdef DWARF2_UNWIND_INFO
6454 case BUILT_IN_DWARF_SP_COLUMN
:
6455 return expand_builtin_dwarf_sp_column ();
6456 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6457 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp
, 0));
6460 case BUILT_IN_FROB_RETURN_ADDR
:
6461 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp
, 0));
6462 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6463 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp
, 0));
6464 case BUILT_IN_EH_RETURN
:
6465 expand_builtin_eh_return (CALL_EXPR_ARG (exp
, 0),
6466 CALL_EXPR_ARG (exp
, 1));
6468 #ifdef EH_RETURN_DATA_REGNO
6469 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6470 return expand_builtin_eh_return_data_regno (exp
);
6472 case BUILT_IN_EXTEND_POINTER
:
6473 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp
, 0));
6474 case BUILT_IN_EH_POINTER
:
6475 return expand_builtin_eh_pointer (exp
);
6476 case BUILT_IN_EH_FILTER
:
6477 return expand_builtin_eh_filter (exp
);
6478 case BUILT_IN_EH_COPY_VALUES
:
6479 return expand_builtin_eh_copy_values (exp
);
6481 case BUILT_IN_VA_START
:
6482 return expand_builtin_va_start (exp
);
6483 case BUILT_IN_VA_END
:
6484 return expand_builtin_va_end (exp
);
6485 case BUILT_IN_VA_COPY
:
6486 return expand_builtin_va_copy (exp
);
6487 case BUILT_IN_EXPECT
:
6488 return expand_builtin_expect (exp
, target
);
6489 case BUILT_IN_ASSUME_ALIGNED
:
6490 return expand_builtin_assume_aligned (exp
, target
);
6491 case BUILT_IN_PREFETCH
:
6492 expand_builtin_prefetch (exp
);
6495 case BUILT_IN_INIT_TRAMPOLINE
:
6496 return expand_builtin_init_trampoline (exp
, true);
6497 case BUILT_IN_INIT_HEAP_TRAMPOLINE
:
6498 return expand_builtin_init_trampoline (exp
, false);
6499 case BUILT_IN_ADJUST_TRAMPOLINE
:
6500 return expand_builtin_adjust_trampoline (exp
);
6503 case BUILT_IN_EXECL
:
6504 case BUILT_IN_EXECV
:
6505 case BUILT_IN_EXECLP
:
6506 case BUILT_IN_EXECLE
:
6507 case BUILT_IN_EXECVP
:
6508 case BUILT_IN_EXECVE
:
6509 target
= expand_builtin_fork_or_exec (fndecl
, exp
, target
, ignore
);
6514 case BUILT_IN_SYNC_FETCH_AND_ADD_1
:
6515 case BUILT_IN_SYNC_FETCH_AND_ADD_2
:
6516 case BUILT_IN_SYNC_FETCH_AND_ADD_4
:
6517 case BUILT_IN_SYNC_FETCH_AND_ADD_8
:
6518 case BUILT_IN_SYNC_FETCH_AND_ADD_16
:
6519 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_ADD_1
);
6520 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, false, target
);
6525 case BUILT_IN_SYNC_FETCH_AND_SUB_1
:
6526 case BUILT_IN_SYNC_FETCH_AND_SUB_2
:
6527 case BUILT_IN_SYNC_FETCH_AND_SUB_4
:
6528 case BUILT_IN_SYNC_FETCH_AND_SUB_8
:
6529 case BUILT_IN_SYNC_FETCH_AND_SUB_16
:
6530 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_SUB_1
);
6531 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, false, target
);
6536 case BUILT_IN_SYNC_FETCH_AND_OR_1
:
6537 case BUILT_IN_SYNC_FETCH_AND_OR_2
:
6538 case BUILT_IN_SYNC_FETCH_AND_OR_4
:
6539 case BUILT_IN_SYNC_FETCH_AND_OR_8
:
6540 case BUILT_IN_SYNC_FETCH_AND_OR_16
:
6541 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_OR_1
);
6542 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, false, target
);
6547 case BUILT_IN_SYNC_FETCH_AND_AND_1
:
6548 case BUILT_IN_SYNC_FETCH_AND_AND_2
:
6549 case BUILT_IN_SYNC_FETCH_AND_AND_4
:
6550 case BUILT_IN_SYNC_FETCH_AND_AND_8
:
6551 case BUILT_IN_SYNC_FETCH_AND_AND_16
:
6552 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_AND_1
);
6553 target
= expand_builtin_sync_operation (mode
, exp
, AND
, false, target
);
6558 case BUILT_IN_SYNC_FETCH_AND_XOR_1
:
6559 case BUILT_IN_SYNC_FETCH_AND_XOR_2
:
6560 case BUILT_IN_SYNC_FETCH_AND_XOR_4
:
6561 case BUILT_IN_SYNC_FETCH_AND_XOR_8
:
6562 case BUILT_IN_SYNC_FETCH_AND_XOR_16
:
6563 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_XOR_1
);
6564 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, false, target
);
6569 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
6570 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
6571 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
6572 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
6573 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
6574 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_NAND_1
);
6575 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, false, target
);
6580 case BUILT_IN_SYNC_ADD_AND_FETCH_1
:
6581 case BUILT_IN_SYNC_ADD_AND_FETCH_2
:
6582 case BUILT_IN_SYNC_ADD_AND_FETCH_4
:
6583 case BUILT_IN_SYNC_ADD_AND_FETCH_8
:
6584 case BUILT_IN_SYNC_ADD_AND_FETCH_16
:
6585 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_ADD_AND_FETCH_1
);
6586 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, true, target
);
6591 case BUILT_IN_SYNC_SUB_AND_FETCH_1
:
6592 case BUILT_IN_SYNC_SUB_AND_FETCH_2
:
6593 case BUILT_IN_SYNC_SUB_AND_FETCH_4
:
6594 case BUILT_IN_SYNC_SUB_AND_FETCH_8
:
6595 case BUILT_IN_SYNC_SUB_AND_FETCH_16
:
6596 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_SUB_AND_FETCH_1
);
6597 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, true, target
);
6602 case BUILT_IN_SYNC_OR_AND_FETCH_1
:
6603 case BUILT_IN_SYNC_OR_AND_FETCH_2
:
6604 case BUILT_IN_SYNC_OR_AND_FETCH_4
:
6605 case BUILT_IN_SYNC_OR_AND_FETCH_8
:
6606 case BUILT_IN_SYNC_OR_AND_FETCH_16
:
6607 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_OR_AND_FETCH_1
);
6608 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, true, target
);
6613 case BUILT_IN_SYNC_AND_AND_FETCH_1
:
6614 case BUILT_IN_SYNC_AND_AND_FETCH_2
:
6615 case BUILT_IN_SYNC_AND_AND_FETCH_4
:
6616 case BUILT_IN_SYNC_AND_AND_FETCH_8
:
6617 case BUILT_IN_SYNC_AND_AND_FETCH_16
:
6618 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_AND_AND_FETCH_1
);
6619 target
= expand_builtin_sync_operation (mode
, exp
, AND
, true, target
);
6624 case BUILT_IN_SYNC_XOR_AND_FETCH_1
:
6625 case BUILT_IN_SYNC_XOR_AND_FETCH_2
:
6626 case BUILT_IN_SYNC_XOR_AND_FETCH_4
:
6627 case BUILT_IN_SYNC_XOR_AND_FETCH_8
:
6628 case BUILT_IN_SYNC_XOR_AND_FETCH_16
:
6629 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_XOR_AND_FETCH_1
);
6630 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, true, target
);
6635 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
6636 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
6637 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
6638 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
6639 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
6640 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_NAND_AND_FETCH_1
);
6641 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, true, target
);
6646 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
:
6647 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2
:
6648 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4
:
6649 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8
:
6650 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16
:
6651 if (mode
== VOIDmode
)
6652 mode
= TYPE_MODE (boolean_type_node
);
6653 if (!target
|| !register_operand (target
, mode
))
6654 target
= gen_reg_rtx (mode
);
6656 mode
= get_builtin_sync_mode
6657 (fcode
- BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
);
6658 target
= expand_builtin_compare_and_swap (mode
, exp
, true, target
);
6663 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
:
6664 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2
:
6665 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4
:
6666 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8
:
6667 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16
:
6668 mode
= get_builtin_sync_mode
6669 (fcode
- BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
);
6670 target
= expand_builtin_compare_and_swap (mode
, exp
, false, target
);
6675 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
:
6676 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2
:
6677 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4
:
6678 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8
:
6679 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16
:
6680 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
);
6681 target
= expand_builtin_sync_lock_test_and_set (mode
, exp
, target
);
6686 case BUILT_IN_SYNC_LOCK_RELEASE_1
:
6687 case BUILT_IN_SYNC_LOCK_RELEASE_2
:
6688 case BUILT_IN_SYNC_LOCK_RELEASE_4
:
6689 case BUILT_IN_SYNC_LOCK_RELEASE_8
:
6690 case BUILT_IN_SYNC_LOCK_RELEASE_16
:
6691 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_RELEASE_1
);
6692 expand_builtin_sync_lock_release (mode
, exp
);
6695 case BUILT_IN_SYNC_SYNCHRONIZE
:
6696 expand_builtin_sync_synchronize ();
6699 case BUILT_IN_ATOMIC_EXCHANGE_1
:
6700 case BUILT_IN_ATOMIC_EXCHANGE_2
:
6701 case BUILT_IN_ATOMIC_EXCHANGE_4
:
6702 case BUILT_IN_ATOMIC_EXCHANGE_8
:
6703 case BUILT_IN_ATOMIC_EXCHANGE_16
:
6704 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_EXCHANGE_1
);
6705 target
= expand_builtin_atomic_exchange (mode
, exp
, target
);
6710 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
6711 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
6712 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
6713 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
6714 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
6716 unsigned int nargs
, z
;
6717 vec
<tree
, va_gc
> *vec
;
6720 get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
);
6721 target
= expand_builtin_atomic_compare_exchange (mode
, exp
, target
);
6725 /* If this is turned into an external library call, the weak parameter
6726 must be dropped to match the expected parameter list. */
6727 nargs
= call_expr_nargs (exp
);
6728 vec_alloc (vec
, nargs
- 1);
6729 for (z
= 0; z
< 3; z
++)
6730 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
6731 /* Skip the boolean weak parameter. */
6732 for (z
= 4; z
< 6; z
++)
6733 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
6734 exp
= build_call_vec (TREE_TYPE (exp
), CALL_EXPR_FN (exp
), vec
);
6738 case BUILT_IN_ATOMIC_LOAD_1
:
6739 case BUILT_IN_ATOMIC_LOAD_2
:
6740 case BUILT_IN_ATOMIC_LOAD_4
:
6741 case BUILT_IN_ATOMIC_LOAD_8
:
6742 case BUILT_IN_ATOMIC_LOAD_16
:
6743 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_LOAD_1
);
6744 target
= expand_builtin_atomic_load (mode
, exp
, target
);
6749 case BUILT_IN_ATOMIC_STORE_1
:
6750 case BUILT_IN_ATOMIC_STORE_2
:
6751 case BUILT_IN_ATOMIC_STORE_4
:
6752 case BUILT_IN_ATOMIC_STORE_8
:
6753 case BUILT_IN_ATOMIC_STORE_16
:
6754 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_STORE_1
);
6755 target
= expand_builtin_atomic_store (mode
, exp
);
6760 case BUILT_IN_ATOMIC_ADD_FETCH_1
:
6761 case BUILT_IN_ATOMIC_ADD_FETCH_2
:
6762 case BUILT_IN_ATOMIC_ADD_FETCH_4
:
6763 case BUILT_IN_ATOMIC_ADD_FETCH_8
:
6764 case BUILT_IN_ATOMIC_ADD_FETCH_16
:
6766 enum built_in_function lib
;
6767 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
);
6768 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_ADD_1
+
6769 (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
));
6770 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, true,
6776 case BUILT_IN_ATOMIC_SUB_FETCH_1
:
6777 case BUILT_IN_ATOMIC_SUB_FETCH_2
:
6778 case BUILT_IN_ATOMIC_SUB_FETCH_4
:
6779 case BUILT_IN_ATOMIC_SUB_FETCH_8
:
6780 case BUILT_IN_ATOMIC_SUB_FETCH_16
:
6782 enum built_in_function lib
;
6783 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
);
6784 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_SUB_1
+
6785 (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
));
6786 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, true,
6792 case BUILT_IN_ATOMIC_AND_FETCH_1
:
6793 case BUILT_IN_ATOMIC_AND_FETCH_2
:
6794 case BUILT_IN_ATOMIC_AND_FETCH_4
:
6795 case BUILT_IN_ATOMIC_AND_FETCH_8
:
6796 case BUILT_IN_ATOMIC_AND_FETCH_16
:
6798 enum built_in_function lib
;
6799 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
);
6800 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_AND_1
+
6801 (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
));
6802 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, true,
6808 case BUILT_IN_ATOMIC_NAND_FETCH_1
:
6809 case BUILT_IN_ATOMIC_NAND_FETCH_2
:
6810 case BUILT_IN_ATOMIC_NAND_FETCH_4
:
6811 case BUILT_IN_ATOMIC_NAND_FETCH_8
:
6812 case BUILT_IN_ATOMIC_NAND_FETCH_16
:
6814 enum built_in_function lib
;
6815 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
);
6816 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_NAND_1
+
6817 (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
));
6818 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, true,
6824 case BUILT_IN_ATOMIC_XOR_FETCH_1
:
6825 case BUILT_IN_ATOMIC_XOR_FETCH_2
:
6826 case BUILT_IN_ATOMIC_XOR_FETCH_4
:
6827 case BUILT_IN_ATOMIC_XOR_FETCH_8
:
6828 case BUILT_IN_ATOMIC_XOR_FETCH_16
:
6830 enum built_in_function lib
;
6831 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
);
6832 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_XOR_1
+
6833 (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
));
6834 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, true,
6840 case BUILT_IN_ATOMIC_OR_FETCH_1
:
6841 case BUILT_IN_ATOMIC_OR_FETCH_2
:
6842 case BUILT_IN_ATOMIC_OR_FETCH_4
:
6843 case BUILT_IN_ATOMIC_OR_FETCH_8
:
6844 case BUILT_IN_ATOMIC_OR_FETCH_16
:
6846 enum built_in_function lib
;
6847 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
);
6848 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_OR_1
+
6849 (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
));
6850 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, true,
6856 case BUILT_IN_ATOMIC_FETCH_ADD_1
:
6857 case BUILT_IN_ATOMIC_FETCH_ADD_2
:
6858 case BUILT_IN_ATOMIC_FETCH_ADD_4
:
6859 case BUILT_IN_ATOMIC_FETCH_ADD_8
:
6860 case BUILT_IN_ATOMIC_FETCH_ADD_16
:
6861 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_ADD_1
);
6862 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, false,
6863 ignore
, BUILT_IN_NONE
);
6868 case BUILT_IN_ATOMIC_FETCH_SUB_1
:
6869 case BUILT_IN_ATOMIC_FETCH_SUB_2
:
6870 case BUILT_IN_ATOMIC_FETCH_SUB_4
:
6871 case BUILT_IN_ATOMIC_FETCH_SUB_8
:
6872 case BUILT_IN_ATOMIC_FETCH_SUB_16
:
6873 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_SUB_1
);
6874 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, false,
6875 ignore
, BUILT_IN_NONE
);
6880 case BUILT_IN_ATOMIC_FETCH_AND_1
:
6881 case BUILT_IN_ATOMIC_FETCH_AND_2
:
6882 case BUILT_IN_ATOMIC_FETCH_AND_4
:
6883 case BUILT_IN_ATOMIC_FETCH_AND_8
:
6884 case BUILT_IN_ATOMIC_FETCH_AND_16
:
6885 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_AND_1
);
6886 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, false,
6887 ignore
, BUILT_IN_NONE
);
6892 case BUILT_IN_ATOMIC_FETCH_NAND_1
:
6893 case BUILT_IN_ATOMIC_FETCH_NAND_2
:
6894 case BUILT_IN_ATOMIC_FETCH_NAND_4
:
6895 case BUILT_IN_ATOMIC_FETCH_NAND_8
:
6896 case BUILT_IN_ATOMIC_FETCH_NAND_16
:
6897 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_NAND_1
);
6898 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, false,
6899 ignore
, BUILT_IN_NONE
);
6904 case BUILT_IN_ATOMIC_FETCH_XOR_1
:
6905 case BUILT_IN_ATOMIC_FETCH_XOR_2
:
6906 case BUILT_IN_ATOMIC_FETCH_XOR_4
:
6907 case BUILT_IN_ATOMIC_FETCH_XOR_8
:
6908 case BUILT_IN_ATOMIC_FETCH_XOR_16
:
6909 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_XOR_1
);
6910 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, false,
6911 ignore
, BUILT_IN_NONE
);
6916 case BUILT_IN_ATOMIC_FETCH_OR_1
:
6917 case BUILT_IN_ATOMIC_FETCH_OR_2
:
6918 case BUILT_IN_ATOMIC_FETCH_OR_4
:
6919 case BUILT_IN_ATOMIC_FETCH_OR_8
:
6920 case BUILT_IN_ATOMIC_FETCH_OR_16
:
6921 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_OR_1
);
6922 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, false,
6923 ignore
, BUILT_IN_NONE
);
6928 case BUILT_IN_ATOMIC_TEST_AND_SET
:
6929 return expand_builtin_atomic_test_and_set (exp
, target
);
6931 case BUILT_IN_ATOMIC_CLEAR
:
6932 return expand_builtin_atomic_clear (exp
);
6934 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
6935 return expand_builtin_atomic_always_lock_free (exp
);
6937 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
6938 target
= expand_builtin_atomic_is_lock_free (exp
);
6943 case BUILT_IN_ATOMIC_THREAD_FENCE
:
6944 expand_builtin_atomic_thread_fence (exp
);
6947 case BUILT_IN_ATOMIC_SIGNAL_FENCE
:
6948 expand_builtin_atomic_signal_fence (exp
);
6951 case BUILT_IN_OBJECT_SIZE
:
6952 return expand_builtin_object_size (exp
);
6954 case BUILT_IN_MEMCPY_CHK
:
6955 case BUILT_IN_MEMPCPY_CHK
:
6956 case BUILT_IN_MEMMOVE_CHK
:
6957 case BUILT_IN_MEMSET_CHK
:
6958 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
6963 case BUILT_IN_STRCPY_CHK
:
6964 case BUILT_IN_STPCPY_CHK
:
6965 case BUILT_IN_STRNCPY_CHK
:
6966 case BUILT_IN_STPNCPY_CHK
:
6967 case BUILT_IN_STRCAT_CHK
:
6968 case BUILT_IN_STRNCAT_CHK
:
6969 case BUILT_IN_SNPRINTF_CHK
:
6970 case BUILT_IN_VSNPRINTF_CHK
:
6971 maybe_emit_chk_warning (exp
, fcode
);
6974 case BUILT_IN_SPRINTF_CHK
:
6975 case BUILT_IN_VSPRINTF_CHK
:
6976 maybe_emit_sprintf_chk_warning (exp
, fcode
);
6980 if (warn_free_nonheap_object
)
6981 maybe_emit_free_warning (exp
);
6984 case BUILT_IN_THREAD_POINTER
:
6985 return expand_builtin_thread_pointer (exp
, target
);
6987 case BUILT_IN_SET_THREAD_POINTER
:
6988 expand_builtin_set_thread_pointer (exp
);
6991 case BUILT_IN_CILK_DETACH
:
6992 expand_builtin_cilk_detach (exp
);
6995 case BUILT_IN_CILK_POP_FRAME
:
6996 expand_builtin_cilk_pop_frame (exp
);
6999 case BUILT_IN_CHKP_INIT_PTR_BOUNDS
:
7000 case BUILT_IN_CHKP_NULL_PTR_BOUNDS
:
7001 case BUILT_IN_CHKP_COPY_PTR_BOUNDS
:
7002 case BUILT_IN_CHKP_CHECK_PTR_LBOUNDS
:
7003 case BUILT_IN_CHKP_CHECK_PTR_UBOUNDS
:
7004 case BUILT_IN_CHKP_CHECK_PTR_BOUNDS
:
7005 case BUILT_IN_CHKP_SET_PTR_BOUNDS
:
7006 case BUILT_IN_CHKP_NARROW_PTR_BOUNDS
:
7007 case BUILT_IN_CHKP_STORE_PTR_BOUNDS
:
7008 case BUILT_IN_CHKP_GET_PTR_LBOUND
:
7009 case BUILT_IN_CHKP_GET_PTR_UBOUND
:
7010 /* We allow user CHKP builtins if Pointer Bounds
7012 if (!chkp_function_instrumented_p (current_function_decl
))
7014 if (fcode
== BUILT_IN_CHKP_SET_PTR_BOUNDS
7015 || fcode
== BUILT_IN_CHKP_NARROW_PTR_BOUNDS
7016 || fcode
== BUILT_IN_CHKP_INIT_PTR_BOUNDS
7017 || fcode
== BUILT_IN_CHKP_NULL_PTR_BOUNDS
7018 || fcode
== BUILT_IN_CHKP_COPY_PTR_BOUNDS
)
7019 return expand_normal (CALL_EXPR_ARG (exp
, 0));
7020 else if (fcode
== BUILT_IN_CHKP_GET_PTR_LBOUND
)
7021 return expand_normal (size_zero_node
);
7022 else if (fcode
== BUILT_IN_CHKP_GET_PTR_UBOUND
)
7023 return expand_normal (size_int (-1));
7029 case BUILT_IN_CHKP_BNDMK
:
7030 case BUILT_IN_CHKP_BNDSTX
:
7031 case BUILT_IN_CHKP_BNDCL
:
7032 case BUILT_IN_CHKP_BNDCU
:
7033 case BUILT_IN_CHKP_BNDLDX
:
7034 case BUILT_IN_CHKP_BNDRET
:
7035 case BUILT_IN_CHKP_INTERSECT
:
7036 case BUILT_IN_CHKP_NARROW
:
7037 case BUILT_IN_CHKP_EXTRACT_LOWER
:
7038 case BUILT_IN_CHKP_EXTRACT_UPPER
:
7039 /* Software implementation of Pointer Bounds Checker is NYI.
7040 Target support is required. */
7041 error ("Your target platform does not support -fcheck-pointer-bounds");
7044 default: /* just do library call, if unknown builtin */
7048 /* The switch statement above can drop through to cause the function
7049 to be called normally. */
7050 return expand_call (exp
, target
, ignore
);
7053 /* Similar to expand_builtin but is used for instrumented calls. */
7056 expand_builtin_with_bounds (tree exp
, rtx target
,
7057 rtx subtarget ATTRIBUTE_UNUSED
,
7058 machine_mode mode
, int ignore
)
7060 tree fndecl
= get_callee_fndecl (exp
);
7061 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7063 gcc_assert (CALL_WITH_BOUNDS_P (exp
));
7065 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7066 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
7068 gcc_assert (fcode
> BEGIN_CHKP_BUILTINS
7069 && fcode
< END_CHKP_BUILTINS
);
7073 case BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP
:
7074 target
= expand_builtin_memcpy_with_bounds (exp
, target
);
7079 case BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP
:
7080 target
= expand_builtin_mempcpy_with_bounds (exp
, target
, mode
);
7085 case BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP
:
7086 target
= expand_builtin_memset_with_bounds (exp
, target
, mode
);
7095 /* The switch statement above can drop through to cause the function
7096 to be called normally. */
7097 return expand_call (exp
, target
, ignore
);
7100 /* Determine whether a tree node represents a call to a built-in
7101 function. If the tree T is a call to a built-in function with
7102 the right number of arguments of the appropriate types, return
7103 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
7104 Otherwise the return value is END_BUILTINS. */
7106 enum built_in_function
7107 builtin_mathfn_code (const_tree t
)
7109 const_tree fndecl
, arg
, parmlist
;
7110 const_tree argtype
, parmtype
;
7111 const_call_expr_arg_iterator iter
;
7113 if (TREE_CODE (t
) != CALL_EXPR
7114 || TREE_CODE (CALL_EXPR_FN (t
)) != ADDR_EXPR
)
7115 return END_BUILTINS
;
7117 fndecl
= get_callee_fndecl (t
);
7118 if (fndecl
== NULL_TREE
7119 || TREE_CODE (fndecl
) != FUNCTION_DECL
7120 || ! DECL_BUILT_IN (fndecl
)
7121 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7122 return END_BUILTINS
;
7124 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
7125 init_const_call_expr_arg_iterator (t
, &iter
);
7126 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
7128 /* If a function doesn't take a variable number of arguments,
7129 the last element in the list will have type `void'. */
7130 parmtype
= TREE_VALUE (parmlist
);
7131 if (VOID_TYPE_P (parmtype
))
7133 if (more_const_call_expr_args_p (&iter
))
7134 return END_BUILTINS
;
7135 return DECL_FUNCTION_CODE (fndecl
);
7138 if (! more_const_call_expr_args_p (&iter
))
7139 return END_BUILTINS
;
7141 arg
= next_const_call_expr_arg (&iter
);
7142 argtype
= TREE_TYPE (arg
);
7144 if (SCALAR_FLOAT_TYPE_P (parmtype
))
7146 if (! SCALAR_FLOAT_TYPE_P (argtype
))
7147 return END_BUILTINS
;
7149 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
7151 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
7152 return END_BUILTINS
;
7154 else if (POINTER_TYPE_P (parmtype
))
7156 if (! POINTER_TYPE_P (argtype
))
7157 return END_BUILTINS
;
7159 else if (INTEGRAL_TYPE_P (parmtype
))
7161 if (! INTEGRAL_TYPE_P (argtype
))
7162 return END_BUILTINS
;
7165 return END_BUILTINS
;
7168 /* Variable-length argument list. */
7169 return DECL_FUNCTION_CODE (fndecl
);
7172 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
7173 evaluate to a constant. */
7176 fold_builtin_constant_p (tree arg
)
7178 /* We return 1 for a numeric type that's known to be a constant
7179 value at compile-time or for an aggregate type that's a
7180 literal constant. */
7183 /* If we know this is a constant, emit the constant of one. */
7184 if (CONSTANT_CLASS_P (arg
)
7185 || (TREE_CODE (arg
) == CONSTRUCTOR
7186 && TREE_CONSTANT (arg
)))
7187 return integer_one_node
;
7188 if (TREE_CODE (arg
) == ADDR_EXPR
)
7190 tree op
= TREE_OPERAND (arg
, 0);
7191 if (TREE_CODE (op
) == STRING_CST
7192 || (TREE_CODE (op
) == ARRAY_REF
7193 && integer_zerop (TREE_OPERAND (op
, 1))
7194 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
7195 return integer_one_node
;
7198 /* If this expression has side effects, show we don't know it to be a
7199 constant. Likewise if it's a pointer or aggregate type since in
7200 those case we only want literals, since those are only optimized
7201 when generating RTL, not later.
7202 And finally, if we are compiling an initializer, not code, we
7203 need to return a definite result now; there's not going to be any
7204 more optimization done. */
7205 if (TREE_SIDE_EFFECTS (arg
)
7206 || AGGREGATE_TYPE_P (TREE_TYPE (arg
))
7207 || POINTER_TYPE_P (TREE_TYPE (arg
))
7209 || folding_initializer
7210 || force_folding_builtin_constant_p
)
7211 return integer_zero_node
;
7216 /* Create builtin_expect with PRED and EXPECTED as its arguments and
7217 return it as a truthvalue. */
7220 build_builtin_expect_predicate (location_t loc
, tree pred
, tree expected
,
7223 tree fn
, arg_types
, pred_type
, expected_type
, call_expr
, ret_type
;
7225 fn
= builtin_decl_explicit (BUILT_IN_EXPECT
);
7226 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7227 ret_type
= TREE_TYPE (TREE_TYPE (fn
));
7228 pred_type
= TREE_VALUE (arg_types
);
7229 expected_type
= TREE_VALUE (TREE_CHAIN (arg_types
));
7231 pred
= fold_convert_loc (loc
, pred_type
, pred
);
7232 expected
= fold_convert_loc (loc
, expected_type
, expected
);
7233 call_expr
= build_call_expr_loc (loc
, fn
, predictor
? 3 : 2, pred
, expected
,
7236 return build2 (NE_EXPR
, TREE_TYPE (pred
), call_expr
,
7237 build_int_cst (ret_type
, 0));
7240 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
7241 NULL_TREE if no simplification is possible. */
7244 fold_builtin_expect (location_t loc
, tree arg0
, tree arg1
, tree arg2
)
7246 tree inner
, fndecl
, inner_arg0
;
7247 enum tree_code code
;
7249 /* Distribute the expected value over short-circuiting operators.
7250 See through the cast from truthvalue_type_node to long. */
7252 while (CONVERT_EXPR_P (inner_arg0
)
7253 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0
))
7254 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0
, 0))))
7255 inner_arg0
= TREE_OPERAND (inner_arg0
, 0);
7257 /* If this is a builtin_expect within a builtin_expect keep the
7258 inner one. See through a comparison against a constant. It
7259 might have been added to create a thruthvalue. */
7262 if (COMPARISON_CLASS_P (inner
)
7263 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
)
7264 inner
= TREE_OPERAND (inner
, 0);
7266 if (TREE_CODE (inner
) == CALL_EXPR
7267 && (fndecl
= get_callee_fndecl (inner
))
7268 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7269 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
)
7273 code
= TREE_CODE (inner
);
7274 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
7276 tree op0
= TREE_OPERAND (inner
, 0);
7277 tree op1
= TREE_OPERAND (inner
, 1);
7279 op0
= build_builtin_expect_predicate (loc
, op0
, arg1
, arg2
);
7280 op1
= build_builtin_expect_predicate (loc
, op1
, arg1
, arg2
);
7281 inner
= build2 (code
, TREE_TYPE (inner
), op0
, op1
);
7283 return fold_convert_loc (loc
, TREE_TYPE (arg0
), inner
);
7286 /* If the argument isn't invariant then there's nothing else we can do. */
7287 if (!TREE_CONSTANT (inner_arg0
))
7290 /* If we expect that a comparison against the argument will fold to
7291 a constant return the constant. In practice, this means a true
7292 constant or the address of a non-weak symbol. */
7295 if (TREE_CODE (inner
) == ADDR_EXPR
)
7299 inner
= TREE_OPERAND (inner
, 0);
7301 while (TREE_CODE (inner
) == COMPONENT_REF
7302 || TREE_CODE (inner
) == ARRAY_REF
);
7303 if ((TREE_CODE (inner
) == VAR_DECL
7304 || TREE_CODE (inner
) == FUNCTION_DECL
)
7305 && DECL_WEAK (inner
))
7309 /* Otherwise, ARG0 already has the proper type for the return value. */
7313 /* Fold a call to __builtin_classify_type with argument ARG. */
7316 fold_builtin_classify_type (tree arg
)
7319 return build_int_cst (integer_type_node
, no_type_class
);
7321 return build_int_cst (integer_type_node
, type_to_class (TREE_TYPE (arg
)));
7324 /* Fold a call to __builtin_strlen with argument ARG. */
7327 fold_builtin_strlen (location_t loc
, tree type
, tree arg
)
7329 if (!validate_arg (arg
, POINTER_TYPE
))
7333 tree len
= c_strlen (arg
, 0);
7336 return fold_convert_loc (loc
, type
, len
);
7342 /* Fold a call to __builtin_inf or __builtin_huge_val. */
7345 fold_builtin_inf (location_t loc
, tree type
, int warn
)
7347 REAL_VALUE_TYPE real
;
7349 /* __builtin_inff is intended to be usable to define INFINITY on all
7350 targets. If an infinity is not available, INFINITY expands "to a
7351 positive constant of type float that overflows at translation
7352 time", footnote "In this case, using INFINITY will violate the
7353 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7354 Thus we pedwarn to ensure this constraint violation is
7356 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
7357 pedwarn (loc
, 0, "target format does not support infinity");
7360 return build_real (type
, real
);
7363 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
7366 fold_builtin_nan (tree arg
, tree type
, int quiet
)
7368 REAL_VALUE_TYPE real
;
7371 if (!validate_arg (arg
, POINTER_TYPE
))
7373 str
= c_getstr (arg
);
7377 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
7380 return build_real (type
, real
);
7383 /* Return true if the floating point expression T has an integer value.
7384 We also allow +Inf, -Inf and NaN to be considered integer values. */
7387 integer_valued_real_p (tree t
)
7389 switch (TREE_CODE (t
))
7396 return integer_valued_real_p (TREE_OPERAND (t
, 0));
7401 return integer_valued_real_p (TREE_OPERAND (t
, 1));
7408 return integer_valued_real_p (TREE_OPERAND (t
, 0))
7409 && integer_valued_real_p (TREE_OPERAND (t
, 1));
7412 return integer_valued_real_p (TREE_OPERAND (t
, 1))
7413 && integer_valued_real_p (TREE_OPERAND (t
, 2));
7416 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
7420 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
7421 if (TREE_CODE (type
) == INTEGER_TYPE
)
7423 if (TREE_CODE (type
) == REAL_TYPE
)
7424 return integer_valued_real_p (TREE_OPERAND (t
, 0));
7429 switch (builtin_mathfn_code (t
))
7431 CASE_FLT_FN (BUILT_IN_CEIL
):
7432 CASE_FLT_FN (BUILT_IN_FLOOR
):
7433 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
7434 CASE_FLT_FN (BUILT_IN_RINT
):
7435 CASE_FLT_FN (BUILT_IN_ROUND
):
7436 CASE_FLT_FN (BUILT_IN_TRUNC
):
7439 CASE_FLT_FN (BUILT_IN_FMIN
):
7440 CASE_FLT_FN (BUILT_IN_FMAX
):
7441 return integer_valued_real_p (CALL_EXPR_ARG (t
, 0))
7442 && integer_valued_real_p (CALL_EXPR_ARG (t
, 1));
7455 /* FNDECL is assumed to be a builtin where truncation can be propagated
7456 across (for instance floor((double)f) == (double)floorf (f).
7457 Do the transformation for a call with argument ARG. */
7460 fold_trunc_transparent_mathfn (location_t loc
, tree fndecl
, tree arg
)
7462 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7464 if (!validate_arg (arg
, REAL_TYPE
))
7467 /* Integer rounding functions are idempotent. */
7468 if (fcode
== builtin_mathfn_code (arg
))
7471 /* If argument is already integer valued, and we don't need to worry
7472 about setting errno, there's no need to perform rounding. */
7473 if (! flag_errno_math
&& integer_valued_real_p (arg
))
7478 tree arg0
= strip_float_extensions (arg
);
7479 tree ftype
= TREE_TYPE (TREE_TYPE (fndecl
));
7480 tree newtype
= TREE_TYPE (arg0
);
7483 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
7484 && (decl
= mathfn_built_in (newtype
, fcode
)))
7485 return fold_convert_loc (loc
, ftype
,
7486 build_call_expr_loc (loc
, decl
, 1,
7487 fold_convert_loc (loc
,
7494 /* FNDECL is assumed to be builtin which can narrow the FP type of
7495 the argument, for instance lround((double)f) -> lroundf (f).
7496 Do the transformation for a call with argument ARG. */
7499 fold_fixed_mathfn (location_t loc
, tree fndecl
, tree arg
)
7501 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7503 if (!validate_arg (arg
, REAL_TYPE
))
7506 /* If argument is already integer valued, and we don't need to worry
7507 about setting errno, there's no need to perform rounding. */
7508 if (! flag_errno_math
&& integer_valued_real_p (arg
))
7509 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
7510 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
7514 tree ftype
= TREE_TYPE (arg
);
7515 tree arg0
= strip_float_extensions (arg
);
7516 tree newtype
= TREE_TYPE (arg0
);
7519 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
7520 && (decl
= mathfn_built_in (newtype
, fcode
)))
7521 return build_call_expr_loc (loc
, decl
, 1,
7522 fold_convert_loc (loc
, newtype
, arg0
));
7525 /* Canonicalize iround (x) to lround (x) on ILP32 targets where
7526 sizeof (int) == sizeof (long). */
7527 if (TYPE_PRECISION (integer_type_node
)
7528 == TYPE_PRECISION (long_integer_type_node
))
7530 tree newfn
= NULL_TREE
;
7533 CASE_FLT_FN (BUILT_IN_ICEIL
):
7534 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
7537 CASE_FLT_FN (BUILT_IN_IFLOOR
):
7538 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
7541 CASE_FLT_FN (BUILT_IN_IROUND
):
7542 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7545 CASE_FLT_FN (BUILT_IN_IRINT
):
7546 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7555 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7556 return fold_convert_loc (loc
,
7557 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7561 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7562 sizeof (long long) == sizeof (long). */
7563 if (TYPE_PRECISION (long_long_integer_type_node
)
7564 == TYPE_PRECISION (long_integer_type_node
))
7566 tree newfn
= NULL_TREE
;
7569 CASE_FLT_FN (BUILT_IN_LLCEIL
):
7570 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
7573 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7574 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
7577 CASE_FLT_FN (BUILT_IN_LLROUND
):
7578 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7581 CASE_FLT_FN (BUILT_IN_LLRINT
):
7582 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7591 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7592 return fold_convert_loc (loc
,
7593 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7600 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7601 return type. Return NULL_TREE if no simplification can be made. */
7604 fold_builtin_cabs (location_t loc
, tree arg
, tree type
, tree fndecl
)
7608 if (!validate_arg (arg
, COMPLEX_TYPE
)
7609 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7612 /* Calculate the result when the argument is a constant. */
7613 if (TREE_CODE (arg
) == COMPLEX_CST
7614 && (res
= do_mpfr_arg2 (TREE_REALPART (arg
), TREE_IMAGPART (arg
),
7618 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7620 tree real
= TREE_OPERAND (arg
, 0);
7621 tree imag
= TREE_OPERAND (arg
, 1);
7623 /* If either part is zero, cabs is fabs of the other. */
7624 if (real_zerop (real
))
7625 return fold_build1_loc (loc
, ABS_EXPR
, type
, imag
);
7626 if (real_zerop (imag
))
7627 return fold_build1_loc (loc
, ABS_EXPR
, type
, real
);
7629 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7630 if (flag_unsafe_math_optimizations
7631 && operand_equal_p (real
, imag
, OEP_PURE_SAME
))
7633 const REAL_VALUE_TYPE sqrt2_trunc
7634 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
7636 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7637 fold_build1_loc (loc
, ABS_EXPR
, type
, real
),
7638 build_real (type
, sqrt2_trunc
));
7642 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7643 if (TREE_CODE (arg
) == NEGATE_EXPR
7644 || TREE_CODE (arg
) == CONJ_EXPR
)
7645 return build_call_expr_loc (loc
, fndecl
, 1, TREE_OPERAND (arg
, 0));
7647 /* Don't do this when optimizing for size. */
7648 if (flag_unsafe_math_optimizations
7649 && optimize
&& optimize_function_for_speed_p (cfun
))
7651 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7653 if (sqrtfn
!= NULL_TREE
)
7655 tree rpart
, ipart
, result
;
7657 arg
= builtin_save_expr (arg
);
7659 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, type
, arg
);
7660 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg
);
7662 rpart
= builtin_save_expr (rpart
);
7663 ipart
= builtin_save_expr (ipart
);
7665 result
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
7666 fold_build2_loc (loc
, MULT_EXPR
, type
,
7668 fold_build2_loc (loc
, MULT_EXPR
, type
,
7671 return build_call_expr_loc (loc
, sqrtfn
, 1, result
);
7678 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7679 complex tree type of the result. If NEG is true, the imaginary
7680 zero is negative. */
7683 build_complex_cproj (tree type
, bool neg
)
7685 REAL_VALUE_TYPE rinf
, rzero
= dconst0
;
7689 return build_complex (type
, build_real (TREE_TYPE (type
), rinf
),
7690 build_real (TREE_TYPE (type
), rzero
));
7693 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7694 return type. Return NULL_TREE if no simplification can be made. */
7697 fold_builtin_cproj (location_t loc
, tree arg
, tree type
)
7699 if (!validate_arg (arg
, COMPLEX_TYPE
)
7700 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7703 /* If there are no infinities, return arg. */
7704 if (! HONOR_INFINITIES (type
))
7705 return non_lvalue_loc (loc
, arg
);
7707 /* Calculate the result when the argument is a constant. */
7708 if (TREE_CODE (arg
) == COMPLEX_CST
)
7710 const REAL_VALUE_TYPE
*real
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
7711 const REAL_VALUE_TYPE
*imag
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
7713 if (real_isinf (real
) || real_isinf (imag
))
7714 return build_complex_cproj (type
, imag
->sign
);
7718 else if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7720 tree real
= TREE_OPERAND (arg
, 0);
7721 tree imag
= TREE_OPERAND (arg
, 1);
7726 /* If the real part is inf and the imag part is known to be
7727 nonnegative, return (inf + 0i). Remember side-effects are
7728 possible in the imag part. */
7729 if (TREE_CODE (real
) == REAL_CST
7730 && real_isinf (TREE_REAL_CST_PTR (real
))
7731 && tree_expr_nonnegative_p (imag
))
7732 return omit_one_operand_loc (loc
, type
,
7733 build_complex_cproj (type
, false),
7736 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7737 Remember side-effects are possible in the real part. */
7738 if (TREE_CODE (imag
) == REAL_CST
7739 && real_isinf (TREE_REAL_CST_PTR (imag
)))
7741 omit_one_operand_loc (loc
, type
,
7742 build_complex_cproj (type
, TREE_REAL_CST_PTR
7743 (imag
)->sign
), arg
);
7749 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7750 Return NULL_TREE if no simplification can be made. */
7753 fold_builtin_sqrt (location_t loc
, tree arg
, tree type
)
7756 enum built_in_function fcode
;
7759 if (!validate_arg (arg
, REAL_TYPE
))
7762 /* Calculate the result when the argument is a constant. */
7763 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_sqrt
, &dconst0
, NULL
, true)))
7766 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7767 fcode
= builtin_mathfn_code (arg
);
7768 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
7770 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7771 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7772 CALL_EXPR_ARG (arg
, 0),
7773 build_real (type
, dconsthalf
));
7774 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7777 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7778 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
7780 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7784 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7786 /* The inner root was either sqrt or cbrt. */
7787 /* This was a conditional expression but it triggered a bug
7789 REAL_VALUE_TYPE dconstroot
;
7790 if (BUILTIN_SQRT_P (fcode
))
7791 dconstroot
= dconsthalf
;
7793 dconstroot
= dconst_third ();
7795 /* Adjust for the outer root. */
7796 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7797 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7798 tree_root
= build_real (type
, dconstroot
);
7799 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7803 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7804 if (flag_unsafe_math_optimizations
7805 && (fcode
== BUILT_IN_POW
7806 || fcode
== BUILT_IN_POWF
7807 || fcode
== BUILT_IN_POWL
))
7809 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7810 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7811 tree arg1
= CALL_EXPR_ARG (arg
, 1);
7813 if (!tree_expr_nonnegative_p (arg0
))
7814 arg0
= build1 (ABS_EXPR
, type
, arg0
);
7815 narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
7816 build_real (type
, dconsthalf
));
7817 return build_call_expr_loc (loc
, powfn
, 2, arg0
, narg1
);
7823 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7824 Return NULL_TREE if no simplification can be made. */
7827 fold_builtin_cbrt (location_t loc
, tree arg
, tree type
)
7829 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7832 if (!validate_arg (arg
, REAL_TYPE
))
7835 /* Calculate the result when the argument is a constant. */
7836 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cbrt
, NULL
, NULL
, 0)))
7839 if (flag_unsafe_math_optimizations
)
7841 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7842 if (BUILTIN_EXPONENT_P (fcode
))
7844 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7845 const REAL_VALUE_TYPE third_trunc
=
7846 real_value_truncate (TYPE_MODE (type
), dconst_third ());
7847 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7848 CALL_EXPR_ARG (arg
, 0),
7849 build_real (type
, third_trunc
));
7850 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7853 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7854 if (BUILTIN_SQRT_P (fcode
))
7856 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7860 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7862 REAL_VALUE_TYPE dconstroot
= dconst_third ();
7864 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7865 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7866 tree_root
= build_real (type
, dconstroot
);
7867 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7871 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7872 if (BUILTIN_CBRT_P (fcode
))
7874 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7875 if (tree_expr_nonnegative_p (arg0
))
7877 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7882 REAL_VALUE_TYPE dconstroot
;
7884 real_arithmetic (&dconstroot
, MULT_EXPR
,
7885 dconst_third_ptr (), dconst_third_ptr ());
7886 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7887 tree_root
= build_real (type
, dconstroot
);
7888 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7893 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7894 if (fcode
== BUILT_IN_POW
7895 || fcode
== BUILT_IN_POWF
7896 || fcode
== BUILT_IN_POWL
)
7898 tree arg00
= CALL_EXPR_ARG (arg
, 0);
7899 tree arg01
= CALL_EXPR_ARG (arg
, 1);
7900 if (tree_expr_nonnegative_p (arg00
))
7902 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7903 const REAL_VALUE_TYPE dconstroot
7904 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
7905 tree narg01
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
,
7906 build_real (type
, dconstroot
));
7907 return build_call_expr_loc (loc
, powfn
, 2, arg00
, narg01
);
7914 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7915 TYPE is the type of the return value. Return NULL_TREE if no
7916 simplification can be made. */
7919 fold_builtin_cos (location_t loc
,
7920 tree arg
, tree type
, tree fndecl
)
7924 if (!validate_arg (arg
, REAL_TYPE
))
7927 /* Calculate the result when the argument is a constant. */
7928 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cos
, NULL
, NULL
, 0)))
7931 /* Optimize cos(-x) into cos (x). */
7932 if ((narg
= fold_strip_sign_ops (arg
)))
7933 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7938 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7939 Return NULL_TREE if no simplification can be made. */
7942 fold_builtin_cosh (location_t loc
, tree arg
, tree type
, tree fndecl
)
7944 if (validate_arg (arg
, REAL_TYPE
))
7948 /* Calculate the result when the argument is a constant. */
7949 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cosh
, NULL
, NULL
, 0)))
7952 /* Optimize cosh(-x) into cosh (x). */
7953 if ((narg
= fold_strip_sign_ops (arg
)))
7954 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7960 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7961 argument ARG. TYPE is the type of the return value. Return
7962 NULL_TREE if no simplification can be made. */
7965 fold_builtin_ccos (location_t loc
, tree arg
, tree type
, tree fndecl
,
7968 if (validate_arg (arg
, COMPLEX_TYPE
)
7969 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
7973 /* Calculate the result when the argument is a constant. */
7974 if ((tmp
= do_mpc_arg1 (arg
, type
, (hyper
? mpc_cosh
: mpc_cos
))))
7977 /* Optimize fn(-x) into fn(x). */
7978 if ((tmp
= fold_strip_sign_ops (arg
)))
7979 return build_call_expr_loc (loc
, fndecl
, 1, tmp
);
7985 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7986 Return NULL_TREE if no simplification can be made. */
7989 fold_builtin_tan (tree arg
, tree type
)
7991 enum built_in_function fcode
;
7994 if (!validate_arg (arg
, REAL_TYPE
))
7997 /* Calculate the result when the argument is a constant. */
7998 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_tan
, NULL
, NULL
, 0)))
8001 /* Optimize tan(atan(x)) = x. */
8002 fcode
= builtin_mathfn_code (arg
);
8003 if (flag_unsafe_math_optimizations
8004 && (fcode
== BUILT_IN_ATAN
8005 || fcode
== BUILT_IN_ATANF
8006 || fcode
== BUILT_IN_ATANL
))
8007 return CALL_EXPR_ARG (arg
, 0);
8012 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
8013 NULL_TREE if no simplification can be made. */
8016 fold_builtin_sincos (location_t loc
,
8017 tree arg0
, tree arg1
, tree arg2
)
8022 if (!validate_arg (arg0
, REAL_TYPE
)
8023 || !validate_arg (arg1
, POINTER_TYPE
)
8024 || !validate_arg (arg2
, POINTER_TYPE
))
8027 type
= TREE_TYPE (arg0
);
8029 /* Calculate the result when the argument is a constant. */
8030 if ((res
= do_mpfr_sincos (arg0
, arg1
, arg2
)))
8033 /* Canonicalize sincos to cexpi. */
8034 if (!targetm
.libc_has_function (function_c99_math_complex
))
8036 fn
= mathfn_built_in (type
, BUILT_IN_CEXPI
);
8040 call
= build_call_expr_loc (loc
, fn
, 1, arg0
);
8041 call
= builtin_save_expr (call
);
8043 return build2 (COMPOUND_EXPR
, void_type_node
,
8044 build2 (MODIFY_EXPR
, void_type_node
,
8045 build_fold_indirect_ref_loc (loc
, arg1
),
8046 build1 (IMAGPART_EXPR
, type
, call
)),
8047 build2 (MODIFY_EXPR
, void_type_node
,
8048 build_fold_indirect_ref_loc (loc
, arg2
),
8049 build1 (REALPART_EXPR
, type
, call
)));
8052 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
8053 NULL_TREE if no simplification can be made. */
8056 fold_builtin_cexp (location_t loc
, tree arg0
, tree type
)
8059 tree realp
, imagp
, ifn
;
8062 if (!validate_arg (arg0
, COMPLEX_TYPE
)
8063 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) != REAL_TYPE
)
8066 /* Calculate the result when the argument is a constant. */
8067 if ((res
= do_mpc_arg1 (arg0
, type
, mpc_exp
)))
8070 rtype
= TREE_TYPE (TREE_TYPE (arg0
));
8072 /* In case we can figure out the real part of arg0 and it is constant zero
8074 if (!targetm
.libc_has_function (function_c99_math_complex
))
8076 ifn
= mathfn_built_in (rtype
, BUILT_IN_CEXPI
);
8080 if ((realp
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
))
8081 && real_zerop (realp
))
8083 tree narg
= fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
8084 return build_call_expr_loc (loc
, ifn
, 1, narg
);
8087 /* In case we can easily decompose real and imaginary parts split cexp
8088 to exp (r) * cexpi (i). */
8089 if (flag_unsafe_math_optimizations
8092 tree rfn
, rcall
, icall
;
8094 rfn
= mathfn_built_in (rtype
, BUILT_IN_EXP
);
8098 imagp
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
8102 icall
= build_call_expr_loc (loc
, ifn
, 1, imagp
);
8103 icall
= builtin_save_expr (icall
);
8104 rcall
= build_call_expr_loc (loc
, rfn
, 1, realp
);
8105 rcall
= builtin_save_expr (rcall
);
8106 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
8107 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
8109 fold_build1_loc (loc
, REALPART_EXPR
,
8111 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
8113 fold_build1_loc (loc
, IMAGPART_EXPR
,
8120 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
8121 Return NULL_TREE if no simplification can be made. */
8124 fold_builtin_trunc (location_t loc
, tree fndecl
, tree arg
)
8126 if (!validate_arg (arg
, REAL_TYPE
))
8129 /* Optimize trunc of constant value. */
8130 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8132 REAL_VALUE_TYPE r
, x
;
8133 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8135 x
= TREE_REAL_CST (arg
);
8136 real_trunc (&r
, TYPE_MODE (type
), &x
);
8137 return build_real (type
, r
);
8140 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8143 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
8144 Return NULL_TREE if no simplification can be made. */
8147 fold_builtin_floor (location_t loc
, tree fndecl
, tree arg
)
8149 if (!validate_arg (arg
, REAL_TYPE
))
8152 /* Optimize floor of constant value. */
8153 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8157 x
= TREE_REAL_CST (arg
);
8158 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
8160 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8163 real_floor (&r
, TYPE_MODE (type
), &x
);
8164 return build_real (type
, r
);
8168 /* Fold floor (x) where x is nonnegative to trunc (x). */
8169 if (tree_expr_nonnegative_p (arg
))
8171 tree truncfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_TRUNC
);
8173 return build_call_expr_loc (loc
, truncfn
, 1, arg
);
8176 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8179 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
8180 Return NULL_TREE if no simplification can be made. */
8183 fold_builtin_ceil (location_t loc
, tree fndecl
, tree arg
)
8185 if (!validate_arg (arg
, REAL_TYPE
))
8188 /* Optimize ceil of constant value. */
8189 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8193 x
= TREE_REAL_CST (arg
);
8194 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
8196 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8199 real_ceil (&r
, TYPE_MODE (type
), &x
);
8200 return build_real (type
, r
);
8204 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8207 /* Fold function call to builtin round, roundf or roundl with argument ARG.
8208 Return NULL_TREE if no simplification can be made. */
8211 fold_builtin_round (location_t loc
, tree fndecl
, tree arg
)
8213 if (!validate_arg (arg
, REAL_TYPE
))
8216 /* Optimize round of constant value. */
8217 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8221 x
= TREE_REAL_CST (arg
);
8222 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
8224 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8227 real_round (&r
, TYPE_MODE (type
), &x
);
8228 return build_real (type
, r
);
8232 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8235 /* Fold function call to builtin lround, lroundf or lroundl (or the
8236 corresponding long long versions) and other rounding functions. ARG
8237 is the argument to the call. Return NULL_TREE if no simplification
8241 fold_builtin_int_roundingfn (location_t loc
, tree fndecl
, tree arg
)
8243 if (!validate_arg (arg
, REAL_TYPE
))
8246 /* Optimize lround of constant value. */
8247 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8249 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
8251 if (real_isfinite (&x
))
8253 tree itype
= TREE_TYPE (TREE_TYPE (fndecl
));
8254 tree ftype
= TREE_TYPE (arg
);
8258 switch (DECL_FUNCTION_CODE (fndecl
))
8260 CASE_FLT_FN (BUILT_IN_IFLOOR
):
8261 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8262 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8263 real_floor (&r
, TYPE_MODE (ftype
), &x
);
8266 CASE_FLT_FN (BUILT_IN_ICEIL
):
8267 CASE_FLT_FN (BUILT_IN_LCEIL
):
8268 CASE_FLT_FN (BUILT_IN_LLCEIL
):
8269 real_ceil (&r
, TYPE_MODE (ftype
), &x
);
8272 CASE_FLT_FN (BUILT_IN_IROUND
):
8273 CASE_FLT_FN (BUILT_IN_LROUND
):
8274 CASE_FLT_FN (BUILT_IN_LLROUND
):
8275 real_round (&r
, TYPE_MODE (ftype
), &x
);
8282 wide_int val
= real_to_integer (&r
, &fail
, TYPE_PRECISION (itype
));
8284 return wide_int_to_tree (itype
, val
);
8288 switch (DECL_FUNCTION_CODE (fndecl
))
8290 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8291 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8292 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
8293 if (tree_expr_nonnegative_p (arg
))
8294 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
8295 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
8300 return fold_fixed_mathfn (loc
, fndecl
, arg
);
8303 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8304 and their long and long long variants (i.e. ffsl and ffsll). ARG is
8305 the argument to the call. Return NULL_TREE if no simplification can
8309 fold_builtin_bitop (tree fndecl
, tree arg
)
8311 if (!validate_arg (arg
, INTEGER_TYPE
))
8314 /* Optimize for constant argument. */
8315 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
8317 tree type
= TREE_TYPE (arg
);
8320 switch (DECL_FUNCTION_CODE (fndecl
))
8322 CASE_INT_FN (BUILT_IN_FFS
):
8323 result
= wi::ffs (arg
);
8326 CASE_INT_FN (BUILT_IN_CLZ
):
8327 if (wi::ne_p (arg
, 0))
8328 result
= wi::clz (arg
);
8329 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
8330 result
= TYPE_PRECISION (type
);
8333 CASE_INT_FN (BUILT_IN_CTZ
):
8334 if (wi::ne_p (arg
, 0))
8335 result
= wi::ctz (arg
);
8336 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
8337 result
= TYPE_PRECISION (type
);
8340 CASE_INT_FN (BUILT_IN_CLRSB
):
8341 result
= wi::clrsb (arg
);
8344 CASE_INT_FN (BUILT_IN_POPCOUNT
):
8345 result
= wi::popcount (arg
);
8348 CASE_INT_FN (BUILT_IN_PARITY
):
8349 result
= wi::parity (arg
);
8356 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), result
);
8362 /* Fold function call to builtin_bswap and the short, long and long long
8363 variants. Return NULL_TREE if no simplification can be made. */
8365 fold_builtin_bswap (tree fndecl
, tree arg
)
8367 if (! validate_arg (arg
, INTEGER_TYPE
))
8370 /* Optimize constant value. */
8371 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
8373 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8375 switch (DECL_FUNCTION_CODE (fndecl
))
8377 case BUILT_IN_BSWAP16
:
8378 case BUILT_IN_BSWAP32
:
8379 case BUILT_IN_BSWAP64
:
8381 signop sgn
= TYPE_SIGN (type
);
8383 wide_int_to_tree (type
,
8384 wide_int::from (arg
, TYPE_PRECISION (type
),
8396 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8397 NULL_TREE if no simplification can be made. */
8400 fold_builtin_hypot (location_t loc
, tree fndecl
,
8401 tree arg0
, tree arg1
, tree type
)
8403 tree res
, narg0
, narg1
;
8405 if (!validate_arg (arg0
, REAL_TYPE
)
8406 || !validate_arg (arg1
, REAL_TYPE
))
8409 /* Calculate the result when the argument is a constant. */
8410 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_hypot
)))
8413 /* If either argument to hypot has a negate or abs, strip that off.
8414 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8415 narg0
= fold_strip_sign_ops (arg0
);
8416 narg1
= fold_strip_sign_ops (arg1
);
8419 return build_call_expr_loc (loc
, fndecl
, 2, narg0
? narg0
: arg0
,
8420 narg1
? narg1
: arg1
);
8423 /* If either argument is zero, hypot is fabs of the other. */
8424 if (real_zerop (arg0
))
8425 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
);
8426 else if (real_zerop (arg1
))
8427 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
);
8429 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8430 if (flag_unsafe_math_optimizations
8431 && operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
8433 const REAL_VALUE_TYPE sqrt2_trunc
8434 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
8435 return fold_build2_loc (loc
, MULT_EXPR
, type
,
8436 fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
),
8437 build_real (type
, sqrt2_trunc
));
8444 /* Fold a builtin function call to pow, powf, or powl. Return
8445 NULL_TREE if no simplification can be made. */
8447 fold_builtin_pow (location_t loc
, tree fndecl
, tree arg0
, tree arg1
, tree type
)
8451 if (!validate_arg (arg0
, REAL_TYPE
)
8452 || !validate_arg (arg1
, REAL_TYPE
))
8455 /* Calculate the result when the argument is a constant. */
8456 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_pow
)))
8459 /* Optimize pow(1.0,y) = 1.0. */
8460 if (real_onep (arg0
))
8461 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8463 if (TREE_CODE (arg1
) == REAL_CST
8464 && !TREE_OVERFLOW (arg1
))
8466 REAL_VALUE_TYPE cint
;
8470 c
= TREE_REAL_CST (arg1
);
8472 /* Optimize pow(x,0.0) = 1.0. */
8473 if (REAL_VALUES_EQUAL (c
, dconst0
))
8474 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8477 /* Optimize pow(x,1.0) = x. */
8478 if (REAL_VALUES_EQUAL (c
, dconst1
))
8481 /* Optimize pow(x,-1.0) = 1.0/x. */
8482 if (REAL_VALUES_EQUAL (c
, dconstm1
))
8483 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8484 build_real (type
, dconst1
), arg0
);
8486 /* Optimize pow(x,0.5) = sqrt(x). */
8487 if (flag_unsafe_math_optimizations
8488 && REAL_VALUES_EQUAL (c
, dconsthalf
))
8490 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
8492 if (sqrtfn
!= NULL_TREE
)
8493 return build_call_expr_loc (loc
, sqrtfn
, 1, arg0
);
8496 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8497 if (flag_unsafe_math_optimizations
)
8499 const REAL_VALUE_TYPE dconstroot
8500 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8502 if (REAL_VALUES_EQUAL (c
, dconstroot
))
8504 tree cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
8505 if (cbrtfn
!= NULL_TREE
)
8506 return build_call_expr_loc (loc
, cbrtfn
, 1, arg0
);
8510 /* Check for an integer exponent. */
8511 n
= real_to_integer (&c
);
8512 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
8513 if (real_identical (&c
, &cint
))
8515 /* Attempt to evaluate pow at compile-time, unless this should
8516 raise an exception. */
8517 if (TREE_CODE (arg0
) == REAL_CST
8518 && !TREE_OVERFLOW (arg0
)
8520 || (!flag_trapping_math
&& !flag_errno_math
)
8521 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
), dconst0
)))
8526 x
= TREE_REAL_CST (arg0
);
8527 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
8528 if (flag_unsafe_math_optimizations
|| !inexact
)
8529 return build_real (type
, x
);
8532 /* Strip sign ops from even integer powers. */
8533 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
8535 tree narg0
= fold_strip_sign_ops (arg0
);
8537 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, arg1
);
8542 if (flag_unsafe_math_optimizations
)
8544 const enum built_in_function fcode
= builtin_mathfn_code (arg0
);
8546 /* Optimize pow(expN(x),y) = expN(x*y). */
8547 if (BUILTIN_EXPONENT_P (fcode
))
8549 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
8550 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8551 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg
, arg1
);
8552 return build_call_expr_loc (loc
, expfn
, 1, arg
);
8555 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8556 if (BUILTIN_SQRT_P (fcode
))
8558 tree narg0
= CALL_EXPR_ARG (arg0
, 0);
8559 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8560 build_real (type
, dconsthalf
));
8561 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, narg1
);
8564 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8565 if (BUILTIN_CBRT_P (fcode
))
8567 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8568 if (tree_expr_nonnegative_p (arg
))
8570 const REAL_VALUE_TYPE dconstroot
8571 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8572 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8573 build_real (type
, dconstroot
));
8574 return build_call_expr_loc (loc
, fndecl
, 2, arg
, narg1
);
8578 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8579 if (fcode
== BUILT_IN_POW
8580 || fcode
== BUILT_IN_POWF
8581 || fcode
== BUILT_IN_POWL
)
8583 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
8584 if (tree_expr_nonnegative_p (arg00
))
8586 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
8587 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
, arg1
);
8588 return build_call_expr_loc (loc
, fndecl
, 2, arg00
, narg1
);
8596 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8597 Return NULL_TREE if no simplification can be made. */
8599 fold_builtin_powi (location_t loc
, tree fndecl ATTRIBUTE_UNUSED
,
8600 tree arg0
, tree arg1
, tree type
)
8602 if (!validate_arg (arg0
, REAL_TYPE
)
8603 || !validate_arg (arg1
, INTEGER_TYPE
))
8606 /* Optimize pow(1.0,y) = 1.0. */
8607 if (real_onep (arg0
))
8608 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8610 if (tree_fits_shwi_p (arg1
))
8612 HOST_WIDE_INT c
= tree_to_shwi (arg1
);
8614 /* Evaluate powi at compile-time. */
8615 if (TREE_CODE (arg0
) == REAL_CST
8616 && !TREE_OVERFLOW (arg0
))
8619 x
= TREE_REAL_CST (arg0
);
8620 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
8621 return build_real (type
, x
);
8624 /* Optimize pow(x,0) = 1.0. */
8626 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8629 /* Optimize pow(x,1) = x. */
8633 /* Optimize pow(x,-1) = 1.0/x. */
8635 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8636 build_real (type
, dconst1
), arg0
);
8642 /* A subroutine of fold_builtin to fold the various exponent
8643 functions. Return NULL_TREE if no simplification can be made.
8644 FUNC is the corresponding MPFR exponent function. */
8647 fold_builtin_exponent (location_t loc
, tree fndecl
, tree arg
,
8648 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
))
8650 if (validate_arg (arg
, REAL_TYPE
))
8652 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8655 /* Calculate the result when the argument is a constant. */
8656 if ((res
= do_mpfr_arg1 (arg
, type
, func
, NULL
, NULL
, 0)))
8659 /* Optimize expN(logN(x)) = x. */
8660 if (flag_unsafe_math_optimizations
)
8662 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
8664 if ((func
== mpfr_exp
8665 && (fcode
== BUILT_IN_LOG
8666 || fcode
== BUILT_IN_LOGF
8667 || fcode
== BUILT_IN_LOGL
))
8668 || (func
== mpfr_exp2
8669 && (fcode
== BUILT_IN_LOG2
8670 || fcode
== BUILT_IN_LOG2F
8671 || fcode
== BUILT_IN_LOG2L
))
8672 || (func
== mpfr_exp10
8673 && (fcode
== BUILT_IN_LOG10
8674 || fcode
== BUILT_IN_LOG10F
8675 || fcode
== BUILT_IN_LOG10L
)))
8676 return fold_convert_loc (loc
, type
, CALL_EXPR_ARG (arg
, 0));
8683 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8684 arguments to the call, and TYPE is its return type.
8685 Return NULL_TREE if no simplification can be made. */
8688 fold_builtin_memchr (location_t loc
, tree arg1
, tree arg2
, tree len
, tree type
)
8690 if (!validate_arg (arg1
, POINTER_TYPE
)
8691 || !validate_arg (arg2
, INTEGER_TYPE
)
8692 || !validate_arg (len
, INTEGER_TYPE
))
8698 if (TREE_CODE (arg2
) != INTEGER_CST
8699 || !tree_fits_uhwi_p (len
))
8702 p1
= c_getstr (arg1
);
8703 if (p1
&& compare_tree_int (len
, strlen (p1
) + 1) <= 0)
8709 if (target_char_cast (arg2
, &c
))
8712 r
= (const char *) memchr (p1
, c
, tree_to_uhwi (len
));
8715 return build_int_cst (TREE_TYPE (arg1
), 0);
8717 tem
= fold_build_pointer_plus_hwi_loc (loc
, arg1
, r
- p1
);
8718 return fold_convert_loc (loc
, type
, tem
);
8724 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8725 Return NULL_TREE if no simplification can be made. */
8728 fold_builtin_memcmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
8730 const char *p1
, *p2
;
8732 if (!validate_arg (arg1
, POINTER_TYPE
)
8733 || !validate_arg (arg2
, POINTER_TYPE
)
8734 || !validate_arg (len
, INTEGER_TYPE
))
8737 /* If the LEN parameter is zero, return zero. */
8738 if (integer_zerop (len
))
8739 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
8742 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8743 if (operand_equal_p (arg1
, arg2
, 0))
8744 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
8746 p1
= c_getstr (arg1
);
8747 p2
= c_getstr (arg2
);
8749 /* If all arguments are constant, and the value of len is not greater
8750 than the lengths of arg1 and arg2, evaluate at compile-time. */
8751 if (tree_fits_uhwi_p (len
) && p1
&& p2
8752 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
8753 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
8755 const int r
= memcmp (p1
, p2
, tree_to_uhwi (len
));
8758 return integer_one_node
;
8760 return integer_minus_one_node
;
8762 return integer_zero_node
;
8765 /* If len parameter is one, return an expression corresponding to
8766 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8767 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
8769 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8770 tree cst_uchar_ptr_node
8771 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8774 = fold_convert_loc (loc
, integer_type_node
,
8775 build1 (INDIRECT_REF
, cst_uchar_node
,
8776 fold_convert_loc (loc
,
8780 = fold_convert_loc (loc
, integer_type_node
,
8781 build1 (INDIRECT_REF
, cst_uchar_node
,
8782 fold_convert_loc (loc
,
8785 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8791 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8792 Return NULL_TREE if no simplification can be made. */
8795 fold_builtin_strcmp (location_t loc
, tree arg1
, tree arg2
)
8797 const char *p1
, *p2
;
8799 if (!validate_arg (arg1
, POINTER_TYPE
)
8800 || !validate_arg (arg2
, POINTER_TYPE
))
8803 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8804 if (operand_equal_p (arg1
, arg2
, 0))
8805 return integer_zero_node
;
8807 p1
= c_getstr (arg1
);
8808 p2
= c_getstr (arg2
);
8812 const int i
= strcmp (p1
, p2
);
8814 return integer_minus_one_node
;
8816 return integer_one_node
;
8818 return integer_zero_node
;
8821 /* If the second arg is "", return *(const unsigned char*)arg1. */
8822 if (p2
&& *p2
== '\0')
8824 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8825 tree cst_uchar_ptr_node
8826 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8828 return fold_convert_loc (loc
, integer_type_node
,
8829 build1 (INDIRECT_REF
, cst_uchar_node
,
8830 fold_convert_loc (loc
,
8835 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8836 if (p1
&& *p1
== '\0')
8838 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8839 tree cst_uchar_ptr_node
8840 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8843 = fold_convert_loc (loc
, integer_type_node
,
8844 build1 (INDIRECT_REF
, cst_uchar_node
,
8845 fold_convert_loc (loc
,
8848 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
8854 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8855 Return NULL_TREE if no simplification can be made. */
8858 fold_builtin_strncmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
8860 const char *p1
, *p2
;
8862 if (!validate_arg (arg1
, POINTER_TYPE
)
8863 || !validate_arg (arg2
, POINTER_TYPE
)
8864 || !validate_arg (len
, INTEGER_TYPE
))
8867 /* If the LEN parameter is zero, return zero. */
8868 if (integer_zerop (len
))
8869 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
8872 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8873 if (operand_equal_p (arg1
, arg2
, 0))
8874 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
8876 p1
= c_getstr (arg1
);
8877 p2
= c_getstr (arg2
);
8879 if (tree_fits_uhwi_p (len
) && p1
&& p2
)
8881 const int i
= strncmp (p1
, p2
, tree_to_uhwi (len
));
8883 return integer_one_node
;
8885 return integer_minus_one_node
;
8887 return integer_zero_node
;
8890 /* If the second arg is "", and the length is greater than zero,
8891 return *(const unsigned char*)arg1. */
8892 if (p2
&& *p2
== '\0'
8893 && TREE_CODE (len
) == INTEGER_CST
8894 && tree_int_cst_sgn (len
) == 1)
8896 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8897 tree cst_uchar_ptr_node
8898 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8900 return fold_convert_loc (loc
, integer_type_node
,
8901 build1 (INDIRECT_REF
, cst_uchar_node
,
8902 fold_convert_loc (loc
,
8907 /* If the first arg is "", and the length is greater than zero,
8908 return -*(const unsigned char*)arg2. */
8909 if (p1
&& *p1
== '\0'
8910 && TREE_CODE (len
) == INTEGER_CST
8911 && tree_int_cst_sgn (len
) == 1)
8913 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8914 tree cst_uchar_ptr_node
8915 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8917 tree temp
= fold_convert_loc (loc
, integer_type_node
,
8918 build1 (INDIRECT_REF
, cst_uchar_node
,
8919 fold_convert_loc (loc
,
8922 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
8925 /* If len parameter is one, return an expression corresponding to
8926 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8927 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
8929 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8930 tree cst_uchar_ptr_node
8931 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8933 tree ind1
= fold_convert_loc (loc
, integer_type_node
,
8934 build1 (INDIRECT_REF
, cst_uchar_node
,
8935 fold_convert_loc (loc
,
8938 tree ind2
= fold_convert_loc (loc
, integer_type_node
,
8939 build1 (INDIRECT_REF
, cst_uchar_node
,
8940 fold_convert_loc (loc
,
8943 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8949 /* Fold function call to builtin signbit, signbitf or signbitl with argument
8950 ARG. Return NULL_TREE if no simplification can be made. */
8953 fold_builtin_signbit (location_t loc
, tree arg
, tree type
)
8955 if (!validate_arg (arg
, REAL_TYPE
))
8958 /* If ARG is a compile-time constant, determine the result. */
8959 if (TREE_CODE (arg
) == REAL_CST
8960 && !TREE_OVERFLOW (arg
))
8964 c
= TREE_REAL_CST (arg
);
8965 return (REAL_VALUE_NEGATIVE (c
)
8966 ? build_one_cst (type
)
8967 : build_zero_cst (type
));
8970 /* If ARG is non-negative, the result is always zero. */
8971 if (tree_expr_nonnegative_p (arg
))
8972 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
8974 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
8975 if (!HONOR_SIGNED_ZEROS (arg
))
8976 return fold_convert (type
,
8977 fold_build2_loc (loc
, LT_EXPR
, boolean_type_node
, arg
,
8978 build_real (TREE_TYPE (arg
), dconst0
)));
8983 /* Fold function call to builtin copysign, copysignf or copysignl with
8984 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
8988 fold_builtin_copysign (location_t loc
, tree fndecl
,
8989 tree arg1
, tree arg2
, tree type
)
8993 if (!validate_arg (arg1
, REAL_TYPE
)
8994 || !validate_arg (arg2
, REAL_TYPE
))
8997 /* copysign(X,X) is X. */
8998 if (operand_equal_p (arg1
, arg2
, 0))
8999 return fold_convert_loc (loc
, type
, arg1
);
9001 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9002 if (TREE_CODE (arg1
) == REAL_CST
9003 && TREE_CODE (arg2
) == REAL_CST
9004 && !TREE_OVERFLOW (arg1
)
9005 && !TREE_OVERFLOW (arg2
))
9007 REAL_VALUE_TYPE c1
, c2
;
9009 c1
= TREE_REAL_CST (arg1
);
9010 c2
= TREE_REAL_CST (arg2
);
9011 /* c1.sign := c2.sign. */
9012 real_copysign (&c1
, &c2
);
9013 return build_real (type
, c1
);
9016 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9017 Remember to evaluate Y for side-effects. */
9018 if (tree_expr_nonnegative_p (arg2
))
9019 return omit_one_operand_loc (loc
, type
,
9020 fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
),
9023 /* Strip sign changing operations for the first argument. */
9024 tem
= fold_strip_sign_ops (arg1
);
9026 return build_call_expr_loc (loc
, fndecl
, 2, tem
, arg2
);
9031 /* Fold a call to builtin isascii with argument ARG. */
9034 fold_builtin_isascii (location_t loc
, tree arg
)
9036 if (!validate_arg (arg
, INTEGER_TYPE
))
9040 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9041 arg
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
9042 build_int_cst (integer_type_node
,
9043 ~ (unsigned HOST_WIDE_INT
) 0x7f));
9044 return fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
,
9045 arg
, integer_zero_node
);
9049 /* Fold a call to builtin toascii with argument ARG. */
9052 fold_builtin_toascii (location_t loc
, tree arg
)
9054 if (!validate_arg (arg
, INTEGER_TYPE
))
9057 /* Transform toascii(c) -> (c & 0x7f). */
9058 return fold_build2_loc (loc
, BIT_AND_EXPR
, integer_type_node
, arg
,
9059 build_int_cst (integer_type_node
, 0x7f));
9062 /* Fold a call to builtin isdigit with argument ARG. */
9065 fold_builtin_isdigit (location_t loc
, tree arg
)
9067 if (!validate_arg (arg
, INTEGER_TYPE
))
9071 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9072 /* According to the C standard, isdigit is unaffected by locale.
9073 However, it definitely is affected by the target character set. */
9074 unsigned HOST_WIDE_INT target_digit0
9075 = lang_hooks
.to_target_charset ('0');
9077 if (target_digit0
== 0)
9080 arg
= fold_convert_loc (loc
, unsigned_type_node
, arg
);
9081 arg
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
9082 build_int_cst (unsigned_type_node
, target_digit0
));
9083 return fold_build2_loc (loc
, LE_EXPR
, integer_type_node
, arg
,
9084 build_int_cst (unsigned_type_node
, 9));
9088 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9091 fold_builtin_fabs (location_t loc
, tree arg
, tree type
)
9093 if (!validate_arg (arg
, REAL_TYPE
))
9096 arg
= fold_convert_loc (loc
, type
, arg
);
9097 if (TREE_CODE (arg
) == REAL_CST
)
9098 return fold_abs_const (arg
, type
);
9099 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9102 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9105 fold_builtin_abs (location_t loc
, tree arg
, tree type
)
9107 if (!validate_arg (arg
, INTEGER_TYPE
))
9110 arg
= fold_convert_loc (loc
, type
, arg
);
9111 if (TREE_CODE (arg
) == INTEGER_CST
)
9112 return fold_abs_const (arg
, type
);
9113 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9116 /* Fold a fma operation with arguments ARG[012]. */
9119 fold_fma (location_t loc ATTRIBUTE_UNUSED
,
9120 tree type
, tree arg0
, tree arg1
, tree arg2
)
9122 if (TREE_CODE (arg0
) == REAL_CST
9123 && TREE_CODE (arg1
) == REAL_CST
9124 && TREE_CODE (arg2
) == REAL_CST
)
9125 return do_mpfr_arg3 (arg0
, arg1
, arg2
, type
, mpfr_fma
);
9130 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
9133 fold_builtin_fma (location_t loc
, tree arg0
, tree arg1
, tree arg2
, tree type
)
9135 if (validate_arg (arg0
, REAL_TYPE
)
9136 && validate_arg (arg1
, REAL_TYPE
)
9137 && validate_arg (arg2
, REAL_TYPE
))
9139 tree tem
= fold_fma (loc
, type
, arg0
, arg1
, arg2
);
9143 /* ??? Only expand to FMA_EXPR if it's directly supported. */
9144 if (optab_handler (fma_optab
, TYPE_MODE (type
)) != CODE_FOR_nothing
)
9145 return fold_build3_loc (loc
, FMA_EXPR
, type
, arg0
, arg1
, arg2
);
9150 /* Fold a call to builtin fmin or fmax. */
9153 fold_builtin_fmin_fmax (location_t loc
, tree arg0
, tree arg1
,
9154 tree type
, bool max
)
9156 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, REAL_TYPE
))
9158 /* Calculate the result when the argument is a constant. */
9159 tree res
= do_mpfr_arg2 (arg0
, arg1
, type
, (max
? mpfr_max
: mpfr_min
));
9164 /* If either argument is NaN, return the other one. Avoid the
9165 transformation if we get (and honor) a signalling NaN. Using
9166 omit_one_operand() ensures we create a non-lvalue. */
9167 if (TREE_CODE (arg0
) == REAL_CST
9168 && real_isnan (&TREE_REAL_CST (arg0
))
9169 && (! HONOR_SNANS (arg0
)
9170 || ! TREE_REAL_CST (arg0
).signalling
))
9171 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
9172 if (TREE_CODE (arg1
) == REAL_CST
9173 && real_isnan (&TREE_REAL_CST (arg1
))
9174 && (! HONOR_SNANS (arg1
)
9175 || ! TREE_REAL_CST (arg1
).signalling
))
9176 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9178 /* Transform fmin/fmax(x,x) -> x. */
9179 if (operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
9180 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9182 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9183 functions to return the numeric arg if the other one is NaN.
9184 These tree codes don't honor that, so only transform if
9185 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9186 handled, so we don't have to worry about it either. */
9187 if (flag_finite_math_only
)
9188 return fold_build2_loc (loc
, (max
? MAX_EXPR
: MIN_EXPR
), type
,
9189 fold_convert_loc (loc
, type
, arg0
),
9190 fold_convert_loc (loc
, type
, arg1
));
9195 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9198 fold_builtin_carg (location_t loc
, tree arg
, tree type
)
9200 if (validate_arg (arg
, COMPLEX_TYPE
)
9201 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
9203 tree atan2_fn
= mathfn_built_in (type
, BUILT_IN_ATAN2
);
9207 tree new_arg
= builtin_save_expr (arg
);
9208 tree r_arg
= fold_build1_loc (loc
, REALPART_EXPR
, type
, new_arg
);
9209 tree i_arg
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, new_arg
);
9210 return build_call_expr_loc (loc
, atan2_fn
, 2, i_arg
, r_arg
);
9217 /* Fold a call to builtin logb/ilogb. */
9220 fold_builtin_logb (location_t loc
, tree arg
, tree rettype
)
9222 if (! validate_arg (arg
, REAL_TYPE
))
9227 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9229 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9235 /* If arg is Inf or NaN and we're logb, return it. */
9236 if (TREE_CODE (rettype
) == REAL_TYPE
)
9238 /* For logb(-Inf) we have to return +Inf. */
9239 if (real_isinf (value
) && real_isneg (value
))
9241 REAL_VALUE_TYPE tem
;
9243 return build_real (rettype
, tem
);
9245 return fold_convert_loc (loc
, rettype
, arg
);
9247 /* Fall through... */
9249 /* Zero may set errno and/or raise an exception for logb, also
9250 for ilogb we don't know FP_ILOGB0. */
9253 /* For normal numbers, proceed iff radix == 2. In GCC,
9254 normalized significands are in the range [0.5, 1.0). We
9255 want the exponent as if they were [1.0, 2.0) so get the
9256 exponent and subtract 1. */
9257 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9258 return fold_convert_loc (loc
, rettype
,
9259 build_int_cst (integer_type_node
,
9260 REAL_EXP (value
)-1));
9268 /* Fold a call to builtin significand, if radix == 2. */
9271 fold_builtin_significand (location_t loc
, tree arg
, tree rettype
)
9273 if (! validate_arg (arg
, REAL_TYPE
))
9278 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9280 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9287 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9288 return fold_convert_loc (loc
, rettype
, arg
);
9290 /* For normal numbers, proceed iff radix == 2. */
9291 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9293 REAL_VALUE_TYPE result
= *value
;
9294 /* In GCC, normalized significands are in the range [0.5,
9295 1.0). We want them to be [1.0, 2.0) so set the
9297 SET_REAL_EXP (&result
, 1);
9298 return build_real (rettype
, result
);
9307 /* Fold a call to builtin frexp, we can assume the base is 2. */
9310 fold_builtin_frexp (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9312 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9317 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9320 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9322 /* Proceed if a valid pointer type was passed in. */
9323 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == integer_type_node
)
9325 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9331 /* For +-0, return (*exp = 0, +-0). */
9332 exp
= integer_zero_node
;
9337 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9338 return omit_one_operand_loc (loc
, rettype
, arg0
, arg1
);
9341 /* Since the frexp function always expects base 2, and in
9342 GCC normalized significands are already in the range
9343 [0.5, 1.0), we have exactly what frexp wants. */
9344 REAL_VALUE_TYPE frac_rvt
= *value
;
9345 SET_REAL_EXP (&frac_rvt
, 0);
9346 frac
= build_real (rettype
, frac_rvt
);
9347 exp
= build_int_cst (integer_type_node
, REAL_EXP (value
));
9354 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9355 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
, exp
);
9356 TREE_SIDE_EFFECTS (arg1
) = 1;
9357 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
, frac
);
9363 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9364 then we can assume the base is two. If it's false, then we have to
9365 check the mode of the TYPE parameter in certain cases. */
9368 fold_builtin_load_exponent (location_t loc
, tree arg0
, tree arg1
,
9369 tree type
, bool ldexp
)
9371 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, INTEGER_TYPE
))
9376 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9377 if (real_zerop (arg0
) || integer_zerop (arg1
)
9378 || (TREE_CODE (arg0
) == REAL_CST
9379 && !real_isfinite (&TREE_REAL_CST (arg0
))))
9380 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9382 /* If both arguments are constant, then try to evaluate it. */
9383 if ((ldexp
|| REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2)
9384 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
9385 && tree_fits_shwi_p (arg1
))
9387 /* Bound the maximum adjustment to twice the range of the
9388 mode's valid exponents. Use abs to ensure the range is
9389 positive as a sanity check. */
9390 const long max_exp_adj
= 2 *
9391 labs (REAL_MODE_FORMAT (TYPE_MODE (type
))->emax
9392 - REAL_MODE_FORMAT (TYPE_MODE (type
))->emin
);
9394 /* Get the user-requested adjustment. */
9395 const HOST_WIDE_INT req_exp_adj
= tree_to_shwi (arg1
);
9397 /* The requested adjustment must be inside this range. This
9398 is a preliminary cap to avoid things like overflow, we
9399 may still fail to compute the result for other reasons. */
9400 if (-max_exp_adj
< req_exp_adj
&& req_exp_adj
< max_exp_adj
)
9402 REAL_VALUE_TYPE initial_result
;
9404 real_ldexp (&initial_result
, &TREE_REAL_CST (arg0
), req_exp_adj
);
9406 /* Ensure we didn't overflow. */
9407 if (! real_isinf (&initial_result
))
9409 const REAL_VALUE_TYPE trunc_result
9410 = real_value_truncate (TYPE_MODE (type
), initial_result
);
9412 /* Only proceed if the target mode can hold the
9414 if (REAL_VALUES_EQUAL (initial_result
, trunc_result
))
9415 return build_real (type
, trunc_result
);
9424 /* Fold a call to builtin modf. */
9427 fold_builtin_modf (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9429 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9434 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9437 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9439 /* Proceed if a valid pointer type was passed in. */
9440 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == TYPE_MAIN_VARIANT (rettype
))
9442 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9443 REAL_VALUE_TYPE trunc
, frac
;
9449 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9450 trunc
= frac
= *value
;
9453 /* For +-Inf, return (*arg1 = arg0, +-0). */
9455 frac
.sign
= value
->sign
;
9459 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9460 real_trunc (&trunc
, VOIDmode
, value
);
9461 real_arithmetic (&frac
, MINUS_EXPR
, value
, &trunc
);
9462 /* If the original number was negative and already
9463 integral, then the fractional part is -0.0. */
9464 if (value
->sign
&& frac
.cl
== rvc_zero
)
9465 frac
.sign
= value
->sign
;
9469 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9470 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
,
9471 build_real (rettype
, trunc
));
9472 TREE_SIDE_EFFECTS (arg1
) = 1;
9473 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
,
9474 build_real (rettype
, frac
));
9480 /* Given a location LOC, an interclass builtin function decl FNDECL
9481 and its single argument ARG, return an folded expression computing
9482 the same, or NULL_TREE if we either couldn't or didn't want to fold
9483 (the latter happen if there's an RTL instruction available). */
9486 fold_builtin_interclass_mathfn (location_t loc
, tree fndecl
, tree arg
)
9490 if (!validate_arg (arg
, REAL_TYPE
))
9493 if (interclass_mathfn_icode (arg
, fndecl
) != CODE_FOR_nothing
)
9496 mode
= TYPE_MODE (TREE_TYPE (arg
));
9498 /* If there is no optab, try generic code. */
9499 switch (DECL_FUNCTION_CODE (fndecl
))
9503 CASE_FLT_FN (BUILT_IN_ISINF
):
9505 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9506 tree
const isgr_fn
= builtin_decl_explicit (BUILT_IN_ISGREATER
);
9507 tree
const type
= TREE_TYPE (arg
);
9511 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9512 real_from_string (&r
, buf
);
9513 result
= build_call_expr (isgr_fn
, 2,
9514 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9515 build_real (type
, r
));
9518 CASE_FLT_FN (BUILT_IN_FINITE
):
9519 case BUILT_IN_ISFINITE
:
9521 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9522 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
9523 tree
const type
= TREE_TYPE (arg
);
9527 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9528 real_from_string (&r
, buf
);
9529 result
= build_call_expr (isle_fn
, 2,
9530 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9531 build_real (type
, r
));
9532 /*result = fold_build2_loc (loc, UNGT_EXPR,
9533 TREE_TYPE (TREE_TYPE (fndecl)),
9534 fold_build1_loc (loc, ABS_EXPR, type, arg),
9535 build_real (type, r));
9536 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9537 TREE_TYPE (TREE_TYPE (fndecl)),
9541 case BUILT_IN_ISNORMAL
:
9543 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9544 islessequal(fabs(x),DBL_MAX). */
9545 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
9546 tree
const isge_fn
= builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL
);
9547 tree
const type
= TREE_TYPE (arg
);
9548 REAL_VALUE_TYPE rmax
, rmin
;
9551 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9552 real_from_string (&rmax
, buf
);
9553 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9554 real_from_string (&rmin
, buf
);
9555 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9556 result
= build_call_expr (isle_fn
, 2, arg
,
9557 build_real (type
, rmax
));
9558 result
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, result
,
9559 build_call_expr (isge_fn
, 2, arg
,
9560 build_real (type
, rmin
)));
9570 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9571 ARG is the argument for the call. */
9574 fold_builtin_classify (location_t loc
, tree fndecl
, tree arg
, int builtin_index
)
9576 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9579 if (!validate_arg (arg
, REAL_TYPE
))
9582 switch (builtin_index
)
9584 case BUILT_IN_ISINF
:
9585 if (!HONOR_INFINITIES (arg
))
9586 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9588 if (TREE_CODE (arg
) == REAL_CST
)
9590 r
= TREE_REAL_CST (arg
);
9591 if (real_isinf (&r
))
9592 return real_compare (GT_EXPR
, &r
, &dconst0
)
9593 ? integer_one_node
: integer_minus_one_node
;
9595 return integer_zero_node
;
9600 case BUILT_IN_ISINF_SIGN
:
9602 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9603 /* In a boolean context, GCC will fold the inner COND_EXPR to
9604 1. So e.g. "if (isinf_sign(x))" would be folded to just
9605 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9606 tree signbit_fn
= mathfn_built_in_1 (TREE_TYPE (arg
), BUILT_IN_SIGNBIT
, 0);
9607 tree isinf_fn
= builtin_decl_explicit (BUILT_IN_ISINF
);
9608 tree tmp
= NULL_TREE
;
9610 arg
= builtin_save_expr (arg
);
9612 if (signbit_fn
&& isinf_fn
)
9614 tree signbit_call
= build_call_expr_loc (loc
, signbit_fn
, 1, arg
);
9615 tree isinf_call
= build_call_expr_loc (loc
, isinf_fn
, 1, arg
);
9617 signbit_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9618 signbit_call
, integer_zero_node
);
9619 isinf_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9620 isinf_call
, integer_zero_node
);
9622 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, signbit_call
,
9623 integer_minus_one_node
, integer_one_node
);
9624 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9632 case BUILT_IN_ISFINITE
:
9633 if (!HONOR_NANS (arg
)
9634 && !HONOR_INFINITIES (arg
))
9635 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
9637 if (TREE_CODE (arg
) == REAL_CST
)
9639 r
= TREE_REAL_CST (arg
);
9640 return real_isfinite (&r
) ? integer_one_node
: integer_zero_node
;
9645 case BUILT_IN_ISNAN
:
9646 if (!HONOR_NANS (arg
))
9647 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9649 if (TREE_CODE (arg
) == REAL_CST
)
9651 r
= TREE_REAL_CST (arg
);
9652 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
9655 arg
= builtin_save_expr (arg
);
9656 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg
, arg
);
9663 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9664 This builtin will generate code to return the appropriate floating
9665 point classification depending on the value of the floating point
9666 number passed in. The possible return values must be supplied as
9667 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9668 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9669 one floating point argument which is "type generic". */
9672 fold_builtin_fpclassify (location_t loc
, tree
*args
, int nargs
)
9674 tree fp_nan
, fp_infinite
, fp_normal
, fp_subnormal
, fp_zero
,
9675 arg
, type
, res
, tmp
;
9680 /* Verify the required arguments in the original call. */
9682 || !validate_arg (args
[0], INTEGER_TYPE
)
9683 || !validate_arg (args
[1], INTEGER_TYPE
)
9684 || !validate_arg (args
[2], INTEGER_TYPE
)
9685 || !validate_arg (args
[3], INTEGER_TYPE
)
9686 || !validate_arg (args
[4], INTEGER_TYPE
)
9687 || !validate_arg (args
[5], REAL_TYPE
))
9691 fp_infinite
= args
[1];
9692 fp_normal
= args
[2];
9693 fp_subnormal
= args
[3];
9696 type
= TREE_TYPE (arg
);
9697 mode
= TYPE_MODE (type
);
9698 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9702 (fabs(x) == Inf ? FP_INFINITE :
9703 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9704 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9706 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9707 build_real (type
, dconst0
));
9708 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9709 tmp
, fp_zero
, fp_subnormal
);
9711 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9712 real_from_string (&r
, buf
);
9713 tmp
= fold_build2_loc (loc
, GE_EXPR
, integer_type_node
,
9714 arg
, build_real (type
, r
));
9715 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, fp_normal
, res
);
9717 if (HONOR_INFINITIES (mode
))
9720 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9721 build_real (type
, r
));
9722 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
,
9726 if (HONOR_NANS (mode
))
9728 tmp
= fold_build2_loc (loc
, ORDERED_EXPR
, integer_type_node
, arg
, arg
);
9729 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, res
, fp_nan
);
9735 /* Fold a call to an unordered comparison function such as
9736 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9737 being called and ARG0 and ARG1 are the arguments for the call.
9738 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9739 the opposite of the desired result. UNORDERED_CODE is used
9740 for modes that can hold NaNs and ORDERED_CODE is used for
9744 fold_builtin_unordered_cmp (location_t loc
, tree fndecl
, tree arg0
, tree arg1
,
9745 enum tree_code unordered_code
,
9746 enum tree_code ordered_code
)
9748 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9749 enum tree_code code
;
9751 enum tree_code code0
, code1
;
9752 tree cmp_type
= NULL_TREE
;
9754 type0
= TREE_TYPE (arg0
);
9755 type1
= TREE_TYPE (arg1
);
9757 code0
= TREE_CODE (type0
);
9758 code1
= TREE_CODE (type1
);
9760 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
9761 /* Choose the wider of two real types. */
9762 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
9764 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
9766 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
9769 arg0
= fold_convert_loc (loc
, cmp_type
, arg0
);
9770 arg1
= fold_convert_loc (loc
, cmp_type
, arg1
);
9772 if (unordered_code
== UNORDERED_EXPR
)
9774 if (!HONOR_NANS (arg0
))
9775 return omit_two_operands_loc (loc
, type
, integer_zero_node
, arg0
, arg1
);
9776 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg0
, arg1
);
9779 code
= HONOR_NANS (arg0
) ? unordered_code
: ordered_code
;
9780 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
,
9781 fold_build2_loc (loc
, code
, type
, arg0
, arg1
));
9784 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
9785 arithmetics if it can never overflow, or into internal functions that
9786 return both result of arithmetics and overflowed boolean flag in
9787 a complex integer result, or some other check for overflow. */
9790 fold_builtin_arith_overflow (location_t loc
, enum built_in_function fcode
,
9791 tree arg0
, tree arg1
, tree arg2
)
9793 enum internal_fn ifn
= IFN_LAST
;
9794 tree type
= TREE_TYPE (TREE_TYPE (arg2
));
9795 tree mem_arg2
= build_fold_indirect_ref_loc (loc
, arg2
);
9798 case BUILT_IN_ADD_OVERFLOW
:
9799 case BUILT_IN_SADD_OVERFLOW
:
9800 case BUILT_IN_SADDL_OVERFLOW
:
9801 case BUILT_IN_SADDLL_OVERFLOW
:
9802 case BUILT_IN_UADD_OVERFLOW
:
9803 case BUILT_IN_UADDL_OVERFLOW
:
9804 case BUILT_IN_UADDLL_OVERFLOW
:
9805 ifn
= IFN_ADD_OVERFLOW
;
9807 case BUILT_IN_SUB_OVERFLOW
:
9808 case BUILT_IN_SSUB_OVERFLOW
:
9809 case BUILT_IN_SSUBL_OVERFLOW
:
9810 case BUILT_IN_SSUBLL_OVERFLOW
:
9811 case BUILT_IN_USUB_OVERFLOW
:
9812 case BUILT_IN_USUBL_OVERFLOW
:
9813 case BUILT_IN_USUBLL_OVERFLOW
:
9814 ifn
= IFN_SUB_OVERFLOW
;
9816 case BUILT_IN_MUL_OVERFLOW
:
9817 case BUILT_IN_SMUL_OVERFLOW
:
9818 case BUILT_IN_SMULL_OVERFLOW
:
9819 case BUILT_IN_SMULLL_OVERFLOW
:
9820 case BUILT_IN_UMUL_OVERFLOW
:
9821 case BUILT_IN_UMULL_OVERFLOW
:
9822 case BUILT_IN_UMULLL_OVERFLOW
:
9823 ifn
= IFN_MUL_OVERFLOW
;
9828 tree ctype
= build_complex_type (type
);
9829 tree call
= build_call_expr_internal_loc (loc
, ifn
, ctype
,
9831 tree tgt
= save_expr (call
);
9832 tree intres
= build1_loc (loc
, REALPART_EXPR
, type
, tgt
);
9833 tree ovfres
= build1_loc (loc
, IMAGPART_EXPR
, type
, tgt
);
9834 ovfres
= fold_convert_loc (loc
, boolean_type_node
, ovfres
);
9836 = fold_build2_loc (loc
, MODIFY_EXPR
, void_type_node
, mem_arg2
, intres
);
9837 return build2_loc (loc
, COMPOUND_EXPR
, boolean_type_node
, store
, ovfres
);
9840 /* Fold a call to built-in function FNDECL with 0 arguments.
9841 This function returns NULL_TREE if no simplification was possible. */
9844 fold_builtin_0 (location_t loc
, tree fndecl
)
9846 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9847 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
9850 CASE_FLT_FN (BUILT_IN_INF
):
9851 case BUILT_IN_INFD32
:
9852 case BUILT_IN_INFD64
:
9853 case BUILT_IN_INFD128
:
9854 return fold_builtin_inf (loc
, type
, true);
9856 CASE_FLT_FN (BUILT_IN_HUGE_VAL
):
9857 return fold_builtin_inf (loc
, type
, false);
9859 case BUILT_IN_CLASSIFY_TYPE
:
9860 return fold_builtin_classify_type (NULL_TREE
);
9868 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9869 This function returns NULL_TREE if no simplification was possible. */
9872 fold_builtin_1 (location_t loc
, tree fndecl
, tree arg0
)
9874 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9875 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
9878 case BUILT_IN_CONSTANT_P
:
9880 tree val
= fold_builtin_constant_p (arg0
);
9882 /* Gimplification will pull the CALL_EXPR for the builtin out of
9883 an if condition. When not optimizing, we'll not CSE it back.
9884 To avoid link error types of regressions, return false now. */
9885 if (!val
&& !optimize
)
9886 val
= integer_zero_node
;
9891 case BUILT_IN_CLASSIFY_TYPE
:
9892 return fold_builtin_classify_type (arg0
);
9894 case BUILT_IN_STRLEN
:
9895 return fold_builtin_strlen (loc
, type
, arg0
);
9897 CASE_FLT_FN (BUILT_IN_FABS
):
9898 case BUILT_IN_FABSD32
:
9899 case BUILT_IN_FABSD64
:
9900 case BUILT_IN_FABSD128
:
9901 return fold_builtin_fabs (loc
, arg0
, type
);
9905 case BUILT_IN_LLABS
:
9906 case BUILT_IN_IMAXABS
:
9907 return fold_builtin_abs (loc
, arg0
, type
);
9909 CASE_FLT_FN (BUILT_IN_CONJ
):
9910 if (validate_arg (arg0
, COMPLEX_TYPE
)
9911 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9912 return fold_build1_loc (loc
, CONJ_EXPR
, type
, arg0
);
9915 CASE_FLT_FN (BUILT_IN_CREAL
):
9916 if (validate_arg (arg0
, COMPLEX_TYPE
)
9917 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9918 return non_lvalue_loc (loc
, fold_build1_loc (loc
, REALPART_EXPR
, type
, arg0
));;
9921 CASE_FLT_FN (BUILT_IN_CIMAG
):
9922 if (validate_arg (arg0
, COMPLEX_TYPE
)
9923 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9924 return non_lvalue_loc (loc
, fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg0
));
9927 CASE_FLT_FN (BUILT_IN_CCOS
):
9928 return fold_builtin_ccos (loc
, arg0
, type
, fndecl
, /*hyper=*/ false);
9930 CASE_FLT_FN (BUILT_IN_CCOSH
):
9931 return fold_builtin_ccos (loc
, arg0
, type
, fndecl
, /*hyper=*/ true);
9933 CASE_FLT_FN (BUILT_IN_CPROJ
):
9934 return fold_builtin_cproj (loc
, arg0
, type
);
9936 CASE_FLT_FN (BUILT_IN_CSIN
):
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_sin
);
9942 CASE_FLT_FN (BUILT_IN_CSINH
):
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_sinh
);
9948 CASE_FLT_FN (BUILT_IN_CTAN
):
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_tan
);
9954 CASE_FLT_FN (BUILT_IN_CTANH
):
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_tanh
);
9960 CASE_FLT_FN (BUILT_IN_CLOG
):
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_log
);
9966 CASE_FLT_FN (BUILT_IN_CSQRT
):
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_sqrt
);
9972 CASE_FLT_FN (BUILT_IN_CASIN
):
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_asin
);
9978 CASE_FLT_FN (BUILT_IN_CACOS
):
9979 if (validate_arg (arg0
, COMPLEX_TYPE
)
9980 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9981 return do_mpc_arg1 (arg0
, type
, mpc_acos
);
9984 CASE_FLT_FN (BUILT_IN_CATAN
):
9985 if (validate_arg (arg0
, COMPLEX_TYPE
)
9986 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9987 return do_mpc_arg1 (arg0
, type
, mpc_atan
);
9990 CASE_FLT_FN (BUILT_IN_CASINH
):
9991 if (validate_arg (arg0
, COMPLEX_TYPE
)
9992 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9993 return do_mpc_arg1 (arg0
, type
, mpc_asinh
);
9996 CASE_FLT_FN (BUILT_IN_CACOSH
):
9997 if (validate_arg (arg0
, COMPLEX_TYPE
)
9998 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9999 return do_mpc_arg1 (arg0
, type
, mpc_acosh
);
10002 CASE_FLT_FN (BUILT_IN_CATANH
):
10003 if (validate_arg (arg0
, COMPLEX_TYPE
)
10004 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10005 return do_mpc_arg1 (arg0
, type
, mpc_atanh
);
10008 CASE_FLT_FN (BUILT_IN_CABS
):
10009 return fold_builtin_cabs (loc
, arg0
, type
, fndecl
);
10011 CASE_FLT_FN (BUILT_IN_CARG
):
10012 return fold_builtin_carg (loc
, arg0
, type
);
10014 CASE_FLT_FN (BUILT_IN_SQRT
):
10015 return fold_builtin_sqrt (loc
, arg0
, type
);
10017 CASE_FLT_FN (BUILT_IN_CBRT
):
10018 return fold_builtin_cbrt (loc
, arg0
, type
);
10020 CASE_FLT_FN (BUILT_IN_ASIN
):
10021 if (validate_arg (arg0
, REAL_TYPE
))
10022 return do_mpfr_arg1 (arg0
, type
, mpfr_asin
,
10023 &dconstm1
, &dconst1
, true);
10026 CASE_FLT_FN (BUILT_IN_ACOS
):
10027 if (validate_arg (arg0
, REAL_TYPE
))
10028 return do_mpfr_arg1 (arg0
, type
, mpfr_acos
,
10029 &dconstm1
, &dconst1
, true);
10032 CASE_FLT_FN (BUILT_IN_ATAN
):
10033 if (validate_arg (arg0
, REAL_TYPE
))
10034 return do_mpfr_arg1 (arg0
, type
, mpfr_atan
, NULL
, NULL
, 0);
10037 CASE_FLT_FN (BUILT_IN_ASINH
):
10038 if (validate_arg (arg0
, REAL_TYPE
))
10039 return do_mpfr_arg1 (arg0
, type
, mpfr_asinh
, NULL
, NULL
, 0);
10042 CASE_FLT_FN (BUILT_IN_ACOSH
):
10043 if (validate_arg (arg0
, REAL_TYPE
))
10044 return do_mpfr_arg1 (arg0
, type
, mpfr_acosh
,
10045 &dconst1
, NULL
, true);
10048 CASE_FLT_FN (BUILT_IN_ATANH
):
10049 if (validate_arg (arg0
, REAL_TYPE
))
10050 return do_mpfr_arg1 (arg0
, type
, mpfr_atanh
,
10051 &dconstm1
, &dconst1
, false);
10054 CASE_FLT_FN (BUILT_IN_SIN
):
10055 if (validate_arg (arg0
, REAL_TYPE
))
10056 return do_mpfr_arg1 (arg0
, type
, mpfr_sin
, NULL
, NULL
, 0);
10059 CASE_FLT_FN (BUILT_IN_COS
):
10060 return fold_builtin_cos (loc
, arg0
, type
, fndecl
);
10062 CASE_FLT_FN (BUILT_IN_TAN
):
10063 return fold_builtin_tan (arg0
, type
);
10065 CASE_FLT_FN (BUILT_IN_CEXP
):
10066 return fold_builtin_cexp (loc
, arg0
, type
);
10068 CASE_FLT_FN (BUILT_IN_CEXPI
):
10069 if (validate_arg (arg0
, REAL_TYPE
))
10070 return do_mpfr_sincos (arg0
, NULL_TREE
, NULL_TREE
);
10073 CASE_FLT_FN (BUILT_IN_SINH
):
10074 if (validate_arg (arg0
, REAL_TYPE
))
10075 return do_mpfr_arg1 (arg0
, type
, mpfr_sinh
, NULL
, NULL
, 0);
10078 CASE_FLT_FN (BUILT_IN_COSH
):
10079 return fold_builtin_cosh (loc
, arg0
, type
, fndecl
);
10081 CASE_FLT_FN (BUILT_IN_TANH
):
10082 if (validate_arg (arg0
, REAL_TYPE
))
10083 return do_mpfr_arg1 (arg0
, type
, mpfr_tanh
, NULL
, NULL
, 0);
10086 CASE_FLT_FN (BUILT_IN_ERF
):
10087 if (validate_arg (arg0
, REAL_TYPE
))
10088 return do_mpfr_arg1 (arg0
, type
, mpfr_erf
, NULL
, NULL
, 0);
10091 CASE_FLT_FN (BUILT_IN_ERFC
):
10092 if (validate_arg (arg0
, REAL_TYPE
))
10093 return do_mpfr_arg1 (arg0
, type
, mpfr_erfc
, NULL
, NULL
, 0);
10096 CASE_FLT_FN (BUILT_IN_TGAMMA
):
10097 if (validate_arg (arg0
, REAL_TYPE
))
10098 return do_mpfr_arg1 (arg0
, type
, mpfr_gamma
, NULL
, NULL
, 0);
10101 CASE_FLT_FN (BUILT_IN_EXP
):
10102 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp
);
10104 CASE_FLT_FN (BUILT_IN_EXP2
):
10105 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp2
);
10107 CASE_FLT_FN (BUILT_IN_EXP10
):
10108 CASE_FLT_FN (BUILT_IN_POW10
):
10109 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp10
);
10111 CASE_FLT_FN (BUILT_IN_EXPM1
):
10112 if (validate_arg (arg0
, REAL_TYPE
))
10113 return do_mpfr_arg1 (arg0
, type
, mpfr_expm1
, NULL
, NULL
, 0);
10116 CASE_FLT_FN (BUILT_IN_LOG
):
10117 if (validate_arg (arg0
, REAL_TYPE
))
10118 return do_mpfr_arg1 (arg0
, type
, mpfr_log
, &dconst0
, NULL
, false);
10121 CASE_FLT_FN (BUILT_IN_LOG2
):
10122 if (validate_arg (arg0
, REAL_TYPE
))
10123 return do_mpfr_arg1 (arg0
, type
, mpfr_log2
, &dconst0
, NULL
, false);
10126 CASE_FLT_FN (BUILT_IN_LOG10
):
10127 if (validate_arg (arg0
, REAL_TYPE
))
10128 return do_mpfr_arg1 (arg0
, type
, mpfr_log10
, &dconst0
, NULL
, false);
10131 CASE_FLT_FN (BUILT_IN_LOG1P
):
10132 if (validate_arg (arg0
, REAL_TYPE
))
10133 return do_mpfr_arg1 (arg0
, type
, mpfr_log1p
,
10134 &dconstm1
, NULL
, false);
10137 CASE_FLT_FN (BUILT_IN_J0
):
10138 if (validate_arg (arg0
, REAL_TYPE
))
10139 return do_mpfr_arg1 (arg0
, type
, mpfr_j0
,
10143 CASE_FLT_FN (BUILT_IN_J1
):
10144 if (validate_arg (arg0
, REAL_TYPE
))
10145 return do_mpfr_arg1 (arg0
, type
, mpfr_j1
,
10149 CASE_FLT_FN (BUILT_IN_Y0
):
10150 if (validate_arg (arg0
, REAL_TYPE
))
10151 return do_mpfr_arg1 (arg0
, type
, mpfr_y0
,
10152 &dconst0
, NULL
, false);
10155 CASE_FLT_FN (BUILT_IN_Y1
):
10156 if (validate_arg (arg0
, REAL_TYPE
))
10157 return do_mpfr_arg1 (arg0
, type
, mpfr_y1
,
10158 &dconst0
, NULL
, false);
10161 CASE_FLT_FN (BUILT_IN_NAN
):
10162 case BUILT_IN_NAND32
:
10163 case BUILT_IN_NAND64
:
10164 case BUILT_IN_NAND128
:
10165 return fold_builtin_nan (arg0
, type
, true);
10167 CASE_FLT_FN (BUILT_IN_NANS
):
10168 return fold_builtin_nan (arg0
, type
, false);
10170 CASE_FLT_FN (BUILT_IN_FLOOR
):
10171 return fold_builtin_floor (loc
, fndecl
, arg0
);
10173 CASE_FLT_FN (BUILT_IN_CEIL
):
10174 return fold_builtin_ceil (loc
, fndecl
, arg0
);
10176 CASE_FLT_FN (BUILT_IN_TRUNC
):
10177 return fold_builtin_trunc (loc
, fndecl
, arg0
);
10179 CASE_FLT_FN (BUILT_IN_ROUND
):
10180 return fold_builtin_round (loc
, fndecl
, arg0
);
10182 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
10183 CASE_FLT_FN (BUILT_IN_RINT
):
10184 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg0
);
10186 CASE_FLT_FN (BUILT_IN_ICEIL
):
10187 CASE_FLT_FN (BUILT_IN_LCEIL
):
10188 CASE_FLT_FN (BUILT_IN_LLCEIL
):
10189 CASE_FLT_FN (BUILT_IN_LFLOOR
):
10190 CASE_FLT_FN (BUILT_IN_IFLOOR
):
10191 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
10192 CASE_FLT_FN (BUILT_IN_IROUND
):
10193 CASE_FLT_FN (BUILT_IN_LROUND
):
10194 CASE_FLT_FN (BUILT_IN_LLROUND
):
10195 return fold_builtin_int_roundingfn (loc
, fndecl
, arg0
);
10197 CASE_FLT_FN (BUILT_IN_IRINT
):
10198 CASE_FLT_FN (BUILT_IN_LRINT
):
10199 CASE_FLT_FN (BUILT_IN_LLRINT
):
10200 return fold_fixed_mathfn (loc
, fndecl
, arg0
);
10202 case BUILT_IN_BSWAP16
:
10203 case BUILT_IN_BSWAP32
:
10204 case BUILT_IN_BSWAP64
:
10205 return fold_builtin_bswap (fndecl
, arg0
);
10207 CASE_INT_FN (BUILT_IN_FFS
):
10208 CASE_INT_FN (BUILT_IN_CLZ
):
10209 CASE_INT_FN (BUILT_IN_CTZ
):
10210 CASE_INT_FN (BUILT_IN_CLRSB
):
10211 CASE_INT_FN (BUILT_IN_POPCOUNT
):
10212 CASE_INT_FN (BUILT_IN_PARITY
):
10213 return fold_builtin_bitop (fndecl
, arg0
);
10215 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
10216 return fold_builtin_signbit (loc
, arg0
, type
);
10218 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
10219 return fold_builtin_significand (loc
, arg0
, type
);
10221 CASE_FLT_FN (BUILT_IN_ILOGB
):
10222 CASE_FLT_FN (BUILT_IN_LOGB
):
10223 return fold_builtin_logb (loc
, arg0
, type
);
10225 case BUILT_IN_ISASCII
:
10226 return fold_builtin_isascii (loc
, arg0
);
10228 case BUILT_IN_TOASCII
:
10229 return fold_builtin_toascii (loc
, arg0
);
10231 case BUILT_IN_ISDIGIT
:
10232 return fold_builtin_isdigit (loc
, arg0
);
10234 CASE_FLT_FN (BUILT_IN_FINITE
):
10235 case BUILT_IN_FINITED32
:
10236 case BUILT_IN_FINITED64
:
10237 case BUILT_IN_FINITED128
:
10238 case BUILT_IN_ISFINITE
:
10240 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISFINITE
);
10243 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10246 CASE_FLT_FN (BUILT_IN_ISINF
):
10247 case BUILT_IN_ISINFD32
:
10248 case BUILT_IN_ISINFD64
:
10249 case BUILT_IN_ISINFD128
:
10251 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF
);
10254 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10257 case BUILT_IN_ISNORMAL
:
10258 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10260 case BUILT_IN_ISINF_SIGN
:
10261 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF_SIGN
);
10263 CASE_FLT_FN (BUILT_IN_ISNAN
):
10264 case BUILT_IN_ISNAND32
:
10265 case BUILT_IN_ISNAND64
:
10266 case BUILT_IN_ISNAND128
:
10267 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISNAN
);
10269 case BUILT_IN_FREE
:
10270 if (integer_zerop (arg0
))
10271 return build_empty_stmt (loc
);
10282 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10283 This function returns NULL_TREE if no simplification was possible. */
10286 fold_builtin_2 (location_t loc
, tree fndecl
, tree arg0
, tree arg1
)
10288 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10289 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10293 CASE_FLT_FN (BUILT_IN_JN
):
10294 if (validate_arg (arg0
, INTEGER_TYPE
)
10295 && validate_arg (arg1
, REAL_TYPE
))
10296 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_jn
, NULL
, 0);
10299 CASE_FLT_FN (BUILT_IN_YN
):
10300 if (validate_arg (arg0
, INTEGER_TYPE
)
10301 && validate_arg (arg1
, REAL_TYPE
))
10302 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_yn
,
10306 CASE_FLT_FN (BUILT_IN_DREM
):
10307 CASE_FLT_FN (BUILT_IN_REMAINDER
):
10308 if (validate_arg (arg0
, REAL_TYPE
)
10309 && validate_arg (arg1
, REAL_TYPE
))
10310 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_remainder
);
10313 CASE_FLT_FN_REENT (BUILT_IN_GAMMA
): /* GAMMA_R */
10314 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA
): /* LGAMMA_R */
10315 if (validate_arg (arg0
, REAL_TYPE
)
10316 && validate_arg (arg1
, POINTER_TYPE
))
10317 return do_mpfr_lgamma_r (arg0
, arg1
, type
);
10320 CASE_FLT_FN (BUILT_IN_ATAN2
):
10321 if (validate_arg (arg0
, REAL_TYPE
)
10322 && validate_arg (arg1
, REAL_TYPE
))
10323 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_atan2
);
10326 CASE_FLT_FN (BUILT_IN_FDIM
):
10327 if (validate_arg (arg0
, REAL_TYPE
)
10328 && validate_arg (arg1
, REAL_TYPE
))
10329 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_dim
);
10332 CASE_FLT_FN (BUILT_IN_HYPOT
):
10333 return fold_builtin_hypot (loc
, fndecl
, arg0
, arg1
, type
);
10335 CASE_FLT_FN (BUILT_IN_CPOW
):
10336 if (validate_arg (arg0
, COMPLEX_TYPE
)
10337 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
10338 && validate_arg (arg1
, COMPLEX_TYPE
)
10339 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
)
10340 return do_mpc_arg2 (arg0
, arg1
, type
, /*do_nonfinite=*/ 0, mpc_pow
);
10343 CASE_FLT_FN (BUILT_IN_LDEXP
):
10344 return fold_builtin_load_exponent (loc
, arg0
, arg1
, type
, /*ldexp=*/true);
10345 CASE_FLT_FN (BUILT_IN_SCALBN
):
10346 CASE_FLT_FN (BUILT_IN_SCALBLN
):
10347 return fold_builtin_load_exponent (loc
, arg0
, arg1
,
10348 type
, /*ldexp=*/false);
10350 CASE_FLT_FN (BUILT_IN_FREXP
):
10351 return fold_builtin_frexp (loc
, arg0
, arg1
, type
);
10353 CASE_FLT_FN (BUILT_IN_MODF
):
10354 return fold_builtin_modf (loc
, arg0
, arg1
, type
);
10356 case BUILT_IN_STRSTR
:
10357 return fold_builtin_strstr (loc
, arg0
, arg1
, type
);
10359 case BUILT_IN_STRSPN
:
10360 return fold_builtin_strspn (loc
, arg0
, arg1
);
10362 case BUILT_IN_STRCSPN
:
10363 return fold_builtin_strcspn (loc
, arg0
, arg1
);
10365 case BUILT_IN_STRCHR
:
10366 case BUILT_IN_INDEX
:
10367 return fold_builtin_strchr (loc
, arg0
, arg1
, type
);
10369 case BUILT_IN_STRRCHR
:
10370 case BUILT_IN_RINDEX
:
10371 return fold_builtin_strrchr (loc
, arg0
, arg1
, type
);
10373 case BUILT_IN_STRCMP
:
10374 return fold_builtin_strcmp (loc
, arg0
, arg1
);
10376 case BUILT_IN_STRPBRK
:
10377 return fold_builtin_strpbrk (loc
, arg0
, arg1
, type
);
10379 case BUILT_IN_EXPECT
:
10380 return fold_builtin_expect (loc
, arg0
, arg1
, NULL_TREE
);
10382 CASE_FLT_FN (BUILT_IN_POW
):
10383 return fold_builtin_pow (loc
, fndecl
, arg0
, arg1
, type
);
10385 CASE_FLT_FN (BUILT_IN_POWI
):
10386 return fold_builtin_powi (loc
, fndecl
, arg0
, arg1
, type
);
10388 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
10389 return fold_builtin_copysign (loc
, fndecl
, arg0
, arg1
, type
);
10391 CASE_FLT_FN (BUILT_IN_FMIN
):
10392 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/false);
10394 CASE_FLT_FN (BUILT_IN_FMAX
):
10395 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/true);
10397 case BUILT_IN_ISGREATER
:
10398 return fold_builtin_unordered_cmp (loc
, fndecl
,
10399 arg0
, arg1
, UNLE_EXPR
, LE_EXPR
);
10400 case BUILT_IN_ISGREATEREQUAL
:
10401 return fold_builtin_unordered_cmp (loc
, fndecl
,
10402 arg0
, arg1
, UNLT_EXPR
, LT_EXPR
);
10403 case BUILT_IN_ISLESS
:
10404 return fold_builtin_unordered_cmp (loc
, fndecl
,
10405 arg0
, arg1
, UNGE_EXPR
, GE_EXPR
);
10406 case BUILT_IN_ISLESSEQUAL
:
10407 return fold_builtin_unordered_cmp (loc
, fndecl
,
10408 arg0
, arg1
, UNGT_EXPR
, GT_EXPR
);
10409 case BUILT_IN_ISLESSGREATER
:
10410 return fold_builtin_unordered_cmp (loc
, fndecl
,
10411 arg0
, arg1
, UNEQ_EXPR
, EQ_EXPR
);
10412 case BUILT_IN_ISUNORDERED
:
10413 return fold_builtin_unordered_cmp (loc
, fndecl
,
10414 arg0
, arg1
, UNORDERED_EXPR
,
10417 /* We do the folding for va_start in the expander. */
10418 case BUILT_IN_VA_START
:
10421 case BUILT_IN_OBJECT_SIZE
:
10422 return fold_builtin_object_size (arg0
, arg1
);
10424 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
10425 return fold_builtin_atomic_always_lock_free (arg0
, arg1
);
10427 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
10428 return fold_builtin_atomic_is_lock_free (arg0
, arg1
);
10436 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10438 This function returns NULL_TREE if no simplification was possible. */
10441 fold_builtin_3 (location_t loc
, tree fndecl
,
10442 tree arg0
, tree arg1
, tree arg2
)
10444 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10445 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10449 CASE_FLT_FN (BUILT_IN_SINCOS
):
10450 return fold_builtin_sincos (loc
, arg0
, arg1
, arg2
);
10452 CASE_FLT_FN (BUILT_IN_FMA
):
10453 return fold_builtin_fma (loc
, arg0
, arg1
, arg2
, type
);
10456 CASE_FLT_FN (BUILT_IN_REMQUO
):
10457 if (validate_arg (arg0
, REAL_TYPE
)
10458 && validate_arg (arg1
, REAL_TYPE
)
10459 && validate_arg (arg2
, POINTER_TYPE
))
10460 return do_mpfr_remquo (arg0
, arg1
, arg2
);
10463 case BUILT_IN_STRNCMP
:
10464 return fold_builtin_strncmp (loc
, arg0
, arg1
, arg2
);
10466 case BUILT_IN_MEMCHR
:
10467 return fold_builtin_memchr (loc
, arg0
, arg1
, arg2
, type
);
10469 case BUILT_IN_BCMP
:
10470 case BUILT_IN_MEMCMP
:
10471 return fold_builtin_memcmp (loc
, arg0
, arg1
, arg2
);;
10473 case BUILT_IN_EXPECT
:
10474 return fold_builtin_expect (loc
, arg0
, arg1
, arg2
);
10476 case BUILT_IN_ADD_OVERFLOW
:
10477 case BUILT_IN_SUB_OVERFLOW
:
10478 case BUILT_IN_MUL_OVERFLOW
:
10479 case BUILT_IN_SADD_OVERFLOW
:
10480 case BUILT_IN_SADDL_OVERFLOW
:
10481 case BUILT_IN_SADDLL_OVERFLOW
:
10482 case BUILT_IN_SSUB_OVERFLOW
:
10483 case BUILT_IN_SSUBL_OVERFLOW
:
10484 case BUILT_IN_SSUBLL_OVERFLOW
:
10485 case BUILT_IN_SMUL_OVERFLOW
:
10486 case BUILT_IN_SMULL_OVERFLOW
:
10487 case BUILT_IN_SMULLL_OVERFLOW
:
10488 case BUILT_IN_UADD_OVERFLOW
:
10489 case BUILT_IN_UADDL_OVERFLOW
:
10490 case BUILT_IN_UADDLL_OVERFLOW
:
10491 case BUILT_IN_USUB_OVERFLOW
:
10492 case BUILT_IN_USUBL_OVERFLOW
:
10493 case BUILT_IN_USUBLL_OVERFLOW
:
10494 case BUILT_IN_UMUL_OVERFLOW
:
10495 case BUILT_IN_UMULL_OVERFLOW
:
10496 case BUILT_IN_UMULLL_OVERFLOW
:
10497 return fold_builtin_arith_overflow (loc
, fcode
, arg0
, arg1
, arg2
);
10505 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10506 arguments. IGNORE is true if the result of the
10507 function call is ignored. This function returns NULL_TREE if no
10508 simplification was possible. */
10511 fold_builtin_n (location_t loc
, tree fndecl
, tree
*args
, int nargs
, bool)
10513 tree ret
= NULL_TREE
;
10518 ret
= fold_builtin_0 (loc
, fndecl
);
10521 ret
= fold_builtin_1 (loc
, fndecl
, args
[0]);
10524 ret
= fold_builtin_2 (loc
, fndecl
, args
[0], args
[1]);
10527 ret
= fold_builtin_3 (loc
, fndecl
, args
[0], args
[1], args
[2]);
10530 ret
= fold_builtin_varargs (loc
, fndecl
, args
, nargs
);
10535 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
10536 SET_EXPR_LOCATION (ret
, loc
);
10537 TREE_NO_WARNING (ret
) = 1;
10543 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10544 list ARGS along with N new arguments in NEWARGS. SKIP is the number
10545 of arguments in ARGS to be omitted. OLDNARGS is the number of
10546 elements in ARGS. */
10549 rewrite_call_expr_valist (location_t loc
, int oldnargs
, tree
*args
,
10550 int skip
, tree fndecl
, int n
, va_list newargs
)
10552 int nargs
= oldnargs
- skip
+ n
;
10559 buffer
= XALLOCAVEC (tree
, nargs
);
10560 for (i
= 0; i
< n
; i
++)
10561 buffer
[i
] = va_arg (newargs
, tree
);
10562 for (j
= skip
; j
< oldnargs
; j
++, i
++)
10563 buffer
[i
] = args
[j
];
10566 buffer
= args
+ skip
;
10568 return build_call_expr_loc_array (loc
, fndecl
, nargs
, buffer
);
10571 /* Return true if FNDECL shouldn't be folded right now.
10572 If a built-in function has an inline attribute always_inline
10573 wrapper, defer folding it after always_inline functions have
10574 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10575 might not be performed. */
10578 avoid_folding_inline_builtin (tree fndecl
)
10580 return (DECL_DECLARED_INLINE_P (fndecl
)
10581 && DECL_DISREGARD_INLINE_LIMITS (fndecl
)
10583 && !cfun
->always_inline_functions_inlined
10584 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl
)));
10587 /* A wrapper function for builtin folding that prevents warnings for
10588 "statement without effect" and the like, caused by removing the
10589 call node earlier than the warning is generated. */
10592 fold_call_expr (location_t loc
, tree exp
, bool ignore
)
10594 tree ret
= NULL_TREE
;
10595 tree fndecl
= get_callee_fndecl (exp
);
10597 && TREE_CODE (fndecl
) == FUNCTION_DECL
10598 && DECL_BUILT_IN (fndecl
)
10599 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10600 yet. Defer folding until we see all the arguments
10601 (after inlining). */
10602 && !CALL_EXPR_VA_ARG_PACK (exp
))
10604 int nargs
= call_expr_nargs (exp
);
10606 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10607 instead last argument is __builtin_va_arg_pack (). Defer folding
10608 even in that case, until arguments are finalized. */
10609 if (nargs
&& TREE_CODE (CALL_EXPR_ARG (exp
, nargs
- 1)) == CALL_EXPR
)
10611 tree fndecl2
= get_callee_fndecl (CALL_EXPR_ARG (exp
, nargs
- 1));
10613 && TREE_CODE (fndecl2
) == FUNCTION_DECL
10614 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
10615 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
10619 if (avoid_folding_inline_builtin (fndecl
))
10622 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10623 return targetm
.fold_builtin (fndecl
, call_expr_nargs (exp
),
10624 CALL_EXPR_ARGP (exp
), ignore
);
10627 tree
*args
= CALL_EXPR_ARGP (exp
);
10628 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
10636 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
10637 N arguments are passed in the array ARGARRAY. Return a folded
10638 expression or NULL_TREE if no simplification was possible. */
10641 fold_builtin_call_array (location_t loc
, tree
,
10646 if (TREE_CODE (fn
) != ADDR_EXPR
)
10649 tree fndecl
= TREE_OPERAND (fn
, 0);
10650 if (TREE_CODE (fndecl
) == FUNCTION_DECL
10651 && DECL_BUILT_IN (fndecl
))
10653 /* If last argument is __builtin_va_arg_pack (), arguments to this
10654 function are not finalized yet. Defer folding until they are. */
10655 if (n
&& TREE_CODE (argarray
[n
- 1]) == CALL_EXPR
)
10657 tree fndecl2
= get_callee_fndecl (argarray
[n
- 1]);
10659 && TREE_CODE (fndecl2
) == FUNCTION_DECL
10660 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
10661 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
10664 if (avoid_folding_inline_builtin (fndecl
))
10666 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10667 return targetm
.fold_builtin (fndecl
, n
, argarray
, false);
10669 return fold_builtin_n (loc
, fndecl
, argarray
, n
, false);
10675 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10676 along with N new arguments specified as the "..." parameters. SKIP
10677 is the number of arguments in EXP to be omitted. This function is used
10678 to do varargs-to-varargs transformations. */
10681 rewrite_call_expr (location_t loc
, tree exp
, int skip
, tree fndecl
, int n
, ...)
10687 t
= rewrite_call_expr_valist (loc
, call_expr_nargs (exp
),
10688 CALL_EXPR_ARGP (exp
), skip
, fndecl
, n
, ap
);
10694 /* Validate a single argument ARG against a tree code CODE representing
10698 validate_arg (const_tree arg
, enum tree_code code
)
10702 else if (code
== POINTER_TYPE
)
10703 return POINTER_TYPE_P (TREE_TYPE (arg
));
10704 else if (code
== INTEGER_TYPE
)
10705 return INTEGRAL_TYPE_P (TREE_TYPE (arg
));
10706 return code
== TREE_CODE (TREE_TYPE (arg
));
10709 /* This function validates the types of a function call argument list
10710 against a specified list of tree_codes. If the last specifier is a 0,
10711 that represents an ellipses, otherwise the last specifier must be a
10714 This is the GIMPLE version of validate_arglist. Eventually we want to
10715 completely convert builtins.c to work from GIMPLEs and the tree based
10716 validate_arglist will then be removed. */
10719 validate_gimple_arglist (const gcall
*call
, ...)
10721 enum tree_code code
;
10727 va_start (ap
, call
);
10732 code
= (enum tree_code
) va_arg (ap
, int);
10736 /* This signifies an ellipses, any further arguments are all ok. */
10740 /* This signifies an endlink, if no arguments remain, return
10741 true, otherwise return false. */
10742 res
= (i
== gimple_call_num_args (call
));
10745 /* If no parameters remain or the parameter's code does not
10746 match the specified code, return false. Otherwise continue
10747 checking any remaining arguments. */
10748 arg
= gimple_call_arg (call
, i
++);
10749 if (!validate_arg (arg
, code
))
10756 /* We need gotos here since we can only have one VA_CLOSE in a
10764 /* Default target-specific builtin expander that does nothing. */
10767 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
10768 rtx target ATTRIBUTE_UNUSED
,
10769 rtx subtarget ATTRIBUTE_UNUSED
,
10770 machine_mode mode ATTRIBUTE_UNUSED
,
10771 int ignore ATTRIBUTE_UNUSED
)
10776 /* Returns true is EXP represents data that would potentially reside
10777 in a readonly section. */
10780 readonly_data_expr (tree exp
)
10784 if (TREE_CODE (exp
) != ADDR_EXPR
)
10787 exp
= get_base_address (TREE_OPERAND (exp
, 0));
10791 /* Make sure we call decl_readonly_section only for trees it
10792 can handle (since it returns true for everything it doesn't
10794 if (TREE_CODE (exp
) == STRING_CST
10795 || TREE_CODE (exp
) == CONSTRUCTOR
10796 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
10797 return decl_readonly_section (exp
, 0);
10802 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
10803 to the call, and TYPE is its return type.
10805 Return NULL_TREE if no simplification was possible, otherwise return the
10806 simplified form of the call as a tree.
10808 The simplified form may be a constant or other expression which
10809 computes the same value, but in a more efficient manner (including
10810 calls to other builtin functions).
10812 The call may contain arguments which need to be evaluated, but
10813 which are not useful to determine the result of the call. In
10814 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10815 COMPOUND_EXPR will be an argument which must be evaluated.
10816 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10817 COMPOUND_EXPR in the chain will contain the tree for the simplified
10818 form of the builtin function call. */
10821 fold_builtin_strstr (location_t loc
, tree s1
, tree s2
, tree type
)
10823 if (!validate_arg (s1
, POINTER_TYPE
)
10824 || !validate_arg (s2
, POINTER_TYPE
))
10829 const char *p1
, *p2
;
10831 p2
= c_getstr (s2
);
10835 p1
= c_getstr (s1
);
10838 const char *r
= strstr (p1
, p2
);
10842 return build_int_cst (TREE_TYPE (s1
), 0);
10844 /* Return an offset into the constant string argument. */
10845 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
10846 return fold_convert_loc (loc
, type
, tem
);
10849 /* The argument is const char *, and the result is char *, so we need
10850 a type conversion here to avoid a warning. */
10852 return fold_convert_loc (loc
, type
, s1
);
10857 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
10861 /* New argument list transforming strstr(s1, s2) to
10862 strchr(s1, s2[0]). */
10863 return build_call_expr_loc (loc
, fn
, 2, s1
,
10864 build_int_cst (integer_type_node
, p2
[0]));
10868 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
10869 the call, and TYPE is its return type.
10871 Return NULL_TREE if no simplification was possible, otherwise return the
10872 simplified form of the call as a tree.
10874 The simplified form may be a constant or other expression which
10875 computes the same value, but in a more efficient manner (including
10876 calls to other builtin functions).
10878 The call may contain arguments which need to be evaluated, but
10879 which are not useful to determine the result of the call. In
10880 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10881 COMPOUND_EXPR will be an argument which must be evaluated.
10882 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10883 COMPOUND_EXPR in the chain will contain the tree for the simplified
10884 form of the builtin function call. */
10887 fold_builtin_strchr (location_t loc
, tree s1
, tree s2
, tree type
)
10889 if (!validate_arg (s1
, POINTER_TYPE
)
10890 || !validate_arg (s2
, INTEGER_TYPE
))
10896 if (TREE_CODE (s2
) != INTEGER_CST
)
10899 p1
= c_getstr (s1
);
10906 if (target_char_cast (s2
, &c
))
10909 r
= strchr (p1
, c
);
10912 return build_int_cst (TREE_TYPE (s1
), 0);
10914 /* Return an offset into the constant string argument. */
10915 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
10916 return fold_convert_loc (loc
, type
, tem
);
10922 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
10923 the call, and TYPE is its return type.
10925 Return NULL_TREE if no simplification was possible, otherwise return the
10926 simplified form of the call as a tree.
10928 The simplified form may be a constant or other expression which
10929 computes the same value, but in a more efficient manner (including
10930 calls to other builtin functions).
10932 The call may contain arguments which need to be evaluated, but
10933 which are not useful to determine the result of the call. In
10934 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10935 COMPOUND_EXPR will be an argument which must be evaluated.
10936 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10937 COMPOUND_EXPR in the chain will contain the tree for the simplified
10938 form of the builtin function call. */
10941 fold_builtin_strrchr (location_t loc
, tree s1
, tree s2
, tree type
)
10943 if (!validate_arg (s1
, POINTER_TYPE
)
10944 || !validate_arg (s2
, INTEGER_TYPE
))
10951 if (TREE_CODE (s2
) != INTEGER_CST
)
10954 p1
= c_getstr (s1
);
10961 if (target_char_cast (s2
, &c
))
10964 r
= strrchr (p1
, c
);
10967 return build_int_cst (TREE_TYPE (s1
), 0);
10969 /* Return an offset into the constant string argument. */
10970 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
10971 return fold_convert_loc (loc
, type
, tem
);
10974 if (! integer_zerop (s2
))
10977 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
10981 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
10982 return build_call_expr_loc (loc
, fn
, 2, s1
, s2
);
10986 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
10987 to the call, and TYPE is its return type.
10989 Return NULL_TREE if no simplification was possible, otherwise return the
10990 simplified form of the call as a tree.
10992 The simplified form may be a constant or other expression which
10993 computes the same value, but in a more efficient manner (including
10994 calls to other builtin functions).
10996 The call may contain arguments which need to be evaluated, but
10997 which are not useful to determine the result of the call. In
10998 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10999 COMPOUND_EXPR will be an argument which must be evaluated.
11000 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11001 COMPOUND_EXPR in the chain will contain the tree for the simplified
11002 form of the builtin function call. */
11005 fold_builtin_strpbrk (location_t loc
, tree s1
, tree s2
, tree type
)
11007 if (!validate_arg (s1
, POINTER_TYPE
)
11008 || !validate_arg (s2
, POINTER_TYPE
))
11013 const char *p1
, *p2
;
11015 p2
= c_getstr (s2
);
11019 p1
= c_getstr (s1
);
11022 const char *r
= strpbrk (p1
, p2
);
11026 return build_int_cst (TREE_TYPE (s1
), 0);
11028 /* Return an offset into the constant string argument. */
11029 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11030 return fold_convert_loc (loc
, type
, tem
);
11034 /* strpbrk(x, "") == NULL.
11035 Evaluate and ignore s1 in case it had side-effects. */
11036 return omit_one_operand_loc (loc
, TREE_TYPE (s1
), integer_zero_node
, s1
);
11039 return NULL_TREE
; /* Really call strpbrk. */
11041 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11045 /* New argument list transforming strpbrk(s1, s2) to
11046 strchr(s1, s2[0]). */
11047 return build_call_expr_loc (loc
, fn
, 2, s1
,
11048 build_int_cst (integer_type_node
, p2
[0]));
11052 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11055 Return NULL_TREE if no simplification was possible, otherwise return the
11056 simplified form of the call as a tree.
11058 The simplified form may be a constant or other expression which
11059 computes the same value, but in a more efficient manner (including
11060 calls to other builtin functions).
11062 The call may contain arguments which need to be evaluated, but
11063 which are not useful to determine the result of the call. In
11064 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11065 COMPOUND_EXPR will be an argument which must be evaluated.
11066 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11067 COMPOUND_EXPR in the chain will contain the tree for the simplified
11068 form of the builtin function call. */
11071 fold_builtin_strspn (location_t loc
, tree s1
, tree s2
)
11073 if (!validate_arg (s1
, POINTER_TYPE
)
11074 || !validate_arg (s2
, POINTER_TYPE
))
11078 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11080 /* If both arguments are constants, evaluate at compile-time. */
11083 const size_t r
= strspn (p1
, p2
);
11084 return build_int_cst (size_type_node
, r
);
11087 /* If either argument is "", return NULL_TREE. */
11088 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
11089 /* Evaluate and ignore both arguments in case either one has
11091 return omit_two_operands_loc (loc
, size_type_node
, size_zero_node
,
11097 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11100 Return NULL_TREE if no simplification was possible, otherwise return the
11101 simplified form of the call as a tree.
11103 The simplified form may be a constant or other expression which
11104 computes the same value, but in a more efficient manner (including
11105 calls to other builtin functions).
11107 The call may contain arguments which need to be evaluated, but
11108 which are not useful to determine the result of the call. In
11109 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11110 COMPOUND_EXPR will be an argument which must be evaluated.
11111 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11112 COMPOUND_EXPR in the chain will contain the tree for the simplified
11113 form of the builtin function call. */
11116 fold_builtin_strcspn (location_t loc
, tree s1
, tree s2
)
11118 if (!validate_arg (s1
, POINTER_TYPE
)
11119 || !validate_arg (s2
, POINTER_TYPE
))
11123 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11125 /* If both arguments are constants, evaluate at compile-time. */
11128 const size_t r
= strcspn (p1
, p2
);
11129 return build_int_cst (size_type_node
, r
);
11132 /* If the first argument is "", return NULL_TREE. */
11133 if (p1
&& *p1
== '\0')
11135 /* Evaluate and ignore argument s2 in case it has
11137 return omit_one_operand_loc (loc
, size_type_node
,
11138 size_zero_node
, s2
);
11141 /* If the second argument is "", return __builtin_strlen(s1). */
11142 if (p2
&& *p2
== '\0')
11144 tree fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
11146 /* If the replacement _DECL isn't initialized, don't do the
11151 return build_call_expr_loc (loc
, fn
, 1, s1
);
11157 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11158 produced. False otherwise. This is done so that we don't output the error
11159 or warning twice or three times. */
11162 fold_builtin_next_arg (tree exp
, bool va_start_p
)
11164 tree fntype
= TREE_TYPE (current_function_decl
);
11165 int nargs
= call_expr_nargs (exp
);
11167 /* There is good chance the current input_location points inside the
11168 definition of the va_start macro (perhaps on the token for
11169 builtin) in a system header, so warnings will not be emitted.
11170 Use the location in real source code. */
11171 source_location current_location
=
11172 linemap_unwind_to_first_non_reserved_loc (line_table
, input_location
,
11175 if (!stdarg_p (fntype
))
11177 error ("%<va_start%> used in function with fixed args");
11183 if (va_start_p
&& (nargs
!= 2))
11185 error ("wrong number of arguments to function %<va_start%>");
11188 arg
= CALL_EXPR_ARG (exp
, 1);
11190 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11191 when we checked the arguments and if needed issued a warning. */
11196 /* Evidently an out of date version of <stdarg.h>; can't validate
11197 va_start's second argument, but can still work as intended. */
11198 warning_at (current_location
,
11200 "%<__builtin_next_arg%> called without an argument");
11203 else if (nargs
> 1)
11205 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11208 arg
= CALL_EXPR_ARG (exp
, 0);
11211 if (TREE_CODE (arg
) == SSA_NAME
)
11212 arg
= SSA_NAME_VAR (arg
);
11214 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11215 or __builtin_next_arg (0) the first time we see it, after checking
11216 the arguments and if needed issuing a warning. */
11217 if (!integer_zerop (arg
))
11219 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
11221 /* Strip off all nops for the sake of the comparison. This
11222 is not quite the same as STRIP_NOPS. It does more.
11223 We must also strip off INDIRECT_EXPR for C++ reference
11225 while (CONVERT_EXPR_P (arg
)
11226 || TREE_CODE (arg
) == INDIRECT_REF
)
11227 arg
= TREE_OPERAND (arg
, 0);
11228 if (arg
!= last_parm
)
11230 /* FIXME: Sometimes with the tree optimizers we can get the
11231 not the last argument even though the user used the last
11232 argument. We just warn and set the arg to be the last
11233 argument so that we will get wrong-code because of
11235 warning_at (current_location
,
11237 "second parameter of %<va_start%> not last named argument");
11240 /* Undefined by C99 7.15.1.4p4 (va_start):
11241 "If the parameter parmN is declared with the register storage
11242 class, with a function or array type, or with a type that is
11243 not compatible with the type that results after application of
11244 the default argument promotions, the behavior is undefined."
11246 else if (DECL_REGISTER (arg
))
11248 warning_at (current_location
,
11250 "undefined behaviour when second parameter of "
11251 "%<va_start%> is declared with %<register%> storage");
11254 /* We want to verify the second parameter just once before the tree
11255 optimizers are run and then avoid keeping it in the tree,
11256 as otherwise we could warn even for correct code like:
11257 void foo (int i, ...)
11258 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11260 CALL_EXPR_ARG (exp
, 1) = integer_zero_node
;
11262 CALL_EXPR_ARG (exp
, 0) = integer_zero_node
;
11268 /* Expand a call EXP to __builtin_object_size. */
11271 expand_builtin_object_size (tree exp
)
11274 int object_size_type
;
11275 tree fndecl
= get_callee_fndecl (exp
);
11277 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11279 error ("%Kfirst argument of %D must be a pointer, second integer constant",
11281 expand_builtin_trap ();
11285 ost
= CALL_EXPR_ARG (exp
, 1);
11288 if (TREE_CODE (ost
) != INTEGER_CST
11289 || tree_int_cst_sgn (ost
) < 0
11290 || compare_tree_int (ost
, 3) > 0)
11292 error ("%Klast argument of %D is not integer constant between 0 and 3",
11294 expand_builtin_trap ();
11298 object_size_type
= tree_to_shwi (ost
);
11300 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
11303 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11304 FCODE is the BUILT_IN_* to use.
11305 Return NULL_RTX if we failed; the caller should emit a normal call,
11306 otherwise try to get the result in TARGET, if convenient (and in
11307 mode MODE if that's convenient). */
11310 expand_builtin_memory_chk (tree exp
, rtx target
, machine_mode mode
,
11311 enum built_in_function fcode
)
11313 tree dest
, src
, len
, size
;
11315 if (!validate_arglist (exp
,
11317 fcode
== BUILT_IN_MEMSET_CHK
11318 ? INTEGER_TYPE
: POINTER_TYPE
,
11319 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11322 dest
= CALL_EXPR_ARG (exp
, 0);
11323 src
= CALL_EXPR_ARG (exp
, 1);
11324 len
= CALL_EXPR_ARG (exp
, 2);
11325 size
= CALL_EXPR_ARG (exp
, 3);
11327 if (! tree_fits_uhwi_p (size
))
11330 if (tree_fits_uhwi_p (len
) || integer_all_onesp (size
))
11334 if (! integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
11336 warning_at (tree_nonartificial_location (exp
),
11337 0, "%Kcall to %D will always overflow destination buffer",
11338 exp
, get_callee_fndecl (exp
));
11343 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11344 mem{cpy,pcpy,move,set} is available. */
11347 case BUILT_IN_MEMCPY_CHK
:
11348 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
11350 case BUILT_IN_MEMPCPY_CHK
:
11351 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
11353 case BUILT_IN_MEMMOVE_CHK
:
11354 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
11356 case BUILT_IN_MEMSET_CHK
:
11357 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
11366 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 3, dest
, src
, len
);
11367 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11368 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11369 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11371 else if (fcode
== BUILT_IN_MEMSET_CHK
)
11375 unsigned int dest_align
= get_pointer_alignment (dest
);
11377 /* If DEST is not a pointer type, call the normal function. */
11378 if (dest_align
== 0)
11381 /* If SRC and DEST are the same (and not volatile), do nothing. */
11382 if (operand_equal_p (src
, dest
, 0))
11386 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
11388 /* Evaluate and ignore LEN in case it has side-effects. */
11389 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
11390 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
11393 expr
= fold_build_pointer_plus (dest
, len
);
11394 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
11397 /* __memmove_chk special case. */
11398 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
11400 unsigned int src_align
= get_pointer_alignment (src
);
11402 if (src_align
== 0)
11405 /* If src is categorized for a readonly section we can use
11406 normal __memcpy_chk. */
11407 if (readonly_data_expr (src
))
11409 tree fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
11412 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 4,
11413 dest
, src
, len
, size
);
11414 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11415 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11416 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11423 /* Emit warning if a buffer overflow is detected at compile time. */
11426 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
11430 location_t loc
= tree_nonartificial_location (exp
);
11434 case BUILT_IN_STRCPY_CHK
:
11435 case BUILT_IN_STPCPY_CHK
:
11436 /* For __strcat_chk the warning will be emitted only if overflowing
11437 by at least strlen (dest) + 1 bytes. */
11438 case BUILT_IN_STRCAT_CHK
:
11439 len
= CALL_EXPR_ARG (exp
, 1);
11440 size
= CALL_EXPR_ARG (exp
, 2);
11443 case BUILT_IN_STRNCAT_CHK
:
11444 case BUILT_IN_STRNCPY_CHK
:
11445 case BUILT_IN_STPNCPY_CHK
:
11446 len
= CALL_EXPR_ARG (exp
, 2);
11447 size
= CALL_EXPR_ARG (exp
, 3);
11449 case BUILT_IN_SNPRINTF_CHK
:
11450 case BUILT_IN_VSNPRINTF_CHK
:
11451 len
= CALL_EXPR_ARG (exp
, 1);
11452 size
= CALL_EXPR_ARG (exp
, 3);
11455 gcc_unreachable ();
11461 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
11466 len
= c_strlen (len
, 1);
11467 if (! len
|| ! tree_fits_uhwi_p (len
) || tree_int_cst_lt (len
, size
))
11470 else if (fcode
== BUILT_IN_STRNCAT_CHK
)
11472 tree src
= CALL_EXPR_ARG (exp
, 1);
11473 if (! src
|| ! tree_fits_uhwi_p (len
) || tree_int_cst_lt (len
, size
))
11475 src
= c_strlen (src
, 1);
11476 if (! src
|| ! tree_fits_uhwi_p (src
))
11478 warning_at (loc
, 0, "%Kcall to %D might overflow destination buffer",
11479 exp
, get_callee_fndecl (exp
));
11482 else if (tree_int_cst_lt (src
, size
))
11485 else if (! tree_fits_uhwi_p (len
) || ! tree_int_cst_lt (size
, len
))
11488 warning_at (loc
, 0, "%Kcall to %D will always overflow destination buffer",
11489 exp
, get_callee_fndecl (exp
));
11492 /* Emit warning if a buffer overflow is detected at compile time
11493 in __sprintf_chk/__vsprintf_chk calls. */
11496 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
11498 tree size
, len
, fmt
;
11499 const char *fmt_str
;
11500 int nargs
= call_expr_nargs (exp
);
11502 /* Verify the required arguments in the original call. */
11506 size
= CALL_EXPR_ARG (exp
, 2);
11507 fmt
= CALL_EXPR_ARG (exp
, 3);
11509 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
11512 /* Check whether the format is a literal string constant. */
11513 fmt_str
= c_getstr (fmt
);
11514 if (fmt_str
== NULL
)
11517 if (!init_target_chars ())
11520 /* If the format doesn't contain % args or %%, we know its size. */
11521 if (strchr (fmt_str
, target_percent
) == 0)
11522 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
11523 /* If the format is "%s" and first ... argument is a string literal,
11525 else if (fcode
== BUILT_IN_SPRINTF_CHK
11526 && strcmp (fmt_str
, target_percent_s
) == 0)
11532 arg
= CALL_EXPR_ARG (exp
, 4);
11533 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
11536 len
= c_strlen (arg
, 1);
11537 if (!len
|| ! tree_fits_uhwi_p (len
))
11543 if (! tree_int_cst_lt (len
, size
))
11544 warning_at (tree_nonartificial_location (exp
),
11545 0, "%Kcall to %D will always overflow destination buffer",
11546 exp
, get_callee_fndecl (exp
));
11549 /* Emit warning if a free is called with address of a variable. */
11552 maybe_emit_free_warning (tree exp
)
11554 tree arg
= CALL_EXPR_ARG (exp
, 0);
11557 if (TREE_CODE (arg
) != ADDR_EXPR
)
11560 arg
= get_base_address (TREE_OPERAND (arg
, 0));
11561 if (arg
== NULL
|| INDIRECT_REF_P (arg
) || TREE_CODE (arg
) == MEM_REF
)
11564 if (SSA_VAR_P (arg
))
11565 warning_at (tree_nonartificial_location (exp
), OPT_Wfree_nonheap_object
,
11566 "%Kattempt to free a non-heap object %qD", exp
, arg
);
11568 warning_at (tree_nonartificial_location (exp
), OPT_Wfree_nonheap_object
,
11569 "%Kattempt to free a non-heap object", exp
);
11572 /* Fold a call to __builtin_object_size with arguments PTR and OST,
11576 fold_builtin_object_size (tree ptr
, tree ost
)
11578 unsigned HOST_WIDE_INT bytes
;
11579 int object_size_type
;
11581 if (!validate_arg (ptr
, POINTER_TYPE
)
11582 || !validate_arg (ost
, INTEGER_TYPE
))
11587 if (TREE_CODE (ost
) != INTEGER_CST
11588 || tree_int_cst_sgn (ost
) < 0
11589 || compare_tree_int (ost
, 3) > 0)
11592 object_size_type
= tree_to_shwi (ost
);
11594 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
11595 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
11596 and (size_t) 0 for types 2 and 3. */
11597 if (TREE_SIDE_EFFECTS (ptr
))
11598 return build_int_cst_type (size_type_node
, object_size_type
< 2 ? -1 : 0);
11600 if (TREE_CODE (ptr
) == ADDR_EXPR
)
11602 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
11603 if (wi::fits_to_tree_p (bytes
, size_type_node
))
11604 return build_int_cstu (size_type_node
, bytes
);
11606 else if (TREE_CODE (ptr
) == SSA_NAME
)
11608 /* If object size is not known yet, delay folding until
11609 later. Maybe subsequent passes will help determining
11611 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
11612 if (bytes
!= (unsigned HOST_WIDE_INT
) (object_size_type
< 2 ? -1 : 0)
11613 && wi::fits_to_tree_p (bytes
, size_type_node
))
11614 return build_int_cstu (size_type_node
, bytes
);
11620 /* Builtins with folding operations that operate on "..." arguments
11621 need special handling; we need to store the arguments in a convenient
11622 data structure before attempting any folding. Fortunately there are
11623 only a few builtins that fall into this category. FNDECL is the
11624 function, EXP is the CALL_EXPR for the call. */
11627 fold_builtin_varargs (location_t loc
, tree fndecl
, tree
*args
, int nargs
)
11629 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
11630 tree ret
= NULL_TREE
;
11634 case BUILT_IN_FPCLASSIFY
:
11635 ret
= fold_builtin_fpclassify (loc
, args
, nargs
);
11643 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
11644 SET_EXPR_LOCATION (ret
, loc
);
11645 TREE_NO_WARNING (ret
) = 1;
11651 /* Initialize format string characters in the target charset. */
11654 init_target_chars (void)
11659 target_newline
= lang_hooks
.to_target_charset ('\n');
11660 target_percent
= lang_hooks
.to_target_charset ('%');
11661 target_c
= lang_hooks
.to_target_charset ('c');
11662 target_s
= lang_hooks
.to_target_charset ('s');
11663 if (target_newline
== 0 || target_percent
== 0 || target_c
== 0
11667 target_percent_c
[0] = target_percent
;
11668 target_percent_c
[1] = target_c
;
11669 target_percent_c
[2] = '\0';
11671 target_percent_s
[0] = target_percent
;
11672 target_percent_s
[1] = target_s
;
11673 target_percent_s
[2] = '\0';
11675 target_percent_s_newline
[0] = target_percent
;
11676 target_percent_s_newline
[1] = target_s
;
11677 target_percent_s_newline
[2] = target_newline
;
11678 target_percent_s_newline
[3] = '\0';
11685 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
11686 and no overflow/underflow occurred. INEXACT is true if M was not
11687 exactly calculated. TYPE is the tree type for the result. This
11688 function assumes that you cleared the MPFR flags and then
11689 calculated M to see if anything subsequently set a flag prior to
11690 entering this function. Return NULL_TREE if any checks fail. */
11693 do_mpfr_ckconv (mpfr_srcptr m
, tree type
, int inexact
)
11695 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
11696 overflow/underflow occurred. If -frounding-math, proceed iff the
11697 result of calling FUNC was exact. */
11698 if (mpfr_number_p (m
) && !mpfr_overflow_p () && !mpfr_underflow_p ()
11699 && (!flag_rounding_math
|| !inexact
))
11701 REAL_VALUE_TYPE rr
;
11703 real_from_mpfr (&rr
, m
, type
, GMP_RNDN
);
11704 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
11705 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
11706 but the mpft_t is not, then we underflowed in the
11708 if (real_isfinite (&rr
)
11709 && (rr
.cl
== rvc_zero
) == (mpfr_zero_p (m
) != 0))
11711 REAL_VALUE_TYPE rmode
;
11713 real_convert (&rmode
, TYPE_MODE (type
), &rr
);
11714 /* Proceed iff the specified mode can hold the value. */
11715 if (real_identical (&rmode
, &rr
))
11716 return build_real (type
, rmode
);
11722 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
11723 number and no overflow/underflow occurred. INEXACT is true if M
11724 was not exactly calculated. TYPE is the tree type for the result.
11725 This function assumes that you cleared the MPFR flags and then
11726 calculated M to see if anything subsequently set a flag prior to
11727 entering this function. Return NULL_TREE if any checks fail, if
11728 FORCE_CONVERT is true, then bypass the checks. */
11731 do_mpc_ckconv (mpc_srcptr m
, tree type
, int inexact
, int force_convert
)
11733 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
11734 overflow/underflow occurred. If -frounding-math, proceed iff the
11735 result of calling FUNC was exact. */
11737 || (mpfr_number_p (mpc_realref (m
)) && mpfr_number_p (mpc_imagref (m
))
11738 && !mpfr_overflow_p () && !mpfr_underflow_p ()
11739 && (!flag_rounding_math
|| !inexact
)))
11741 REAL_VALUE_TYPE re
, im
;
11743 real_from_mpfr (&re
, mpc_realref (m
), TREE_TYPE (type
), GMP_RNDN
);
11744 real_from_mpfr (&im
, mpc_imagref (m
), TREE_TYPE (type
), GMP_RNDN
);
11745 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
11746 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
11747 but the mpft_t is not, then we underflowed in the
11750 || (real_isfinite (&re
) && real_isfinite (&im
)
11751 && (re
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_realref (m
)) != 0)
11752 && (im
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_imagref (m
)) != 0)))
11754 REAL_VALUE_TYPE re_mode
, im_mode
;
11756 real_convert (&re_mode
, TYPE_MODE (TREE_TYPE (type
)), &re
);
11757 real_convert (&im_mode
, TYPE_MODE (TREE_TYPE (type
)), &im
);
11758 /* Proceed iff the specified mode can hold the value. */
11760 || (real_identical (&re_mode
, &re
)
11761 && real_identical (&im_mode
, &im
)))
11762 return build_complex (type
, build_real (TREE_TYPE (type
), re_mode
),
11763 build_real (TREE_TYPE (type
), im_mode
));
11769 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
11770 FUNC on it and return the resulting value as a tree with type TYPE.
11771 If MIN and/or MAX are not NULL, then the supplied ARG must be
11772 within those bounds. If INCLUSIVE is true, then MIN/MAX are
11773 acceptable values, otherwise they are not. The mpfr precision is
11774 set to the precision of TYPE. We assume that function FUNC returns
11775 zero if the result could be calculated exactly within the requested
11779 do_mpfr_arg1 (tree arg
, tree type
, int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
11780 const REAL_VALUE_TYPE
*min
, const REAL_VALUE_TYPE
*max
,
11783 tree result
= NULL_TREE
;
11787 /* To proceed, MPFR must exactly represent the target floating point
11788 format, which only happens when the target base equals two. */
11789 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11790 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
11792 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
11794 if (real_isfinite (ra
)
11795 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
))
11796 && (!max
|| real_compare (inclusive
? LE_EXPR
: LT_EXPR
, ra
, max
)))
11798 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11799 const int prec
= fmt
->p
;
11800 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11804 mpfr_init2 (m
, prec
);
11805 mpfr_from_real (m
, ra
, GMP_RNDN
);
11806 mpfr_clear_flags ();
11807 inexact
= func (m
, m
, rnd
);
11808 result
= do_mpfr_ckconv (m
, type
, inexact
);
11816 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
11817 FUNC on it and return the resulting value as a tree with type TYPE.
11818 The mpfr precision is set to the precision of TYPE. We assume that
11819 function FUNC returns zero if the result could be calculated
11820 exactly within the requested precision. */
11823 do_mpfr_arg2 (tree arg1
, tree arg2
, tree type
,
11824 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
11826 tree result
= NULL_TREE
;
11831 /* To proceed, MPFR must exactly represent the target floating point
11832 format, which only happens when the target base equals two. */
11833 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11834 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
11835 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
11837 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
11838 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
11840 if (real_isfinite (ra1
) && real_isfinite (ra2
))
11842 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11843 const int prec
= fmt
->p
;
11844 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11848 mpfr_inits2 (prec
, m1
, m2
, NULL
);
11849 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
11850 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
11851 mpfr_clear_flags ();
11852 inexact
= func (m1
, m1
, m2
, rnd
);
11853 result
= do_mpfr_ckconv (m1
, type
, inexact
);
11854 mpfr_clears (m1
, m2
, NULL
);
11861 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
11862 FUNC on it and return the resulting value as a tree with type TYPE.
11863 The mpfr precision is set to the precision of TYPE. We assume that
11864 function FUNC returns zero if the result could be calculated
11865 exactly within the requested precision. */
11868 do_mpfr_arg3 (tree arg1
, tree arg2
, tree arg3
, tree type
,
11869 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
11871 tree result
= NULL_TREE
;
11877 /* To proceed, MPFR must exactly represent the target floating point
11878 format, which only happens when the target base equals two. */
11879 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11880 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
11881 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
)
11882 && TREE_CODE (arg3
) == REAL_CST
&& !TREE_OVERFLOW (arg3
))
11884 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
11885 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
11886 const REAL_VALUE_TYPE
*const ra3
= &TREE_REAL_CST (arg3
);
11888 if (real_isfinite (ra1
) && real_isfinite (ra2
) && real_isfinite (ra3
))
11890 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11891 const int prec
= fmt
->p
;
11892 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11896 mpfr_inits2 (prec
, m1
, m2
, m3
, NULL
);
11897 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
11898 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
11899 mpfr_from_real (m3
, ra3
, GMP_RNDN
);
11900 mpfr_clear_flags ();
11901 inexact
= func (m1
, m1
, m2
, m3
, rnd
);
11902 result
= do_mpfr_ckconv (m1
, type
, inexact
);
11903 mpfr_clears (m1
, m2
, m3
, NULL
);
11910 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
11911 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
11912 If ARG_SINP and ARG_COSP are NULL then the result is returned
11913 as a complex value.
11914 The type is taken from the type of ARG and is used for setting the
11915 precision of the calculation and results. */
11918 do_mpfr_sincos (tree arg
, tree arg_sinp
, tree arg_cosp
)
11920 tree
const type
= TREE_TYPE (arg
);
11921 tree result
= NULL_TREE
;
11925 /* To proceed, MPFR must exactly represent the target floating point
11926 format, which only happens when the target base equals two. */
11927 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11928 && TREE_CODE (arg
) == REAL_CST
11929 && !TREE_OVERFLOW (arg
))
11931 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
11933 if (real_isfinite (ra
))
11935 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11936 const int prec
= fmt
->p
;
11937 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11938 tree result_s
, result_c
;
11942 mpfr_inits2 (prec
, m
, ms
, mc
, NULL
);
11943 mpfr_from_real (m
, ra
, GMP_RNDN
);
11944 mpfr_clear_flags ();
11945 inexact
= mpfr_sin_cos (ms
, mc
, m
, rnd
);
11946 result_s
= do_mpfr_ckconv (ms
, type
, inexact
);
11947 result_c
= do_mpfr_ckconv (mc
, type
, inexact
);
11948 mpfr_clears (m
, ms
, mc
, NULL
);
11949 if (result_s
&& result_c
)
11951 /* If we are to return in a complex value do so. */
11952 if (!arg_sinp
&& !arg_cosp
)
11953 return build_complex (build_complex_type (type
),
11954 result_c
, result_s
);
11956 /* Dereference the sin/cos pointer arguments. */
11957 arg_sinp
= build_fold_indirect_ref (arg_sinp
);
11958 arg_cosp
= build_fold_indirect_ref (arg_cosp
);
11959 /* Proceed if valid pointer type were passed in. */
11960 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp
)) == TYPE_MAIN_VARIANT (type
)
11961 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp
)) == TYPE_MAIN_VARIANT (type
))
11963 /* Set the values. */
11964 result_s
= fold_build2 (MODIFY_EXPR
, type
, arg_sinp
,
11966 TREE_SIDE_EFFECTS (result_s
) = 1;
11967 result_c
= fold_build2 (MODIFY_EXPR
, type
, arg_cosp
,
11969 TREE_SIDE_EFFECTS (result_c
) = 1;
11970 /* Combine the assignments into a compound expr. */
11971 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
11972 result_s
, result_c
));
11980 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
11981 two-argument mpfr order N Bessel function FUNC on them and return
11982 the resulting value as a tree with type TYPE. The mpfr precision
11983 is set to the precision of TYPE. We assume that function FUNC
11984 returns zero if the result could be calculated exactly within the
11985 requested precision. */
11987 do_mpfr_bessel_n (tree arg1
, tree arg2
, tree type
,
11988 int (*func
)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
11989 const REAL_VALUE_TYPE
*min
, bool inclusive
)
11991 tree result
= NULL_TREE
;
11996 /* To proceed, MPFR must exactly represent the target floating point
11997 format, which only happens when the target base equals two. */
11998 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11999 && tree_fits_shwi_p (arg1
)
12000 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
12002 const HOST_WIDE_INT n
= tree_to_shwi (arg1
);
12003 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg2
);
12006 && real_isfinite (ra
)
12007 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
)))
12009 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
12010 const int prec
= fmt
->p
;
12011 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12015 mpfr_init2 (m
, prec
);
12016 mpfr_from_real (m
, ra
, GMP_RNDN
);
12017 mpfr_clear_flags ();
12018 inexact
= func (m
, n
, m
, rnd
);
12019 result
= do_mpfr_ckconv (m
, type
, inexact
);
12027 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
12028 the pointer *(ARG_QUO) and return the result. The type is taken
12029 from the type of ARG0 and is used for setting the precision of the
12030 calculation and results. */
12033 do_mpfr_remquo (tree arg0
, tree arg1
, tree arg_quo
)
12035 tree
const type
= TREE_TYPE (arg0
);
12036 tree result
= NULL_TREE
;
12041 /* To proceed, MPFR must exactly represent the target floating point
12042 format, which only happens when the target base equals two. */
12043 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
12044 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
12045 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
))
12047 const REAL_VALUE_TYPE
*const ra0
= TREE_REAL_CST_PTR (arg0
);
12048 const REAL_VALUE_TYPE
*const ra1
= TREE_REAL_CST_PTR (arg1
);
12050 if (real_isfinite (ra0
) && real_isfinite (ra1
))
12052 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
12053 const int prec
= fmt
->p
;
12054 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12059 mpfr_inits2 (prec
, m0
, m1
, NULL
);
12060 mpfr_from_real (m0
, ra0
, GMP_RNDN
);
12061 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
12062 mpfr_clear_flags ();
12063 mpfr_remquo (m0
, &integer_quo
, m0
, m1
, rnd
);
12064 /* Remquo is independent of the rounding mode, so pass
12065 inexact=0 to do_mpfr_ckconv(). */
12066 result_rem
= do_mpfr_ckconv (m0
, type
, /*inexact=*/ 0);
12067 mpfr_clears (m0
, m1
, NULL
);
12070 /* MPFR calculates quo in the host's long so it may
12071 return more bits in quo than the target int can hold
12072 if sizeof(host long) > sizeof(target int). This can
12073 happen even for native compilers in LP64 mode. In
12074 these cases, modulo the quo value with the largest
12075 number that the target int can hold while leaving one
12076 bit for the sign. */
12077 if (sizeof (integer_quo
) * CHAR_BIT
> INT_TYPE_SIZE
)
12078 integer_quo
%= (long)(1UL << (INT_TYPE_SIZE
- 1));
12080 /* Dereference the quo pointer argument. */
12081 arg_quo
= build_fold_indirect_ref (arg_quo
);
12082 /* Proceed iff a valid pointer type was passed in. */
12083 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo
)) == integer_type_node
)
12085 /* Set the value. */
12087 = fold_build2 (MODIFY_EXPR
, TREE_TYPE (arg_quo
), arg_quo
,
12088 build_int_cst (TREE_TYPE (arg_quo
),
12090 TREE_SIDE_EFFECTS (result_quo
) = 1;
12091 /* Combine the quo assignment with the rem. */
12092 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
12093 result_quo
, result_rem
));
12101 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
12102 resulting value as a tree with type TYPE. The mpfr precision is
12103 set to the precision of TYPE. We assume that this mpfr function
12104 returns zero if the result could be calculated exactly within the
12105 requested precision. In addition, the integer pointer represented
12106 by ARG_SG will be dereferenced and set to the appropriate signgam
12110 do_mpfr_lgamma_r (tree arg
, tree arg_sg
, tree type
)
12112 tree result
= NULL_TREE
;
12116 /* To proceed, MPFR must exactly represent the target floating point
12117 format, which only happens when the target base equals two. Also
12118 verify ARG is a constant and that ARG_SG is an int pointer. */
12119 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
12120 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
)
12121 && TREE_CODE (TREE_TYPE (arg_sg
)) == POINTER_TYPE
12122 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg
))) == integer_type_node
)
12124 const REAL_VALUE_TYPE
*const ra
= TREE_REAL_CST_PTR (arg
);
12126 /* In addition to NaN and Inf, the argument cannot be zero or a
12127 negative integer. */
12128 if (real_isfinite (ra
)
12129 && ra
->cl
!= rvc_zero
12130 && !(real_isneg (ra
) && real_isinteger (ra
, TYPE_MODE (type
))))
12132 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
12133 const int prec
= fmt
->p
;
12134 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12139 mpfr_init2 (m
, prec
);
12140 mpfr_from_real (m
, ra
, GMP_RNDN
);
12141 mpfr_clear_flags ();
12142 inexact
= mpfr_lgamma (m
, &sg
, m
, rnd
);
12143 result_lg
= do_mpfr_ckconv (m
, type
, inexact
);
12149 /* Dereference the arg_sg pointer argument. */
12150 arg_sg
= build_fold_indirect_ref (arg_sg
);
12151 /* Assign the signgam value into *arg_sg. */
12152 result_sg
= fold_build2 (MODIFY_EXPR
,
12153 TREE_TYPE (arg_sg
), arg_sg
,
12154 build_int_cst (TREE_TYPE (arg_sg
), sg
));
12155 TREE_SIDE_EFFECTS (result_sg
) = 1;
12156 /* Combine the signgam assignment with the lgamma result. */
12157 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
12158 result_sg
, result_lg
));
12166 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
12167 function FUNC on it and return the resulting value as a tree with
12168 type TYPE. The mpfr precision is set to the precision of TYPE. We
12169 assume that function FUNC returns zero if the result could be
12170 calculated exactly within the requested precision. */
12173 do_mpc_arg1 (tree arg
, tree type
, int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
))
12175 tree result
= NULL_TREE
;
12179 /* To proceed, MPFR must exactly represent the target floating point
12180 format, which only happens when the target base equals two. */
12181 if (TREE_CODE (arg
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg
)
12182 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
12183 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg
))))->b
== 2)
12185 const REAL_VALUE_TYPE
*const re
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
12186 const REAL_VALUE_TYPE
*const im
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
12188 if (real_isfinite (re
) && real_isfinite (im
))
12190 const struct real_format
*const fmt
=
12191 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
12192 const int prec
= fmt
->p
;
12193 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12194 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
12198 mpc_init2 (m
, prec
);
12199 mpfr_from_real (mpc_realref (m
), re
, rnd
);
12200 mpfr_from_real (mpc_imagref (m
), im
, rnd
);
12201 mpfr_clear_flags ();
12202 inexact
= func (m
, m
, crnd
);
12203 result
= do_mpc_ckconv (m
, type
, inexact
, /*force_convert=*/ 0);
12211 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
12212 mpc function FUNC on it and return the resulting value as a tree
12213 with type TYPE. The mpfr precision is set to the precision of
12214 TYPE. We assume that function FUNC returns zero if the result
12215 could be calculated exactly within the requested precision. If
12216 DO_NONFINITE is true, then fold expressions containing Inf or NaN
12217 in the arguments and/or results. */
12220 do_mpc_arg2 (tree arg0
, tree arg1
, tree type
, int do_nonfinite
,
12221 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
))
12223 tree result
= NULL_TREE
;
12228 /* To proceed, MPFR must exactly represent the target floating point
12229 format, which only happens when the target base equals two. */
12230 if (TREE_CODE (arg0
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg0
)
12231 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
12232 && TREE_CODE (arg1
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg1
)
12233 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
12234 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0
))))->b
== 2)
12236 const REAL_VALUE_TYPE
*const re0
= TREE_REAL_CST_PTR (TREE_REALPART (arg0
));
12237 const REAL_VALUE_TYPE
*const im0
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg0
));
12238 const REAL_VALUE_TYPE
*const re1
= TREE_REAL_CST_PTR (TREE_REALPART (arg1
));
12239 const REAL_VALUE_TYPE
*const im1
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg1
));
12242 || (real_isfinite (re0
) && real_isfinite (im0
)
12243 && real_isfinite (re1
) && real_isfinite (im1
)))
12245 const struct real_format
*const fmt
=
12246 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
12247 const int prec
= fmt
->p
;
12248 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12249 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
12253 mpc_init2 (m0
, prec
);
12254 mpc_init2 (m1
, prec
);
12255 mpfr_from_real (mpc_realref (m0
), re0
, rnd
);
12256 mpfr_from_real (mpc_imagref (m0
), im0
, rnd
);
12257 mpfr_from_real (mpc_realref (m1
), re1
, rnd
);
12258 mpfr_from_real (mpc_imagref (m1
), im1
, rnd
);
12259 mpfr_clear_flags ();
12260 inexact
= func (m0
, m0
, m1
, crnd
);
12261 result
= do_mpc_ckconv (m0
, type
, inexact
, do_nonfinite
);
12270 /* A wrapper function for builtin folding that prevents warnings for
12271 "statement without effect" and the like, caused by removing the
12272 call node earlier than the warning is generated. */
12275 fold_call_stmt (gcall
*stmt
, bool ignore
)
12277 tree ret
= NULL_TREE
;
12278 tree fndecl
= gimple_call_fndecl (stmt
);
12279 location_t loc
= gimple_location (stmt
);
12281 && TREE_CODE (fndecl
) == FUNCTION_DECL
12282 && DECL_BUILT_IN (fndecl
)
12283 && !gimple_call_va_arg_pack_p (stmt
))
12285 int nargs
= gimple_call_num_args (stmt
);
12286 tree
*args
= (nargs
> 0
12287 ? gimple_call_arg_ptr (stmt
, 0)
12288 : &error_mark_node
);
12290 if (avoid_folding_inline_builtin (fndecl
))
12292 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
12294 return targetm
.fold_builtin (fndecl
, nargs
, args
, ignore
);
12298 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
12301 /* Propagate location information from original call to
12302 expansion of builtin. Otherwise things like
12303 maybe_emit_chk_warning, that operate on the expansion
12304 of a builtin, will use the wrong location information. */
12305 if (gimple_has_location (stmt
))
12307 tree realret
= ret
;
12308 if (TREE_CODE (ret
) == NOP_EXPR
)
12309 realret
= TREE_OPERAND (ret
, 0);
12310 if (CAN_HAVE_LOCATION_P (realret
)
12311 && !EXPR_HAS_LOCATION (realret
))
12312 SET_EXPR_LOCATION (realret
, loc
);
12322 /* Look up the function in builtin_decl that corresponds to DECL
12323 and set ASMSPEC as its user assembler name. DECL must be a
12324 function decl that declares a builtin. */
12327 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
12330 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
12331 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
12334 builtin
= builtin_decl_explicit (DECL_FUNCTION_CODE (decl
));
12335 set_user_assembler_name (builtin
, asmspec
);
12336 switch (DECL_FUNCTION_CODE (decl
))
12338 case BUILT_IN_MEMCPY
:
12339 init_block_move_fn (asmspec
);
12340 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
12342 case BUILT_IN_MEMSET
:
12343 init_block_clear_fn (asmspec
);
12344 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
12346 case BUILT_IN_MEMMOVE
:
12347 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
12349 case BUILT_IN_MEMCMP
:
12350 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
12352 case BUILT_IN_ABORT
:
12353 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
12356 if (INT_TYPE_SIZE
< BITS_PER_WORD
)
12358 set_user_assembler_libfunc ("ffs", asmspec
);
12359 set_optab_libfunc (ffs_optab
, mode_for_size (INT_TYPE_SIZE
,
12360 MODE_INT
, 0), "ffs");
12368 /* Return true if DECL is a builtin that expands to a constant or similarly
12371 is_simple_builtin (tree decl
)
12373 if (decl
&& DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
12374 switch (DECL_FUNCTION_CODE (decl
))
12376 /* Builtins that expand to constants. */
12377 case BUILT_IN_CONSTANT_P
:
12378 case BUILT_IN_EXPECT
:
12379 case BUILT_IN_OBJECT_SIZE
:
12380 case BUILT_IN_UNREACHABLE
:
12381 /* Simple register moves or loads from stack. */
12382 case BUILT_IN_ASSUME_ALIGNED
:
12383 case BUILT_IN_RETURN_ADDRESS
:
12384 case BUILT_IN_EXTRACT_RETURN_ADDR
:
12385 case BUILT_IN_FROB_RETURN_ADDR
:
12386 case BUILT_IN_RETURN
:
12387 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
12388 case BUILT_IN_FRAME_ADDRESS
:
12389 case BUILT_IN_VA_END
:
12390 case BUILT_IN_STACK_SAVE
:
12391 case BUILT_IN_STACK_RESTORE
:
12392 /* Exception state returns or moves registers around. */
12393 case BUILT_IN_EH_FILTER
:
12394 case BUILT_IN_EH_POINTER
:
12395 case BUILT_IN_EH_COPY_VALUES
:
12405 /* Return true if DECL is a builtin that is not expensive, i.e., they are
12406 most probably expanded inline into reasonably simple code. This is a
12407 superset of is_simple_builtin. */
12409 is_inexpensive_builtin (tree decl
)
12413 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_MD
)
12415 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
12416 switch (DECL_FUNCTION_CODE (decl
))
12419 case BUILT_IN_ALLOCA
:
12420 case BUILT_IN_ALLOCA_WITH_ALIGN
:
12421 case BUILT_IN_BSWAP16
:
12422 case BUILT_IN_BSWAP32
:
12423 case BUILT_IN_BSWAP64
:
12425 case BUILT_IN_CLZIMAX
:
12426 case BUILT_IN_CLZL
:
12427 case BUILT_IN_CLZLL
:
12429 case BUILT_IN_CTZIMAX
:
12430 case BUILT_IN_CTZL
:
12431 case BUILT_IN_CTZLL
:
12433 case BUILT_IN_FFSIMAX
:
12434 case BUILT_IN_FFSL
:
12435 case BUILT_IN_FFSLL
:
12436 case BUILT_IN_IMAXABS
:
12437 case BUILT_IN_FINITE
:
12438 case BUILT_IN_FINITEF
:
12439 case BUILT_IN_FINITEL
:
12440 case BUILT_IN_FINITED32
:
12441 case BUILT_IN_FINITED64
:
12442 case BUILT_IN_FINITED128
:
12443 case BUILT_IN_FPCLASSIFY
:
12444 case BUILT_IN_ISFINITE
:
12445 case BUILT_IN_ISINF_SIGN
:
12446 case BUILT_IN_ISINF
:
12447 case BUILT_IN_ISINFF
:
12448 case BUILT_IN_ISINFL
:
12449 case BUILT_IN_ISINFD32
:
12450 case BUILT_IN_ISINFD64
:
12451 case BUILT_IN_ISINFD128
:
12452 case BUILT_IN_ISNAN
:
12453 case BUILT_IN_ISNANF
:
12454 case BUILT_IN_ISNANL
:
12455 case BUILT_IN_ISNAND32
:
12456 case BUILT_IN_ISNAND64
:
12457 case BUILT_IN_ISNAND128
:
12458 case BUILT_IN_ISNORMAL
:
12459 case BUILT_IN_ISGREATER
:
12460 case BUILT_IN_ISGREATEREQUAL
:
12461 case BUILT_IN_ISLESS
:
12462 case BUILT_IN_ISLESSEQUAL
:
12463 case BUILT_IN_ISLESSGREATER
:
12464 case BUILT_IN_ISUNORDERED
:
12465 case BUILT_IN_VA_ARG_PACK
:
12466 case BUILT_IN_VA_ARG_PACK_LEN
:
12467 case BUILT_IN_VA_COPY
:
12468 case BUILT_IN_TRAP
:
12469 case BUILT_IN_SAVEREGS
:
12470 case BUILT_IN_POPCOUNTL
:
12471 case BUILT_IN_POPCOUNTLL
:
12472 case BUILT_IN_POPCOUNTIMAX
:
12473 case BUILT_IN_POPCOUNT
:
12474 case BUILT_IN_PARITYL
:
12475 case BUILT_IN_PARITYLL
:
12476 case BUILT_IN_PARITYIMAX
:
12477 case BUILT_IN_PARITY
:
12478 case BUILT_IN_LABS
:
12479 case BUILT_IN_LLABS
:
12480 case BUILT_IN_PREFETCH
:
12484 return is_simple_builtin (decl
);