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"
87 #include "gomp-constants.h"
90 static tree
do_mpc_arg1 (tree
, tree
, int (*)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
));
92 struct target_builtins default_target_builtins
;
94 struct target_builtins
*this_target_builtins
= &default_target_builtins
;
97 /* Define the names of the builtin function types and codes. */
98 const char *const built_in_class_names
[BUILT_IN_LAST
]
99 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
101 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
102 const char * built_in_names
[(int) END_BUILTINS
] =
104 #include "builtins.def"
108 /* Setup an array of builtin_info_type, make sure each element decl is
109 initialized to NULL_TREE. */
110 builtin_info_type builtin_info
[(int)END_BUILTINS
];
112 /* Non-zero if __builtin_constant_p should be folded right away. */
113 bool force_folding_builtin_constant_p
;
115 static rtx
c_readstr (const char *, machine_mode
);
116 static int target_char_cast (tree
, char *);
117 static rtx
get_memory_rtx (tree
, tree
);
118 static int apply_args_size (void);
119 static int apply_result_size (void);
120 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
121 static rtx
result_vector (int, 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
;
361 unsigned HOST_WIDE_INT ptr_bitmask
= ~0;
363 /* If the address is explicitely aligned, handle that. */
364 if (TREE_CODE (addr
) == BIT_AND_EXPR
365 && TREE_CODE (TREE_OPERAND (addr
, 1)) == INTEGER_CST
)
367 ptr_bitmask
= TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1));
368 ptr_bitmask
*= BITS_PER_UNIT
;
369 align
= ptr_bitmask
& -ptr_bitmask
;
370 addr
= TREE_OPERAND (addr
, 0);
374 = get_pointer_alignment_1 (addr
, &ptr_align
, &ptr_bitpos
);
375 align
= MAX (ptr_align
, align
);
377 /* Re-apply explicit alignment to the bitpos. */
378 ptr_bitpos
&= ptr_bitmask
;
380 /* The alignment of the pointer operand in a TARGET_MEM_REF
381 has to take the variable offset parts into account. */
382 if (TREE_CODE (exp
) == TARGET_MEM_REF
)
386 unsigned HOST_WIDE_INT step
= 1;
388 step
= TREE_INT_CST_LOW (TMR_STEP (exp
));
389 align
= MIN (align
, (step
& -step
) * BITS_PER_UNIT
);
391 if (TMR_INDEX2 (exp
))
392 align
= BITS_PER_UNIT
;
393 known_alignment
= false;
396 /* When EXP is an actual memory reference then we can use
397 TYPE_ALIGN of a pointer indirection to derive alignment.
398 Do so only if get_pointer_alignment_1 did not reveal absolute
399 alignment knowledge and if using that alignment would
400 improve the situation. */
401 if (!addr_p
&& !known_alignment
402 && TYPE_ALIGN (TREE_TYPE (exp
)) > align
)
403 align
= TYPE_ALIGN (TREE_TYPE (exp
));
406 /* Else adjust bitpos accordingly. */
407 bitpos
+= ptr_bitpos
;
408 if (TREE_CODE (exp
) == MEM_REF
409 || TREE_CODE (exp
) == TARGET_MEM_REF
)
410 bitpos
+= mem_ref_offset (exp
).to_short_addr () * BITS_PER_UNIT
;
413 else if (TREE_CODE (exp
) == STRING_CST
)
415 /* STRING_CST are the only constant objects we allow to be not
416 wrapped inside a CONST_DECL. */
417 align
= TYPE_ALIGN (TREE_TYPE (exp
));
418 #ifdef CONSTANT_ALIGNMENT
419 if (CONSTANT_CLASS_P (exp
))
420 align
= (unsigned) CONSTANT_ALIGNMENT (exp
, align
);
422 known_alignment
= true;
425 /* If there is a non-constant offset part extract the maximum
426 alignment that can prevail. */
429 unsigned int trailing_zeros
= tree_ctz (offset
);
430 if (trailing_zeros
< HOST_BITS_PER_INT
)
432 unsigned int inner
= (1U << trailing_zeros
) * BITS_PER_UNIT
;
434 align
= MIN (align
, inner
);
439 *bitposp
= bitpos
& (*alignp
- 1);
440 return known_alignment
;
443 /* For a memory reference expression EXP compute values M and N such that M
444 divides (&EXP - N) and such that N < M. If these numbers can be determined,
445 store M in alignp and N in *BITPOSP and return true. Otherwise return false
446 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
449 get_object_alignment_1 (tree exp
, unsigned int *alignp
,
450 unsigned HOST_WIDE_INT
*bitposp
)
452 return get_object_alignment_2 (exp
, alignp
, bitposp
, false);
455 /* Return the alignment in bits of EXP, an object. */
458 get_object_alignment (tree exp
)
460 unsigned HOST_WIDE_INT bitpos
= 0;
463 get_object_alignment_1 (exp
, &align
, &bitpos
);
465 /* align and bitpos now specify known low bits of the pointer.
466 ptr & (align - 1) == bitpos. */
469 align
= (bitpos
& -bitpos
);
473 /* For a pointer valued expression EXP compute values M and N such that M
474 divides (EXP - N) and such that N < M. If these numbers can be determined,
475 store M in alignp and N in *BITPOSP and return true. Return false if
476 the results are just a conservative approximation.
478 If EXP is not a pointer, false is returned too. */
481 get_pointer_alignment_1 (tree exp
, unsigned int *alignp
,
482 unsigned HOST_WIDE_INT
*bitposp
)
486 if (TREE_CODE (exp
) == ADDR_EXPR
)
487 return get_object_alignment_2 (TREE_OPERAND (exp
, 0),
488 alignp
, bitposp
, true);
489 else if (TREE_CODE (exp
) == SSA_NAME
490 && POINTER_TYPE_P (TREE_TYPE (exp
)))
492 unsigned int ptr_align
, ptr_misalign
;
493 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (exp
);
495 if (pi
&& get_ptr_info_alignment (pi
, &ptr_align
, &ptr_misalign
))
497 *bitposp
= ptr_misalign
* BITS_PER_UNIT
;
498 *alignp
= ptr_align
* BITS_PER_UNIT
;
499 /* We cannot really tell whether this result is an approximation. */
505 *alignp
= BITS_PER_UNIT
;
509 else if (TREE_CODE (exp
) == INTEGER_CST
)
511 *alignp
= BIGGEST_ALIGNMENT
;
512 *bitposp
= ((TREE_INT_CST_LOW (exp
) * BITS_PER_UNIT
)
513 & (BIGGEST_ALIGNMENT
- 1));
518 *alignp
= BITS_PER_UNIT
;
522 /* Return the alignment in bits of EXP, a pointer valued expression.
523 The alignment returned is, by default, the alignment of the thing that
524 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
526 Otherwise, look at the expression to see if we can do better, i.e., if the
527 expression is actually pointing at an object whose alignment is tighter. */
530 get_pointer_alignment (tree exp
)
532 unsigned HOST_WIDE_INT bitpos
= 0;
535 get_pointer_alignment_1 (exp
, &align
, &bitpos
);
537 /* align and bitpos now specify known low bits of the pointer.
538 ptr & (align - 1) == bitpos. */
541 align
= (bitpos
& -bitpos
);
546 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
547 way, because it could contain a zero byte in the middle.
548 TREE_STRING_LENGTH is the size of the character array, not the string.
550 ONLY_VALUE should be nonzero if the result is not going to be emitted
551 into the instruction stream and zero if it is going to be expanded.
552 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
553 is returned, otherwise NULL, since
554 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
555 evaluate the side-effects.
557 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
558 accesses. Note that this implies the result is not going to be emitted
559 into the instruction stream.
561 The value returned is of type `ssizetype'.
563 Unfortunately, string_constant can't access the values of const char
564 arrays with initializers, so neither can we do so here. */
567 c_strlen (tree src
, int only_value
)
570 HOST_WIDE_INT offset
;
576 if (TREE_CODE (src
) == COND_EXPR
577 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
581 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
582 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
583 if (tree_int_cst_equal (len1
, len2
))
587 if (TREE_CODE (src
) == COMPOUND_EXPR
588 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
589 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
591 loc
= EXPR_LOC_OR_LOC (src
, input_location
);
593 src
= string_constant (src
, &offset_node
);
597 max
= TREE_STRING_LENGTH (src
) - 1;
598 ptr
= TREE_STRING_POINTER (src
);
600 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
602 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
603 compute the offset to the following null if we don't know where to
604 start searching for it. */
607 for (i
= 0; i
< max
; i
++)
611 /* We don't know the starting offset, but we do know that the string
612 has no internal zero bytes. We can assume that the offset falls
613 within the bounds of the string; otherwise, the programmer deserves
614 what he gets. Subtract the offset from the length of the string,
615 and return that. This would perhaps not be valid if we were dealing
616 with named arrays in addition to literal string constants. */
618 return size_diffop_loc (loc
, size_int (max
), offset_node
);
621 /* We have a known offset into the string. Start searching there for
622 a null character if we can represent it as a single HOST_WIDE_INT. */
623 if (offset_node
== 0)
625 else if (! tree_fits_shwi_p (offset_node
))
628 offset
= tree_to_shwi (offset_node
);
630 /* If the offset is known to be out of bounds, warn, and call strlen at
632 if (offset
< 0 || offset
> max
)
634 /* Suppress multiple warnings for propagated constant strings. */
636 && !TREE_NO_WARNING (src
))
638 warning_at (loc
, 0, "offset outside bounds of constant string");
639 TREE_NO_WARNING (src
) = 1;
644 /* Use strlen to search for the first zero byte. Since any strings
645 constructed with build_string will have nulls appended, we win even
646 if we get handed something like (char[4])"abcd".
648 Since OFFSET is our starting index into the string, no further
649 calculation is needed. */
650 return ssize_int (strlen (ptr
+ offset
));
653 /* Return a char pointer for a C string if it is a string constant
654 or sum of string constant and integer constant. */
661 src
= string_constant (src
, &offset_node
);
665 if (offset_node
== 0)
666 return TREE_STRING_POINTER (src
);
667 else if (!tree_fits_uhwi_p (offset_node
)
668 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
671 return TREE_STRING_POINTER (src
) + tree_to_uhwi (offset_node
);
674 /* Return a constant integer corresponding to target reading
675 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
678 c_readstr (const char *str
, machine_mode mode
)
682 HOST_WIDE_INT tmp
[MAX_BITSIZE_MODE_ANY_INT
/ HOST_BITS_PER_WIDE_INT
];
684 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
685 unsigned int len
= (GET_MODE_PRECISION (mode
) + HOST_BITS_PER_WIDE_INT
- 1)
686 / HOST_BITS_PER_WIDE_INT
;
688 gcc_assert (len
<= MAX_BITSIZE_MODE_ANY_INT
/ HOST_BITS_PER_WIDE_INT
);
689 for (i
= 0; i
< len
; i
++)
693 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
696 if (WORDS_BIG_ENDIAN
)
697 j
= GET_MODE_SIZE (mode
) - i
- 1;
698 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
699 && GET_MODE_SIZE (mode
) >= UNITS_PER_WORD
)
700 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
704 ch
= (unsigned char) str
[i
];
705 tmp
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
708 wide_int c
= wide_int::from_array (tmp
, len
, GET_MODE_PRECISION (mode
));
709 return immed_wide_int_const (c
, mode
);
712 /* Cast a target constant CST to target CHAR and if that value fits into
713 host char type, return zero and put that value into variable pointed to by
717 target_char_cast (tree cst
, char *p
)
719 unsigned HOST_WIDE_INT val
, hostval
;
721 if (TREE_CODE (cst
) != INTEGER_CST
722 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
725 /* Do not care if it fits or not right here. */
726 val
= TREE_INT_CST_LOW (cst
);
728 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
729 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
732 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
733 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
742 /* Similar to save_expr, but assumes that arbitrary code is not executed
743 in between the multiple evaluations. In particular, we assume that a
744 non-addressable local variable will not be modified. */
747 builtin_save_expr (tree exp
)
749 if (TREE_CODE (exp
) == SSA_NAME
750 || (TREE_ADDRESSABLE (exp
) == 0
751 && (TREE_CODE (exp
) == PARM_DECL
752 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
)))))
755 return save_expr (exp
);
758 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
759 times to get the address of either a higher stack frame, or a return
760 address located within it (depending on FNDECL_CODE). */
763 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
767 #ifdef INITIAL_FRAME_ADDRESS_RTX
768 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
772 /* For a zero count with __builtin_return_address, we don't care what
773 frame address we return, because target-specific definitions will
774 override us. Therefore frame pointer elimination is OK, and using
775 the soft frame pointer is OK.
777 For a nonzero count, or a zero count with __builtin_frame_address,
778 we require a stable offset from the current frame pointer to the
779 previous one, so we must use the hard frame pointer, and
780 we must disable frame pointer elimination. */
781 if (count
== 0 && fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
782 tem
= frame_pointer_rtx
;
785 tem
= hard_frame_pointer_rtx
;
787 /* Tell reload not to eliminate the frame pointer. */
788 crtl
->accesses_prior_frames
= 1;
792 /* Some machines need special handling before we can access
793 arbitrary frames. For example, on the SPARC, we must first flush
794 all register windows to the stack. */
795 #ifdef SETUP_FRAME_ADDRESSES
797 SETUP_FRAME_ADDRESSES ();
800 /* On the SPARC, the return address is not in the frame, it is in a
801 register. There is no way to access it off of the current frame
802 pointer, but it can be accessed off the previous frame pointer by
803 reading the value from the register window save area. */
804 if (RETURN_ADDR_IN_PREVIOUS_FRAME
&& fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
807 /* Scan back COUNT frames to the specified frame. */
808 for (i
= 0; i
< count
; i
++)
810 /* Assume the dynamic chain pointer is in the word that the
811 frame address points to, unless otherwise specified. */
812 #ifdef DYNAMIC_CHAIN_ADDRESS
813 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
815 tem
= memory_address (Pmode
, tem
);
816 tem
= gen_frame_mem (Pmode
, tem
);
817 tem
= copy_to_reg (tem
);
820 /* For __builtin_frame_address, return what we've got. But, on
821 the SPARC for example, we may have to add a bias. */
822 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
823 #ifdef FRAME_ADDR_RTX
824 return FRAME_ADDR_RTX (tem
);
829 /* For __builtin_return_address, get the return address from that frame. */
830 #ifdef RETURN_ADDR_RTX
831 tem
= RETURN_ADDR_RTX (count
, tem
);
833 tem
= memory_address (Pmode
,
834 plus_constant (Pmode
, tem
, GET_MODE_SIZE (Pmode
)));
835 tem
= gen_frame_mem (Pmode
, tem
);
840 /* Alias set used for setjmp buffer. */
841 static alias_set_type setjmp_alias_set
= -1;
843 /* Construct the leading half of a __builtin_setjmp call. Control will
844 return to RECEIVER_LABEL. This is also called directly by the SJLJ
845 exception handling code. */
848 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
850 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
854 if (setjmp_alias_set
== -1)
855 setjmp_alias_set
= new_alias_set ();
857 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
859 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
861 /* We store the frame pointer and the address of receiver_label in
862 the buffer and use the rest of it for the stack save area, which
863 is machine-dependent. */
865 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
866 set_mem_alias_set (mem
, setjmp_alias_set
);
867 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
869 mem
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
870 GET_MODE_SIZE (Pmode
))),
871 set_mem_alias_set (mem
, setjmp_alias_set
);
873 emit_move_insn (validize_mem (mem
),
874 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
876 stack_save
= gen_rtx_MEM (sa_mode
,
877 plus_constant (Pmode
, buf_addr
,
878 2 * GET_MODE_SIZE (Pmode
)));
879 set_mem_alias_set (stack_save
, setjmp_alias_set
);
880 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
882 /* If there is further processing to do, do it. */
883 #ifdef HAVE_builtin_setjmp_setup
884 if (HAVE_builtin_setjmp_setup
)
885 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
888 /* We have a nonlocal label. */
889 cfun
->has_nonlocal_label
= 1;
892 /* Construct the trailing part of a __builtin_setjmp call. This is
893 also called directly by the SJLJ exception handling code.
894 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
897 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
901 /* Mark the FP as used when we get here, so we have to make sure it's
902 marked as used by this function. */
903 emit_use (hard_frame_pointer_rtx
);
905 /* Mark the static chain as clobbered here so life information
906 doesn't get messed up for it. */
907 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
908 if (chain
&& REG_P (chain
))
909 emit_clobber (chain
);
911 /* Now put in the code to restore the frame pointer, and argument
912 pointer, if needed. */
913 #ifdef HAVE_nonlocal_goto
914 if (! HAVE_nonlocal_goto
)
917 /* First adjust our frame pointer to its actual value. It was
918 previously set to the start of the virtual area corresponding to
919 the stacked variables when we branched here and now needs to be
920 adjusted to the actual hardware fp value.
922 Assignments to virtual registers are converted by
923 instantiate_virtual_regs into the corresponding assignment
924 to the underlying register (fp in this case) that makes
925 the original assignment true.
926 So the following insn will actually be decrementing fp by
927 STARTING_FRAME_OFFSET. */
928 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
930 /* Restoring the frame pointer also modifies the hard frame pointer.
931 Mark it used (so that the previous assignment remains live once
932 the frame pointer is eliminated) and clobbered (to represent the
933 implicit update from the assignment). */
934 emit_use (hard_frame_pointer_rtx
);
935 emit_clobber (hard_frame_pointer_rtx
);
938 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
939 if (fixed_regs
[ARG_POINTER_REGNUM
])
941 #ifdef ELIMINABLE_REGS
942 /* If the argument pointer can be eliminated in favor of the
943 frame pointer, we don't need to restore it. We assume here
944 that if such an elimination is present, it can always be used.
945 This is the case on all known machines; if we don't make this
946 assumption, we do unnecessary saving on many machines. */
948 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
950 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
951 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
952 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
955 if (i
== ARRAY_SIZE (elim_regs
))
958 /* Now restore our arg pointer from the address at which it
959 was saved in our stack frame. */
960 emit_move_insn (crtl
->args
.internal_arg_pointer
,
961 copy_to_reg (get_arg_pointer_save_area ()));
966 #ifdef HAVE_builtin_setjmp_receiver
967 if (receiver_label
!= NULL
&& HAVE_builtin_setjmp_receiver
)
968 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
971 #ifdef HAVE_nonlocal_goto_receiver
972 if (HAVE_nonlocal_goto_receiver
)
973 emit_insn (gen_nonlocal_goto_receiver ());
978 /* We must not allow the code we just generated to be reordered by
979 scheduling. Specifically, the update of the frame pointer must
980 happen immediately, not later. */
981 emit_insn (gen_blockage ());
984 /* __builtin_longjmp is passed a pointer to an array of five words (not
985 all will be used on all machines). It operates similarly to the C
986 library function of the same name, but is more efficient. Much of
987 the code below is copied from the handling of non-local gotos. */
990 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
993 rtx_insn
*insn
, *last
;
994 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
996 /* DRAP is needed for stack realign if longjmp is expanded to current
998 if (SUPPORTS_STACK_ALIGNMENT
)
999 crtl
->need_drap
= true;
1001 if (setjmp_alias_set
== -1)
1002 setjmp_alias_set
= new_alias_set ();
1004 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
1006 buf_addr
= force_reg (Pmode
, buf_addr
);
1008 /* We require that the user must pass a second argument of 1, because
1009 that is what builtin_setjmp will return. */
1010 gcc_assert (value
== const1_rtx
);
1012 last
= get_last_insn ();
1013 #ifdef HAVE_builtin_longjmp
1014 if (HAVE_builtin_longjmp
)
1015 emit_insn (gen_builtin_longjmp (buf_addr
));
1019 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
1020 lab
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
1021 GET_MODE_SIZE (Pmode
)));
1023 stack
= gen_rtx_MEM (sa_mode
, plus_constant (Pmode
, buf_addr
,
1024 2 * GET_MODE_SIZE (Pmode
)));
1025 set_mem_alias_set (fp
, setjmp_alias_set
);
1026 set_mem_alias_set (lab
, setjmp_alias_set
);
1027 set_mem_alias_set (stack
, setjmp_alias_set
);
1029 /* Pick up FP, label, and SP from the block and jump. This code is
1030 from expand_goto in stmt.c; see there for detailed comments. */
1031 #ifdef HAVE_nonlocal_goto
1032 if (HAVE_nonlocal_goto
)
1033 /* We have to pass a value to the nonlocal_goto pattern that will
1034 get copied into the static_chain pointer, but it does not matter
1035 what that value is, because builtin_setjmp does not use it. */
1036 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
1040 lab
= copy_to_reg (lab
);
1042 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1043 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1045 emit_move_insn (hard_frame_pointer_rtx
, fp
);
1046 emit_stack_restore (SAVE_NONLOCAL
, stack
);
1048 emit_use (hard_frame_pointer_rtx
);
1049 emit_use (stack_pointer_rtx
);
1050 emit_indirect_jump (lab
);
1054 /* Search backwards and mark the jump insn as a non-local goto.
1055 Note that this precludes the use of __builtin_longjmp to a
1056 __builtin_setjmp target in the same function. However, we've
1057 already cautioned the user that these functions are for
1058 internal exception handling use only. */
1059 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1061 gcc_assert (insn
!= last
);
1065 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1068 else if (CALL_P (insn
))
1074 more_const_call_expr_args_p (const const_call_expr_arg_iterator
*iter
)
1076 return (iter
->i
< iter
->n
);
1079 /* This function validates the types of a function call argument list
1080 against a specified list of tree_codes. If the last specifier is a 0,
1081 that represents an ellipses, otherwise the last specifier must be a
1085 validate_arglist (const_tree callexpr
, ...)
1087 enum tree_code code
;
1090 const_call_expr_arg_iterator iter
;
1093 va_start (ap
, callexpr
);
1094 init_const_call_expr_arg_iterator (callexpr
, &iter
);
1098 code
= (enum tree_code
) va_arg (ap
, int);
1102 /* This signifies an ellipses, any further arguments are all ok. */
1106 /* This signifies an endlink, if no arguments remain, return
1107 true, otherwise return false. */
1108 res
= !more_const_call_expr_args_p (&iter
);
1111 /* If no parameters remain or the parameter's code does not
1112 match the specified code, return false. Otherwise continue
1113 checking any remaining arguments. */
1114 arg
= next_const_call_expr_arg (&iter
);
1115 if (!validate_arg (arg
, code
))
1122 /* We need gotos here since we can only have one VA_CLOSE in a
1130 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1131 and the address of the save area. */
1134 expand_builtin_nonlocal_goto (tree exp
)
1136 tree t_label
, t_save_area
;
1137 rtx r_label
, r_save_area
, r_fp
, r_sp
;
1140 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1143 t_label
= CALL_EXPR_ARG (exp
, 0);
1144 t_save_area
= CALL_EXPR_ARG (exp
, 1);
1146 r_label
= expand_normal (t_label
);
1147 r_label
= convert_memory_address (Pmode
, r_label
);
1148 r_save_area
= expand_normal (t_save_area
);
1149 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
1150 /* Copy the address of the save location to a register just in case it was
1151 based on the frame pointer. */
1152 r_save_area
= copy_to_reg (r_save_area
);
1153 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
1154 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
1155 plus_constant (Pmode
, r_save_area
,
1156 GET_MODE_SIZE (Pmode
)));
1158 crtl
->has_nonlocal_goto
= 1;
1160 #ifdef HAVE_nonlocal_goto
1161 /* ??? We no longer need to pass the static chain value, afaik. */
1162 if (HAVE_nonlocal_goto
)
1163 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
1167 r_label
= copy_to_reg (r_label
);
1169 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1170 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1172 /* Restore frame pointer for containing function. */
1173 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
1174 emit_stack_restore (SAVE_NONLOCAL
, r_sp
);
1176 /* USE of hard_frame_pointer_rtx added for consistency;
1177 not clear if really needed. */
1178 emit_use (hard_frame_pointer_rtx
);
1179 emit_use (stack_pointer_rtx
);
1181 /* If the architecture is using a GP register, we must
1182 conservatively assume that the target function makes use of it.
1183 The prologue of functions with nonlocal gotos must therefore
1184 initialize the GP register to the appropriate value, and we
1185 must then make sure that this value is live at the point
1186 of the jump. (Note that this doesn't necessarily apply
1187 to targets with a nonlocal_goto pattern; they are free
1188 to implement it in their own way. Note also that this is
1189 a no-op if the GP register is a global invariant.) */
1190 if ((unsigned) PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
1191 && fixed_regs
[PIC_OFFSET_TABLE_REGNUM
])
1192 emit_use (pic_offset_table_rtx
);
1194 emit_indirect_jump (r_label
);
1197 /* Search backwards to the jump insn and mark it as a
1199 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1203 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1206 else if (CALL_P (insn
))
1213 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1214 (not all will be used on all machines) that was passed to __builtin_setjmp.
1215 It updates the stack pointer in that block to the current value. This is
1216 also called directly by the SJLJ exception handling code. */
1219 expand_builtin_update_setjmp_buf (rtx buf_addr
)
1221 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
1223 = gen_rtx_MEM (sa_mode
,
1226 plus_constant (Pmode
, buf_addr
,
1227 2 * GET_MODE_SIZE (Pmode
))));
1229 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
1232 /* Expand a call to __builtin_prefetch. For a target that does not support
1233 data prefetch, evaluate the memory address argument in case it has side
1237 expand_builtin_prefetch (tree exp
)
1239 tree arg0
, arg1
, arg2
;
1243 if (!validate_arglist (exp
, POINTER_TYPE
, 0))
1246 arg0
= CALL_EXPR_ARG (exp
, 0);
1248 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1249 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1251 nargs
= call_expr_nargs (exp
);
1253 arg1
= CALL_EXPR_ARG (exp
, 1);
1255 arg1
= integer_zero_node
;
1257 arg2
= CALL_EXPR_ARG (exp
, 2);
1259 arg2
= integer_three_node
;
1261 /* Argument 0 is an address. */
1262 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
1264 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1265 if (TREE_CODE (arg1
) != INTEGER_CST
)
1267 error ("second argument to %<__builtin_prefetch%> must be a constant");
1268 arg1
= integer_zero_node
;
1270 op1
= expand_normal (arg1
);
1271 /* Argument 1 must be either zero or one. */
1272 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
1274 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1279 /* Argument 2 (locality) must be a compile-time constant int. */
1280 if (TREE_CODE (arg2
) != INTEGER_CST
)
1282 error ("third argument to %<__builtin_prefetch%> must be a constant");
1283 arg2
= integer_zero_node
;
1285 op2
= expand_normal (arg2
);
1286 /* Argument 2 must be 0, 1, 2, or 3. */
1287 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
1289 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1293 #ifdef HAVE_prefetch
1296 struct expand_operand ops
[3];
1298 create_address_operand (&ops
[0], op0
);
1299 create_integer_operand (&ops
[1], INTVAL (op1
));
1300 create_integer_operand (&ops
[2], INTVAL (op2
));
1301 if (maybe_expand_insn (CODE_FOR_prefetch
, 3, ops
))
1306 /* Don't do anything with direct references to volatile memory, but
1307 generate code to handle other side effects. */
1308 if (!MEM_P (op0
) && side_effects_p (op0
))
1312 /* Get a MEM rtx for expression EXP which is the address of an operand
1313 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1314 the maximum length of the block of memory that might be accessed or
1318 get_memory_rtx (tree exp
, tree len
)
1320 tree orig_exp
= exp
;
1323 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1324 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1325 if (TREE_CODE (exp
) == SAVE_EXPR
&& !SAVE_EXPR_RESOLVED_P (exp
))
1326 exp
= TREE_OPERAND (exp
, 0);
1328 addr
= expand_expr (orig_exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1329 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1331 /* Get an expression we can use to find the attributes to assign to MEM.
1332 First remove any nops. */
1333 while (CONVERT_EXPR_P (exp
)
1334 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1335 exp
= TREE_OPERAND (exp
, 0);
1337 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1338 (as builtin stringops may alias with anything). */
1339 exp
= fold_build2 (MEM_REF
,
1340 build_array_type (char_type_node
,
1341 build_range_type (sizetype
,
1342 size_one_node
, len
)),
1343 exp
, build_int_cst (ptr_type_node
, 0));
1345 /* If the MEM_REF has no acceptable address, try to get the base object
1346 from the original address we got, and build an all-aliasing
1347 unknown-sized access to that one. */
1348 if (is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
1349 set_mem_attributes (mem
, exp
, 0);
1350 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
1351 && (exp
= get_base_address (TREE_OPERAND (TREE_OPERAND (exp
, 0),
1354 exp
= build_fold_addr_expr (exp
);
1355 exp
= fold_build2 (MEM_REF
,
1356 build_array_type (char_type_node
,
1357 build_range_type (sizetype
,
1360 exp
, build_int_cst (ptr_type_node
, 0));
1361 set_mem_attributes (mem
, exp
, 0);
1363 set_mem_alias_set (mem
, 0);
1367 /* Built-in functions to perform an untyped call and return. */
1369 #define apply_args_mode \
1370 (this_target_builtins->x_apply_args_mode)
1371 #define apply_result_mode \
1372 (this_target_builtins->x_apply_result_mode)
1374 /* Return the size required for the block returned by __builtin_apply_args,
1375 and initialize apply_args_mode. */
1378 apply_args_size (void)
1380 static int size
= -1;
1385 /* The values computed by this function never change. */
1388 /* The first value is the incoming arg-pointer. */
1389 size
= GET_MODE_SIZE (Pmode
);
1391 /* The second value is the structure value address unless this is
1392 passed as an "invisible" first argument. */
1393 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1394 size
+= GET_MODE_SIZE (Pmode
);
1396 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1397 if (FUNCTION_ARG_REGNO_P (regno
))
1399 mode
= targetm
.calls
.get_raw_arg_mode (regno
);
1401 gcc_assert (mode
!= VOIDmode
);
1403 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1404 if (size
% align
!= 0)
1405 size
= CEIL (size
, align
) * align
;
1406 size
+= GET_MODE_SIZE (mode
);
1407 apply_args_mode
[regno
] = mode
;
1411 apply_args_mode
[regno
] = VOIDmode
;
1417 /* Return the size required for the block returned by __builtin_apply,
1418 and initialize apply_result_mode. */
1421 apply_result_size (void)
1423 static int size
= -1;
1427 /* The values computed by this function never change. */
1432 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1433 if (targetm
.calls
.function_value_regno_p (regno
))
1435 mode
= targetm
.calls
.get_raw_result_mode (regno
);
1437 gcc_assert (mode
!= VOIDmode
);
1439 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1440 if (size
% align
!= 0)
1441 size
= CEIL (size
, align
) * align
;
1442 size
+= GET_MODE_SIZE (mode
);
1443 apply_result_mode
[regno
] = mode
;
1446 apply_result_mode
[regno
] = VOIDmode
;
1448 /* Allow targets that use untyped_call and untyped_return to override
1449 the size so that machine-specific information can be stored here. */
1450 #ifdef APPLY_RESULT_SIZE
1451 size
= APPLY_RESULT_SIZE
;
1457 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1458 /* Create a vector describing the result block RESULT. If SAVEP is true,
1459 the result block is used to save the values; otherwise it is used to
1460 restore the values. */
1463 result_vector (int savep
, rtx result
)
1465 int regno
, size
, align
, nelts
;
1468 rtx
*savevec
= XALLOCAVEC (rtx
, FIRST_PSEUDO_REGISTER
);
1471 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1472 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1474 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1475 if (size
% align
!= 0)
1476 size
= CEIL (size
, align
) * align
;
1477 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1478 mem
= adjust_address (result
, mode
, size
);
1479 savevec
[nelts
++] = (savep
1480 ? gen_rtx_SET (mem
, reg
)
1481 : gen_rtx_SET (reg
, mem
));
1482 size
+= GET_MODE_SIZE (mode
);
1484 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1486 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1488 /* Save the state required to perform an untyped call with the same
1489 arguments as were passed to the current function. */
1492 expand_builtin_apply_args_1 (void)
1495 int size
, align
, regno
;
1497 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1499 /* Create a block where the arg-pointer, structure value address,
1500 and argument registers can be saved. */
1501 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1503 /* Walk past the arg-pointer and structure value address. */
1504 size
= GET_MODE_SIZE (Pmode
);
1505 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1506 size
+= GET_MODE_SIZE (Pmode
);
1508 /* Save each register used in calling a function to the block. */
1509 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1510 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1512 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1513 if (size
% align
!= 0)
1514 size
= CEIL (size
, align
) * align
;
1516 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1518 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1519 size
+= GET_MODE_SIZE (mode
);
1522 /* Save the arg pointer to the block. */
1523 tem
= copy_to_reg (crtl
->args
.internal_arg_pointer
);
1524 #ifdef STACK_GROWS_DOWNWARD
1525 /* We need the pointer as the caller actually passed them to us, not
1526 as we might have pretended they were passed. Make sure it's a valid
1527 operand, as emit_move_insn isn't expected to handle a PLUS. */
1529 = force_operand (plus_constant (Pmode
, tem
, crtl
->args
.pretend_args_size
),
1532 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1534 size
= GET_MODE_SIZE (Pmode
);
1536 /* Save the structure value address unless this is passed as an
1537 "invisible" first argument. */
1538 if (struct_incoming_value
)
1540 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1541 copy_to_reg (struct_incoming_value
));
1542 size
+= GET_MODE_SIZE (Pmode
);
1545 /* Return the address of the block. */
1546 return copy_addr_to_reg (XEXP (registers
, 0));
1549 /* __builtin_apply_args returns block of memory allocated on
1550 the stack into which is stored the arg pointer, structure
1551 value address, static chain, and all the registers that might
1552 possibly be used in performing a function call. The code is
1553 moved to the start of the function so the incoming values are
1557 expand_builtin_apply_args (void)
1559 /* Don't do __builtin_apply_args more than once in a function.
1560 Save the result of the first call and reuse it. */
1561 if (apply_args_value
!= 0)
1562 return apply_args_value
;
1564 /* When this function is called, it means that registers must be
1565 saved on entry to this function. So we migrate the
1566 call to the first insn of this function. */
1571 temp
= expand_builtin_apply_args_1 ();
1575 apply_args_value
= temp
;
1577 /* Put the insns after the NOTE that starts the function.
1578 If this is inside a start_sequence, make the outer-level insn
1579 chain current, so the code is placed at the start of the
1580 function. If internal_arg_pointer is a non-virtual pseudo,
1581 it needs to be placed after the function that initializes
1583 push_topmost_sequence ();
1584 if (REG_P (crtl
->args
.internal_arg_pointer
)
1585 && REGNO (crtl
->args
.internal_arg_pointer
) > LAST_VIRTUAL_REGISTER
)
1586 emit_insn_before (seq
, parm_birth_insn
);
1588 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1589 pop_topmost_sequence ();
1594 /* Perform an untyped call and save the state required to perform an
1595 untyped return of whatever value was returned by the given function. */
1598 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1600 int size
, align
, regno
;
1602 rtx incoming_args
, result
, reg
, dest
, src
;
1603 rtx_call_insn
*call_insn
;
1604 rtx old_stack_level
= 0;
1605 rtx call_fusage
= 0;
1606 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1608 arguments
= convert_memory_address (Pmode
, arguments
);
1610 /* Create a block where the return registers can be saved. */
1611 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1613 /* Fetch the arg pointer from the ARGUMENTS block. */
1614 incoming_args
= gen_reg_rtx (Pmode
);
1615 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1616 #ifndef STACK_GROWS_DOWNWARD
1617 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1618 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1621 /* Push a new argument block and copy the arguments. Do not allow
1622 the (potential) memcpy call below to interfere with our stack
1624 do_pending_stack_adjust ();
1627 /* Save the stack with nonlocal if available. */
1628 #ifdef HAVE_save_stack_nonlocal
1629 if (HAVE_save_stack_nonlocal
)
1630 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
);
1633 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
1635 /* Allocate a block of memory onto the stack and copy the memory
1636 arguments to the outgoing arguments address. We can pass TRUE
1637 as the 4th argument because we just saved the stack pointer
1638 and will restore it right after the call. */
1639 allocate_dynamic_stack_space (argsize
, 0, BIGGEST_ALIGNMENT
, true);
1641 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1642 may have already set current_function_calls_alloca to true.
1643 current_function_calls_alloca won't be set if argsize is zero,
1644 so we have to guarantee need_drap is true here. */
1645 if (SUPPORTS_STACK_ALIGNMENT
)
1646 crtl
->need_drap
= true;
1648 dest
= virtual_outgoing_args_rtx
;
1649 #ifndef STACK_GROWS_DOWNWARD
1650 if (CONST_INT_P (argsize
))
1651 dest
= plus_constant (Pmode
, dest
, -INTVAL (argsize
));
1653 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1655 dest
= gen_rtx_MEM (BLKmode
, dest
);
1656 set_mem_align (dest
, PARM_BOUNDARY
);
1657 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1658 set_mem_align (src
, PARM_BOUNDARY
);
1659 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1661 /* Refer to the argument block. */
1663 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1664 set_mem_align (arguments
, PARM_BOUNDARY
);
1666 /* Walk past the arg-pointer and structure value address. */
1667 size
= GET_MODE_SIZE (Pmode
);
1669 size
+= GET_MODE_SIZE (Pmode
);
1671 /* Restore each of the registers previously saved. Make USE insns
1672 for each of these registers for use in making the call. */
1673 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1674 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1676 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1677 if (size
% align
!= 0)
1678 size
= CEIL (size
, align
) * align
;
1679 reg
= gen_rtx_REG (mode
, regno
);
1680 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1681 use_reg (&call_fusage
, reg
);
1682 size
+= GET_MODE_SIZE (mode
);
1685 /* Restore the structure value address unless this is passed as an
1686 "invisible" first argument. */
1687 size
= GET_MODE_SIZE (Pmode
);
1690 rtx value
= gen_reg_rtx (Pmode
);
1691 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1692 emit_move_insn (struct_value
, value
);
1693 if (REG_P (struct_value
))
1694 use_reg (&call_fusage
, struct_value
);
1695 size
+= GET_MODE_SIZE (Pmode
);
1698 /* All arguments and registers used for the call are set up by now! */
1699 function
= prepare_call_address (NULL
, function
, NULL
, &call_fusage
, 0, 0);
1701 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1702 and we don't want to load it into a register as an optimization,
1703 because prepare_call_address already did it if it should be done. */
1704 if (GET_CODE (function
) != SYMBOL_REF
)
1705 function
= memory_address (FUNCTION_MODE
, function
);
1707 /* Generate the actual call instruction and save the return value. */
1708 #ifdef HAVE_untyped_call
1709 if (HAVE_untyped_call
)
1710 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1711 result
, result_vector (1, result
)));
1714 #ifdef HAVE_call_value
1715 if (HAVE_call_value
)
1719 /* Locate the unique return register. It is not possible to
1720 express a call that sets more than one return register using
1721 call_value; use untyped_call for that. In fact, untyped_call
1722 only needs to save the return registers in the given block. */
1723 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1724 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1726 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1728 valreg
= gen_rtx_REG (mode
, regno
);
1731 emit_call_insn (GEN_CALL_VALUE (valreg
,
1732 gen_rtx_MEM (FUNCTION_MODE
, function
),
1733 const0_rtx
, NULL_RTX
, const0_rtx
));
1735 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1741 /* Find the CALL insn we just emitted, and attach the register usage
1743 call_insn
= last_call_insn ();
1744 add_function_usage_to (call_insn
, call_fusage
);
1746 /* Restore the stack. */
1747 #ifdef HAVE_save_stack_nonlocal
1748 if (HAVE_save_stack_nonlocal
)
1749 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
);
1752 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
1753 fixup_args_size_notes (call_insn
, get_last_insn (), 0);
1757 /* Return the address of the result block. */
1758 result
= copy_addr_to_reg (XEXP (result
, 0));
1759 return convert_memory_address (ptr_mode
, result
);
1762 /* Perform an untyped return. */
1765 expand_builtin_return (rtx result
)
1767 int size
, align
, regno
;
1770 rtx_insn
*call_fusage
= 0;
1772 result
= convert_memory_address (Pmode
, result
);
1774 apply_result_size ();
1775 result
= gen_rtx_MEM (BLKmode
, result
);
1777 #ifdef HAVE_untyped_return
1778 if (HAVE_untyped_return
)
1780 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1786 /* Restore the return value and note that each value is used. */
1788 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1789 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1791 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1792 if (size
% align
!= 0)
1793 size
= CEIL (size
, align
) * align
;
1794 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1795 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1797 push_to_sequence (call_fusage
);
1799 call_fusage
= get_insns ();
1801 size
+= GET_MODE_SIZE (mode
);
1804 /* Put the USE insns before the return. */
1805 emit_insn (call_fusage
);
1807 /* Return whatever values was restored by jumping directly to the end
1809 expand_naked_return ();
1812 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1814 static enum type_class
1815 type_to_class (tree type
)
1817 switch (TREE_CODE (type
))
1819 case VOID_TYPE
: return void_type_class
;
1820 case INTEGER_TYPE
: return integer_type_class
;
1821 case ENUMERAL_TYPE
: return enumeral_type_class
;
1822 case BOOLEAN_TYPE
: return boolean_type_class
;
1823 case POINTER_TYPE
: return pointer_type_class
;
1824 case REFERENCE_TYPE
: return reference_type_class
;
1825 case OFFSET_TYPE
: return offset_type_class
;
1826 case REAL_TYPE
: return real_type_class
;
1827 case COMPLEX_TYPE
: return complex_type_class
;
1828 case FUNCTION_TYPE
: return function_type_class
;
1829 case METHOD_TYPE
: return method_type_class
;
1830 case RECORD_TYPE
: return record_type_class
;
1832 case QUAL_UNION_TYPE
: return union_type_class
;
1833 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1834 ? string_type_class
: array_type_class
);
1835 case LANG_TYPE
: return lang_type_class
;
1836 default: return no_type_class
;
1840 /* Expand a call EXP to __builtin_classify_type. */
1843 expand_builtin_classify_type (tree exp
)
1845 if (call_expr_nargs (exp
))
1846 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))));
1847 return GEN_INT (no_type_class
);
1850 /* This helper macro, meant to be used in mathfn_built_in below,
1851 determines which among a set of three builtin math functions is
1852 appropriate for a given type mode. The `F' and `L' cases are
1853 automatically generated from the `double' case. */
1854 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1855 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1856 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1857 fcodel = BUILT_IN_MATHFN##L ; break;
1858 /* Similar to above, but appends _R after any F/L suffix. */
1859 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1860 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1861 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1862 fcodel = BUILT_IN_MATHFN##L_R ; break;
1864 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1865 if available. If IMPLICIT is true use the implicit builtin declaration,
1866 otherwise use the explicit declaration. If we can't do the conversion,
1870 mathfn_built_in_1 (tree type
, enum built_in_function fn
, bool implicit_p
)
1872 enum built_in_function fcode
, fcodef
, fcodel
, fcode2
;
1876 CASE_MATHFN (BUILT_IN_ACOS
)
1877 CASE_MATHFN (BUILT_IN_ACOSH
)
1878 CASE_MATHFN (BUILT_IN_ASIN
)
1879 CASE_MATHFN (BUILT_IN_ASINH
)
1880 CASE_MATHFN (BUILT_IN_ATAN
)
1881 CASE_MATHFN (BUILT_IN_ATAN2
)
1882 CASE_MATHFN (BUILT_IN_ATANH
)
1883 CASE_MATHFN (BUILT_IN_CBRT
)
1884 CASE_MATHFN (BUILT_IN_CEIL
)
1885 CASE_MATHFN (BUILT_IN_CEXPI
)
1886 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1887 CASE_MATHFN (BUILT_IN_COS
)
1888 CASE_MATHFN (BUILT_IN_COSH
)
1889 CASE_MATHFN (BUILT_IN_DREM
)
1890 CASE_MATHFN (BUILT_IN_ERF
)
1891 CASE_MATHFN (BUILT_IN_ERFC
)
1892 CASE_MATHFN (BUILT_IN_EXP
)
1893 CASE_MATHFN (BUILT_IN_EXP10
)
1894 CASE_MATHFN (BUILT_IN_EXP2
)
1895 CASE_MATHFN (BUILT_IN_EXPM1
)
1896 CASE_MATHFN (BUILT_IN_FABS
)
1897 CASE_MATHFN (BUILT_IN_FDIM
)
1898 CASE_MATHFN (BUILT_IN_FLOOR
)
1899 CASE_MATHFN (BUILT_IN_FMA
)
1900 CASE_MATHFN (BUILT_IN_FMAX
)
1901 CASE_MATHFN (BUILT_IN_FMIN
)
1902 CASE_MATHFN (BUILT_IN_FMOD
)
1903 CASE_MATHFN (BUILT_IN_FREXP
)
1904 CASE_MATHFN (BUILT_IN_GAMMA
)
1905 CASE_MATHFN_REENT (BUILT_IN_GAMMA
) /* GAMMA_R */
1906 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1907 CASE_MATHFN (BUILT_IN_HYPOT
)
1908 CASE_MATHFN (BUILT_IN_ILOGB
)
1909 CASE_MATHFN (BUILT_IN_ICEIL
)
1910 CASE_MATHFN (BUILT_IN_IFLOOR
)
1911 CASE_MATHFN (BUILT_IN_INF
)
1912 CASE_MATHFN (BUILT_IN_IRINT
)
1913 CASE_MATHFN (BUILT_IN_IROUND
)
1914 CASE_MATHFN (BUILT_IN_ISINF
)
1915 CASE_MATHFN (BUILT_IN_J0
)
1916 CASE_MATHFN (BUILT_IN_J1
)
1917 CASE_MATHFN (BUILT_IN_JN
)
1918 CASE_MATHFN (BUILT_IN_LCEIL
)
1919 CASE_MATHFN (BUILT_IN_LDEXP
)
1920 CASE_MATHFN (BUILT_IN_LFLOOR
)
1921 CASE_MATHFN (BUILT_IN_LGAMMA
)
1922 CASE_MATHFN_REENT (BUILT_IN_LGAMMA
) /* LGAMMA_R */
1923 CASE_MATHFN (BUILT_IN_LLCEIL
)
1924 CASE_MATHFN (BUILT_IN_LLFLOOR
)
1925 CASE_MATHFN (BUILT_IN_LLRINT
)
1926 CASE_MATHFN (BUILT_IN_LLROUND
)
1927 CASE_MATHFN (BUILT_IN_LOG
)
1928 CASE_MATHFN (BUILT_IN_LOG10
)
1929 CASE_MATHFN (BUILT_IN_LOG1P
)
1930 CASE_MATHFN (BUILT_IN_LOG2
)
1931 CASE_MATHFN (BUILT_IN_LOGB
)
1932 CASE_MATHFN (BUILT_IN_LRINT
)
1933 CASE_MATHFN (BUILT_IN_LROUND
)
1934 CASE_MATHFN (BUILT_IN_MODF
)
1935 CASE_MATHFN (BUILT_IN_NAN
)
1936 CASE_MATHFN (BUILT_IN_NANS
)
1937 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1938 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1939 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1940 CASE_MATHFN (BUILT_IN_POW
)
1941 CASE_MATHFN (BUILT_IN_POWI
)
1942 CASE_MATHFN (BUILT_IN_POW10
)
1943 CASE_MATHFN (BUILT_IN_REMAINDER
)
1944 CASE_MATHFN (BUILT_IN_REMQUO
)
1945 CASE_MATHFN (BUILT_IN_RINT
)
1946 CASE_MATHFN (BUILT_IN_ROUND
)
1947 CASE_MATHFN (BUILT_IN_SCALB
)
1948 CASE_MATHFN (BUILT_IN_SCALBLN
)
1949 CASE_MATHFN (BUILT_IN_SCALBN
)
1950 CASE_MATHFN (BUILT_IN_SIGNBIT
)
1951 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1952 CASE_MATHFN (BUILT_IN_SIN
)
1953 CASE_MATHFN (BUILT_IN_SINCOS
)
1954 CASE_MATHFN (BUILT_IN_SINH
)
1955 CASE_MATHFN (BUILT_IN_SQRT
)
1956 CASE_MATHFN (BUILT_IN_TAN
)
1957 CASE_MATHFN (BUILT_IN_TANH
)
1958 CASE_MATHFN (BUILT_IN_TGAMMA
)
1959 CASE_MATHFN (BUILT_IN_TRUNC
)
1960 CASE_MATHFN (BUILT_IN_Y0
)
1961 CASE_MATHFN (BUILT_IN_Y1
)
1962 CASE_MATHFN (BUILT_IN_YN
)
1968 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1970 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1972 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1977 if (implicit_p
&& !builtin_decl_implicit_p (fcode2
))
1980 return builtin_decl_explicit (fcode2
);
1983 /* Like mathfn_built_in_1(), but always use the implicit array. */
1986 mathfn_built_in (tree type
, enum built_in_function fn
)
1988 return mathfn_built_in_1 (type
, fn
, /*implicit=*/ 1);
1991 /* If errno must be maintained, expand the RTL to check if the result,
1992 TARGET, of a built-in function call, EXP, is NaN, and if so set
1996 expand_errno_check (tree exp
, rtx target
)
1998 rtx_code_label
*lab
= gen_label_rtx ();
2000 /* Test the result; if it is NaN, set errno=EDOM because
2001 the argument was not in the domain. */
2002 do_compare_rtx_and_jump (target
, target
, EQ
, 0, GET_MODE (target
),
2003 NULL_RTX
, NULL
, lab
,
2004 /* The jump is very likely. */
2005 REG_BR_PROB_BASE
- (REG_BR_PROB_BASE
/ 2000 - 1));
2008 /* If this built-in doesn't throw an exception, set errno directly. */
2009 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp
), 0)))
2011 #ifdef GEN_ERRNO_RTX
2012 rtx errno_rtx
= GEN_ERRNO_RTX
;
2015 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
2017 emit_move_insn (errno_rtx
,
2018 gen_int_mode (TARGET_EDOM
, GET_MODE (errno_rtx
)));
2024 /* Make sure the library call isn't expanded as a tail call. */
2025 CALL_EXPR_TAILCALL (exp
) = 0;
2027 /* We can't set errno=EDOM directly; let the library call do it.
2028 Pop the arguments right away in case the call gets deleted. */
2030 expand_call (exp
, target
, 0);
2035 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
2036 Return NULL_RTX if a normal call should be emitted rather than expanding
2037 the function in-line. EXP is the expression that is a call to the builtin
2038 function; if convenient, the result should be placed in TARGET.
2039 SUBTARGET may be used as the target for computing one of EXP's operands. */
2042 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
2044 optab builtin_optab
;
2047 tree fndecl
= get_callee_fndecl (exp
);
2049 bool errno_set
= false;
2050 bool try_widening
= false;
2053 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2056 arg
= CALL_EXPR_ARG (exp
, 0);
2058 switch (DECL_FUNCTION_CODE (fndecl
))
2060 CASE_FLT_FN (BUILT_IN_SQRT
):
2061 errno_set
= ! tree_expr_nonnegative_p (arg
);
2062 try_widening
= true;
2063 builtin_optab
= sqrt_optab
;
2065 CASE_FLT_FN (BUILT_IN_EXP
):
2066 errno_set
= true; builtin_optab
= exp_optab
; break;
2067 CASE_FLT_FN (BUILT_IN_EXP10
):
2068 CASE_FLT_FN (BUILT_IN_POW10
):
2069 errno_set
= true; builtin_optab
= exp10_optab
; break;
2070 CASE_FLT_FN (BUILT_IN_EXP2
):
2071 errno_set
= true; builtin_optab
= exp2_optab
; break;
2072 CASE_FLT_FN (BUILT_IN_EXPM1
):
2073 errno_set
= true; builtin_optab
= expm1_optab
; break;
2074 CASE_FLT_FN (BUILT_IN_LOGB
):
2075 errno_set
= true; builtin_optab
= logb_optab
; break;
2076 CASE_FLT_FN (BUILT_IN_LOG
):
2077 errno_set
= true; builtin_optab
= log_optab
; break;
2078 CASE_FLT_FN (BUILT_IN_LOG10
):
2079 errno_set
= true; builtin_optab
= log10_optab
; break;
2080 CASE_FLT_FN (BUILT_IN_LOG2
):
2081 errno_set
= true; builtin_optab
= log2_optab
; break;
2082 CASE_FLT_FN (BUILT_IN_LOG1P
):
2083 errno_set
= true; builtin_optab
= log1p_optab
; break;
2084 CASE_FLT_FN (BUILT_IN_ASIN
):
2085 builtin_optab
= asin_optab
; break;
2086 CASE_FLT_FN (BUILT_IN_ACOS
):
2087 builtin_optab
= acos_optab
; break;
2088 CASE_FLT_FN (BUILT_IN_TAN
):
2089 builtin_optab
= tan_optab
; break;
2090 CASE_FLT_FN (BUILT_IN_ATAN
):
2091 builtin_optab
= atan_optab
; break;
2092 CASE_FLT_FN (BUILT_IN_FLOOR
):
2093 builtin_optab
= floor_optab
; break;
2094 CASE_FLT_FN (BUILT_IN_CEIL
):
2095 builtin_optab
= ceil_optab
; break;
2096 CASE_FLT_FN (BUILT_IN_TRUNC
):
2097 builtin_optab
= btrunc_optab
; break;
2098 CASE_FLT_FN (BUILT_IN_ROUND
):
2099 builtin_optab
= round_optab
; break;
2100 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
2101 builtin_optab
= nearbyint_optab
;
2102 if (flag_trapping_math
)
2104 /* Else fallthrough and expand as rint. */
2105 CASE_FLT_FN (BUILT_IN_RINT
):
2106 builtin_optab
= rint_optab
; break;
2107 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
2108 builtin_optab
= significand_optab
; break;
2113 /* Make a suitable register to place result in. */
2114 mode
= TYPE_MODE (TREE_TYPE (exp
));
2116 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2119 /* Before working hard, check whether the instruction is available, but try
2120 to widen the mode for specific operations. */
2121 if ((optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
2122 || (try_widening
&& !excess_precision_type (TREE_TYPE (exp
))))
2123 && (!errno_set
|| !optimize_insn_for_size_p ()))
2125 rtx result
= gen_reg_rtx (mode
);
2127 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2128 need to expand the argument again. This way, we will not perform
2129 side-effects more the once. */
2130 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2132 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2136 /* Compute into RESULT.
2137 Set RESULT to wherever the result comes back. */
2138 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2143 expand_errno_check (exp
, result
);
2145 /* Output the entire sequence. */
2146 insns
= get_insns ();
2152 /* If we were unable to expand via the builtin, stop the sequence
2153 (without outputting the insns) and call to the library function
2154 with the stabilized argument list. */
2158 return expand_call (exp
, target
, target
== const0_rtx
);
2161 /* Expand a call to the builtin binary math functions (pow and atan2).
2162 Return NULL_RTX if a normal call should be emitted rather than expanding the
2163 function in-line. EXP is the expression that is a call to the builtin
2164 function; if convenient, the result should be placed in TARGET.
2165 SUBTARGET may be used as the target for computing one of EXP's
2169 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
2171 optab builtin_optab
;
2172 rtx op0
, op1
, result
;
2174 int op1_type
= REAL_TYPE
;
2175 tree fndecl
= get_callee_fndecl (exp
);
2178 bool errno_set
= true;
2180 switch (DECL_FUNCTION_CODE (fndecl
))
2182 CASE_FLT_FN (BUILT_IN_SCALBN
):
2183 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2184 CASE_FLT_FN (BUILT_IN_LDEXP
):
2185 op1_type
= INTEGER_TYPE
;
2190 if (!validate_arglist (exp
, REAL_TYPE
, op1_type
, VOID_TYPE
))
2193 arg0
= CALL_EXPR_ARG (exp
, 0);
2194 arg1
= CALL_EXPR_ARG (exp
, 1);
2196 switch (DECL_FUNCTION_CODE (fndecl
))
2198 CASE_FLT_FN (BUILT_IN_POW
):
2199 builtin_optab
= pow_optab
; break;
2200 CASE_FLT_FN (BUILT_IN_ATAN2
):
2201 builtin_optab
= atan2_optab
; break;
2202 CASE_FLT_FN (BUILT_IN_SCALB
):
2203 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2205 builtin_optab
= scalb_optab
; break;
2206 CASE_FLT_FN (BUILT_IN_SCALBN
):
2207 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2208 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2210 /* Fall through... */
2211 CASE_FLT_FN (BUILT_IN_LDEXP
):
2212 builtin_optab
= ldexp_optab
; break;
2213 CASE_FLT_FN (BUILT_IN_FMOD
):
2214 builtin_optab
= fmod_optab
; break;
2215 CASE_FLT_FN (BUILT_IN_REMAINDER
):
2216 CASE_FLT_FN (BUILT_IN_DREM
):
2217 builtin_optab
= remainder_optab
; break;
2222 /* Make a suitable register to place result in. */
2223 mode
= TYPE_MODE (TREE_TYPE (exp
));
2225 /* Before working hard, check whether the instruction is available. */
2226 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2229 result
= gen_reg_rtx (mode
);
2231 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2234 if (errno_set
&& optimize_insn_for_size_p ())
2237 /* Always stabilize the argument list. */
2238 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2239 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2241 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2242 op1
= expand_normal (arg1
);
2246 /* Compute into RESULT.
2247 Set RESULT to wherever the result comes back. */
2248 result
= expand_binop (mode
, builtin_optab
, op0
, op1
,
2249 result
, 0, OPTAB_DIRECT
);
2251 /* If we were unable to expand via the builtin, stop the sequence
2252 (without outputting the insns) and call to the library function
2253 with the stabilized argument list. */
2257 return expand_call (exp
, target
, target
== const0_rtx
);
2261 expand_errno_check (exp
, result
);
2263 /* Output the entire sequence. */
2264 insns
= get_insns ();
2271 /* Expand a call to the builtin trinary math functions (fma).
2272 Return NULL_RTX if a normal call should be emitted rather than expanding the
2273 function in-line. EXP is the expression that is a call to the builtin
2274 function; if convenient, the result should be placed in TARGET.
2275 SUBTARGET may be used as the target for computing one of EXP's
2279 expand_builtin_mathfn_ternary (tree exp
, rtx target
, rtx subtarget
)
2281 optab builtin_optab
;
2282 rtx op0
, op1
, op2
, result
;
2284 tree fndecl
= get_callee_fndecl (exp
);
2285 tree arg0
, arg1
, arg2
;
2288 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2291 arg0
= CALL_EXPR_ARG (exp
, 0);
2292 arg1
= CALL_EXPR_ARG (exp
, 1);
2293 arg2
= CALL_EXPR_ARG (exp
, 2);
2295 switch (DECL_FUNCTION_CODE (fndecl
))
2297 CASE_FLT_FN (BUILT_IN_FMA
):
2298 builtin_optab
= fma_optab
; break;
2303 /* Make a suitable register to place result in. */
2304 mode
= TYPE_MODE (TREE_TYPE (exp
));
2306 /* Before working hard, check whether the instruction is available. */
2307 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2310 result
= gen_reg_rtx (mode
);
2312 /* Always stabilize the argument list. */
2313 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2314 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2315 CALL_EXPR_ARG (exp
, 2) = arg2
= builtin_save_expr (arg2
);
2317 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2318 op1
= expand_normal (arg1
);
2319 op2
= expand_normal (arg2
);
2323 /* Compute into RESULT.
2324 Set RESULT to wherever the result comes back. */
2325 result
= expand_ternary_op (mode
, builtin_optab
, op0
, op1
, op2
,
2328 /* If we were unable to expand via the builtin, stop the sequence
2329 (without outputting the insns) and call to the library function
2330 with the stabilized argument list. */
2334 return expand_call (exp
, target
, target
== const0_rtx
);
2337 /* Output the entire sequence. */
2338 insns
= get_insns ();
2345 /* Expand a call to the builtin sin and cos math functions.
2346 Return NULL_RTX if a normal call should be emitted rather than expanding the
2347 function in-line. EXP is the expression that is a call to the builtin
2348 function; if convenient, the result should be placed in TARGET.
2349 SUBTARGET may be used as the target for computing one of EXP's
2353 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2355 optab builtin_optab
;
2358 tree fndecl
= get_callee_fndecl (exp
);
2362 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2365 arg
= CALL_EXPR_ARG (exp
, 0);
2367 switch (DECL_FUNCTION_CODE (fndecl
))
2369 CASE_FLT_FN (BUILT_IN_SIN
):
2370 CASE_FLT_FN (BUILT_IN_COS
):
2371 builtin_optab
= sincos_optab
; break;
2376 /* Make a suitable register to place result in. */
2377 mode
= TYPE_MODE (TREE_TYPE (exp
));
2379 /* Check if sincos insn is available, otherwise fallback
2380 to sin or cos insn. */
2381 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2382 switch (DECL_FUNCTION_CODE (fndecl
))
2384 CASE_FLT_FN (BUILT_IN_SIN
):
2385 builtin_optab
= sin_optab
; break;
2386 CASE_FLT_FN (BUILT_IN_COS
):
2387 builtin_optab
= cos_optab
; break;
2392 /* Before working hard, check whether the instruction is available. */
2393 if (optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
)
2395 rtx result
= gen_reg_rtx (mode
);
2397 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2398 need to expand the argument again. This way, we will not perform
2399 side-effects more the once. */
2400 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2402 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2406 /* Compute into RESULT.
2407 Set RESULT to wherever the result comes back. */
2408 if (builtin_optab
== sincos_optab
)
2412 switch (DECL_FUNCTION_CODE (fndecl
))
2414 CASE_FLT_FN (BUILT_IN_SIN
):
2415 ok
= expand_twoval_unop (builtin_optab
, op0
, 0, result
, 0);
2417 CASE_FLT_FN (BUILT_IN_COS
):
2418 ok
= expand_twoval_unop (builtin_optab
, op0
, result
, 0, 0);
2426 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2430 /* Output the entire sequence. */
2431 insns
= get_insns ();
2437 /* If we were unable to expand via the builtin, stop the sequence
2438 (without outputting the insns) and call to the library function
2439 with the stabilized argument list. */
2443 return expand_call (exp
, target
, target
== const0_rtx
);
2446 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2447 return an RTL instruction code that implements the functionality.
2448 If that isn't possible or available return CODE_FOR_nothing. */
2450 static enum insn_code
2451 interclass_mathfn_icode (tree arg
, tree fndecl
)
2453 bool errno_set
= false;
2454 optab builtin_optab
= unknown_optab
;
2457 switch (DECL_FUNCTION_CODE (fndecl
))
2459 CASE_FLT_FN (BUILT_IN_ILOGB
):
2460 errno_set
= true; builtin_optab
= ilogb_optab
; break;
2461 CASE_FLT_FN (BUILT_IN_ISINF
):
2462 builtin_optab
= isinf_optab
; break;
2463 case BUILT_IN_ISNORMAL
:
2464 case BUILT_IN_ISFINITE
:
2465 CASE_FLT_FN (BUILT_IN_FINITE
):
2466 case BUILT_IN_FINITED32
:
2467 case BUILT_IN_FINITED64
:
2468 case BUILT_IN_FINITED128
:
2469 case BUILT_IN_ISINFD32
:
2470 case BUILT_IN_ISINFD64
:
2471 case BUILT_IN_ISINFD128
:
2472 /* These builtins have no optabs (yet). */
2478 /* There's no easy way to detect the case we need to set EDOM. */
2479 if (flag_errno_math
&& errno_set
)
2480 return CODE_FOR_nothing
;
2482 /* Optab mode depends on the mode of the input argument. */
2483 mode
= TYPE_MODE (TREE_TYPE (arg
));
2486 return optab_handler (builtin_optab
, mode
);
2487 return CODE_FOR_nothing
;
2490 /* Expand a call to one of the builtin math functions that operate on
2491 floating point argument and output an integer result (ilogb, isinf,
2493 Return 0 if a normal call should be emitted rather than expanding the
2494 function in-line. EXP is the expression that is a call to the builtin
2495 function; if convenient, the result should be placed in TARGET. */
2498 expand_builtin_interclass_mathfn (tree exp
, rtx target
)
2500 enum insn_code icode
= CODE_FOR_nothing
;
2502 tree fndecl
= get_callee_fndecl (exp
);
2506 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2509 arg
= CALL_EXPR_ARG (exp
, 0);
2510 icode
= interclass_mathfn_icode (arg
, fndecl
);
2511 mode
= TYPE_MODE (TREE_TYPE (arg
));
2513 if (icode
!= CODE_FOR_nothing
)
2515 struct expand_operand ops
[1];
2516 rtx_insn
*last
= get_last_insn ();
2517 tree orig_arg
= arg
;
2519 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2520 need to expand the argument again. This way, we will not perform
2521 side-effects more the once. */
2522 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2524 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2526 if (mode
!= GET_MODE (op0
))
2527 op0
= convert_to_mode (mode
, op0
, 0);
2529 create_output_operand (&ops
[0], target
, TYPE_MODE (TREE_TYPE (exp
)));
2530 if (maybe_legitimize_operands (icode
, 0, 1, ops
)
2531 && maybe_emit_unop_insn (icode
, ops
[0].value
, op0
, UNKNOWN
))
2532 return ops
[0].value
;
2534 delete_insns_since (last
);
2535 CALL_EXPR_ARG (exp
, 0) = orig_arg
;
2541 /* Expand a call to the builtin sincos math function.
2542 Return NULL_RTX if a normal call should be emitted rather than expanding the
2543 function in-line. EXP is the expression that is a call to the builtin
2547 expand_builtin_sincos (tree exp
)
2549 rtx op0
, op1
, op2
, target1
, target2
;
2551 tree arg
, sinp
, cosp
;
2553 location_t loc
= EXPR_LOCATION (exp
);
2554 tree alias_type
, alias_off
;
2556 if (!validate_arglist (exp
, REAL_TYPE
,
2557 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2560 arg
= CALL_EXPR_ARG (exp
, 0);
2561 sinp
= CALL_EXPR_ARG (exp
, 1);
2562 cosp
= CALL_EXPR_ARG (exp
, 2);
2564 /* Make a suitable register to place result in. */
2565 mode
= TYPE_MODE (TREE_TYPE (arg
));
2567 /* Check if sincos insn is available, otherwise emit the call. */
2568 if (optab_handler (sincos_optab
, mode
) == CODE_FOR_nothing
)
2571 target1
= gen_reg_rtx (mode
);
2572 target2
= gen_reg_rtx (mode
);
2574 op0
= expand_normal (arg
);
2575 alias_type
= build_pointer_type_for_mode (TREE_TYPE (arg
), ptr_mode
, true);
2576 alias_off
= build_int_cst (alias_type
, 0);
2577 op1
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2579 op2
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2582 /* Compute into target1 and target2.
2583 Set TARGET to wherever the result comes back. */
2584 result
= expand_twoval_unop (sincos_optab
, op0
, target2
, target1
, 0);
2585 gcc_assert (result
);
2587 /* Move target1 and target2 to the memory locations indicated
2589 emit_move_insn (op1
, target1
);
2590 emit_move_insn (op2
, target2
);
2595 /* Expand a call to the internal cexpi builtin to the sincos math function.
2596 EXP is the expression that is a call to the builtin function; if convenient,
2597 the result should be placed in TARGET. */
2600 expand_builtin_cexpi (tree exp
, rtx target
)
2602 tree fndecl
= get_callee_fndecl (exp
);
2606 location_t loc
= EXPR_LOCATION (exp
);
2608 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2611 arg
= CALL_EXPR_ARG (exp
, 0);
2612 type
= TREE_TYPE (arg
);
2613 mode
= TYPE_MODE (TREE_TYPE (arg
));
2615 /* Try expanding via a sincos optab, fall back to emitting a libcall
2616 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2617 is only generated from sincos, cexp or if we have either of them. */
2618 if (optab_handler (sincos_optab
, mode
) != CODE_FOR_nothing
)
2620 op1
= gen_reg_rtx (mode
);
2621 op2
= gen_reg_rtx (mode
);
2623 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2625 /* Compute into op1 and op2. */
2626 expand_twoval_unop (sincos_optab
, op0
, op2
, op1
, 0);
2628 else if (targetm
.libc_has_function (function_sincos
))
2630 tree call
, fn
= NULL_TREE
;
2634 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2635 fn
= builtin_decl_explicit (BUILT_IN_SINCOSF
);
2636 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2637 fn
= builtin_decl_explicit (BUILT_IN_SINCOS
);
2638 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2639 fn
= builtin_decl_explicit (BUILT_IN_SINCOSL
);
2643 op1
= assign_temp (TREE_TYPE (arg
), 1, 1);
2644 op2
= assign_temp (TREE_TYPE (arg
), 1, 1);
2645 op1a
= copy_addr_to_reg (XEXP (op1
, 0));
2646 op2a
= copy_addr_to_reg (XEXP (op2
, 0));
2647 top1
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op1a
);
2648 top2
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op2a
);
2650 /* Make sure not to fold the sincos call again. */
2651 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2652 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn
)),
2653 call
, 3, arg
, top1
, top2
));
2657 tree call
, fn
= NULL_TREE
, narg
;
2658 tree ctype
= build_complex_type (type
);
2660 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2661 fn
= builtin_decl_explicit (BUILT_IN_CEXPF
);
2662 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2663 fn
= builtin_decl_explicit (BUILT_IN_CEXP
);
2664 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2665 fn
= builtin_decl_explicit (BUILT_IN_CEXPL
);
2669 /* If we don't have a decl for cexp create one. This is the
2670 friendliest fallback if the user calls __builtin_cexpi
2671 without full target C99 function support. */
2672 if (fn
== NULL_TREE
)
2675 const char *name
= NULL
;
2677 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2679 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2681 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2684 fntype
= build_function_type_list (ctype
, ctype
, NULL_TREE
);
2685 fn
= build_fn_decl (name
, fntype
);
2688 narg
= fold_build2_loc (loc
, COMPLEX_EXPR
, ctype
,
2689 build_real (type
, dconst0
), arg
);
2691 /* Make sure not to fold the cexp call again. */
2692 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2693 return expand_expr (build_call_nary (ctype
, call
, 1, narg
),
2694 target
, VOIDmode
, EXPAND_NORMAL
);
2697 /* Now build the proper return type. */
2698 return expand_expr (build2 (COMPLEX_EXPR
, build_complex_type (type
),
2699 make_tree (TREE_TYPE (arg
), op2
),
2700 make_tree (TREE_TYPE (arg
), op1
)),
2701 target
, VOIDmode
, EXPAND_NORMAL
);
2704 /* Conveniently construct a function call expression. FNDECL names the
2705 function to be called, N is the number of arguments, and the "..."
2706 parameters are the argument expressions. Unlike build_call_exr
2707 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2710 build_call_nofold_loc (location_t loc
, tree fndecl
, int n
, ...)
2713 tree fntype
= TREE_TYPE (fndecl
);
2714 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
2717 fn
= build_call_valist (TREE_TYPE (fntype
), fn
, n
, ap
);
2719 SET_EXPR_LOCATION (fn
, loc
);
2723 /* Expand a call to one of the builtin rounding functions gcc defines
2724 as an extension (lfloor and lceil). As these are gcc extensions we
2725 do not need to worry about setting errno to EDOM.
2726 If expanding via optab fails, lower expression to (int)(floor(x)).
2727 EXP is the expression that is a call to the builtin function;
2728 if convenient, the result should be placed in TARGET. */
2731 expand_builtin_int_roundingfn (tree exp
, rtx target
)
2733 convert_optab builtin_optab
;
2736 tree fndecl
= get_callee_fndecl (exp
);
2737 enum built_in_function fallback_fn
;
2738 tree fallback_fndecl
;
2742 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2745 arg
= CALL_EXPR_ARG (exp
, 0);
2747 switch (DECL_FUNCTION_CODE (fndecl
))
2749 CASE_FLT_FN (BUILT_IN_ICEIL
):
2750 CASE_FLT_FN (BUILT_IN_LCEIL
):
2751 CASE_FLT_FN (BUILT_IN_LLCEIL
):
2752 builtin_optab
= lceil_optab
;
2753 fallback_fn
= BUILT_IN_CEIL
;
2756 CASE_FLT_FN (BUILT_IN_IFLOOR
):
2757 CASE_FLT_FN (BUILT_IN_LFLOOR
):
2758 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
2759 builtin_optab
= lfloor_optab
;
2760 fallback_fn
= BUILT_IN_FLOOR
;
2767 /* Make a suitable register to place result in. */
2768 mode
= TYPE_MODE (TREE_TYPE (exp
));
2770 target
= gen_reg_rtx (mode
);
2772 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2773 need to expand the argument again. This way, we will not perform
2774 side-effects more the once. */
2775 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2777 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2781 /* Compute into TARGET. */
2782 if (expand_sfix_optab (target
, op0
, builtin_optab
))
2784 /* Output the entire sequence. */
2785 insns
= get_insns ();
2791 /* If we were unable to expand via the builtin, stop the sequence
2792 (without outputting the insns). */
2795 /* Fall back to floating point rounding optab. */
2796 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
2798 /* For non-C99 targets we may end up without a fallback fndecl here
2799 if the user called __builtin_lfloor directly. In this case emit
2800 a call to the floor/ceil variants nevertheless. This should result
2801 in the best user experience for not full C99 targets. */
2802 if (fallback_fndecl
== NULL_TREE
)
2805 const char *name
= NULL
;
2807 switch (DECL_FUNCTION_CODE (fndecl
))
2809 case BUILT_IN_ICEIL
:
2810 case BUILT_IN_LCEIL
:
2811 case BUILT_IN_LLCEIL
:
2814 case BUILT_IN_ICEILF
:
2815 case BUILT_IN_LCEILF
:
2816 case BUILT_IN_LLCEILF
:
2819 case BUILT_IN_ICEILL
:
2820 case BUILT_IN_LCEILL
:
2821 case BUILT_IN_LLCEILL
:
2824 case BUILT_IN_IFLOOR
:
2825 case BUILT_IN_LFLOOR
:
2826 case BUILT_IN_LLFLOOR
:
2829 case BUILT_IN_IFLOORF
:
2830 case BUILT_IN_LFLOORF
:
2831 case BUILT_IN_LLFLOORF
:
2834 case BUILT_IN_IFLOORL
:
2835 case BUILT_IN_LFLOORL
:
2836 case BUILT_IN_LLFLOORL
:
2843 fntype
= build_function_type_list (TREE_TYPE (arg
),
2844 TREE_TYPE (arg
), NULL_TREE
);
2845 fallback_fndecl
= build_fn_decl (name
, fntype
);
2848 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
), fallback_fndecl
, 1, arg
);
2850 tmp
= expand_normal (exp
);
2851 tmp
= maybe_emit_group_store (tmp
, TREE_TYPE (exp
));
2853 /* Truncate the result of floating point optab to integer
2854 via expand_fix (). */
2855 target
= gen_reg_rtx (mode
);
2856 expand_fix (target
, tmp
, 0);
2861 /* Expand a call to one of the builtin math functions doing integer
2863 Return 0 if a normal call should be emitted rather than expanding the
2864 function in-line. EXP is the expression that is a call to the builtin
2865 function; if convenient, the result should be placed in TARGET. */
2868 expand_builtin_int_roundingfn_2 (tree exp
, rtx target
)
2870 convert_optab builtin_optab
;
2873 tree fndecl
= get_callee_fndecl (exp
);
2876 enum built_in_function fallback_fn
= BUILT_IN_NONE
;
2878 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2881 arg
= CALL_EXPR_ARG (exp
, 0);
2883 switch (DECL_FUNCTION_CODE (fndecl
))
2885 CASE_FLT_FN (BUILT_IN_IRINT
):
2886 fallback_fn
= BUILT_IN_LRINT
;
2888 CASE_FLT_FN (BUILT_IN_LRINT
):
2889 CASE_FLT_FN (BUILT_IN_LLRINT
):
2890 builtin_optab
= lrint_optab
;
2893 CASE_FLT_FN (BUILT_IN_IROUND
):
2894 fallback_fn
= BUILT_IN_LROUND
;
2896 CASE_FLT_FN (BUILT_IN_LROUND
):
2897 CASE_FLT_FN (BUILT_IN_LLROUND
):
2898 builtin_optab
= lround_optab
;
2905 /* There's no easy way to detect the case we need to set EDOM. */
2906 if (flag_errno_math
&& fallback_fn
== BUILT_IN_NONE
)
2909 /* Make a suitable register to place result in. */
2910 mode
= TYPE_MODE (TREE_TYPE (exp
));
2912 /* There's no easy way to detect the case we need to set EDOM. */
2913 if (!flag_errno_math
)
2915 rtx result
= gen_reg_rtx (mode
);
2917 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2918 need to expand the argument again. This way, we will not perform
2919 side-effects more the once. */
2920 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2922 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2926 if (expand_sfix_optab (result
, op0
, builtin_optab
))
2928 /* Output the entire sequence. */
2929 insns
= get_insns ();
2935 /* If we were unable to expand via the builtin, stop the sequence
2936 (without outputting the insns) and call to the library function
2937 with the stabilized argument list. */
2941 if (fallback_fn
!= BUILT_IN_NONE
)
2943 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2944 targets, (int) round (x) should never be transformed into
2945 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2946 a call to lround in the hope that the target provides at least some
2947 C99 functions. This should result in the best user experience for
2948 not full C99 targets. */
2949 tree fallback_fndecl
= mathfn_built_in_1 (TREE_TYPE (arg
),
2952 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
),
2953 fallback_fndecl
, 1, arg
);
2955 target
= expand_call (exp
, NULL_RTX
, target
== const0_rtx
);
2956 target
= maybe_emit_group_store (target
, TREE_TYPE (exp
));
2957 return convert_to_mode (mode
, target
, 0);
2960 return expand_call (exp
, target
, target
== const0_rtx
);
2963 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2964 a normal call should be emitted rather than expanding the function
2965 in-line. EXP is the expression that is a call to the builtin
2966 function; if convenient, the result should be placed in TARGET. */
2969 expand_builtin_powi (tree exp
, rtx target
)
2976 if (! validate_arglist (exp
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2979 arg0
= CALL_EXPR_ARG (exp
, 0);
2980 arg1
= CALL_EXPR_ARG (exp
, 1);
2981 mode
= TYPE_MODE (TREE_TYPE (exp
));
2983 /* Emit a libcall to libgcc. */
2985 /* Mode of the 2nd argument must match that of an int. */
2986 mode2
= mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0);
2988 if (target
== NULL_RTX
)
2989 target
= gen_reg_rtx (mode
);
2991 op0
= expand_expr (arg0
, NULL_RTX
, mode
, EXPAND_NORMAL
);
2992 if (GET_MODE (op0
) != mode
)
2993 op0
= convert_to_mode (mode
, op0
, 0);
2994 op1
= expand_expr (arg1
, NULL_RTX
, mode2
, EXPAND_NORMAL
);
2995 if (GET_MODE (op1
) != mode2
)
2996 op1
= convert_to_mode (mode2
, op1
, 0);
2998 target
= emit_library_call_value (optab_libfunc (powi_optab
, mode
),
2999 target
, LCT_CONST
, mode
, 2,
3000 op0
, mode
, op1
, mode2
);
3005 /* Expand expression EXP which is a call to the strlen builtin. Return
3006 NULL_RTX if we failed the caller should emit a normal call, otherwise
3007 try to get the result in TARGET, if convenient. */
3010 expand_builtin_strlen (tree exp
, rtx target
,
3011 machine_mode target_mode
)
3013 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
3017 struct expand_operand ops
[4];
3020 tree src
= CALL_EXPR_ARG (exp
, 0);
3022 rtx_insn
*before_strlen
;
3023 machine_mode insn_mode
= target_mode
;
3024 enum insn_code icode
= CODE_FOR_nothing
;
3027 /* If the length can be computed at compile-time, return it. */
3028 len
= c_strlen (src
, 0);
3030 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3032 /* If the length can be computed at compile-time and is constant
3033 integer, but there are side-effects in src, evaluate
3034 src for side-effects, then return len.
3035 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3036 can be optimized into: i++; x = 3; */
3037 len
= c_strlen (src
, 1);
3038 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
3040 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3041 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3044 align
= get_pointer_alignment (src
) / BITS_PER_UNIT
;
3046 /* If SRC is not a pointer type, don't do this operation inline. */
3050 /* Bail out if we can't compute strlen in the right mode. */
3051 while (insn_mode
!= VOIDmode
)
3053 icode
= optab_handler (strlen_optab
, insn_mode
);
3054 if (icode
!= CODE_FOR_nothing
)
3057 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
3059 if (insn_mode
== VOIDmode
)
3062 /* Make a place to hold the source address. We will not expand
3063 the actual source until we are sure that the expansion will
3064 not fail -- there are trees that cannot be expanded twice. */
3065 src_reg
= gen_reg_rtx (Pmode
);
3067 /* Mark the beginning of the strlen sequence so we can emit the
3068 source operand later. */
3069 before_strlen
= get_last_insn ();
3071 create_output_operand (&ops
[0], target
, insn_mode
);
3072 create_fixed_operand (&ops
[1], gen_rtx_MEM (BLKmode
, src_reg
));
3073 create_integer_operand (&ops
[2], 0);
3074 create_integer_operand (&ops
[3], align
);
3075 if (!maybe_expand_insn (icode
, 4, ops
))
3078 /* Now that we are assured of success, expand the source. */
3080 pat
= expand_expr (src
, src_reg
, Pmode
, EXPAND_NORMAL
);
3083 #ifdef POINTERS_EXTEND_UNSIGNED
3084 if (GET_MODE (pat
) != Pmode
)
3085 pat
= convert_to_mode (Pmode
, pat
,
3086 POINTERS_EXTEND_UNSIGNED
);
3088 emit_move_insn (src_reg
, pat
);
3094 emit_insn_after (pat
, before_strlen
);
3096 emit_insn_before (pat
, get_insns ());
3098 /* Return the value in the proper mode for this function. */
3099 if (GET_MODE (ops
[0].value
) == target_mode
)
3100 target
= ops
[0].value
;
3101 else if (target
!= 0)
3102 convert_move (target
, ops
[0].value
, 0);
3104 target
= convert_to_mode (target_mode
, ops
[0].value
, 0);
3110 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3111 bytes from constant string DATA + OFFSET and return it as target
3115 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
3118 const char *str
= (const char *) data
;
3120 gcc_assert (offset
>= 0
3121 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
3122 <= strlen (str
) + 1));
3124 return c_readstr (str
+ offset
, mode
);
3127 /* LEN specify length of the block of memcpy/memset operation.
3128 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
3129 In some cases we can make very likely guess on max size, then we
3130 set it into PROBABLE_MAX_SIZE. */
3133 determine_block_size (tree len
, rtx len_rtx
,
3134 unsigned HOST_WIDE_INT
*min_size
,
3135 unsigned HOST_WIDE_INT
*max_size
,
3136 unsigned HOST_WIDE_INT
*probable_max_size
)
3138 if (CONST_INT_P (len_rtx
))
3140 *min_size
= *max_size
= *probable_max_size
= UINTVAL (len_rtx
);
3146 enum value_range_type range_type
= VR_UNDEFINED
;
3148 /* Determine bounds from the type. */
3149 if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len
))))
3150 *min_size
= tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len
)));
3153 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len
))))
3154 *probable_max_size
= *max_size
3155 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len
)));
3157 *probable_max_size
= *max_size
= GET_MODE_MASK (GET_MODE (len_rtx
));
3159 if (TREE_CODE (len
) == SSA_NAME
)
3160 range_type
= get_range_info (len
, &min
, &max
);
3161 if (range_type
== VR_RANGE
)
3163 if (wi::fits_uhwi_p (min
) && *min_size
< min
.to_uhwi ())
3164 *min_size
= min
.to_uhwi ();
3165 if (wi::fits_uhwi_p (max
) && *max_size
> max
.to_uhwi ())
3166 *probable_max_size
= *max_size
= max
.to_uhwi ();
3168 else if (range_type
== VR_ANTI_RANGE
)
3170 /* Anti range 0...N lets us to determine minimal size to N+1. */
3173 if (wi::fits_uhwi_p (max
) && max
.to_uhwi () + 1 != 0)
3174 *min_size
= max
.to_uhwi () + 1;
3182 Produce anti range allowing negative values of N. We still
3183 can use the information and make a guess that N is not negative.
3185 else if (!wi::leu_p (max
, 1 << 30) && wi::fits_uhwi_p (min
))
3186 *probable_max_size
= min
.to_uhwi () - 1;
3189 gcc_checking_assert (*max_size
<=
3190 (unsigned HOST_WIDE_INT
)
3191 GET_MODE_MASK (GET_MODE (len_rtx
)));
3194 /* Helper function to do the actual work for expand_builtin_memcpy. */
3197 expand_builtin_memcpy_args (tree dest
, tree src
, tree len
, rtx target
, tree exp
)
3199 const char *src_str
;
3200 unsigned int src_align
= get_pointer_alignment (src
);
3201 unsigned int dest_align
= get_pointer_alignment (dest
);
3202 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
3203 HOST_WIDE_INT expected_size
= -1;
3204 unsigned int expected_align
= 0;
3205 unsigned HOST_WIDE_INT min_size
;
3206 unsigned HOST_WIDE_INT max_size
;
3207 unsigned HOST_WIDE_INT probable_max_size
;
3209 /* If DEST is not a pointer type, call the normal function. */
3210 if (dest_align
== 0)
3213 /* If either SRC is not a pointer type, don't do this
3214 operation in-line. */
3218 if (currently_expanding_gimple_stmt
)
3219 stringop_block_profile (currently_expanding_gimple_stmt
,
3220 &expected_align
, &expected_size
);
3222 if (expected_align
< dest_align
)
3223 expected_align
= dest_align
;
3224 dest_mem
= get_memory_rtx (dest
, len
);
3225 set_mem_align (dest_mem
, dest_align
);
3226 len_rtx
= expand_normal (len
);
3227 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3228 &probable_max_size
);
3229 src_str
= c_getstr (src
);
3231 /* If SRC is a string constant and block move would be done
3232 by pieces, we can avoid loading the string from memory
3233 and only stored the computed constants. */
3235 && CONST_INT_P (len_rtx
)
3236 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3237 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3238 CONST_CAST (char *, src_str
),
3241 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3242 builtin_memcpy_read_str
,
3243 CONST_CAST (char *, src_str
),
3244 dest_align
, false, 0);
3245 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3246 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3250 src_mem
= get_memory_rtx (src
, len
);
3251 set_mem_align (src_mem
, src_align
);
3253 /* Copy word part most expediently. */
3254 dest_addr
= emit_block_move_hints (dest_mem
, src_mem
, len_rtx
,
3255 CALL_EXPR_TAILCALL (exp
)
3256 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3257 expected_align
, expected_size
,
3258 min_size
, max_size
, probable_max_size
);
3262 dest_addr
= force_operand (XEXP (dest_mem
, 0), target
);
3263 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3269 /* Expand a call EXP to the memcpy builtin.
3270 Return NULL_RTX if we failed, the caller should emit a normal call,
3271 otherwise try to get the result in TARGET, if convenient (and in
3272 mode MODE if that's convenient). */
3275 expand_builtin_memcpy (tree exp
, rtx target
)
3277 if (!validate_arglist (exp
,
3278 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3282 tree dest
= CALL_EXPR_ARG (exp
, 0);
3283 tree src
= CALL_EXPR_ARG (exp
, 1);
3284 tree len
= CALL_EXPR_ARG (exp
, 2);
3285 return expand_builtin_memcpy_args (dest
, src
, len
, target
, exp
);
3289 /* Expand an instrumented call EXP to the memcpy builtin.
3290 Return NULL_RTX if we failed, the caller should emit a normal call,
3291 otherwise try to get the result in TARGET, if convenient (and in
3292 mode MODE if that's convenient). */
3295 expand_builtin_memcpy_with_bounds (tree exp
, rtx target
)
3297 if (!validate_arglist (exp
,
3298 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3299 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3300 INTEGER_TYPE
, VOID_TYPE
))
3304 tree dest
= CALL_EXPR_ARG (exp
, 0);
3305 tree src
= CALL_EXPR_ARG (exp
, 2);
3306 tree len
= CALL_EXPR_ARG (exp
, 4);
3307 rtx res
= expand_builtin_memcpy_args (dest
, src
, len
, target
, exp
);
3309 /* Return src bounds with the result. */
3312 rtx bnd
= force_reg (targetm
.chkp_bound_mode (),
3313 expand_normal (CALL_EXPR_ARG (exp
, 1)));
3314 res
= chkp_join_splitted_slot (res
, bnd
);
3320 /* Expand a call EXP to the mempcpy builtin.
3321 Return NULL_RTX if we failed; the caller should emit a normal call,
3322 otherwise try to get the result in TARGET, if convenient (and in
3323 mode MODE if that's convenient). If ENDP is 0 return the
3324 destination pointer, if ENDP is 1 return the end pointer ala
3325 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3329 expand_builtin_mempcpy (tree exp
, rtx target
, machine_mode mode
)
3331 if (!validate_arglist (exp
,
3332 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3336 tree dest
= CALL_EXPR_ARG (exp
, 0);
3337 tree src
= CALL_EXPR_ARG (exp
, 1);
3338 tree len
= CALL_EXPR_ARG (exp
, 2);
3339 return expand_builtin_mempcpy_args (dest
, src
, len
,
3340 target
, mode
, /*endp=*/ 1,
3345 /* Expand an instrumented call EXP to the mempcpy builtin.
3346 Return NULL_RTX if we failed, the caller should emit a normal call,
3347 otherwise try to get the result in TARGET, if convenient (and in
3348 mode MODE if that's convenient). */
3351 expand_builtin_mempcpy_with_bounds (tree exp
, rtx target
, machine_mode mode
)
3353 if (!validate_arglist (exp
,
3354 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3355 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3356 INTEGER_TYPE
, VOID_TYPE
))
3360 tree dest
= CALL_EXPR_ARG (exp
, 0);
3361 tree src
= CALL_EXPR_ARG (exp
, 2);
3362 tree len
= CALL_EXPR_ARG (exp
, 4);
3363 rtx res
= expand_builtin_mempcpy_args (dest
, src
, len
, target
,
3366 /* Return src bounds with the result. */
3369 rtx bnd
= force_reg (targetm
.chkp_bound_mode (),
3370 expand_normal (CALL_EXPR_ARG (exp
, 1)));
3371 res
= chkp_join_splitted_slot (res
, bnd
);
3377 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3378 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3379 so that this can also be called without constructing an actual CALL_EXPR.
3380 The other arguments and return value are the same as for
3381 expand_builtin_mempcpy. */
3384 expand_builtin_mempcpy_args (tree dest
, tree src
, tree len
,
3385 rtx target
, machine_mode mode
, int endp
,
3388 tree fndecl
= get_callee_fndecl (orig_exp
);
3390 /* If return value is ignored, transform mempcpy into memcpy. */
3391 if (target
== const0_rtx
3392 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP
3393 && builtin_decl_implicit_p (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP
))
3395 tree fn
= builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP
);
3396 tree result
= build_call_nofold_loc (UNKNOWN_LOCATION
, fn
, 3,
3398 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3400 else if (target
== const0_rtx
3401 && builtin_decl_implicit_p (BUILT_IN_MEMCPY
))
3403 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3404 tree result
= build_call_nofold_loc (UNKNOWN_LOCATION
, fn
, 3,
3406 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3410 const char *src_str
;
3411 unsigned int src_align
= get_pointer_alignment (src
);
3412 unsigned int dest_align
= get_pointer_alignment (dest
);
3413 rtx dest_mem
, src_mem
, len_rtx
;
3415 /* If either SRC or DEST is not a pointer type, don't do this
3416 operation in-line. */
3417 if (dest_align
== 0 || src_align
== 0)
3420 /* If LEN is not constant, call the normal function. */
3421 if (! tree_fits_uhwi_p (len
))
3424 len_rtx
= expand_normal (len
);
3425 src_str
= c_getstr (src
);
3427 /* If SRC is a string constant and block move would be done
3428 by pieces, we can avoid loading the string from memory
3429 and only stored the computed constants. */
3431 && CONST_INT_P (len_rtx
)
3432 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3433 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3434 CONST_CAST (char *, src_str
),
3437 dest_mem
= get_memory_rtx (dest
, len
);
3438 set_mem_align (dest_mem
, dest_align
);
3439 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3440 builtin_memcpy_read_str
,
3441 CONST_CAST (char *, src_str
),
3442 dest_align
, false, endp
);
3443 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3444 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3448 if (CONST_INT_P (len_rtx
)
3449 && can_move_by_pieces (INTVAL (len_rtx
),
3450 MIN (dest_align
, src_align
)))
3452 dest_mem
= get_memory_rtx (dest
, len
);
3453 set_mem_align (dest_mem
, dest_align
);
3454 src_mem
= get_memory_rtx (src
, len
);
3455 set_mem_align (src_mem
, src_align
);
3456 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
3457 MIN (dest_align
, src_align
), endp
);
3458 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3459 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3468 # define HAVE_movstr 0
3469 # define CODE_FOR_movstr CODE_FOR_nothing
3472 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3473 we failed, the caller should emit a normal call, otherwise try to
3474 get the result in TARGET, if convenient. If ENDP is 0 return the
3475 destination pointer, if ENDP is 1 return the end pointer ala
3476 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3480 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3482 struct expand_operand ops
[3];
3489 dest_mem
= get_memory_rtx (dest
, NULL
);
3490 src_mem
= get_memory_rtx (src
, NULL
);
3493 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3494 dest_mem
= replace_equiv_address (dest_mem
, target
);
3497 create_output_operand (&ops
[0], endp
? target
: NULL_RTX
, Pmode
);
3498 create_fixed_operand (&ops
[1], dest_mem
);
3499 create_fixed_operand (&ops
[2], src_mem
);
3500 if (!maybe_expand_insn (CODE_FOR_movstr
, 3, ops
))
3503 if (endp
&& target
!= const0_rtx
)
3505 target
= ops
[0].value
;
3506 /* movstr is supposed to set end to the address of the NUL
3507 terminator. If the caller requested a mempcpy-like return value,
3511 rtx tem
= plus_constant (GET_MODE (target
),
3512 gen_lowpart (GET_MODE (target
), target
), 1);
3513 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3519 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3520 NULL_RTX if we failed the caller should emit a normal call, otherwise
3521 try to get the result in TARGET, if convenient (and in mode MODE if that's
3525 expand_builtin_strcpy (tree exp
, rtx target
)
3527 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3529 tree dest
= CALL_EXPR_ARG (exp
, 0);
3530 tree src
= CALL_EXPR_ARG (exp
, 1);
3531 return expand_builtin_strcpy_args (dest
, src
, target
);
3536 /* Helper function to do the actual work for expand_builtin_strcpy. The
3537 arguments to the builtin_strcpy call DEST and SRC are broken out
3538 so that this can also be called without constructing an actual CALL_EXPR.
3539 The other arguments and return value are the same as for
3540 expand_builtin_strcpy. */
3543 expand_builtin_strcpy_args (tree dest
, tree src
, rtx target
)
3545 return expand_movstr (dest
, src
, target
, /*endp=*/0);
3548 /* Expand a call EXP to the stpcpy builtin.
3549 Return NULL_RTX if we failed the caller should emit a normal call,
3550 otherwise try to get the result in TARGET, if convenient (and in
3551 mode MODE if that's convenient). */
3554 expand_builtin_stpcpy (tree exp
, rtx target
, machine_mode mode
)
3557 location_t loc
= EXPR_LOCATION (exp
);
3559 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3562 dst
= CALL_EXPR_ARG (exp
, 0);
3563 src
= CALL_EXPR_ARG (exp
, 1);
3565 /* If return value is ignored, transform stpcpy into strcpy. */
3566 if (target
== const0_rtx
&& builtin_decl_implicit (BUILT_IN_STRCPY
))
3568 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3569 tree result
= build_call_nofold_loc (loc
, fn
, 2, dst
, src
);
3570 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3577 /* Ensure we get an actual string whose length can be evaluated at
3578 compile-time, not an expression containing a string. This is
3579 because the latter will potentially produce pessimized code
3580 when used to produce the return value. */
3581 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3582 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3584 lenp1
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
3585 ret
= expand_builtin_mempcpy_args (dst
, src
, lenp1
,
3586 target
, mode
, /*endp=*/2,
3592 if (TREE_CODE (len
) == INTEGER_CST
)
3594 rtx len_rtx
= expand_normal (len
);
3596 if (CONST_INT_P (len_rtx
))
3598 ret
= expand_builtin_strcpy_args (dst
, src
, target
);
3604 if (mode
!= VOIDmode
)
3605 target
= gen_reg_rtx (mode
);
3607 target
= gen_reg_rtx (GET_MODE (ret
));
3609 if (GET_MODE (target
) != GET_MODE (ret
))
3610 ret
= gen_lowpart (GET_MODE (target
), ret
);
3612 ret
= plus_constant (GET_MODE (ret
), ret
, INTVAL (len_rtx
));
3613 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3621 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3625 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3626 bytes from constant string DATA + OFFSET and return it as target
3630 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3633 const char *str
= (const char *) data
;
3635 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3638 return c_readstr (str
+ offset
, mode
);
3641 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3642 NULL_RTX if we failed the caller should emit a normal call. */
3645 expand_builtin_strncpy (tree exp
, rtx target
)
3647 location_t loc
= EXPR_LOCATION (exp
);
3649 if (validate_arglist (exp
,
3650 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3652 tree dest
= CALL_EXPR_ARG (exp
, 0);
3653 tree src
= CALL_EXPR_ARG (exp
, 1);
3654 tree len
= CALL_EXPR_ARG (exp
, 2);
3655 tree slen
= c_strlen (src
, 1);
3657 /* We must be passed a constant len and src parameter. */
3658 if (!tree_fits_uhwi_p (len
) || !slen
|| !tree_fits_uhwi_p (slen
))
3661 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
3663 /* We're required to pad with trailing zeros if the requested
3664 len is greater than strlen(s2)+1. In that case try to
3665 use store_by_pieces, if it fails, punt. */
3666 if (tree_int_cst_lt (slen
, len
))
3668 unsigned int dest_align
= get_pointer_alignment (dest
);
3669 const char *p
= c_getstr (src
);
3672 if (!p
|| dest_align
== 0 || !tree_fits_uhwi_p (len
)
3673 || !can_store_by_pieces (tree_to_uhwi (len
),
3674 builtin_strncpy_read_str
,
3675 CONST_CAST (char *, p
),
3679 dest_mem
= get_memory_rtx (dest
, len
);
3680 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3681 builtin_strncpy_read_str
,
3682 CONST_CAST (char *, p
), dest_align
, false, 0);
3683 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3684 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3691 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3692 bytes from constant string DATA + OFFSET and return it as target
3696 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3699 const char *c
= (const char *) data
;
3700 char *p
= XALLOCAVEC (char, GET_MODE_SIZE (mode
));
3702 memset (p
, *c
, GET_MODE_SIZE (mode
));
3704 return c_readstr (p
, mode
);
3707 /* Callback routine for store_by_pieces. Return the RTL of a register
3708 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3709 char value given in the RTL register data. For example, if mode is
3710 4 bytes wide, return the RTL for 0x01010101*data. */
3713 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3720 size
= GET_MODE_SIZE (mode
);
3724 p
= XALLOCAVEC (char, size
);
3725 memset (p
, 1, size
);
3726 coeff
= c_readstr (p
, mode
);
3728 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3729 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3730 return force_reg (mode
, target
);
3733 /* Expand expression EXP, which is a call to the memset builtin. Return
3734 NULL_RTX if we failed the caller should emit a normal call, otherwise
3735 try to get the result in TARGET, if convenient (and in mode MODE if that's
3739 expand_builtin_memset (tree exp
, rtx target
, machine_mode mode
)
3741 if (!validate_arglist (exp
,
3742 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3746 tree dest
= CALL_EXPR_ARG (exp
, 0);
3747 tree val
= CALL_EXPR_ARG (exp
, 1);
3748 tree len
= CALL_EXPR_ARG (exp
, 2);
3749 return expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
3753 /* Expand expression EXP, which is an instrumented call to the memset builtin.
3754 Return NULL_RTX if we failed the caller should emit a normal call, otherwise
3755 try to get the result in TARGET, if convenient (and in mode MODE if that's
3759 expand_builtin_memset_with_bounds (tree exp
, rtx target
, machine_mode mode
)
3761 if (!validate_arglist (exp
,
3762 POINTER_TYPE
, POINTER_BOUNDS_TYPE
,
3763 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3767 tree dest
= CALL_EXPR_ARG (exp
, 0);
3768 tree val
= CALL_EXPR_ARG (exp
, 2);
3769 tree len
= CALL_EXPR_ARG (exp
, 3);
3770 rtx res
= expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
3772 /* Return src bounds with the result. */
3775 rtx bnd
= force_reg (targetm
.chkp_bound_mode (),
3776 expand_normal (CALL_EXPR_ARG (exp
, 1)));
3777 res
= chkp_join_splitted_slot (res
, bnd
);
3783 /* Helper function to do the actual work for expand_builtin_memset. The
3784 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3785 so that this can also be called without constructing an actual CALL_EXPR.
3786 The other arguments and return value are the same as for
3787 expand_builtin_memset. */
3790 expand_builtin_memset_args (tree dest
, tree val
, tree len
,
3791 rtx target
, machine_mode mode
, tree orig_exp
)
3794 enum built_in_function fcode
;
3795 machine_mode val_mode
;
3797 unsigned int dest_align
;
3798 rtx dest_mem
, dest_addr
, len_rtx
;
3799 HOST_WIDE_INT expected_size
= -1;
3800 unsigned int expected_align
= 0;
3801 unsigned HOST_WIDE_INT min_size
;
3802 unsigned HOST_WIDE_INT max_size
;
3803 unsigned HOST_WIDE_INT probable_max_size
;
3805 dest_align
= get_pointer_alignment (dest
);
3807 /* If DEST is not a pointer type, don't do this operation in-line. */
3808 if (dest_align
== 0)
3811 if (currently_expanding_gimple_stmt
)
3812 stringop_block_profile (currently_expanding_gimple_stmt
,
3813 &expected_align
, &expected_size
);
3815 if (expected_align
< dest_align
)
3816 expected_align
= dest_align
;
3818 /* If the LEN parameter is zero, return DEST. */
3819 if (integer_zerop (len
))
3821 /* Evaluate and ignore VAL in case it has side-effects. */
3822 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3823 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3826 /* Stabilize the arguments in case we fail. */
3827 dest
= builtin_save_expr (dest
);
3828 val
= builtin_save_expr (val
);
3829 len
= builtin_save_expr (len
);
3831 len_rtx
= expand_normal (len
);
3832 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3833 &probable_max_size
);
3834 dest_mem
= get_memory_rtx (dest
, len
);
3835 val_mode
= TYPE_MODE (unsigned_char_type_node
);
3837 if (TREE_CODE (val
) != INTEGER_CST
)
3841 val_rtx
= expand_normal (val
);
3842 val_rtx
= convert_to_mode (val_mode
, val_rtx
, 0);
3844 /* Assume that we can memset by pieces if we can store
3845 * the coefficients by pieces (in the required modes).
3846 * We can't pass builtin_memset_gen_str as that emits RTL. */
3848 if (tree_fits_uhwi_p (len
)
3849 && can_store_by_pieces (tree_to_uhwi (len
),
3850 builtin_memset_read_str
, &c
, dest_align
,
3853 val_rtx
= force_reg (val_mode
, val_rtx
);
3854 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3855 builtin_memset_gen_str
, val_rtx
, dest_align
,
3858 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, val_rtx
,
3859 dest_align
, expected_align
,
3860 expected_size
, min_size
, max_size
,
3864 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3865 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3869 if (target_char_cast (val
, &c
))
3874 if (tree_fits_uhwi_p (len
)
3875 && can_store_by_pieces (tree_to_uhwi (len
),
3876 builtin_memset_read_str
, &c
, dest_align
,
3878 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3879 builtin_memset_read_str
, &c
, dest_align
, true, 0);
3880 else if (!set_storage_via_setmem (dest_mem
, len_rtx
,
3881 gen_int_mode (c
, val_mode
),
3882 dest_align
, expected_align
,
3883 expected_size
, min_size
, max_size
,
3887 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3888 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3892 set_mem_align (dest_mem
, dest_align
);
3893 dest_addr
= clear_storage_hints (dest_mem
, len_rtx
,
3894 CALL_EXPR_TAILCALL (orig_exp
)
3895 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3896 expected_align
, expected_size
,
3902 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3903 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3909 fndecl
= get_callee_fndecl (orig_exp
);
3910 fcode
= DECL_FUNCTION_CODE (fndecl
);
3911 if (fcode
== BUILT_IN_MEMSET
3912 || fcode
== BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP
)
3913 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 3,
3915 else if (fcode
== BUILT_IN_BZERO
)
3916 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 2,
3920 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
3921 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
3922 return expand_call (fn
, target
, target
== const0_rtx
);
3925 /* Expand expression EXP, which is a call to the bzero builtin. Return
3926 NULL_RTX if we failed the caller should emit a normal call. */
3929 expand_builtin_bzero (tree exp
)
3932 location_t loc
= EXPR_LOCATION (exp
);
3934 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3937 dest
= CALL_EXPR_ARG (exp
, 0);
3938 size
= CALL_EXPR_ARG (exp
, 1);
3940 /* New argument list transforming bzero(ptr x, int y) to
3941 memset(ptr x, int 0, size_t y). This is done this way
3942 so that if it isn't expanded inline, we fallback to
3943 calling bzero instead of memset. */
3945 return expand_builtin_memset_args (dest
, integer_zero_node
,
3946 fold_convert_loc (loc
,
3947 size_type_node
, size
),
3948 const0_rtx
, VOIDmode
, exp
);
3951 /* Expand expression EXP, which is a call to the memcmp built-in function.
3952 Return NULL_RTX if we failed and the caller should emit a normal call,
3953 otherwise try to get the result in TARGET, if convenient (and in mode
3954 MODE, if that's convenient). */
3957 expand_builtin_memcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
3958 ATTRIBUTE_UNUSED machine_mode mode
)
3960 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
3962 if (!validate_arglist (exp
,
3963 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3966 /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3967 implementing memcmp because it will stop if it encounters two
3969 #if defined HAVE_cmpmemsi
3971 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3974 tree arg1
= CALL_EXPR_ARG (exp
, 0);
3975 tree arg2
= CALL_EXPR_ARG (exp
, 1);
3976 tree len
= CALL_EXPR_ARG (exp
, 2);
3978 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
3979 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
3980 machine_mode insn_mode
;
3983 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3987 /* If we don't have POINTER_TYPE, call the function. */
3988 if (arg1_align
== 0 || arg2_align
== 0)
3991 /* Make a place to write the result of the instruction. */
3994 && REG_P (result
) && GET_MODE (result
) == insn_mode
3995 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3996 result
= gen_reg_rtx (insn_mode
);
3998 arg1_rtx
= get_memory_rtx (arg1
, len
);
3999 arg2_rtx
= get_memory_rtx (arg2
, len
);
4000 arg3_rtx
= expand_normal (fold_convert_loc (loc
, sizetype
, len
));
4002 /* Set MEM_SIZE as appropriate. */
4003 if (CONST_INT_P (arg3_rtx
))
4005 set_mem_size (arg1_rtx
, INTVAL (arg3_rtx
));
4006 set_mem_size (arg2_rtx
, INTVAL (arg3_rtx
));
4010 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4011 GEN_INT (MIN (arg1_align
, arg2_align
)));
4018 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE
,
4019 TYPE_MODE (integer_type_node
), 3,
4020 XEXP (arg1_rtx
, 0), Pmode
,
4021 XEXP (arg2_rtx
, 0), Pmode
,
4022 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
4023 TYPE_UNSIGNED (sizetype
)),
4024 TYPE_MODE (sizetype
));
4026 /* Return the value in the proper mode for this function. */
4027 mode
= TYPE_MODE (TREE_TYPE (exp
));
4028 if (GET_MODE (result
) == mode
)
4030 else if (target
!= 0)
4032 convert_move (target
, result
, 0);
4036 return convert_to_mode (mode
, result
, 0);
4038 #endif /* HAVE_cmpmemsi. */
4043 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4044 if we failed the caller should emit a normal call, otherwise try to get
4045 the result in TARGET, if convenient. */
4048 expand_builtin_strcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
)
4050 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4053 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4054 if (direct_optab_handler (cmpstr_optab
, SImode
) != CODE_FOR_nothing
4055 || direct_optab_handler (cmpstrn_optab
, SImode
) != CODE_FOR_nothing
)
4057 rtx arg1_rtx
, arg2_rtx
;
4058 rtx result
, insn
= NULL_RTX
;
4060 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4061 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4063 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4064 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4066 /* If we don't have POINTER_TYPE, call the function. */
4067 if (arg1_align
== 0 || arg2_align
== 0)
4070 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4071 arg1
= builtin_save_expr (arg1
);
4072 arg2
= builtin_save_expr (arg2
);
4074 arg1_rtx
= get_memory_rtx (arg1
, NULL
);
4075 arg2_rtx
= get_memory_rtx (arg2
, NULL
);
4077 #ifdef HAVE_cmpstrsi
4078 /* Try to call cmpstrsi. */
4081 machine_mode insn_mode
4082 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
4084 /* Make a place to write the result of the instruction. */
4087 && REG_P (result
) && GET_MODE (result
) == insn_mode
4088 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4089 result
= gen_reg_rtx (insn_mode
);
4091 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
,
4092 GEN_INT (MIN (arg1_align
, arg2_align
)));
4095 #ifdef HAVE_cmpstrnsi
4096 /* Try to determine at least one length and call cmpstrnsi. */
4097 if (!insn
&& HAVE_cmpstrnsi
)
4102 machine_mode insn_mode
4103 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4104 tree len1
= c_strlen (arg1
, 1);
4105 tree len2
= c_strlen (arg2
, 1);
4108 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
4110 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
4112 /* If we don't have a constant length for the first, use the length
4113 of the second, if we know it. We don't require a constant for
4114 this case; some cost analysis could be done if both are available
4115 but neither is constant. For now, assume they're equally cheap,
4116 unless one has side effects. If both strings have constant lengths,
4123 else if (TREE_SIDE_EFFECTS (len1
))
4125 else if (TREE_SIDE_EFFECTS (len2
))
4127 else if (TREE_CODE (len1
) != INTEGER_CST
)
4129 else if (TREE_CODE (len2
) != INTEGER_CST
)
4131 else if (tree_int_cst_lt (len1
, len2
))
4136 /* If both arguments have side effects, we cannot optimize. */
4137 if (!len
|| TREE_SIDE_EFFECTS (len
))
4140 arg3_rtx
= expand_normal (len
);
4142 /* Make a place to write the result of the instruction. */
4145 && REG_P (result
) && GET_MODE (result
) == insn_mode
4146 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4147 result
= gen_reg_rtx (insn_mode
);
4149 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4150 GEN_INT (MIN (arg1_align
, arg2_align
)));
4159 /* Return the value in the proper mode for this function. */
4160 mode
= TYPE_MODE (TREE_TYPE (exp
));
4161 if (GET_MODE (result
) == mode
)
4164 return convert_to_mode (mode
, result
, 0);
4165 convert_move (target
, result
, 0);
4169 /* Expand the library call ourselves using a stabilized argument
4170 list to avoid re-evaluating the function's arguments twice. */
4171 #ifdef HAVE_cmpstrnsi
4174 fndecl
= get_callee_fndecl (exp
);
4175 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 2, arg1
, arg2
);
4176 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4177 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4178 return expand_call (fn
, target
, target
== const0_rtx
);
4184 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4185 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4186 the result in TARGET, if convenient. */
4189 expand_builtin_strncmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
4190 ATTRIBUTE_UNUSED machine_mode mode
)
4192 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
4194 if (!validate_arglist (exp
,
4195 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4198 /* If c_strlen can determine an expression for one of the string
4199 lengths, and it doesn't have side effects, then emit cmpstrnsi
4200 using length MIN(strlen(string)+1, arg3). */
4201 #ifdef HAVE_cmpstrnsi
4204 tree len
, len1
, len2
;
4205 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
4208 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4209 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4210 tree arg3
= CALL_EXPR_ARG (exp
, 2);
4212 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4213 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4214 machine_mode insn_mode
4215 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4217 len1
= c_strlen (arg1
, 1);
4218 len2
= c_strlen (arg2
, 1);
4221 len1
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len1
);
4223 len2
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len2
);
4225 /* If we don't have a constant length for the first, use the length
4226 of the second, if we know it. We don't require a constant for
4227 this case; some cost analysis could be done if both are available
4228 but neither is constant. For now, assume they're equally cheap,
4229 unless one has side effects. If both strings have constant lengths,
4236 else if (TREE_SIDE_EFFECTS (len1
))
4238 else if (TREE_SIDE_EFFECTS (len2
))
4240 else if (TREE_CODE (len1
) != INTEGER_CST
)
4242 else if (TREE_CODE (len2
) != INTEGER_CST
)
4244 else if (tree_int_cst_lt (len1
, len2
))
4249 /* If both arguments have side effects, we cannot optimize. */
4250 if (!len
|| TREE_SIDE_EFFECTS (len
))
4253 /* The actual new length parameter is MIN(len,arg3). */
4254 len
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (len
), len
,
4255 fold_convert_loc (loc
, TREE_TYPE (len
), arg3
));
4257 /* If we don't have POINTER_TYPE, call the function. */
4258 if (arg1_align
== 0 || arg2_align
== 0)
4261 /* Make a place to write the result of the instruction. */
4264 && REG_P (result
) && GET_MODE (result
) == insn_mode
4265 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4266 result
= gen_reg_rtx (insn_mode
);
4268 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4269 arg1
= builtin_save_expr (arg1
);
4270 arg2
= builtin_save_expr (arg2
);
4271 len
= builtin_save_expr (len
);
4273 arg1_rtx
= get_memory_rtx (arg1
, len
);
4274 arg2_rtx
= get_memory_rtx (arg2
, len
);
4275 arg3_rtx
= expand_normal (len
);
4276 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4277 GEN_INT (MIN (arg1_align
, arg2_align
)));
4282 /* Return the value in the proper mode for this function. */
4283 mode
= TYPE_MODE (TREE_TYPE (exp
));
4284 if (GET_MODE (result
) == mode
)
4287 return convert_to_mode (mode
, result
, 0);
4288 convert_move (target
, result
, 0);
4292 /* Expand the library call ourselves using a stabilized argument
4293 list to avoid re-evaluating the function's arguments twice. */
4294 fndecl
= get_callee_fndecl (exp
);
4295 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 3,
4297 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4298 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4299 return expand_call (fn
, target
, target
== const0_rtx
);
4305 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4306 if that's convenient. */
4309 expand_builtin_saveregs (void)
4314 /* Don't do __builtin_saveregs more than once in a function.
4315 Save the result of the first call and reuse it. */
4316 if (saveregs_value
!= 0)
4317 return saveregs_value
;
4319 /* When this function is called, it means that registers must be
4320 saved on entry to this function. So we migrate the call to the
4321 first insn of this function. */
4325 /* Do whatever the machine needs done in this case. */
4326 val
= targetm
.calls
.expand_builtin_saveregs ();
4331 saveregs_value
= val
;
4333 /* Put the insns after the NOTE that starts the function. If this
4334 is inside a start_sequence, make the outer-level insn chain current, so
4335 the code is placed at the start of the function. */
4336 push_topmost_sequence ();
4337 emit_insn_after (seq
, entry_of_function ());
4338 pop_topmost_sequence ();
4343 /* Expand a call to __builtin_next_arg. */
4346 expand_builtin_next_arg (void)
4348 /* Checking arguments is already done in fold_builtin_next_arg
4349 that must be called before this function. */
4350 return expand_binop (ptr_mode
, add_optab
,
4351 crtl
->args
.internal_arg_pointer
,
4352 crtl
->args
.arg_offset_rtx
,
4353 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4356 /* Make it easier for the backends by protecting the valist argument
4357 from multiple evaluations. */
4360 stabilize_va_list_loc (location_t loc
, tree valist
, int needs_lvalue
)
4362 tree vatype
= targetm
.canonical_va_list_type (TREE_TYPE (valist
));
4364 /* The current way of determining the type of valist is completely
4365 bogus. We should have the information on the va builtin instead. */
4367 vatype
= targetm
.fn_abi_va_list (cfun
->decl
);
4369 if (TREE_CODE (vatype
) == ARRAY_TYPE
)
4371 if (TREE_SIDE_EFFECTS (valist
))
4372 valist
= save_expr (valist
);
4374 /* For this case, the backends will be expecting a pointer to
4375 vatype, but it's possible we've actually been given an array
4376 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4378 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4380 tree p1
= build_pointer_type (TREE_TYPE (vatype
));
4381 valist
= build_fold_addr_expr_with_type_loc (loc
, valist
, p1
);
4386 tree pt
= build_pointer_type (vatype
);
4390 if (! TREE_SIDE_EFFECTS (valist
))
4393 valist
= fold_build1_loc (loc
, ADDR_EXPR
, pt
, valist
);
4394 TREE_SIDE_EFFECTS (valist
) = 1;
4397 if (TREE_SIDE_EFFECTS (valist
))
4398 valist
= save_expr (valist
);
4399 valist
= fold_build2_loc (loc
, MEM_REF
,
4400 vatype
, valist
, build_int_cst (pt
, 0));
4406 /* The "standard" definition of va_list is void*. */
4409 std_build_builtin_va_list (void)
4411 return ptr_type_node
;
4414 /* The "standard" abi va_list is va_list_type_node. */
4417 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED
)
4419 return va_list_type_node
;
4422 /* The "standard" type of va_list is va_list_type_node. */
4425 std_canonical_va_list_type (tree type
)
4429 if (INDIRECT_REF_P (type
))
4430 type
= TREE_TYPE (type
);
4431 else if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (TREE_TYPE (type
)))
4432 type
= TREE_TYPE (type
);
4433 wtype
= va_list_type_node
;
4435 /* Treat structure va_list types. */
4436 if (TREE_CODE (wtype
) == RECORD_TYPE
&& POINTER_TYPE_P (htype
))
4437 htype
= TREE_TYPE (htype
);
4438 else if (TREE_CODE (wtype
) == ARRAY_TYPE
)
4440 /* If va_list is an array type, the argument may have decayed
4441 to a pointer type, e.g. by being passed to another function.
4442 In that case, unwrap both types so that we can compare the
4443 underlying records. */
4444 if (TREE_CODE (htype
) == ARRAY_TYPE
4445 || POINTER_TYPE_P (htype
))
4447 wtype
= TREE_TYPE (wtype
);
4448 htype
= TREE_TYPE (htype
);
4451 if (TYPE_MAIN_VARIANT (wtype
) == TYPE_MAIN_VARIANT (htype
))
4452 return va_list_type_node
;
4457 /* The "standard" implementation of va_start: just assign `nextarg' to
4461 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4463 rtx va_r
= expand_expr (valist
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4464 convert_move (va_r
, nextarg
, 0);
4466 /* We do not have any valid bounds for the pointer, so
4467 just store zero bounds for it. */
4468 if (chkp_function_instrumented_p (current_function_decl
))
4469 chkp_expand_bounds_reset_for_mem (valist
,
4470 make_tree (TREE_TYPE (valist
),
4474 /* Expand EXP, a call to __builtin_va_start. */
4477 expand_builtin_va_start (tree exp
)
4481 location_t loc
= EXPR_LOCATION (exp
);
4483 if (call_expr_nargs (exp
) < 2)
4485 error_at (loc
, "too few arguments to function %<va_start%>");
4489 if (fold_builtin_next_arg (exp
, true))
4492 nextarg
= expand_builtin_next_arg ();
4493 valist
= stabilize_va_list_loc (loc
, CALL_EXPR_ARG (exp
, 0), 1);
4495 if (targetm
.expand_builtin_va_start
)
4496 targetm
.expand_builtin_va_start (valist
, nextarg
);
4498 std_expand_builtin_va_start (valist
, nextarg
);
4503 /* Expand EXP, a call to __builtin_va_end. */
4506 expand_builtin_va_end (tree exp
)
4508 tree valist
= CALL_EXPR_ARG (exp
, 0);
4510 /* Evaluate for side effects, if needed. I hate macros that don't
4512 if (TREE_SIDE_EFFECTS (valist
))
4513 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4518 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4519 builtin rather than just as an assignment in stdarg.h because of the
4520 nastiness of array-type va_list types. */
4523 expand_builtin_va_copy (tree exp
)
4526 location_t loc
= EXPR_LOCATION (exp
);
4528 dst
= CALL_EXPR_ARG (exp
, 0);
4529 src
= CALL_EXPR_ARG (exp
, 1);
4531 dst
= stabilize_va_list_loc (loc
, dst
, 1);
4532 src
= stabilize_va_list_loc (loc
, src
, 0);
4534 gcc_assert (cfun
!= NULL
&& cfun
->decl
!= NULL_TREE
);
4536 if (TREE_CODE (targetm
.fn_abi_va_list (cfun
->decl
)) != ARRAY_TYPE
)
4538 t
= build2 (MODIFY_EXPR
, targetm
.fn_abi_va_list (cfun
->decl
), dst
, src
);
4539 TREE_SIDE_EFFECTS (t
) = 1;
4540 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4544 rtx dstb
, srcb
, size
;
4546 /* Evaluate to pointers. */
4547 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4548 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4549 size
= expand_expr (TYPE_SIZE_UNIT (targetm
.fn_abi_va_list (cfun
->decl
)),
4550 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
4552 dstb
= convert_memory_address (Pmode
, dstb
);
4553 srcb
= convert_memory_address (Pmode
, srcb
);
4555 /* "Dereference" to BLKmode memories. */
4556 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4557 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4558 set_mem_align (dstb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4559 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4560 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4561 set_mem_align (srcb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4564 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4570 /* Expand a call to one of the builtin functions __builtin_frame_address or
4571 __builtin_return_address. */
4574 expand_builtin_frame_address (tree fndecl
, tree exp
)
4576 /* The argument must be a nonnegative integer constant.
4577 It counts the number of frames to scan up the stack.
4578 The value is the return address saved in that frame. */
4579 if (call_expr_nargs (exp
) == 0)
4580 /* Warning about missing arg was already issued. */
4582 else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp
, 0)))
4584 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4585 error ("invalid argument to %<__builtin_frame_address%>");
4587 error ("invalid argument to %<__builtin_return_address%>");
4593 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4594 tree_to_uhwi (CALL_EXPR_ARG (exp
, 0)));
4596 /* Some ports cannot access arbitrary stack frames. */
4599 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4600 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4602 warning (0, "unsupported argument to %<__builtin_return_address%>");
4606 /* For __builtin_frame_address, return what we've got. */
4607 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4611 && ! CONSTANT_P (tem
))
4612 tem
= copy_addr_to_reg (tem
);
4617 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4618 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4619 is the same as for allocate_dynamic_stack_space. */
4622 expand_builtin_alloca (tree exp
, bool cannot_accumulate
)
4628 bool alloca_with_align
= (DECL_FUNCTION_CODE (get_callee_fndecl (exp
))
4629 == BUILT_IN_ALLOCA_WITH_ALIGN
);
4632 = (alloca_with_align
4633 ? validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
4634 : validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
));
4639 /* Compute the argument. */
4640 op0
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4642 /* Compute the alignment. */
4643 align
= (alloca_with_align
4644 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp
, 1))
4645 : BIGGEST_ALIGNMENT
);
4647 /* Allocate the desired space. */
4648 result
= allocate_dynamic_stack_space (op0
, 0, align
, cannot_accumulate
);
4649 result
= convert_memory_address (ptr_mode
, result
);
4654 /* Expand a call to bswap builtin in EXP.
4655 Return NULL_RTX if a normal call should be emitted rather than expanding the
4656 function in-line. If convenient, the result should be placed in TARGET.
4657 SUBTARGET may be used as the target for computing one of EXP's operands. */
4660 expand_builtin_bswap (machine_mode target_mode
, tree exp
, rtx target
,
4666 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4669 arg
= CALL_EXPR_ARG (exp
, 0);
4670 op0
= expand_expr (arg
,
4671 subtarget
&& GET_MODE (subtarget
) == target_mode
4672 ? subtarget
: NULL_RTX
,
4673 target_mode
, EXPAND_NORMAL
);
4674 if (GET_MODE (op0
) != target_mode
)
4675 op0
= convert_to_mode (target_mode
, op0
, 1);
4677 target
= expand_unop (target_mode
, bswap_optab
, op0
, target
, 1);
4679 gcc_assert (target
);
4681 return convert_to_mode (target_mode
, target
, 1);
4684 /* Expand a call to a unary builtin in EXP.
4685 Return NULL_RTX if a normal call should be emitted rather than expanding the
4686 function in-line. If convenient, the result should be placed in TARGET.
4687 SUBTARGET may be used as the target for computing one of EXP's operands. */
4690 expand_builtin_unop (machine_mode target_mode
, tree exp
, rtx target
,
4691 rtx subtarget
, optab op_optab
)
4695 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4698 /* Compute the argument. */
4699 op0
= expand_expr (CALL_EXPR_ARG (exp
, 0),
4701 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0)))
4702 == GET_MODE (subtarget
))) ? subtarget
: NULL_RTX
,
4703 VOIDmode
, EXPAND_NORMAL
);
4704 /* Compute op, into TARGET if possible.
4705 Set TARGET to wherever the result comes back. */
4706 target
= expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))),
4707 op_optab
, op0
, target
, op_optab
!= clrsb_optab
);
4708 gcc_assert (target
);
4710 return convert_to_mode (target_mode
, target
, 0);
4713 /* Expand a call to __builtin_expect. We just return our argument
4714 as the builtin_expect semantic should've been already executed by
4715 tree branch prediction pass. */
4718 expand_builtin_expect (tree exp
, rtx target
)
4722 if (call_expr_nargs (exp
) < 2)
4724 arg
= CALL_EXPR_ARG (exp
, 0);
4726 target
= expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
4727 /* When guessing was done, the hints should be already stripped away. */
4728 gcc_assert (!flag_guess_branch_prob
4729 || optimize
== 0 || seen_error ());
4733 /* Expand a call to __builtin_assume_aligned. We just return our first
4734 argument as the builtin_assume_aligned semantic should've been already
4738 expand_builtin_assume_aligned (tree exp
, rtx target
)
4740 if (call_expr_nargs (exp
) < 2)
4742 target
= expand_expr (CALL_EXPR_ARG (exp
, 0), target
, VOIDmode
,
4744 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 1))
4745 && (call_expr_nargs (exp
) < 3
4746 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 2))));
4751 expand_builtin_trap (void)
4756 rtx_insn
*insn
= emit_insn (gen_trap ());
4757 /* For trap insns when not accumulating outgoing args force
4758 REG_ARGS_SIZE note to prevent crossjumping of calls with
4759 different args sizes. */
4760 if (!ACCUMULATE_OUTGOING_ARGS
)
4761 add_reg_note (insn
, REG_ARGS_SIZE
, GEN_INT (stack_pointer_delta
));
4765 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4769 /* Expand a call to __builtin_unreachable. We do nothing except emit
4770 a barrier saying that control flow will not pass here.
4772 It is the responsibility of the program being compiled to ensure
4773 that control flow does never reach __builtin_unreachable. */
4775 expand_builtin_unreachable (void)
4780 /* Expand EXP, a call to fabs, fabsf or fabsl.
4781 Return NULL_RTX if a normal call should be emitted rather than expanding
4782 the function inline. If convenient, the result should be placed
4783 in TARGET. SUBTARGET may be used as the target for computing
4787 expand_builtin_fabs (tree exp
, rtx target
, rtx subtarget
)
4793 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
4796 arg
= CALL_EXPR_ARG (exp
, 0);
4797 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
4798 mode
= TYPE_MODE (TREE_TYPE (arg
));
4799 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
4800 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4803 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4804 Return NULL is a normal call should be emitted rather than expanding the
4805 function inline. If convenient, the result should be placed in TARGET.
4806 SUBTARGET may be used as the target for computing the operand. */
4809 expand_builtin_copysign (tree exp
, rtx target
, rtx subtarget
)
4814 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
4817 arg
= CALL_EXPR_ARG (exp
, 0);
4818 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
4820 arg
= CALL_EXPR_ARG (exp
, 1);
4821 op1
= expand_normal (arg
);
4823 return expand_copysign (op0
, op1
, target
);
4826 /* Expand a call to __builtin___clear_cache. */
4829 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED
)
4831 #ifndef HAVE_clear_cache
4832 #ifdef CLEAR_INSN_CACHE
4833 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4834 does something. Just do the default expansion to a call to
4838 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4839 does nothing. There is no need to call it. Do nothing. */
4841 #endif /* CLEAR_INSN_CACHE */
4843 /* We have a "clear_cache" insn, and it will handle everything. */
4845 rtx begin_rtx
, end_rtx
;
4847 /* We must not expand to a library call. If we did, any
4848 fallback library function in libgcc that might contain a call to
4849 __builtin___clear_cache() would recurse infinitely. */
4850 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4852 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4856 if (HAVE_clear_cache
)
4858 struct expand_operand ops
[2];
4860 begin
= CALL_EXPR_ARG (exp
, 0);
4861 begin_rtx
= expand_expr (begin
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4863 end
= CALL_EXPR_ARG (exp
, 1);
4864 end_rtx
= expand_expr (end
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4866 create_address_operand (&ops
[0], begin_rtx
);
4867 create_address_operand (&ops
[1], end_rtx
);
4868 if (maybe_expand_insn (CODE_FOR_clear_cache
, 2, ops
))
4872 #endif /* HAVE_clear_cache */
4875 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
4878 round_trampoline_addr (rtx tramp
)
4880 rtx temp
, addend
, mask
;
4882 /* If we don't need too much alignment, we'll have been guaranteed
4883 proper alignment by get_trampoline_type. */
4884 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
4887 /* Round address up to desired boundary. */
4888 temp
= gen_reg_rtx (Pmode
);
4889 addend
= gen_int_mode (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1, Pmode
);
4890 mask
= gen_int_mode (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
, Pmode
);
4892 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
4893 temp
, 0, OPTAB_LIB_WIDEN
);
4894 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
4895 temp
, 0, OPTAB_LIB_WIDEN
);
4901 expand_builtin_init_trampoline (tree exp
, bool onstack
)
4903 tree t_tramp
, t_func
, t_chain
;
4904 rtx m_tramp
, r_tramp
, r_chain
, tmp
;
4906 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
,
4907 POINTER_TYPE
, VOID_TYPE
))
4910 t_tramp
= CALL_EXPR_ARG (exp
, 0);
4911 t_func
= CALL_EXPR_ARG (exp
, 1);
4912 t_chain
= CALL_EXPR_ARG (exp
, 2);
4914 r_tramp
= expand_normal (t_tramp
);
4915 m_tramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
4916 MEM_NOTRAP_P (m_tramp
) = 1;
4918 /* If ONSTACK, the TRAMP argument should be the address of a field
4919 within the local function's FRAME decl. Either way, let's see if
4920 we can fill in the MEM_ATTRs for this memory. */
4921 if (TREE_CODE (t_tramp
) == ADDR_EXPR
)
4922 set_mem_attributes (m_tramp
, TREE_OPERAND (t_tramp
, 0), true);
4924 /* Creator of a heap trampoline is responsible for making sure the
4925 address is aligned to at least STACK_BOUNDARY. Normally malloc
4926 will ensure this anyhow. */
4927 tmp
= round_trampoline_addr (r_tramp
);
4930 m_tramp
= change_address (m_tramp
, BLKmode
, tmp
);
4931 set_mem_align (m_tramp
, TRAMPOLINE_ALIGNMENT
);
4932 set_mem_size (m_tramp
, TRAMPOLINE_SIZE
);
4935 /* The FUNC argument should be the address of the nested function.
4936 Extract the actual function decl to pass to the hook. */
4937 gcc_assert (TREE_CODE (t_func
) == ADDR_EXPR
);
4938 t_func
= TREE_OPERAND (t_func
, 0);
4939 gcc_assert (TREE_CODE (t_func
) == FUNCTION_DECL
);
4941 r_chain
= expand_normal (t_chain
);
4943 /* Generate insns to initialize the trampoline. */
4944 targetm
.calls
.trampoline_init (m_tramp
, t_func
, r_chain
);
4948 trampolines_created
= 1;
4950 warning_at (DECL_SOURCE_LOCATION (t_func
), OPT_Wtrampolines
,
4951 "trampoline generated for nested function %qD", t_func
);
4958 expand_builtin_adjust_trampoline (tree exp
)
4962 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
4965 tramp
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4966 tramp
= round_trampoline_addr (tramp
);
4967 if (targetm
.calls
.trampoline_adjust_address
)
4968 tramp
= targetm
.calls
.trampoline_adjust_address (tramp
);
4973 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4974 function. The function first checks whether the back end provides
4975 an insn to implement signbit for the respective mode. If not, it
4976 checks whether the floating point format of the value is such that
4977 the sign bit can be extracted. If that is not the case, the
4978 function returns NULL_RTX to indicate that a normal call should be
4979 emitted rather than expanding the function in-line. EXP is the
4980 expression that is a call to the builtin function; if convenient,
4981 the result should be placed in TARGET. */
4983 expand_builtin_signbit (tree exp
, rtx target
)
4985 const struct real_format
*fmt
;
4986 machine_mode fmode
, imode
, rmode
;
4989 enum insn_code icode
;
4991 location_t loc
= EXPR_LOCATION (exp
);
4993 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
4996 arg
= CALL_EXPR_ARG (exp
, 0);
4997 fmode
= TYPE_MODE (TREE_TYPE (arg
));
4998 rmode
= TYPE_MODE (TREE_TYPE (exp
));
4999 fmt
= REAL_MODE_FORMAT (fmode
);
5001 arg
= builtin_save_expr (arg
);
5003 /* Expand the argument yielding a RTX expression. */
5004 temp
= expand_normal (arg
);
5006 /* Check if the back end provides an insn that handles signbit for the
5008 icode
= optab_handler (signbit_optab
, fmode
);
5009 if (icode
!= CODE_FOR_nothing
)
5011 rtx_insn
*last
= get_last_insn ();
5012 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
5013 if (maybe_emit_unop_insn (icode
, target
, temp
, UNKNOWN
))
5015 delete_insns_since (last
);
5018 /* For floating point formats without a sign bit, implement signbit
5020 bitpos
= fmt
->signbit_ro
;
5023 /* But we can't do this if the format supports signed zero. */
5024 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5027 arg
= fold_build2_loc (loc
, LT_EXPR
, TREE_TYPE (exp
), arg
,
5028 build_real (TREE_TYPE (arg
), dconst0
));
5029 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5032 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
5034 imode
= int_mode_for_mode (fmode
);
5035 if (imode
== BLKmode
)
5037 temp
= gen_lowpart (imode
, temp
);
5042 /* Handle targets with different FP word orders. */
5043 if (FLOAT_WORDS_BIG_ENDIAN
)
5044 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
5046 word
= bitpos
/ BITS_PER_WORD
;
5047 temp
= operand_subword_force (temp
, word
, fmode
);
5048 bitpos
= bitpos
% BITS_PER_WORD
;
5051 /* Force the intermediate word_mode (or narrower) result into a
5052 register. This avoids attempting to create paradoxical SUBREGs
5053 of floating point modes below. */
5054 temp
= force_reg (imode
, temp
);
5056 /* If the bitpos is within the "result mode" lowpart, the operation
5057 can be implement with a single bitwise AND. Otherwise, we need
5058 a right shift and an AND. */
5060 if (bitpos
< GET_MODE_BITSIZE (rmode
))
5062 wide_int mask
= wi::set_bit_in_zero (bitpos
, GET_MODE_PRECISION (rmode
));
5064 if (GET_MODE_SIZE (imode
) > GET_MODE_SIZE (rmode
))
5065 temp
= gen_lowpart (rmode
, temp
);
5066 temp
= expand_binop (rmode
, and_optab
, temp
,
5067 immed_wide_int_const (mask
, rmode
),
5068 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5072 /* Perform a logical right shift to place the signbit in the least
5073 significant bit, then truncate the result to the desired mode
5074 and mask just this bit. */
5075 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
, bitpos
, NULL_RTX
, 1);
5076 temp
= gen_lowpart (rmode
, temp
);
5077 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
5078 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5084 /* Expand fork or exec calls. TARGET is the desired target of the
5085 call. EXP is the call. FN is the
5086 identificator of the actual function. IGNORE is nonzero if the
5087 value is to be ignored. */
5090 expand_builtin_fork_or_exec (tree fn
, tree exp
, rtx target
, int ignore
)
5095 /* If we are not profiling, just call the function. */
5096 if (!profile_arc_flag
)
5099 /* Otherwise call the wrapper. This should be equivalent for the rest of
5100 compiler, so the code does not diverge, and the wrapper may run the
5101 code necessary for keeping the profiling sane. */
5103 switch (DECL_FUNCTION_CODE (fn
))
5106 id
= get_identifier ("__gcov_fork");
5109 case BUILT_IN_EXECL
:
5110 id
= get_identifier ("__gcov_execl");
5113 case BUILT_IN_EXECV
:
5114 id
= get_identifier ("__gcov_execv");
5117 case BUILT_IN_EXECLP
:
5118 id
= get_identifier ("__gcov_execlp");
5121 case BUILT_IN_EXECLE
:
5122 id
= get_identifier ("__gcov_execle");
5125 case BUILT_IN_EXECVP
:
5126 id
= get_identifier ("__gcov_execvp");
5129 case BUILT_IN_EXECVE
:
5130 id
= get_identifier ("__gcov_execve");
5137 decl
= build_decl (DECL_SOURCE_LOCATION (fn
),
5138 FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5139 DECL_EXTERNAL (decl
) = 1;
5140 TREE_PUBLIC (decl
) = 1;
5141 DECL_ARTIFICIAL (decl
) = 1;
5142 TREE_NOTHROW (decl
) = 1;
5143 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5144 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5145 call
= rewrite_call_expr (EXPR_LOCATION (exp
), exp
, 0, decl
, 0);
5146 return expand_call (call
, target
, ignore
);
5151 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5152 the pointer in these functions is void*, the tree optimizers may remove
5153 casts. The mode computed in expand_builtin isn't reliable either, due
5154 to __sync_bool_compare_and_swap.
5156 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5157 group of builtins. This gives us log2 of the mode size. */
5159 static inline machine_mode
5160 get_builtin_sync_mode (int fcode_diff
)
5162 /* The size is not negotiable, so ask not to get BLKmode in return
5163 if the target indicates that a smaller size would be better. */
5164 return mode_for_size (BITS_PER_UNIT
<< fcode_diff
, MODE_INT
, 0);
5167 /* Expand the memory expression LOC and return the appropriate memory operand
5168 for the builtin_sync operations. */
5171 get_builtin_sync_mem (tree loc
, machine_mode mode
)
5175 addr
= expand_expr (loc
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
5176 addr
= convert_memory_address (Pmode
, addr
);
5178 /* Note that we explicitly do not want any alias information for this
5179 memory, so that we kill all other live memories. Otherwise we don't
5180 satisfy the full barrier semantics of the intrinsic. */
5181 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5183 /* The alignment needs to be at least according to that of the mode. */
5184 set_mem_align (mem
, MAX (GET_MODE_ALIGNMENT (mode
),
5185 get_pointer_alignment (loc
)));
5186 set_mem_alias_set (mem
, ALIAS_SET_MEMORY_BARRIER
);
5187 MEM_VOLATILE_P (mem
) = 1;
5192 /* Make sure an argument is in the right mode.
5193 EXP is the tree argument.
5194 MODE is the mode it should be in. */
5197 expand_expr_force_mode (tree exp
, machine_mode mode
)
5200 machine_mode old_mode
;
5202 val
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_NORMAL
);
5203 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5204 of CONST_INTs, where we know the old_mode only from the call argument. */
5206 old_mode
= GET_MODE (val
);
5207 if (old_mode
== VOIDmode
)
5208 old_mode
= TYPE_MODE (TREE_TYPE (exp
));
5209 val
= convert_modes (mode
, old_mode
, val
, 1);
5214 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5215 EXP is the CALL_EXPR. CODE is the rtx code
5216 that corresponds to the arithmetic or logical operation from the name;
5217 an exception here is that NOT actually means NAND. TARGET is an optional
5218 place for us to store the results; AFTER is true if this is the
5219 fetch_and_xxx form. */
5222 expand_builtin_sync_operation (machine_mode mode
, tree exp
,
5223 enum rtx_code code
, bool after
,
5227 location_t loc
= EXPR_LOCATION (exp
);
5229 if (code
== NOT
&& warn_sync_nand
)
5231 tree fndecl
= get_callee_fndecl (exp
);
5232 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5234 static bool warned_f_a_n
, warned_n_a_f
;
5238 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
5239 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
5240 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
5241 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
5242 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
5246 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N
);
5247 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5248 warned_f_a_n
= true;
5251 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
5252 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
5253 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
5254 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
5255 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
5259 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N
);
5260 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5261 warned_n_a_f
= true;
5269 /* Expand the operands. */
5270 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5271 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5273 return expand_atomic_fetch_op (target
, mem
, val
, code
, MEMMODEL_SYNC_SEQ_CST
,
5277 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5278 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5279 true if this is the boolean form. TARGET is a place for us to store the
5280 results; this is NOT optional if IS_BOOL is true. */
5283 expand_builtin_compare_and_swap (machine_mode mode
, tree exp
,
5284 bool is_bool
, rtx target
)
5286 rtx old_val
, new_val
, mem
;
5289 /* Expand the operands. */
5290 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5291 old_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5292 new_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
5294 pbool
= poval
= NULL
;
5295 if (target
!= const0_rtx
)
5302 if (!expand_atomic_compare_and_swap (pbool
, poval
, mem
, old_val
, new_val
,
5303 false, MEMMODEL_SYNC_SEQ_CST
,
5304 MEMMODEL_SYNC_SEQ_CST
))
5310 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5311 general form is actually an atomic exchange, and some targets only
5312 support a reduced form with the second argument being a constant 1.
5313 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5317 expand_builtin_sync_lock_test_and_set (machine_mode mode
, tree exp
,
5322 /* Expand the operands. */
5323 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5324 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5326 return expand_sync_lock_test_and_set (target
, mem
, val
);
5329 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5332 expand_builtin_sync_lock_release (machine_mode mode
, tree exp
)
5336 /* Expand the operands. */
5337 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5339 expand_atomic_store (mem
, const0_rtx
, MEMMODEL_SYNC_RELEASE
, true);
5342 /* Given an integer representing an ``enum memmodel'', verify its
5343 correctness and return the memory model enum. */
5345 static enum memmodel
5346 get_memmodel (tree exp
)
5349 unsigned HOST_WIDE_INT val
;
5351 /* If the parameter is not a constant, it's a run time value so we'll just
5352 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5353 if (TREE_CODE (exp
) != INTEGER_CST
)
5354 return MEMMODEL_SEQ_CST
;
5356 op
= expand_normal (exp
);
5359 if (targetm
.memmodel_check
)
5360 val
= targetm
.memmodel_check (val
);
5361 else if (val
& ~MEMMODEL_MASK
)
5363 warning (OPT_Winvalid_memory_model
,
5364 "Unknown architecture specifier in memory model to builtin.");
5365 return MEMMODEL_SEQ_CST
;
5368 /* Should never see a user explicit SYNC memodel model, so >= LAST works. */
5369 if (memmodel_base (val
) >= MEMMODEL_LAST
)
5371 warning (OPT_Winvalid_memory_model
,
5372 "invalid memory model argument to builtin");
5373 return MEMMODEL_SEQ_CST
;
5376 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
5377 be conservative and promote consume to acquire. */
5378 if (val
== MEMMODEL_CONSUME
)
5379 val
= MEMMODEL_ACQUIRE
;
5381 return (enum memmodel
) val
;
5384 /* Expand the __atomic_exchange intrinsic:
5385 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5386 EXP is the CALL_EXPR.
5387 TARGET is an optional place for us to store the results. */
5390 expand_builtin_atomic_exchange (machine_mode mode
, tree exp
, rtx target
)
5393 enum memmodel model
;
5395 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5397 if (!flag_inline_atomics
)
5400 /* Expand the operands. */
5401 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5402 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5404 return expand_atomic_exchange (target
, mem
, val
, model
);
5407 /* Expand the __atomic_compare_exchange intrinsic:
5408 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5409 TYPE desired, BOOL weak,
5410 enum memmodel success,
5411 enum memmodel failure)
5412 EXP is the CALL_EXPR.
5413 TARGET is an optional place for us to store the results. */
5416 expand_builtin_atomic_compare_exchange (machine_mode mode
, tree exp
,
5419 rtx expect
, desired
, mem
, oldval
;
5420 rtx_code_label
*label
;
5421 enum memmodel success
, failure
;
5425 success
= get_memmodel (CALL_EXPR_ARG (exp
, 4));
5426 failure
= get_memmodel (CALL_EXPR_ARG (exp
, 5));
5428 if (failure
> success
)
5430 warning (OPT_Winvalid_memory_model
,
5431 "failure memory model cannot be stronger than success memory "
5432 "model for %<__atomic_compare_exchange%>");
5433 success
= MEMMODEL_SEQ_CST
;
5436 if (is_mm_release (failure
) || is_mm_acq_rel (failure
))
5438 warning (OPT_Winvalid_memory_model
,
5439 "invalid failure memory model for "
5440 "%<__atomic_compare_exchange%>");
5441 failure
= MEMMODEL_SEQ_CST
;
5442 success
= MEMMODEL_SEQ_CST
;
5446 if (!flag_inline_atomics
)
5449 /* Expand the operands. */
5450 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5452 expect
= expand_normal (CALL_EXPR_ARG (exp
, 1));
5453 expect
= convert_memory_address (Pmode
, expect
);
5454 expect
= gen_rtx_MEM (mode
, expect
);
5455 desired
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
5457 weak
= CALL_EXPR_ARG (exp
, 3);
5459 if (tree_fits_shwi_p (weak
) && tree_to_shwi (weak
) != 0)
5462 if (target
== const0_rtx
)
5465 /* Lest the rtl backend create a race condition with an imporoper store
5466 to memory, always create a new pseudo for OLDVAL. */
5469 if (!expand_atomic_compare_and_swap (&target
, &oldval
, mem
, expect
, desired
,
5470 is_weak
, success
, failure
))
5473 /* Conditionally store back to EXPECT, lest we create a race condition
5474 with an improper store to memory. */
5475 /* ??? With a rearrangement of atomics at the gimple level, we can handle
5476 the normal case where EXPECT is totally private, i.e. a register. At
5477 which point the store can be unconditional. */
5478 label
= gen_label_rtx ();
5479 emit_cmp_and_jump_insns (target
, const0_rtx
, NE
, NULL
, VOIDmode
, 1, label
);
5480 emit_move_insn (expect
, oldval
);
5486 /* Expand the __atomic_load intrinsic:
5487 TYPE __atomic_load (TYPE *object, enum memmodel)
5488 EXP is the CALL_EXPR.
5489 TARGET is an optional place for us to store the results. */
5492 expand_builtin_atomic_load (machine_mode mode
, tree exp
, rtx target
)
5495 enum memmodel model
;
5497 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5498 if (is_mm_release (model
) || is_mm_acq_rel (model
))
5500 warning (OPT_Winvalid_memory_model
,
5501 "invalid memory model for %<__atomic_load%>");
5502 model
= MEMMODEL_SEQ_CST
;
5505 if (!flag_inline_atomics
)
5508 /* Expand the operand. */
5509 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5511 return expand_atomic_load (target
, mem
, model
);
5515 /* Expand the __atomic_store intrinsic:
5516 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5517 EXP is the CALL_EXPR.
5518 TARGET is an optional place for us to store the results. */
5521 expand_builtin_atomic_store (machine_mode mode
, tree exp
)
5524 enum memmodel model
;
5526 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5527 if (!(is_mm_relaxed (model
) || is_mm_seq_cst (model
)
5528 || is_mm_release (model
)))
5530 warning (OPT_Winvalid_memory_model
,
5531 "invalid memory model for %<__atomic_store%>");
5532 model
= MEMMODEL_SEQ_CST
;
5535 if (!flag_inline_atomics
)
5538 /* Expand the operands. */
5539 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5540 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5542 return expand_atomic_store (mem
, val
, model
, false);
5545 /* Expand the __atomic_fetch_XXX intrinsic:
5546 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5547 EXP is the CALL_EXPR.
5548 TARGET is an optional place for us to store the results.
5549 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5550 FETCH_AFTER is true if returning the result of the operation.
5551 FETCH_AFTER is false if returning the value before the operation.
5552 IGNORE is true if the result is not used.
5553 EXT_CALL is the correct builtin for an external call if this cannot be
5554 resolved to an instruction sequence. */
5557 expand_builtin_atomic_fetch_op (machine_mode mode
, tree exp
, rtx target
,
5558 enum rtx_code code
, bool fetch_after
,
5559 bool ignore
, enum built_in_function ext_call
)
5562 enum memmodel model
;
5566 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5568 /* Expand the operands. */
5569 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5570 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5572 /* Only try generating instructions if inlining is turned on. */
5573 if (flag_inline_atomics
)
5575 ret
= expand_atomic_fetch_op (target
, mem
, val
, code
, model
, fetch_after
);
5580 /* Return if a different routine isn't needed for the library call. */
5581 if (ext_call
== BUILT_IN_NONE
)
5584 /* Change the call to the specified function. */
5585 fndecl
= get_callee_fndecl (exp
);
5586 addr
= CALL_EXPR_FN (exp
);
5589 gcc_assert (TREE_OPERAND (addr
, 0) == fndecl
);
5590 TREE_OPERAND (addr
, 0) = builtin_decl_explicit (ext_call
);
5592 /* Expand the call here so we can emit trailing code. */
5593 ret
= expand_call (exp
, target
, ignore
);
5595 /* Replace the original function just in case it matters. */
5596 TREE_OPERAND (addr
, 0) = fndecl
;
5598 /* Then issue the arithmetic correction to return the right result. */
5603 ret
= expand_simple_binop (mode
, AND
, ret
, val
, NULL_RTX
, true,
5605 ret
= expand_simple_unop (mode
, NOT
, ret
, target
, true);
5608 ret
= expand_simple_binop (mode
, code
, ret
, val
, target
, true,
5615 #ifndef HAVE_atomic_clear
5616 # define HAVE_atomic_clear 0
5617 # define gen_atomic_clear(x,y) (gcc_unreachable (), NULL_RTX)
5620 /* Expand an atomic clear operation.
5621 void _atomic_clear (BOOL *obj, enum memmodel)
5622 EXP is the call expression. */
5625 expand_builtin_atomic_clear (tree exp
)
5629 enum memmodel model
;
5631 mode
= mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0);
5632 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5633 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5635 if (is_mm_consume (model
) || is_mm_acquire (model
) || is_mm_acq_rel (model
))
5637 warning (OPT_Winvalid_memory_model
,
5638 "invalid memory model for %<__atomic_store%>");
5639 model
= MEMMODEL_SEQ_CST
;
5642 if (HAVE_atomic_clear
)
5644 emit_insn (gen_atomic_clear (mem
, model
));
5648 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5649 Failing that, a store is issued by __atomic_store. The only way this can
5650 fail is if the bool type is larger than a word size. Unlikely, but
5651 handle it anyway for completeness. Assume a single threaded model since
5652 there is no atomic support in this case, and no barriers are required. */
5653 ret
= expand_atomic_store (mem
, const0_rtx
, model
, true);
5655 emit_move_insn (mem
, const0_rtx
);
5659 /* Expand an atomic test_and_set operation.
5660 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5661 EXP is the call expression. */
5664 expand_builtin_atomic_test_and_set (tree exp
, rtx target
)
5667 enum memmodel model
;
5670 mode
= mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0);
5671 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5672 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5674 return expand_atomic_test_and_set (target
, mem
, model
);
5678 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5679 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
5682 fold_builtin_atomic_always_lock_free (tree arg0
, tree arg1
)
5686 unsigned int mode_align
, type_align
;
5688 if (TREE_CODE (arg0
) != INTEGER_CST
)
5691 size
= INTVAL (expand_normal (arg0
)) * BITS_PER_UNIT
;
5692 mode
= mode_for_size (size
, MODE_INT
, 0);
5693 mode_align
= GET_MODE_ALIGNMENT (mode
);
5695 if (TREE_CODE (arg1
) == INTEGER_CST
&& INTVAL (expand_normal (arg1
)) == 0)
5696 type_align
= mode_align
;
5699 tree ttype
= TREE_TYPE (arg1
);
5701 /* This function is usually invoked and folded immediately by the front
5702 end before anything else has a chance to look at it. The pointer
5703 parameter at this point is usually cast to a void *, so check for that
5704 and look past the cast. */
5705 if (CONVERT_EXPR_P (arg1
) && POINTER_TYPE_P (ttype
)
5706 && VOID_TYPE_P (TREE_TYPE (ttype
)))
5707 arg1
= TREE_OPERAND (arg1
, 0);
5709 ttype
= TREE_TYPE (arg1
);
5710 gcc_assert (POINTER_TYPE_P (ttype
));
5712 /* Get the underlying type of the object. */
5713 ttype
= TREE_TYPE (ttype
);
5714 type_align
= TYPE_ALIGN (ttype
);
5717 /* If the object has smaller alignment, the the lock free routines cannot
5719 if (type_align
< mode_align
)
5720 return boolean_false_node
;
5722 /* Check if a compare_and_swap pattern exists for the mode which represents
5723 the required size. The pattern is not allowed to fail, so the existence
5724 of the pattern indicates support is present. */
5725 if (can_compare_and_swap_p (mode
, true))
5726 return boolean_true_node
;
5728 return boolean_false_node
;
5731 /* Return true if the parameters to call EXP represent an object which will
5732 always generate lock free instructions. The first argument represents the
5733 size of the object, and the second parameter is a pointer to the object
5734 itself. If NULL is passed for the object, then the result is based on
5735 typical alignment for an object of the specified size. Otherwise return
5739 expand_builtin_atomic_always_lock_free (tree exp
)
5742 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5743 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5745 if (TREE_CODE (arg0
) != INTEGER_CST
)
5747 error ("non-constant argument 1 to __atomic_always_lock_free");
5751 size
= fold_builtin_atomic_always_lock_free (arg0
, arg1
);
5752 if (size
== boolean_true_node
)
5757 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5758 is lock free on this architecture. */
5761 fold_builtin_atomic_is_lock_free (tree arg0
, tree arg1
)
5763 if (!flag_inline_atomics
)
5766 /* If it isn't always lock free, don't generate a result. */
5767 if (fold_builtin_atomic_always_lock_free (arg0
, arg1
) == boolean_true_node
)
5768 return boolean_true_node
;
5773 /* Return true if the parameters to call EXP represent an object which will
5774 always generate lock free instructions. The first argument represents the
5775 size of the object, and the second parameter is a pointer to the object
5776 itself. If NULL is passed for the object, then the result is based on
5777 typical alignment for an object of the specified size. Otherwise return
5781 expand_builtin_atomic_is_lock_free (tree exp
)
5784 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5785 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5787 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
5789 error ("non-integer argument 1 to __atomic_is_lock_free");
5793 if (!flag_inline_atomics
)
5796 /* If the value is known at compile time, return the RTX for it. */
5797 size
= fold_builtin_atomic_is_lock_free (arg0
, arg1
);
5798 if (size
== boolean_true_node
)
5804 /* Expand the __atomic_thread_fence intrinsic:
5805 void __atomic_thread_fence (enum memmodel)
5806 EXP is the CALL_EXPR. */
5809 expand_builtin_atomic_thread_fence (tree exp
)
5811 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
5812 expand_mem_thread_fence (model
);
5815 /* Expand the __atomic_signal_fence intrinsic:
5816 void __atomic_signal_fence (enum memmodel)
5817 EXP is the CALL_EXPR. */
5820 expand_builtin_atomic_signal_fence (tree exp
)
5822 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
5823 expand_mem_signal_fence (model
);
5826 /* Expand the __sync_synchronize intrinsic. */
5829 expand_builtin_sync_synchronize (void)
5831 expand_mem_thread_fence (MEMMODEL_SYNC_SEQ_CST
);
5835 expand_builtin_thread_pointer (tree exp
, rtx target
)
5837 enum insn_code icode
;
5838 if (!validate_arglist (exp
, VOID_TYPE
))
5840 icode
= direct_optab_handler (get_thread_pointer_optab
, Pmode
);
5841 if (icode
!= CODE_FOR_nothing
)
5843 struct expand_operand op
;
5844 /* If the target is not sutitable then create a new target. */
5845 if (target
== NULL_RTX
5847 || GET_MODE (target
) != Pmode
)
5848 target
= gen_reg_rtx (Pmode
);
5849 create_output_operand (&op
, target
, Pmode
);
5850 expand_insn (icode
, 1, &op
);
5853 error ("__builtin_thread_pointer is not supported on this target");
5858 expand_builtin_set_thread_pointer (tree exp
)
5860 enum insn_code icode
;
5861 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5863 icode
= direct_optab_handler (set_thread_pointer_optab
, Pmode
);
5864 if (icode
!= CODE_FOR_nothing
)
5866 struct expand_operand op
;
5867 rtx val
= expand_expr (CALL_EXPR_ARG (exp
, 0), NULL_RTX
,
5868 Pmode
, EXPAND_NORMAL
);
5869 create_input_operand (&op
, val
, Pmode
);
5870 expand_insn (icode
, 1, &op
);
5873 error ("__builtin_set_thread_pointer is not supported on this target");
5877 /* Emit code to restore the current value of stack. */
5880 expand_stack_restore (tree var
)
5883 rtx sa
= expand_normal (var
);
5885 sa
= convert_memory_address (Pmode
, sa
);
5887 prev
= get_last_insn ();
5888 emit_stack_restore (SAVE_BLOCK
, sa
);
5890 record_new_stack_level ();
5892 fixup_args_size_notes (prev
, get_last_insn (), 0);
5895 /* Emit code to save the current value of stack. */
5898 expand_stack_save (void)
5902 emit_stack_save (SAVE_BLOCK
, &ret
);
5907 /* Expand OpenACC acc_on_device.
5909 This has to happen late (that is, not in early folding; expand_builtin_*,
5910 rather than fold_builtin_*), as we have to act differently for host and
5911 acceleration device (ACCEL_COMPILER conditional). */
5914 expand_builtin_acc_on_device (tree exp
, rtx target
)
5916 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
5919 tree arg
= CALL_EXPR_ARG (exp
, 0);
5921 /* Return (arg == v1 || arg == v2) ? 1 : 0. */
5922 machine_mode v_mode
= TYPE_MODE (TREE_TYPE (arg
));
5923 rtx v
= expand_normal (arg
), v1
, v2
;
5924 #ifdef ACCEL_COMPILER
5925 v1
= GEN_INT (GOMP_DEVICE_NOT_HOST
);
5926 v2
= GEN_INT (ACCEL_COMPILER_acc_device
);
5928 v1
= GEN_INT (GOMP_DEVICE_NONE
);
5929 v2
= GEN_INT (GOMP_DEVICE_HOST
);
5931 machine_mode target_mode
= TYPE_MODE (integer_type_node
);
5932 if (!target
|| !register_operand (target
, target_mode
))
5933 target
= gen_reg_rtx (target_mode
);
5934 emit_move_insn (target
, const1_rtx
);
5935 rtx_code_label
*done_label
= gen_label_rtx ();
5936 do_compare_rtx_and_jump (v
, v1
, EQ
, false, v_mode
, NULL_RTX
,
5937 NULL
, done_label
, PROB_EVEN
);
5938 do_compare_rtx_and_jump (v
, v2
, EQ
, false, v_mode
, NULL_RTX
,
5939 NULL
, done_label
, PROB_EVEN
);
5940 emit_move_insn (target
, const0_rtx
);
5941 emit_label (done_label
);
5947 /* Expand an expression EXP that calls a built-in function,
5948 with result going to TARGET if that's convenient
5949 (and in mode MODE if that's convenient).
5950 SUBTARGET may be used as the target for computing one of EXP's operands.
5951 IGNORE is nonzero if the value is to be ignored. */
5954 expand_builtin (tree exp
, rtx target
, rtx subtarget
, machine_mode mode
,
5957 tree fndecl
= get_callee_fndecl (exp
);
5958 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5959 machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5962 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5963 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5965 /* When ASan is enabled, we don't want to expand some memory/string
5966 builtins and rely on libsanitizer's hooks. This allows us to avoid
5967 redundant checks and be sure, that possible overflow will be detected
5970 if ((flag_sanitize
& SANITIZE_ADDRESS
) && asan_intercepted_p (fcode
))
5971 return expand_call (exp
, target
, ignore
);
5973 /* When not optimizing, generate calls to library functions for a certain
5976 && !called_as_built_in (fndecl
)
5977 && fcode
!= BUILT_IN_FORK
5978 && fcode
!= BUILT_IN_EXECL
5979 && fcode
!= BUILT_IN_EXECV
5980 && fcode
!= BUILT_IN_EXECLP
5981 && fcode
!= BUILT_IN_EXECLE
5982 && fcode
!= BUILT_IN_EXECVP
5983 && fcode
!= BUILT_IN_EXECVE
5984 && fcode
!= BUILT_IN_ALLOCA
5985 && fcode
!= BUILT_IN_ALLOCA_WITH_ALIGN
5986 && fcode
!= BUILT_IN_FREE
5987 && fcode
!= BUILT_IN_CHKP_SET_PTR_BOUNDS
5988 && fcode
!= BUILT_IN_CHKP_INIT_PTR_BOUNDS
5989 && fcode
!= BUILT_IN_CHKP_NULL_PTR_BOUNDS
5990 && fcode
!= BUILT_IN_CHKP_COPY_PTR_BOUNDS
5991 && fcode
!= BUILT_IN_CHKP_NARROW_PTR_BOUNDS
5992 && fcode
!= BUILT_IN_CHKP_STORE_PTR_BOUNDS
5993 && fcode
!= BUILT_IN_CHKP_CHECK_PTR_LBOUNDS
5994 && fcode
!= BUILT_IN_CHKP_CHECK_PTR_UBOUNDS
5995 && fcode
!= BUILT_IN_CHKP_CHECK_PTR_BOUNDS
5996 && fcode
!= BUILT_IN_CHKP_GET_PTR_LBOUND
5997 && fcode
!= BUILT_IN_CHKP_GET_PTR_UBOUND
5998 && fcode
!= BUILT_IN_CHKP_BNDRET
)
5999 return expand_call (exp
, target
, ignore
);
6001 /* The built-in function expanders test for target == const0_rtx
6002 to determine whether the function's result will be ignored. */
6004 target
= const0_rtx
;
6006 /* If the result of a pure or const built-in function is ignored, and
6007 none of its arguments are volatile, we can avoid expanding the
6008 built-in call and just evaluate the arguments for side-effects. */
6009 if (target
== const0_rtx
6010 && ((flags
= flags_from_decl_or_type (fndecl
)) & (ECF_CONST
| ECF_PURE
))
6011 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
6013 bool volatilep
= false;
6015 call_expr_arg_iterator iter
;
6017 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
6018 if (TREE_THIS_VOLATILE (arg
))
6026 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
6027 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
6032 /* expand_builtin_with_bounds is supposed to be used for
6033 instrumented builtin calls. */
6034 gcc_assert (!CALL_WITH_BOUNDS_P (exp
));
6038 CASE_FLT_FN (BUILT_IN_FABS
):
6039 case BUILT_IN_FABSD32
:
6040 case BUILT_IN_FABSD64
:
6041 case BUILT_IN_FABSD128
:
6042 target
= expand_builtin_fabs (exp
, target
, subtarget
);
6047 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
6048 target
= expand_builtin_copysign (exp
, target
, subtarget
);
6053 /* Just do a normal library call if we were unable to fold
6055 CASE_FLT_FN (BUILT_IN_CABS
):
6058 CASE_FLT_FN (BUILT_IN_EXP
):
6059 CASE_FLT_FN (BUILT_IN_EXP10
):
6060 CASE_FLT_FN (BUILT_IN_POW10
):
6061 CASE_FLT_FN (BUILT_IN_EXP2
):
6062 CASE_FLT_FN (BUILT_IN_EXPM1
):
6063 CASE_FLT_FN (BUILT_IN_LOGB
):
6064 CASE_FLT_FN (BUILT_IN_LOG
):
6065 CASE_FLT_FN (BUILT_IN_LOG10
):
6066 CASE_FLT_FN (BUILT_IN_LOG2
):
6067 CASE_FLT_FN (BUILT_IN_LOG1P
):
6068 CASE_FLT_FN (BUILT_IN_TAN
):
6069 CASE_FLT_FN (BUILT_IN_ASIN
):
6070 CASE_FLT_FN (BUILT_IN_ACOS
):
6071 CASE_FLT_FN (BUILT_IN_ATAN
):
6072 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
6073 /* Treat these like sqrt only if unsafe math optimizations are allowed,
6074 because of possible accuracy problems. */
6075 if (! flag_unsafe_math_optimizations
)
6077 CASE_FLT_FN (BUILT_IN_SQRT
):
6078 CASE_FLT_FN (BUILT_IN_FLOOR
):
6079 CASE_FLT_FN (BUILT_IN_CEIL
):
6080 CASE_FLT_FN (BUILT_IN_TRUNC
):
6081 CASE_FLT_FN (BUILT_IN_ROUND
):
6082 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
6083 CASE_FLT_FN (BUILT_IN_RINT
):
6084 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
6089 CASE_FLT_FN (BUILT_IN_FMA
):
6090 target
= expand_builtin_mathfn_ternary (exp
, target
, subtarget
);
6095 CASE_FLT_FN (BUILT_IN_ILOGB
):
6096 if (! flag_unsafe_math_optimizations
)
6098 CASE_FLT_FN (BUILT_IN_ISINF
):
6099 CASE_FLT_FN (BUILT_IN_FINITE
):
6100 case BUILT_IN_ISFINITE
:
6101 case BUILT_IN_ISNORMAL
:
6102 target
= expand_builtin_interclass_mathfn (exp
, target
);
6107 CASE_FLT_FN (BUILT_IN_ICEIL
):
6108 CASE_FLT_FN (BUILT_IN_LCEIL
):
6109 CASE_FLT_FN (BUILT_IN_LLCEIL
):
6110 CASE_FLT_FN (BUILT_IN_LFLOOR
):
6111 CASE_FLT_FN (BUILT_IN_IFLOOR
):
6112 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
6113 target
= expand_builtin_int_roundingfn (exp
, target
);
6118 CASE_FLT_FN (BUILT_IN_IRINT
):
6119 CASE_FLT_FN (BUILT_IN_LRINT
):
6120 CASE_FLT_FN (BUILT_IN_LLRINT
):
6121 CASE_FLT_FN (BUILT_IN_IROUND
):
6122 CASE_FLT_FN (BUILT_IN_LROUND
):
6123 CASE_FLT_FN (BUILT_IN_LLROUND
):
6124 target
= expand_builtin_int_roundingfn_2 (exp
, target
);
6129 CASE_FLT_FN (BUILT_IN_POWI
):
6130 target
= expand_builtin_powi (exp
, target
);
6135 CASE_FLT_FN (BUILT_IN_ATAN2
):
6136 CASE_FLT_FN (BUILT_IN_LDEXP
):
6137 CASE_FLT_FN (BUILT_IN_SCALB
):
6138 CASE_FLT_FN (BUILT_IN_SCALBN
):
6139 CASE_FLT_FN (BUILT_IN_SCALBLN
):
6140 if (! flag_unsafe_math_optimizations
)
6143 CASE_FLT_FN (BUILT_IN_FMOD
):
6144 CASE_FLT_FN (BUILT_IN_REMAINDER
):
6145 CASE_FLT_FN (BUILT_IN_DREM
):
6146 CASE_FLT_FN (BUILT_IN_POW
):
6147 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
6152 CASE_FLT_FN (BUILT_IN_CEXPI
):
6153 target
= expand_builtin_cexpi (exp
, target
);
6154 gcc_assert (target
);
6157 CASE_FLT_FN (BUILT_IN_SIN
):
6158 CASE_FLT_FN (BUILT_IN_COS
):
6159 if (! flag_unsafe_math_optimizations
)
6161 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
6166 CASE_FLT_FN (BUILT_IN_SINCOS
):
6167 if (! flag_unsafe_math_optimizations
)
6169 target
= expand_builtin_sincos (exp
);
6174 case BUILT_IN_APPLY_ARGS
:
6175 return expand_builtin_apply_args ();
6177 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6178 FUNCTION with a copy of the parameters described by
6179 ARGUMENTS, and ARGSIZE. It returns a block of memory
6180 allocated on the stack into which is stored all the registers
6181 that might possibly be used for returning the result of a
6182 function. ARGUMENTS is the value returned by
6183 __builtin_apply_args. ARGSIZE is the number of bytes of
6184 arguments that must be copied. ??? How should this value be
6185 computed? We'll also need a safe worst case value for varargs
6187 case BUILT_IN_APPLY
:
6188 if (!validate_arglist (exp
, POINTER_TYPE
,
6189 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
6190 && !validate_arglist (exp
, REFERENCE_TYPE
,
6191 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6197 ops
[0] = expand_normal (CALL_EXPR_ARG (exp
, 0));
6198 ops
[1] = expand_normal (CALL_EXPR_ARG (exp
, 1));
6199 ops
[2] = expand_normal (CALL_EXPR_ARG (exp
, 2));
6201 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
6204 /* __builtin_return (RESULT) causes the function to return the
6205 value described by RESULT. RESULT is address of the block of
6206 memory returned by __builtin_apply. */
6207 case BUILT_IN_RETURN
:
6208 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6209 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp
, 0)));
6212 case BUILT_IN_SAVEREGS
:
6213 return expand_builtin_saveregs ();
6215 case BUILT_IN_VA_ARG_PACK
:
6216 /* All valid uses of __builtin_va_arg_pack () are removed during
6218 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp
);
6221 case BUILT_IN_VA_ARG_PACK_LEN
:
6222 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6224 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp
);
6227 /* Return the address of the first anonymous stack arg. */
6228 case BUILT_IN_NEXT_ARG
:
6229 if (fold_builtin_next_arg (exp
, false))
6231 return expand_builtin_next_arg ();
6233 case BUILT_IN_CLEAR_CACHE
:
6234 target
= expand_builtin___clear_cache (exp
);
6239 case BUILT_IN_CLASSIFY_TYPE
:
6240 return expand_builtin_classify_type (exp
);
6242 case BUILT_IN_CONSTANT_P
:
6245 case BUILT_IN_FRAME_ADDRESS
:
6246 case BUILT_IN_RETURN_ADDRESS
:
6247 return expand_builtin_frame_address (fndecl
, exp
);
6249 /* Returns the address of the area where the structure is returned.
6251 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
6252 if (call_expr_nargs (exp
) != 0
6253 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
6254 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
6257 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
6259 case BUILT_IN_ALLOCA
:
6260 case BUILT_IN_ALLOCA_WITH_ALIGN
:
6261 /* If the allocation stems from the declaration of a variable-sized
6262 object, it cannot accumulate. */
6263 target
= expand_builtin_alloca (exp
, CALL_ALLOCA_FOR_VAR_P (exp
));
6268 case BUILT_IN_STACK_SAVE
:
6269 return expand_stack_save ();
6271 case BUILT_IN_STACK_RESTORE
:
6272 expand_stack_restore (CALL_EXPR_ARG (exp
, 0));
6275 case BUILT_IN_BSWAP16
:
6276 case BUILT_IN_BSWAP32
:
6277 case BUILT_IN_BSWAP64
:
6278 target
= expand_builtin_bswap (target_mode
, exp
, target
, subtarget
);
6283 CASE_INT_FN (BUILT_IN_FFS
):
6284 target
= expand_builtin_unop (target_mode
, exp
, target
,
6285 subtarget
, ffs_optab
);
6290 CASE_INT_FN (BUILT_IN_CLZ
):
6291 target
= expand_builtin_unop (target_mode
, exp
, target
,
6292 subtarget
, clz_optab
);
6297 CASE_INT_FN (BUILT_IN_CTZ
):
6298 target
= expand_builtin_unop (target_mode
, exp
, target
,
6299 subtarget
, ctz_optab
);
6304 CASE_INT_FN (BUILT_IN_CLRSB
):
6305 target
= expand_builtin_unop (target_mode
, exp
, target
,
6306 subtarget
, clrsb_optab
);
6311 CASE_INT_FN (BUILT_IN_POPCOUNT
):
6312 target
= expand_builtin_unop (target_mode
, exp
, target
,
6313 subtarget
, popcount_optab
);
6318 CASE_INT_FN (BUILT_IN_PARITY
):
6319 target
= expand_builtin_unop (target_mode
, exp
, target
,
6320 subtarget
, parity_optab
);
6325 case BUILT_IN_STRLEN
:
6326 target
= expand_builtin_strlen (exp
, target
, target_mode
);
6331 case BUILT_IN_STRCPY
:
6332 target
= expand_builtin_strcpy (exp
, target
);
6337 case BUILT_IN_STRNCPY
:
6338 target
= expand_builtin_strncpy (exp
, target
);
6343 case BUILT_IN_STPCPY
:
6344 target
= expand_builtin_stpcpy (exp
, target
, mode
);
6349 case BUILT_IN_MEMCPY
:
6350 target
= expand_builtin_memcpy (exp
, target
);
6355 case BUILT_IN_MEMPCPY
:
6356 target
= expand_builtin_mempcpy (exp
, target
, mode
);
6361 case BUILT_IN_MEMSET
:
6362 target
= expand_builtin_memset (exp
, target
, mode
);
6367 case BUILT_IN_BZERO
:
6368 target
= expand_builtin_bzero (exp
);
6373 case BUILT_IN_STRCMP
:
6374 target
= expand_builtin_strcmp (exp
, target
);
6379 case BUILT_IN_STRNCMP
:
6380 target
= expand_builtin_strncmp (exp
, target
, mode
);
6386 case BUILT_IN_MEMCMP
:
6387 target
= expand_builtin_memcmp (exp
, target
, mode
);
6392 case BUILT_IN_SETJMP
:
6393 /* This should have been lowered to the builtins below. */
6396 case BUILT_IN_SETJMP_SETUP
:
6397 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6398 and the receiver label. */
6399 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
6401 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6402 VOIDmode
, EXPAND_NORMAL
);
6403 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 1), 0);
6404 rtx label_r
= label_rtx (label
);
6406 /* This is copied from the handling of non-local gotos. */
6407 expand_builtin_setjmp_setup (buf_addr
, label_r
);
6408 nonlocal_goto_handler_labels
6409 = gen_rtx_INSN_LIST (VOIDmode
, label_r
,
6410 nonlocal_goto_handler_labels
);
6411 /* ??? Do not let expand_label treat us as such since we would
6412 not want to be both on the list of non-local labels and on
6413 the list of forced labels. */
6414 FORCED_LABEL (label
) = 0;
6419 case BUILT_IN_SETJMP_RECEIVER
:
6420 /* __builtin_setjmp_receiver is passed the receiver label. */
6421 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6423 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 0), 0);
6424 rtx label_r
= label_rtx (label
);
6426 expand_builtin_setjmp_receiver (label_r
);
6431 /* __builtin_longjmp is passed a pointer to an array of five words.
6432 It's similar to the C library longjmp function but works with
6433 __builtin_setjmp above. */
6434 case BUILT_IN_LONGJMP
:
6435 if (validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6437 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6438 VOIDmode
, EXPAND_NORMAL
);
6439 rtx value
= expand_normal (CALL_EXPR_ARG (exp
, 1));
6441 if (value
!= const1_rtx
)
6443 error ("%<__builtin_longjmp%> second argument must be 1");
6447 expand_builtin_longjmp (buf_addr
, value
);
6452 case BUILT_IN_NONLOCAL_GOTO
:
6453 target
= expand_builtin_nonlocal_goto (exp
);
6458 /* This updates the setjmp buffer that is its argument with the value
6459 of the current stack pointer. */
6460 case BUILT_IN_UPDATE_SETJMP_BUF
:
6461 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6464 = expand_normal (CALL_EXPR_ARG (exp
, 0));
6466 expand_builtin_update_setjmp_buf (buf_addr
);
6472 expand_builtin_trap ();
6475 case BUILT_IN_UNREACHABLE
:
6476 expand_builtin_unreachable ();
6479 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
6480 case BUILT_IN_SIGNBITD32
:
6481 case BUILT_IN_SIGNBITD64
:
6482 case BUILT_IN_SIGNBITD128
:
6483 target
= expand_builtin_signbit (exp
, target
);
6488 /* Various hooks for the DWARF 2 __throw routine. */
6489 case BUILT_IN_UNWIND_INIT
:
6490 expand_builtin_unwind_init ();
6492 case BUILT_IN_DWARF_CFA
:
6493 return virtual_cfa_rtx
;
6494 #ifdef DWARF2_UNWIND_INFO
6495 case BUILT_IN_DWARF_SP_COLUMN
:
6496 return expand_builtin_dwarf_sp_column ();
6497 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6498 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp
, 0));
6501 case BUILT_IN_FROB_RETURN_ADDR
:
6502 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp
, 0));
6503 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6504 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp
, 0));
6505 case BUILT_IN_EH_RETURN
:
6506 expand_builtin_eh_return (CALL_EXPR_ARG (exp
, 0),
6507 CALL_EXPR_ARG (exp
, 1));
6509 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6510 return expand_builtin_eh_return_data_regno (exp
);
6511 case BUILT_IN_EXTEND_POINTER
:
6512 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp
, 0));
6513 case BUILT_IN_EH_POINTER
:
6514 return expand_builtin_eh_pointer (exp
);
6515 case BUILT_IN_EH_FILTER
:
6516 return expand_builtin_eh_filter (exp
);
6517 case BUILT_IN_EH_COPY_VALUES
:
6518 return expand_builtin_eh_copy_values (exp
);
6520 case BUILT_IN_VA_START
:
6521 return expand_builtin_va_start (exp
);
6522 case BUILT_IN_VA_END
:
6523 return expand_builtin_va_end (exp
);
6524 case BUILT_IN_VA_COPY
:
6525 return expand_builtin_va_copy (exp
);
6526 case BUILT_IN_EXPECT
:
6527 return expand_builtin_expect (exp
, target
);
6528 case BUILT_IN_ASSUME_ALIGNED
:
6529 return expand_builtin_assume_aligned (exp
, target
);
6530 case BUILT_IN_PREFETCH
:
6531 expand_builtin_prefetch (exp
);
6534 case BUILT_IN_INIT_TRAMPOLINE
:
6535 return expand_builtin_init_trampoline (exp
, true);
6536 case BUILT_IN_INIT_HEAP_TRAMPOLINE
:
6537 return expand_builtin_init_trampoline (exp
, false);
6538 case BUILT_IN_ADJUST_TRAMPOLINE
:
6539 return expand_builtin_adjust_trampoline (exp
);
6542 case BUILT_IN_EXECL
:
6543 case BUILT_IN_EXECV
:
6544 case BUILT_IN_EXECLP
:
6545 case BUILT_IN_EXECLE
:
6546 case BUILT_IN_EXECVP
:
6547 case BUILT_IN_EXECVE
:
6548 target
= expand_builtin_fork_or_exec (fndecl
, exp
, target
, ignore
);
6553 case BUILT_IN_SYNC_FETCH_AND_ADD_1
:
6554 case BUILT_IN_SYNC_FETCH_AND_ADD_2
:
6555 case BUILT_IN_SYNC_FETCH_AND_ADD_4
:
6556 case BUILT_IN_SYNC_FETCH_AND_ADD_8
:
6557 case BUILT_IN_SYNC_FETCH_AND_ADD_16
:
6558 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_ADD_1
);
6559 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, false, target
);
6564 case BUILT_IN_SYNC_FETCH_AND_SUB_1
:
6565 case BUILT_IN_SYNC_FETCH_AND_SUB_2
:
6566 case BUILT_IN_SYNC_FETCH_AND_SUB_4
:
6567 case BUILT_IN_SYNC_FETCH_AND_SUB_8
:
6568 case BUILT_IN_SYNC_FETCH_AND_SUB_16
:
6569 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_SUB_1
);
6570 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, false, target
);
6575 case BUILT_IN_SYNC_FETCH_AND_OR_1
:
6576 case BUILT_IN_SYNC_FETCH_AND_OR_2
:
6577 case BUILT_IN_SYNC_FETCH_AND_OR_4
:
6578 case BUILT_IN_SYNC_FETCH_AND_OR_8
:
6579 case BUILT_IN_SYNC_FETCH_AND_OR_16
:
6580 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_OR_1
);
6581 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, false, target
);
6586 case BUILT_IN_SYNC_FETCH_AND_AND_1
:
6587 case BUILT_IN_SYNC_FETCH_AND_AND_2
:
6588 case BUILT_IN_SYNC_FETCH_AND_AND_4
:
6589 case BUILT_IN_SYNC_FETCH_AND_AND_8
:
6590 case BUILT_IN_SYNC_FETCH_AND_AND_16
:
6591 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_AND_1
);
6592 target
= expand_builtin_sync_operation (mode
, exp
, AND
, false, target
);
6597 case BUILT_IN_SYNC_FETCH_AND_XOR_1
:
6598 case BUILT_IN_SYNC_FETCH_AND_XOR_2
:
6599 case BUILT_IN_SYNC_FETCH_AND_XOR_4
:
6600 case BUILT_IN_SYNC_FETCH_AND_XOR_8
:
6601 case BUILT_IN_SYNC_FETCH_AND_XOR_16
:
6602 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_XOR_1
);
6603 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, false, target
);
6608 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
6609 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
6610 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
6611 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
6612 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
6613 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_NAND_1
);
6614 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, false, target
);
6619 case BUILT_IN_SYNC_ADD_AND_FETCH_1
:
6620 case BUILT_IN_SYNC_ADD_AND_FETCH_2
:
6621 case BUILT_IN_SYNC_ADD_AND_FETCH_4
:
6622 case BUILT_IN_SYNC_ADD_AND_FETCH_8
:
6623 case BUILT_IN_SYNC_ADD_AND_FETCH_16
:
6624 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_ADD_AND_FETCH_1
);
6625 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, true, target
);
6630 case BUILT_IN_SYNC_SUB_AND_FETCH_1
:
6631 case BUILT_IN_SYNC_SUB_AND_FETCH_2
:
6632 case BUILT_IN_SYNC_SUB_AND_FETCH_4
:
6633 case BUILT_IN_SYNC_SUB_AND_FETCH_8
:
6634 case BUILT_IN_SYNC_SUB_AND_FETCH_16
:
6635 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_SUB_AND_FETCH_1
);
6636 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, true, target
);
6641 case BUILT_IN_SYNC_OR_AND_FETCH_1
:
6642 case BUILT_IN_SYNC_OR_AND_FETCH_2
:
6643 case BUILT_IN_SYNC_OR_AND_FETCH_4
:
6644 case BUILT_IN_SYNC_OR_AND_FETCH_8
:
6645 case BUILT_IN_SYNC_OR_AND_FETCH_16
:
6646 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_OR_AND_FETCH_1
);
6647 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, true, target
);
6652 case BUILT_IN_SYNC_AND_AND_FETCH_1
:
6653 case BUILT_IN_SYNC_AND_AND_FETCH_2
:
6654 case BUILT_IN_SYNC_AND_AND_FETCH_4
:
6655 case BUILT_IN_SYNC_AND_AND_FETCH_8
:
6656 case BUILT_IN_SYNC_AND_AND_FETCH_16
:
6657 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_AND_AND_FETCH_1
);
6658 target
= expand_builtin_sync_operation (mode
, exp
, AND
, true, target
);
6663 case BUILT_IN_SYNC_XOR_AND_FETCH_1
:
6664 case BUILT_IN_SYNC_XOR_AND_FETCH_2
:
6665 case BUILT_IN_SYNC_XOR_AND_FETCH_4
:
6666 case BUILT_IN_SYNC_XOR_AND_FETCH_8
:
6667 case BUILT_IN_SYNC_XOR_AND_FETCH_16
:
6668 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_XOR_AND_FETCH_1
);
6669 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, true, target
);
6674 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
6675 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
6676 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
6677 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
6678 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
6679 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_NAND_AND_FETCH_1
);
6680 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, true, target
);
6685 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
:
6686 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2
:
6687 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4
:
6688 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8
:
6689 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16
:
6690 if (mode
== VOIDmode
)
6691 mode
= TYPE_MODE (boolean_type_node
);
6692 if (!target
|| !register_operand (target
, mode
))
6693 target
= gen_reg_rtx (mode
);
6695 mode
= get_builtin_sync_mode
6696 (fcode
- BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
);
6697 target
= expand_builtin_compare_and_swap (mode
, exp
, true, target
);
6702 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
:
6703 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2
:
6704 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4
:
6705 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8
:
6706 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16
:
6707 mode
= get_builtin_sync_mode
6708 (fcode
- BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
);
6709 target
= expand_builtin_compare_and_swap (mode
, exp
, false, target
);
6714 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
:
6715 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2
:
6716 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4
:
6717 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8
:
6718 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16
:
6719 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
);
6720 target
= expand_builtin_sync_lock_test_and_set (mode
, exp
, target
);
6725 case BUILT_IN_SYNC_LOCK_RELEASE_1
:
6726 case BUILT_IN_SYNC_LOCK_RELEASE_2
:
6727 case BUILT_IN_SYNC_LOCK_RELEASE_4
:
6728 case BUILT_IN_SYNC_LOCK_RELEASE_8
:
6729 case BUILT_IN_SYNC_LOCK_RELEASE_16
:
6730 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_RELEASE_1
);
6731 expand_builtin_sync_lock_release (mode
, exp
);
6734 case BUILT_IN_SYNC_SYNCHRONIZE
:
6735 expand_builtin_sync_synchronize ();
6738 case BUILT_IN_ATOMIC_EXCHANGE_1
:
6739 case BUILT_IN_ATOMIC_EXCHANGE_2
:
6740 case BUILT_IN_ATOMIC_EXCHANGE_4
:
6741 case BUILT_IN_ATOMIC_EXCHANGE_8
:
6742 case BUILT_IN_ATOMIC_EXCHANGE_16
:
6743 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_EXCHANGE_1
);
6744 target
= expand_builtin_atomic_exchange (mode
, exp
, target
);
6749 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
6750 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
6751 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
6752 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
6753 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
6755 unsigned int nargs
, z
;
6756 vec
<tree
, va_gc
> *vec
;
6759 get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
);
6760 target
= expand_builtin_atomic_compare_exchange (mode
, exp
, target
);
6764 /* If this is turned into an external library call, the weak parameter
6765 must be dropped to match the expected parameter list. */
6766 nargs
= call_expr_nargs (exp
);
6767 vec_alloc (vec
, nargs
- 1);
6768 for (z
= 0; z
< 3; z
++)
6769 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
6770 /* Skip the boolean weak parameter. */
6771 for (z
= 4; z
< 6; z
++)
6772 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
6773 exp
= build_call_vec (TREE_TYPE (exp
), CALL_EXPR_FN (exp
), vec
);
6777 case BUILT_IN_ATOMIC_LOAD_1
:
6778 case BUILT_IN_ATOMIC_LOAD_2
:
6779 case BUILT_IN_ATOMIC_LOAD_4
:
6780 case BUILT_IN_ATOMIC_LOAD_8
:
6781 case BUILT_IN_ATOMIC_LOAD_16
:
6782 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_LOAD_1
);
6783 target
= expand_builtin_atomic_load (mode
, exp
, target
);
6788 case BUILT_IN_ATOMIC_STORE_1
:
6789 case BUILT_IN_ATOMIC_STORE_2
:
6790 case BUILT_IN_ATOMIC_STORE_4
:
6791 case BUILT_IN_ATOMIC_STORE_8
:
6792 case BUILT_IN_ATOMIC_STORE_16
:
6793 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_STORE_1
);
6794 target
= expand_builtin_atomic_store (mode
, exp
);
6799 case BUILT_IN_ATOMIC_ADD_FETCH_1
:
6800 case BUILT_IN_ATOMIC_ADD_FETCH_2
:
6801 case BUILT_IN_ATOMIC_ADD_FETCH_4
:
6802 case BUILT_IN_ATOMIC_ADD_FETCH_8
:
6803 case BUILT_IN_ATOMIC_ADD_FETCH_16
:
6805 enum built_in_function lib
;
6806 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
);
6807 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_ADD_1
+
6808 (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
));
6809 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, true,
6815 case BUILT_IN_ATOMIC_SUB_FETCH_1
:
6816 case BUILT_IN_ATOMIC_SUB_FETCH_2
:
6817 case BUILT_IN_ATOMIC_SUB_FETCH_4
:
6818 case BUILT_IN_ATOMIC_SUB_FETCH_8
:
6819 case BUILT_IN_ATOMIC_SUB_FETCH_16
:
6821 enum built_in_function lib
;
6822 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
);
6823 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_SUB_1
+
6824 (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
));
6825 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, true,
6831 case BUILT_IN_ATOMIC_AND_FETCH_1
:
6832 case BUILT_IN_ATOMIC_AND_FETCH_2
:
6833 case BUILT_IN_ATOMIC_AND_FETCH_4
:
6834 case BUILT_IN_ATOMIC_AND_FETCH_8
:
6835 case BUILT_IN_ATOMIC_AND_FETCH_16
:
6837 enum built_in_function lib
;
6838 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
);
6839 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_AND_1
+
6840 (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
));
6841 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, true,
6847 case BUILT_IN_ATOMIC_NAND_FETCH_1
:
6848 case BUILT_IN_ATOMIC_NAND_FETCH_2
:
6849 case BUILT_IN_ATOMIC_NAND_FETCH_4
:
6850 case BUILT_IN_ATOMIC_NAND_FETCH_8
:
6851 case BUILT_IN_ATOMIC_NAND_FETCH_16
:
6853 enum built_in_function lib
;
6854 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
);
6855 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_NAND_1
+
6856 (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
));
6857 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, true,
6863 case BUILT_IN_ATOMIC_XOR_FETCH_1
:
6864 case BUILT_IN_ATOMIC_XOR_FETCH_2
:
6865 case BUILT_IN_ATOMIC_XOR_FETCH_4
:
6866 case BUILT_IN_ATOMIC_XOR_FETCH_8
:
6867 case BUILT_IN_ATOMIC_XOR_FETCH_16
:
6869 enum built_in_function lib
;
6870 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
);
6871 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_XOR_1
+
6872 (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
));
6873 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, true,
6879 case BUILT_IN_ATOMIC_OR_FETCH_1
:
6880 case BUILT_IN_ATOMIC_OR_FETCH_2
:
6881 case BUILT_IN_ATOMIC_OR_FETCH_4
:
6882 case BUILT_IN_ATOMIC_OR_FETCH_8
:
6883 case BUILT_IN_ATOMIC_OR_FETCH_16
:
6885 enum built_in_function lib
;
6886 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
);
6887 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_OR_1
+
6888 (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
));
6889 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, true,
6895 case BUILT_IN_ATOMIC_FETCH_ADD_1
:
6896 case BUILT_IN_ATOMIC_FETCH_ADD_2
:
6897 case BUILT_IN_ATOMIC_FETCH_ADD_4
:
6898 case BUILT_IN_ATOMIC_FETCH_ADD_8
:
6899 case BUILT_IN_ATOMIC_FETCH_ADD_16
:
6900 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_ADD_1
);
6901 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, false,
6902 ignore
, BUILT_IN_NONE
);
6907 case BUILT_IN_ATOMIC_FETCH_SUB_1
:
6908 case BUILT_IN_ATOMIC_FETCH_SUB_2
:
6909 case BUILT_IN_ATOMIC_FETCH_SUB_4
:
6910 case BUILT_IN_ATOMIC_FETCH_SUB_8
:
6911 case BUILT_IN_ATOMIC_FETCH_SUB_16
:
6912 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_SUB_1
);
6913 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, false,
6914 ignore
, BUILT_IN_NONE
);
6919 case BUILT_IN_ATOMIC_FETCH_AND_1
:
6920 case BUILT_IN_ATOMIC_FETCH_AND_2
:
6921 case BUILT_IN_ATOMIC_FETCH_AND_4
:
6922 case BUILT_IN_ATOMIC_FETCH_AND_8
:
6923 case BUILT_IN_ATOMIC_FETCH_AND_16
:
6924 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_AND_1
);
6925 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, false,
6926 ignore
, BUILT_IN_NONE
);
6931 case BUILT_IN_ATOMIC_FETCH_NAND_1
:
6932 case BUILT_IN_ATOMIC_FETCH_NAND_2
:
6933 case BUILT_IN_ATOMIC_FETCH_NAND_4
:
6934 case BUILT_IN_ATOMIC_FETCH_NAND_8
:
6935 case BUILT_IN_ATOMIC_FETCH_NAND_16
:
6936 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_NAND_1
);
6937 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, false,
6938 ignore
, BUILT_IN_NONE
);
6943 case BUILT_IN_ATOMIC_FETCH_XOR_1
:
6944 case BUILT_IN_ATOMIC_FETCH_XOR_2
:
6945 case BUILT_IN_ATOMIC_FETCH_XOR_4
:
6946 case BUILT_IN_ATOMIC_FETCH_XOR_8
:
6947 case BUILT_IN_ATOMIC_FETCH_XOR_16
:
6948 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_XOR_1
);
6949 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, false,
6950 ignore
, BUILT_IN_NONE
);
6955 case BUILT_IN_ATOMIC_FETCH_OR_1
:
6956 case BUILT_IN_ATOMIC_FETCH_OR_2
:
6957 case BUILT_IN_ATOMIC_FETCH_OR_4
:
6958 case BUILT_IN_ATOMIC_FETCH_OR_8
:
6959 case BUILT_IN_ATOMIC_FETCH_OR_16
:
6960 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_OR_1
);
6961 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, false,
6962 ignore
, BUILT_IN_NONE
);
6967 case BUILT_IN_ATOMIC_TEST_AND_SET
:
6968 return expand_builtin_atomic_test_and_set (exp
, target
);
6970 case BUILT_IN_ATOMIC_CLEAR
:
6971 return expand_builtin_atomic_clear (exp
);
6973 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
6974 return expand_builtin_atomic_always_lock_free (exp
);
6976 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
6977 target
= expand_builtin_atomic_is_lock_free (exp
);
6982 case BUILT_IN_ATOMIC_THREAD_FENCE
:
6983 expand_builtin_atomic_thread_fence (exp
);
6986 case BUILT_IN_ATOMIC_SIGNAL_FENCE
:
6987 expand_builtin_atomic_signal_fence (exp
);
6990 case BUILT_IN_OBJECT_SIZE
:
6991 return expand_builtin_object_size (exp
);
6993 case BUILT_IN_MEMCPY_CHK
:
6994 case BUILT_IN_MEMPCPY_CHK
:
6995 case BUILT_IN_MEMMOVE_CHK
:
6996 case BUILT_IN_MEMSET_CHK
:
6997 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
7002 case BUILT_IN_STRCPY_CHK
:
7003 case BUILT_IN_STPCPY_CHK
:
7004 case BUILT_IN_STRNCPY_CHK
:
7005 case BUILT_IN_STPNCPY_CHK
:
7006 case BUILT_IN_STRCAT_CHK
:
7007 case BUILT_IN_STRNCAT_CHK
:
7008 case BUILT_IN_SNPRINTF_CHK
:
7009 case BUILT_IN_VSNPRINTF_CHK
:
7010 maybe_emit_chk_warning (exp
, fcode
);
7013 case BUILT_IN_SPRINTF_CHK
:
7014 case BUILT_IN_VSPRINTF_CHK
:
7015 maybe_emit_sprintf_chk_warning (exp
, fcode
);
7019 if (warn_free_nonheap_object
)
7020 maybe_emit_free_warning (exp
);
7023 case BUILT_IN_THREAD_POINTER
:
7024 return expand_builtin_thread_pointer (exp
, target
);
7026 case BUILT_IN_SET_THREAD_POINTER
:
7027 expand_builtin_set_thread_pointer (exp
);
7030 case BUILT_IN_CILK_DETACH
:
7031 expand_builtin_cilk_detach (exp
);
7034 case BUILT_IN_CILK_POP_FRAME
:
7035 expand_builtin_cilk_pop_frame (exp
);
7038 case BUILT_IN_CHKP_INIT_PTR_BOUNDS
:
7039 case BUILT_IN_CHKP_NULL_PTR_BOUNDS
:
7040 case BUILT_IN_CHKP_COPY_PTR_BOUNDS
:
7041 case BUILT_IN_CHKP_CHECK_PTR_LBOUNDS
:
7042 case BUILT_IN_CHKP_CHECK_PTR_UBOUNDS
:
7043 case BUILT_IN_CHKP_CHECK_PTR_BOUNDS
:
7044 case BUILT_IN_CHKP_SET_PTR_BOUNDS
:
7045 case BUILT_IN_CHKP_NARROW_PTR_BOUNDS
:
7046 case BUILT_IN_CHKP_STORE_PTR_BOUNDS
:
7047 case BUILT_IN_CHKP_GET_PTR_LBOUND
:
7048 case BUILT_IN_CHKP_GET_PTR_UBOUND
:
7049 /* We allow user CHKP builtins if Pointer Bounds
7051 if (!chkp_function_instrumented_p (current_function_decl
))
7053 if (fcode
== BUILT_IN_CHKP_SET_PTR_BOUNDS
7054 || fcode
== BUILT_IN_CHKP_NARROW_PTR_BOUNDS
7055 || fcode
== BUILT_IN_CHKP_INIT_PTR_BOUNDS
7056 || fcode
== BUILT_IN_CHKP_NULL_PTR_BOUNDS
7057 || fcode
== BUILT_IN_CHKP_COPY_PTR_BOUNDS
)
7058 return expand_normal (CALL_EXPR_ARG (exp
, 0));
7059 else if (fcode
== BUILT_IN_CHKP_GET_PTR_LBOUND
)
7060 return expand_normal (size_zero_node
);
7061 else if (fcode
== BUILT_IN_CHKP_GET_PTR_UBOUND
)
7062 return expand_normal (size_int (-1));
7068 case BUILT_IN_CHKP_BNDMK
:
7069 case BUILT_IN_CHKP_BNDSTX
:
7070 case BUILT_IN_CHKP_BNDCL
:
7071 case BUILT_IN_CHKP_BNDCU
:
7072 case BUILT_IN_CHKP_BNDLDX
:
7073 case BUILT_IN_CHKP_BNDRET
:
7074 case BUILT_IN_CHKP_INTERSECT
:
7075 case BUILT_IN_CHKP_NARROW
:
7076 case BUILT_IN_CHKP_EXTRACT_LOWER
:
7077 case BUILT_IN_CHKP_EXTRACT_UPPER
:
7078 /* Software implementation of Pointer Bounds Checker is NYI.
7079 Target support is required. */
7080 error ("Your target platform does not support -fcheck-pointer-bounds");
7083 case BUILT_IN_ACC_ON_DEVICE
:
7084 target
= expand_builtin_acc_on_device (exp
, target
);
7089 default: /* just do library call, if unknown builtin */
7093 /* The switch statement above can drop through to cause the function
7094 to be called normally. */
7095 return expand_call (exp
, target
, ignore
);
7098 /* Similar to expand_builtin but is used for instrumented calls. */
7101 expand_builtin_with_bounds (tree exp
, rtx target
,
7102 rtx subtarget ATTRIBUTE_UNUSED
,
7103 machine_mode mode
, int ignore
)
7105 tree fndecl
= get_callee_fndecl (exp
);
7106 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7108 gcc_assert (CALL_WITH_BOUNDS_P (exp
));
7110 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7111 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
7113 gcc_assert (fcode
> BEGIN_CHKP_BUILTINS
7114 && fcode
< END_CHKP_BUILTINS
);
7118 case BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP
:
7119 target
= expand_builtin_memcpy_with_bounds (exp
, target
);
7124 case BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP
:
7125 target
= expand_builtin_mempcpy_with_bounds (exp
, target
, mode
);
7130 case BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP
:
7131 target
= expand_builtin_memset_with_bounds (exp
, target
, mode
);
7140 /* The switch statement above can drop through to cause the function
7141 to be called normally. */
7142 return expand_call (exp
, target
, ignore
);
7145 /* Determine whether a tree node represents a call to a built-in
7146 function. If the tree T is a call to a built-in function with
7147 the right number of arguments of the appropriate types, return
7148 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
7149 Otherwise the return value is END_BUILTINS. */
7151 enum built_in_function
7152 builtin_mathfn_code (const_tree t
)
7154 const_tree fndecl
, arg
, parmlist
;
7155 const_tree argtype
, parmtype
;
7156 const_call_expr_arg_iterator iter
;
7158 if (TREE_CODE (t
) != CALL_EXPR
7159 || TREE_CODE (CALL_EXPR_FN (t
)) != ADDR_EXPR
)
7160 return END_BUILTINS
;
7162 fndecl
= get_callee_fndecl (t
);
7163 if (fndecl
== NULL_TREE
7164 || TREE_CODE (fndecl
) != FUNCTION_DECL
7165 || ! DECL_BUILT_IN (fndecl
)
7166 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7167 return END_BUILTINS
;
7169 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
7170 init_const_call_expr_arg_iterator (t
, &iter
);
7171 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
7173 /* If a function doesn't take a variable number of arguments,
7174 the last element in the list will have type `void'. */
7175 parmtype
= TREE_VALUE (parmlist
);
7176 if (VOID_TYPE_P (parmtype
))
7178 if (more_const_call_expr_args_p (&iter
))
7179 return END_BUILTINS
;
7180 return DECL_FUNCTION_CODE (fndecl
);
7183 if (! more_const_call_expr_args_p (&iter
))
7184 return END_BUILTINS
;
7186 arg
= next_const_call_expr_arg (&iter
);
7187 argtype
= TREE_TYPE (arg
);
7189 if (SCALAR_FLOAT_TYPE_P (parmtype
))
7191 if (! SCALAR_FLOAT_TYPE_P (argtype
))
7192 return END_BUILTINS
;
7194 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
7196 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
7197 return END_BUILTINS
;
7199 else if (POINTER_TYPE_P (parmtype
))
7201 if (! POINTER_TYPE_P (argtype
))
7202 return END_BUILTINS
;
7204 else if (INTEGRAL_TYPE_P (parmtype
))
7206 if (! INTEGRAL_TYPE_P (argtype
))
7207 return END_BUILTINS
;
7210 return END_BUILTINS
;
7213 /* Variable-length argument list. */
7214 return DECL_FUNCTION_CODE (fndecl
);
7217 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
7218 evaluate to a constant. */
7221 fold_builtin_constant_p (tree arg
)
7223 /* We return 1 for a numeric type that's known to be a constant
7224 value at compile-time or for an aggregate type that's a
7225 literal constant. */
7228 /* If we know this is a constant, emit the constant of one. */
7229 if (CONSTANT_CLASS_P (arg
)
7230 || (TREE_CODE (arg
) == CONSTRUCTOR
7231 && TREE_CONSTANT (arg
)))
7232 return integer_one_node
;
7233 if (TREE_CODE (arg
) == ADDR_EXPR
)
7235 tree op
= TREE_OPERAND (arg
, 0);
7236 if (TREE_CODE (op
) == STRING_CST
7237 || (TREE_CODE (op
) == ARRAY_REF
7238 && integer_zerop (TREE_OPERAND (op
, 1))
7239 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
7240 return integer_one_node
;
7243 /* If this expression has side effects, show we don't know it to be a
7244 constant. Likewise if it's a pointer or aggregate type since in
7245 those case we only want literals, since those are only optimized
7246 when generating RTL, not later.
7247 And finally, if we are compiling an initializer, not code, we
7248 need to return a definite result now; there's not going to be any
7249 more optimization done. */
7250 if (TREE_SIDE_EFFECTS (arg
)
7251 || AGGREGATE_TYPE_P (TREE_TYPE (arg
))
7252 || POINTER_TYPE_P (TREE_TYPE (arg
))
7254 || folding_initializer
7255 || force_folding_builtin_constant_p
)
7256 return integer_zero_node
;
7261 /* Create builtin_expect with PRED and EXPECTED as its arguments and
7262 return it as a truthvalue. */
7265 build_builtin_expect_predicate (location_t loc
, tree pred
, tree expected
,
7268 tree fn
, arg_types
, pred_type
, expected_type
, call_expr
, ret_type
;
7270 fn
= builtin_decl_explicit (BUILT_IN_EXPECT
);
7271 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7272 ret_type
= TREE_TYPE (TREE_TYPE (fn
));
7273 pred_type
= TREE_VALUE (arg_types
);
7274 expected_type
= TREE_VALUE (TREE_CHAIN (arg_types
));
7276 pred
= fold_convert_loc (loc
, pred_type
, pred
);
7277 expected
= fold_convert_loc (loc
, expected_type
, expected
);
7278 call_expr
= build_call_expr_loc (loc
, fn
, predictor
? 3 : 2, pred
, expected
,
7281 return build2 (NE_EXPR
, TREE_TYPE (pred
), call_expr
,
7282 build_int_cst (ret_type
, 0));
7285 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
7286 NULL_TREE if no simplification is possible. */
7289 fold_builtin_expect (location_t loc
, tree arg0
, tree arg1
, tree arg2
)
7291 tree inner
, fndecl
, inner_arg0
;
7292 enum tree_code code
;
7294 /* Distribute the expected value over short-circuiting operators.
7295 See through the cast from truthvalue_type_node to long. */
7297 while (CONVERT_EXPR_P (inner_arg0
)
7298 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0
))
7299 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0
, 0))))
7300 inner_arg0
= TREE_OPERAND (inner_arg0
, 0);
7302 /* If this is a builtin_expect within a builtin_expect keep the
7303 inner one. See through a comparison against a constant. It
7304 might have been added to create a thruthvalue. */
7307 if (COMPARISON_CLASS_P (inner
)
7308 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
)
7309 inner
= TREE_OPERAND (inner
, 0);
7311 if (TREE_CODE (inner
) == CALL_EXPR
7312 && (fndecl
= get_callee_fndecl (inner
))
7313 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7314 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
)
7318 code
= TREE_CODE (inner
);
7319 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
7321 tree op0
= TREE_OPERAND (inner
, 0);
7322 tree op1
= TREE_OPERAND (inner
, 1);
7324 op0
= build_builtin_expect_predicate (loc
, op0
, arg1
, arg2
);
7325 op1
= build_builtin_expect_predicate (loc
, op1
, arg1
, arg2
);
7326 inner
= build2 (code
, TREE_TYPE (inner
), op0
, op1
);
7328 return fold_convert_loc (loc
, TREE_TYPE (arg0
), inner
);
7331 /* If the argument isn't invariant then there's nothing else we can do. */
7332 if (!TREE_CONSTANT (inner_arg0
))
7335 /* If we expect that a comparison against the argument will fold to
7336 a constant return the constant. In practice, this means a true
7337 constant or the address of a non-weak symbol. */
7340 if (TREE_CODE (inner
) == ADDR_EXPR
)
7344 inner
= TREE_OPERAND (inner
, 0);
7346 while (TREE_CODE (inner
) == COMPONENT_REF
7347 || TREE_CODE (inner
) == ARRAY_REF
);
7348 if ((TREE_CODE (inner
) == VAR_DECL
7349 || TREE_CODE (inner
) == FUNCTION_DECL
)
7350 && DECL_WEAK (inner
))
7354 /* Otherwise, ARG0 already has the proper type for the return value. */
7358 /* Fold a call to __builtin_classify_type with argument ARG. */
7361 fold_builtin_classify_type (tree arg
)
7364 return build_int_cst (integer_type_node
, no_type_class
);
7366 return build_int_cst (integer_type_node
, type_to_class (TREE_TYPE (arg
)));
7369 /* Fold a call to __builtin_strlen with argument ARG. */
7372 fold_builtin_strlen (location_t loc
, tree type
, tree arg
)
7374 if (!validate_arg (arg
, POINTER_TYPE
))
7378 tree len
= c_strlen (arg
, 0);
7381 return fold_convert_loc (loc
, type
, len
);
7387 /* Fold a call to __builtin_inf or __builtin_huge_val. */
7390 fold_builtin_inf (location_t loc
, tree type
, int warn
)
7392 REAL_VALUE_TYPE real
;
7394 /* __builtin_inff is intended to be usable to define INFINITY on all
7395 targets. If an infinity is not available, INFINITY expands "to a
7396 positive constant of type float that overflows at translation
7397 time", footnote "In this case, using INFINITY will violate the
7398 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7399 Thus we pedwarn to ensure this constraint violation is
7401 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
7402 pedwarn (loc
, 0, "target format does not support infinity");
7405 return build_real (type
, real
);
7408 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
7411 fold_builtin_nan (tree arg
, tree type
, int quiet
)
7413 REAL_VALUE_TYPE real
;
7416 if (!validate_arg (arg
, POINTER_TYPE
))
7418 str
= c_getstr (arg
);
7422 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
7425 return build_real (type
, real
);
7428 /* Return true if the floating point expression T has an integer value.
7429 We also allow +Inf, -Inf and NaN to be considered integer values. */
7432 integer_valued_real_p (tree t
)
7434 switch (TREE_CODE (t
))
7441 return integer_valued_real_p (TREE_OPERAND (t
, 0));
7446 return integer_valued_real_p (TREE_OPERAND (t
, 1));
7453 return integer_valued_real_p (TREE_OPERAND (t
, 0))
7454 && integer_valued_real_p (TREE_OPERAND (t
, 1));
7457 return integer_valued_real_p (TREE_OPERAND (t
, 1))
7458 && integer_valued_real_p (TREE_OPERAND (t
, 2));
7461 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
7465 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
7466 if (TREE_CODE (type
) == INTEGER_TYPE
)
7468 if (TREE_CODE (type
) == REAL_TYPE
)
7469 return integer_valued_real_p (TREE_OPERAND (t
, 0));
7474 switch (builtin_mathfn_code (t
))
7476 CASE_FLT_FN (BUILT_IN_CEIL
):
7477 CASE_FLT_FN (BUILT_IN_FLOOR
):
7478 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
7479 CASE_FLT_FN (BUILT_IN_RINT
):
7480 CASE_FLT_FN (BUILT_IN_ROUND
):
7481 CASE_FLT_FN (BUILT_IN_TRUNC
):
7484 CASE_FLT_FN (BUILT_IN_FMIN
):
7485 CASE_FLT_FN (BUILT_IN_FMAX
):
7486 return integer_valued_real_p (CALL_EXPR_ARG (t
, 0))
7487 && integer_valued_real_p (CALL_EXPR_ARG (t
, 1));
7500 /* FNDECL is assumed to be a builtin where truncation can be propagated
7501 across (for instance floor((double)f) == (double)floorf (f).
7502 Do the transformation for a call with argument ARG. */
7505 fold_trunc_transparent_mathfn (location_t loc
, tree fndecl
, tree arg
)
7507 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7509 if (!validate_arg (arg
, REAL_TYPE
))
7512 /* Integer rounding functions are idempotent. */
7513 if (fcode
== builtin_mathfn_code (arg
))
7516 /* If argument is already integer valued, and we don't need to worry
7517 about setting errno, there's no need to perform rounding. */
7518 if (! flag_errno_math
&& integer_valued_real_p (arg
))
7523 tree arg0
= strip_float_extensions (arg
);
7524 tree ftype
= TREE_TYPE (TREE_TYPE (fndecl
));
7525 tree newtype
= TREE_TYPE (arg0
);
7528 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
7529 && (decl
= mathfn_built_in (newtype
, fcode
)))
7530 return fold_convert_loc (loc
, ftype
,
7531 build_call_expr_loc (loc
, decl
, 1,
7532 fold_convert_loc (loc
,
7539 /* FNDECL is assumed to be builtin which can narrow the FP type of
7540 the argument, for instance lround((double)f) -> lroundf (f).
7541 Do the transformation for a call with argument ARG. */
7544 fold_fixed_mathfn (location_t loc
, tree fndecl
, tree arg
)
7546 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7548 if (!validate_arg (arg
, REAL_TYPE
))
7551 /* If argument is already integer valued, and we don't need to worry
7552 about setting errno, there's no need to perform rounding. */
7553 if (! flag_errno_math
&& integer_valued_real_p (arg
))
7554 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
7555 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
7559 tree ftype
= TREE_TYPE (arg
);
7560 tree arg0
= strip_float_extensions (arg
);
7561 tree newtype
= TREE_TYPE (arg0
);
7564 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
7565 && (decl
= mathfn_built_in (newtype
, fcode
)))
7566 return build_call_expr_loc (loc
, decl
, 1,
7567 fold_convert_loc (loc
, newtype
, arg0
));
7570 /* Canonicalize iround (x) to lround (x) on ILP32 targets where
7571 sizeof (int) == sizeof (long). */
7572 if (TYPE_PRECISION (integer_type_node
)
7573 == TYPE_PRECISION (long_integer_type_node
))
7575 tree newfn
= NULL_TREE
;
7578 CASE_FLT_FN (BUILT_IN_ICEIL
):
7579 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
7582 CASE_FLT_FN (BUILT_IN_IFLOOR
):
7583 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
7586 CASE_FLT_FN (BUILT_IN_IROUND
):
7587 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7590 CASE_FLT_FN (BUILT_IN_IRINT
):
7591 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7600 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7601 return fold_convert_loc (loc
,
7602 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7606 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7607 sizeof (long long) == sizeof (long). */
7608 if (TYPE_PRECISION (long_long_integer_type_node
)
7609 == TYPE_PRECISION (long_integer_type_node
))
7611 tree newfn
= NULL_TREE
;
7614 CASE_FLT_FN (BUILT_IN_LLCEIL
):
7615 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
7618 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7619 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
7622 CASE_FLT_FN (BUILT_IN_LLROUND
):
7623 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7626 CASE_FLT_FN (BUILT_IN_LLRINT
):
7627 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7636 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7637 return fold_convert_loc (loc
,
7638 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7645 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7646 return type. Return NULL_TREE if no simplification can be made. */
7649 fold_builtin_cabs (location_t loc
, tree arg
, tree type
, tree fndecl
)
7653 if (!validate_arg (arg
, COMPLEX_TYPE
)
7654 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7657 /* Calculate the result when the argument is a constant. */
7658 if (TREE_CODE (arg
) == COMPLEX_CST
7659 && (res
= do_mpfr_arg2 (TREE_REALPART (arg
), TREE_IMAGPART (arg
),
7663 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7665 tree real
= TREE_OPERAND (arg
, 0);
7666 tree imag
= TREE_OPERAND (arg
, 1);
7668 /* If either part is zero, cabs is fabs of the other. */
7669 if (real_zerop (real
))
7670 return fold_build1_loc (loc
, ABS_EXPR
, type
, imag
);
7671 if (real_zerop (imag
))
7672 return fold_build1_loc (loc
, ABS_EXPR
, type
, real
);
7674 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7675 if (flag_unsafe_math_optimizations
7676 && operand_equal_p (real
, imag
, OEP_PURE_SAME
))
7678 const REAL_VALUE_TYPE sqrt2_trunc
7679 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
7681 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7682 fold_build1_loc (loc
, ABS_EXPR
, type
, real
),
7683 build_real (type
, sqrt2_trunc
));
7687 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7688 if (TREE_CODE (arg
) == NEGATE_EXPR
7689 || TREE_CODE (arg
) == CONJ_EXPR
)
7690 return build_call_expr_loc (loc
, fndecl
, 1, TREE_OPERAND (arg
, 0));
7692 /* Don't do this when optimizing for size. */
7693 if (flag_unsafe_math_optimizations
7694 && optimize
&& optimize_function_for_speed_p (cfun
))
7696 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7698 if (sqrtfn
!= NULL_TREE
)
7700 tree rpart
, ipart
, result
;
7702 arg
= builtin_save_expr (arg
);
7704 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, type
, arg
);
7705 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg
);
7707 rpart
= builtin_save_expr (rpart
);
7708 ipart
= builtin_save_expr (ipart
);
7710 result
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
7711 fold_build2_loc (loc
, MULT_EXPR
, type
,
7713 fold_build2_loc (loc
, MULT_EXPR
, type
,
7716 return build_call_expr_loc (loc
, sqrtfn
, 1, result
);
7723 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7724 complex tree type of the result. If NEG is true, the imaginary
7725 zero is negative. */
7728 build_complex_cproj (tree type
, bool neg
)
7730 REAL_VALUE_TYPE rinf
, rzero
= dconst0
;
7734 return build_complex (type
, build_real (TREE_TYPE (type
), rinf
),
7735 build_real (TREE_TYPE (type
), rzero
));
7738 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7739 return type. Return NULL_TREE if no simplification can be made. */
7742 fold_builtin_cproj (location_t loc
, tree arg
, tree type
)
7744 if (!validate_arg (arg
, COMPLEX_TYPE
)
7745 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7748 /* If there are no infinities, return arg. */
7749 if (! HONOR_INFINITIES (type
))
7750 return non_lvalue_loc (loc
, arg
);
7752 /* Calculate the result when the argument is a constant. */
7753 if (TREE_CODE (arg
) == COMPLEX_CST
)
7755 const REAL_VALUE_TYPE
*real
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
7756 const REAL_VALUE_TYPE
*imag
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
7758 if (real_isinf (real
) || real_isinf (imag
))
7759 return build_complex_cproj (type
, imag
->sign
);
7763 else if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7765 tree real
= TREE_OPERAND (arg
, 0);
7766 tree imag
= TREE_OPERAND (arg
, 1);
7771 /* If the real part is inf and the imag part is known to be
7772 nonnegative, return (inf + 0i). Remember side-effects are
7773 possible in the imag part. */
7774 if (TREE_CODE (real
) == REAL_CST
7775 && real_isinf (TREE_REAL_CST_PTR (real
))
7776 && tree_expr_nonnegative_p (imag
))
7777 return omit_one_operand_loc (loc
, type
,
7778 build_complex_cproj (type
, false),
7781 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7782 Remember side-effects are possible in the real part. */
7783 if (TREE_CODE (imag
) == REAL_CST
7784 && real_isinf (TREE_REAL_CST_PTR (imag
)))
7786 omit_one_operand_loc (loc
, type
,
7787 build_complex_cproj (type
, TREE_REAL_CST_PTR
7788 (imag
)->sign
), arg
);
7794 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7795 Return NULL_TREE if no simplification can be made. */
7798 fold_builtin_sqrt (location_t loc
, tree arg
, tree type
)
7801 enum built_in_function fcode
;
7804 if (!validate_arg (arg
, REAL_TYPE
))
7807 /* Calculate the result when the argument is a constant. */
7808 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_sqrt
, &dconst0
, NULL
, true)))
7811 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7812 fcode
= builtin_mathfn_code (arg
);
7813 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
7815 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7816 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7817 CALL_EXPR_ARG (arg
, 0),
7818 build_real (type
, dconsthalf
));
7819 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7822 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7823 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
7825 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7829 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7831 /* The inner root was either sqrt or cbrt. */
7832 /* This was a conditional expression but it triggered a bug
7834 REAL_VALUE_TYPE dconstroot
;
7835 if (BUILTIN_SQRT_P (fcode
))
7836 dconstroot
= dconsthalf
;
7838 dconstroot
= dconst_third ();
7840 /* Adjust for the outer root. */
7841 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7842 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7843 tree_root
= build_real (type
, dconstroot
);
7844 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7848 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7849 if (flag_unsafe_math_optimizations
7850 && (fcode
== BUILT_IN_POW
7851 || fcode
== BUILT_IN_POWF
7852 || fcode
== BUILT_IN_POWL
))
7854 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7855 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7856 tree arg1
= CALL_EXPR_ARG (arg
, 1);
7858 if (!tree_expr_nonnegative_p (arg0
))
7859 arg0
= build1 (ABS_EXPR
, type
, arg0
);
7860 narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
7861 build_real (type
, dconsthalf
));
7862 return build_call_expr_loc (loc
, powfn
, 2, arg0
, narg1
);
7868 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7869 Return NULL_TREE if no simplification can be made. */
7872 fold_builtin_cbrt (location_t loc
, tree arg
, tree type
)
7874 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7877 if (!validate_arg (arg
, REAL_TYPE
))
7880 /* Calculate the result when the argument is a constant. */
7881 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cbrt
, NULL
, NULL
, 0)))
7884 if (flag_unsafe_math_optimizations
)
7886 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7887 if (BUILTIN_EXPONENT_P (fcode
))
7889 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7890 const REAL_VALUE_TYPE third_trunc
=
7891 real_value_truncate (TYPE_MODE (type
), dconst_third ());
7892 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7893 CALL_EXPR_ARG (arg
, 0),
7894 build_real (type
, third_trunc
));
7895 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7898 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7899 if (BUILTIN_SQRT_P (fcode
))
7901 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7905 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7907 REAL_VALUE_TYPE dconstroot
= dconst_third ();
7909 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7910 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7911 tree_root
= build_real (type
, dconstroot
);
7912 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7916 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7917 if (BUILTIN_CBRT_P (fcode
))
7919 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7920 if (tree_expr_nonnegative_p (arg0
))
7922 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7927 REAL_VALUE_TYPE dconstroot
;
7929 real_arithmetic (&dconstroot
, MULT_EXPR
,
7930 dconst_third_ptr (), dconst_third_ptr ());
7931 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7932 tree_root
= build_real (type
, dconstroot
);
7933 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7938 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7939 if (fcode
== BUILT_IN_POW
7940 || fcode
== BUILT_IN_POWF
7941 || fcode
== BUILT_IN_POWL
)
7943 tree arg00
= CALL_EXPR_ARG (arg
, 0);
7944 tree arg01
= CALL_EXPR_ARG (arg
, 1);
7945 if (tree_expr_nonnegative_p (arg00
))
7947 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7948 const REAL_VALUE_TYPE dconstroot
7949 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
7950 tree narg01
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
,
7951 build_real (type
, dconstroot
));
7952 return build_call_expr_loc (loc
, powfn
, 2, arg00
, narg01
);
7959 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7960 TYPE is the type of the return value. Return NULL_TREE if no
7961 simplification can be made. */
7964 fold_builtin_cos (location_t loc
,
7965 tree arg
, tree type
, tree fndecl
)
7969 if (!validate_arg (arg
, REAL_TYPE
))
7972 /* Calculate the result when the argument is a constant. */
7973 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cos
, NULL
, NULL
, 0)))
7976 /* Optimize cos(-x) into cos (x). */
7977 if ((narg
= fold_strip_sign_ops (arg
)))
7978 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7983 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7984 Return NULL_TREE if no simplification can be made. */
7987 fold_builtin_cosh (location_t loc
, tree arg
, tree type
, tree fndecl
)
7989 if (validate_arg (arg
, REAL_TYPE
))
7993 /* Calculate the result when the argument is a constant. */
7994 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cosh
, NULL
, NULL
, 0)))
7997 /* Optimize cosh(-x) into cosh (x). */
7998 if ((narg
= fold_strip_sign_ops (arg
)))
7999 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
8005 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
8006 argument ARG. TYPE is the type of the return value. Return
8007 NULL_TREE if no simplification can be made. */
8010 fold_builtin_ccos (location_t loc
, tree arg
, tree type
, tree fndecl
,
8013 if (validate_arg (arg
, COMPLEX_TYPE
)
8014 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
8018 /* Calculate the result when the argument is a constant. */
8019 if ((tmp
= do_mpc_arg1 (arg
, type
, (hyper
? mpc_cosh
: mpc_cos
))))
8022 /* Optimize fn(-x) into fn(x). */
8023 if ((tmp
= fold_strip_sign_ops (arg
)))
8024 return build_call_expr_loc (loc
, fndecl
, 1, tmp
);
8030 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
8031 Return NULL_TREE if no simplification can be made. */
8034 fold_builtin_tan (tree arg
, tree type
)
8036 enum built_in_function fcode
;
8039 if (!validate_arg (arg
, REAL_TYPE
))
8042 /* Calculate the result when the argument is a constant. */
8043 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_tan
, NULL
, NULL
, 0)))
8046 /* Optimize tan(atan(x)) = x. */
8047 fcode
= builtin_mathfn_code (arg
);
8048 if (flag_unsafe_math_optimizations
8049 && (fcode
== BUILT_IN_ATAN
8050 || fcode
== BUILT_IN_ATANF
8051 || fcode
== BUILT_IN_ATANL
))
8052 return CALL_EXPR_ARG (arg
, 0);
8057 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
8058 NULL_TREE if no simplification can be made. */
8061 fold_builtin_sincos (location_t loc
,
8062 tree arg0
, tree arg1
, tree arg2
)
8067 if (!validate_arg (arg0
, REAL_TYPE
)
8068 || !validate_arg (arg1
, POINTER_TYPE
)
8069 || !validate_arg (arg2
, POINTER_TYPE
))
8072 type
= TREE_TYPE (arg0
);
8074 /* Calculate the result when the argument is a constant. */
8075 if ((res
= do_mpfr_sincos (arg0
, arg1
, arg2
)))
8078 /* Canonicalize sincos to cexpi. */
8079 if (!targetm
.libc_has_function (function_c99_math_complex
))
8081 fn
= mathfn_built_in (type
, BUILT_IN_CEXPI
);
8085 call
= build_call_expr_loc (loc
, fn
, 1, arg0
);
8086 call
= builtin_save_expr (call
);
8088 return build2 (COMPOUND_EXPR
, void_type_node
,
8089 build2 (MODIFY_EXPR
, void_type_node
,
8090 build_fold_indirect_ref_loc (loc
, arg1
),
8091 build1 (IMAGPART_EXPR
, type
, call
)),
8092 build2 (MODIFY_EXPR
, void_type_node
,
8093 build_fold_indirect_ref_loc (loc
, arg2
),
8094 build1 (REALPART_EXPR
, type
, call
)));
8097 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
8098 NULL_TREE if no simplification can be made. */
8101 fold_builtin_cexp (location_t loc
, tree arg0
, tree type
)
8104 tree realp
, imagp
, ifn
;
8107 if (!validate_arg (arg0
, COMPLEX_TYPE
)
8108 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) != REAL_TYPE
)
8111 /* Calculate the result when the argument is a constant. */
8112 if ((res
= do_mpc_arg1 (arg0
, type
, mpc_exp
)))
8115 rtype
= TREE_TYPE (TREE_TYPE (arg0
));
8117 /* In case we can figure out the real part of arg0 and it is constant zero
8119 if (!targetm
.libc_has_function (function_c99_math_complex
))
8121 ifn
= mathfn_built_in (rtype
, BUILT_IN_CEXPI
);
8125 if ((realp
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
))
8126 && real_zerop (realp
))
8128 tree narg
= fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
8129 return build_call_expr_loc (loc
, ifn
, 1, narg
);
8132 /* In case we can easily decompose real and imaginary parts split cexp
8133 to exp (r) * cexpi (i). */
8134 if (flag_unsafe_math_optimizations
8137 tree rfn
, rcall
, icall
;
8139 rfn
= mathfn_built_in (rtype
, BUILT_IN_EXP
);
8143 imagp
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
8147 icall
= build_call_expr_loc (loc
, ifn
, 1, imagp
);
8148 icall
= builtin_save_expr (icall
);
8149 rcall
= build_call_expr_loc (loc
, rfn
, 1, realp
);
8150 rcall
= builtin_save_expr (rcall
);
8151 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
8152 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
8154 fold_build1_loc (loc
, REALPART_EXPR
,
8156 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
8158 fold_build1_loc (loc
, IMAGPART_EXPR
,
8165 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
8166 Return NULL_TREE if no simplification can be made. */
8169 fold_builtin_trunc (location_t loc
, tree fndecl
, tree arg
)
8171 if (!validate_arg (arg
, REAL_TYPE
))
8174 /* Optimize trunc of constant value. */
8175 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8177 REAL_VALUE_TYPE r
, x
;
8178 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8180 x
= TREE_REAL_CST (arg
);
8181 real_trunc (&r
, TYPE_MODE (type
), &x
);
8182 return build_real (type
, r
);
8185 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8188 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
8189 Return NULL_TREE if no simplification can be made. */
8192 fold_builtin_floor (location_t loc
, tree fndecl
, tree arg
)
8194 if (!validate_arg (arg
, REAL_TYPE
))
8197 /* Optimize floor of constant value. */
8198 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8202 x
= TREE_REAL_CST (arg
);
8203 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
8205 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8208 real_floor (&r
, TYPE_MODE (type
), &x
);
8209 return build_real (type
, r
);
8213 /* Fold floor (x) where x is nonnegative to trunc (x). */
8214 if (tree_expr_nonnegative_p (arg
))
8216 tree truncfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_TRUNC
);
8218 return build_call_expr_loc (loc
, truncfn
, 1, arg
);
8221 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8224 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
8225 Return NULL_TREE if no simplification can be made. */
8228 fold_builtin_ceil (location_t loc
, tree fndecl
, tree arg
)
8230 if (!validate_arg (arg
, REAL_TYPE
))
8233 /* Optimize ceil of constant value. */
8234 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8238 x
= TREE_REAL_CST (arg
);
8239 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
8241 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8244 real_ceil (&r
, TYPE_MODE (type
), &x
);
8245 return build_real (type
, r
);
8249 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8252 /* Fold function call to builtin round, roundf or roundl with argument ARG.
8253 Return NULL_TREE if no simplification can be made. */
8256 fold_builtin_round (location_t loc
, tree fndecl
, tree arg
)
8258 if (!validate_arg (arg
, REAL_TYPE
))
8261 /* Optimize round of constant value. */
8262 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8266 x
= TREE_REAL_CST (arg
);
8267 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
8269 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8272 real_round (&r
, TYPE_MODE (type
), &x
);
8273 return build_real (type
, r
);
8277 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
8280 /* Fold function call to builtin lround, lroundf or lroundl (or the
8281 corresponding long long versions) and other rounding functions. ARG
8282 is the argument to the call. Return NULL_TREE if no simplification
8286 fold_builtin_int_roundingfn (location_t loc
, tree fndecl
, tree arg
)
8288 if (!validate_arg (arg
, REAL_TYPE
))
8291 /* Optimize lround of constant value. */
8292 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8294 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
8296 if (real_isfinite (&x
))
8298 tree itype
= TREE_TYPE (TREE_TYPE (fndecl
));
8299 tree ftype
= TREE_TYPE (arg
);
8303 switch (DECL_FUNCTION_CODE (fndecl
))
8305 CASE_FLT_FN (BUILT_IN_IFLOOR
):
8306 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8307 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8308 real_floor (&r
, TYPE_MODE (ftype
), &x
);
8311 CASE_FLT_FN (BUILT_IN_ICEIL
):
8312 CASE_FLT_FN (BUILT_IN_LCEIL
):
8313 CASE_FLT_FN (BUILT_IN_LLCEIL
):
8314 real_ceil (&r
, TYPE_MODE (ftype
), &x
);
8317 CASE_FLT_FN (BUILT_IN_IROUND
):
8318 CASE_FLT_FN (BUILT_IN_LROUND
):
8319 CASE_FLT_FN (BUILT_IN_LLROUND
):
8320 real_round (&r
, TYPE_MODE (ftype
), &x
);
8327 wide_int val
= real_to_integer (&r
, &fail
, TYPE_PRECISION (itype
));
8329 return wide_int_to_tree (itype
, val
);
8333 switch (DECL_FUNCTION_CODE (fndecl
))
8335 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8336 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8337 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
8338 if (tree_expr_nonnegative_p (arg
))
8339 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
8340 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
8345 return fold_fixed_mathfn (loc
, fndecl
, arg
);
8348 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8349 and their long and long long variants (i.e. ffsl and ffsll). ARG is
8350 the argument to the call. Return NULL_TREE if no simplification can
8354 fold_builtin_bitop (tree fndecl
, tree arg
)
8356 if (!validate_arg (arg
, INTEGER_TYPE
))
8359 /* Optimize for constant argument. */
8360 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
8362 tree type
= TREE_TYPE (arg
);
8365 switch (DECL_FUNCTION_CODE (fndecl
))
8367 CASE_INT_FN (BUILT_IN_FFS
):
8368 result
= wi::ffs (arg
);
8371 CASE_INT_FN (BUILT_IN_CLZ
):
8372 if (wi::ne_p (arg
, 0))
8373 result
= wi::clz (arg
);
8374 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
8375 result
= TYPE_PRECISION (type
);
8378 CASE_INT_FN (BUILT_IN_CTZ
):
8379 if (wi::ne_p (arg
, 0))
8380 result
= wi::ctz (arg
);
8381 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
8382 result
= TYPE_PRECISION (type
);
8385 CASE_INT_FN (BUILT_IN_CLRSB
):
8386 result
= wi::clrsb (arg
);
8389 CASE_INT_FN (BUILT_IN_POPCOUNT
):
8390 result
= wi::popcount (arg
);
8393 CASE_INT_FN (BUILT_IN_PARITY
):
8394 result
= wi::parity (arg
);
8401 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), result
);
8407 /* Fold function call to builtin_bswap and the short, long and long long
8408 variants. Return NULL_TREE if no simplification can be made. */
8410 fold_builtin_bswap (tree fndecl
, tree arg
)
8412 if (! validate_arg (arg
, INTEGER_TYPE
))
8415 /* Optimize constant value. */
8416 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
8418 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8420 switch (DECL_FUNCTION_CODE (fndecl
))
8422 case BUILT_IN_BSWAP16
:
8423 case BUILT_IN_BSWAP32
:
8424 case BUILT_IN_BSWAP64
:
8426 signop sgn
= TYPE_SIGN (type
);
8428 wide_int_to_tree (type
,
8429 wide_int::from (arg
, TYPE_PRECISION (type
),
8441 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8442 NULL_TREE if no simplification can be made. */
8445 fold_builtin_hypot (location_t loc
, tree fndecl
,
8446 tree arg0
, tree arg1
, tree type
)
8448 tree res
, narg0
, narg1
;
8450 if (!validate_arg (arg0
, REAL_TYPE
)
8451 || !validate_arg (arg1
, REAL_TYPE
))
8454 /* Calculate the result when the argument is a constant. */
8455 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_hypot
)))
8458 /* If either argument to hypot has a negate or abs, strip that off.
8459 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8460 narg0
= fold_strip_sign_ops (arg0
);
8461 narg1
= fold_strip_sign_ops (arg1
);
8464 return build_call_expr_loc (loc
, fndecl
, 2, narg0
? narg0
: arg0
,
8465 narg1
? narg1
: arg1
);
8468 /* If either argument is zero, hypot is fabs of the other. */
8469 if (real_zerop (arg0
))
8470 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
);
8471 else if (real_zerop (arg1
))
8472 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
);
8474 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8475 if (flag_unsafe_math_optimizations
8476 && operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
8478 const REAL_VALUE_TYPE sqrt2_trunc
8479 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
8480 return fold_build2_loc (loc
, MULT_EXPR
, type
,
8481 fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
),
8482 build_real (type
, sqrt2_trunc
));
8489 /* Fold a builtin function call to pow, powf, or powl. Return
8490 NULL_TREE if no simplification can be made. */
8492 fold_builtin_pow (location_t loc
, tree fndecl
, tree arg0
, tree arg1
, tree type
)
8496 if (!validate_arg (arg0
, REAL_TYPE
)
8497 || !validate_arg (arg1
, REAL_TYPE
))
8500 /* Calculate the result when the argument is a constant. */
8501 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_pow
)))
8504 /* Optimize pow(1.0,y) = 1.0. */
8505 if (real_onep (arg0
))
8506 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8508 if (TREE_CODE (arg1
) == REAL_CST
8509 && !TREE_OVERFLOW (arg1
))
8511 REAL_VALUE_TYPE cint
;
8515 c
= TREE_REAL_CST (arg1
);
8517 /* Optimize pow(x,0.0) = 1.0. */
8518 if (REAL_VALUES_EQUAL (c
, dconst0
))
8519 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8522 /* Optimize pow(x,1.0) = x. */
8523 if (REAL_VALUES_EQUAL (c
, dconst1
))
8526 /* Optimize pow(x,-1.0) = 1.0/x. */
8527 if (REAL_VALUES_EQUAL (c
, dconstm1
))
8528 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8529 build_real (type
, dconst1
), arg0
);
8531 /* Optimize pow(x,0.5) = sqrt(x). */
8532 if (flag_unsafe_math_optimizations
8533 && REAL_VALUES_EQUAL (c
, dconsthalf
))
8535 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
8537 if (sqrtfn
!= NULL_TREE
)
8538 return build_call_expr_loc (loc
, sqrtfn
, 1, arg0
);
8541 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8542 if (flag_unsafe_math_optimizations
)
8544 const REAL_VALUE_TYPE dconstroot
8545 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8547 if (REAL_VALUES_EQUAL (c
, dconstroot
))
8549 tree cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
8550 if (cbrtfn
!= NULL_TREE
)
8551 return build_call_expr_loc (loc
, cbrtfn
, 1, arg0
);
8555 /* Check for an integer exponent. */
8556 n
= real_to_integer (&c
);
8557 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
8558 if (real_identical (&c
, &cint
))
8560 /* Attempt to evaluate pow at compile-time, unless this should
8561 raise an exception. */
8562 if (TREE_CODE (arg0
) == REAL_CST
8563 && !TREE_OVERFLOW (arg0
)
8565 || (!flag_trapping_math
&& !flag_errno_math
)
8566 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
), dconst0
)))
8571 x
= TREE_REAL_CST (arg0
);
8572 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
8573 if (flag_unsafe_math_optimizations
|| !inexact
)
8574 return build_real (type
, x
);
8577 /* Strip sign ops from even integer powers. */
8578 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
8580 tree narg0
= fold_strip_sign_ops (arg0
);
8582 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, arg1
);
8587 if (flag_unsafe_math_optimizations
)
8589 const enum built_in_function fcode
= builtin_mathfn_code (arg0
);
8591 /* Optimize pow(expN(x),y) = expN(x*y). */
8592 if (BUILTIN_EXPONENT_P (fcode
))
8594 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
8595 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8596 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg
, arg1
);
8597 return build_call_expr_loc (loc
, expfn
, 1, arg
);
8600 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8601 if (BUILTIN_SQRT_P (fcode
))
8603 tree narg0
= CALL_EXPR_ARG (arg0
, 0);
8604 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8605 build_real (type
, dconsthalf
));
8606 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, narg1
);
8609 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8610 if (BUILTIN_CBRT_P (fcode
))
8612 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8613 if (tree_expr_nonnegative_p (arg
))
8615 const REAL_VALUE_TYPE dconstroot
8616 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8617 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8618 build_real (type
, dconstroot
));
8619 return build_call_expr_loc (loc
, fndecl
, 2, arg
, narg1
);
8623 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8624 if (fcode
== BUILT_IN_POW
8625 || fcode
== BUILT_IN_POWF
8626 || fcode
== BUILT_IN_POWL
)
8628 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
8629 if (tree_expr_nonnegative_p (arg00
))
8631 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
8632 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
, arg1
);
8633 return build_call_expr_loc (loc
, fndecl
, 2, arg00
, narg1
);
8641 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8642 Return NULL_TREE if no simplification can be made. */
8644 fold_builtin_powi (location_t loc
, tree fndecl ATTRIBUTE_UNUSED
,
8645 tree arg0
, tree arg1
, tree type
)
8647 if (!validate_arg (arg0
, REAL_TYPE
)
8648 || !validate_arg (arg1
, INTEGER_TYPE
))
8651 /* Optimize pow(1.0,y) = 1.0. */
8652 if (real_onep (arg0
))
8653 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8655 if (tree_fits_shwi_p (arg1
))
8657 HOST_WIDE_INT c
= tree_to_shwi (arg1
);
8659 /* Evaluate powi at compile-time. */
8660 if (TREE_CODE (arg0
) == REAL_CST
8661 && !TREE_OVERFLOW (arg0
))
8664 x
= TREE_REAL_CST (arg0
);
8665 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
8666 return build_real (type
, x
);
8669 /* Optimize pow(x,0) = 1.0. */
8671 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8674 /* Optimize pow(x,1) = x. */
8678 /* Optimize pow(x,-1) = 1.0/x. */
8680 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8681 build_real (type
, dconst1
), arg0
);
8687 /* A subroutine of fold_builtin to fold the various exponent
8688 functions. Return NULL_TREE if no simplification can be made.
8689 FUNC is the corresponding MPFR exponent function. */
8692 fold_builtin_exponent (location_t loc
, tree fndecl
, tree arg
,
8693 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
))
8695 if (validate_arg (arg
, REAL_TYPE
))
8697 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8700 /* Calculate the result when the argument is a constant. */
8701 if ((res
= do_mpfr_arg1 (arg
, type
, func
, NULL
, NULL
, 0)))
8704 /* Optimize expN(logN(x)) = x. */
8705 if (flag_unsafe_math_optimizations
)
8707 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
8709 if ((func
== mpfr_exp
8710 && (fcode
== BUILT_IN_LOG
8711 || fcode
== BUILT_IN_LOGF
8712 || fcode
== BUILT_IN_LOGL
))
8713 || (func
== mpfr_exp2
8714 && (fcode
== BUILT_IN_LOG2
8715 || fcode
== BUILT_IN_LOG2F
8716 || fcode
== BUILT_IN_LOG2L
))
8717 || (func
== mpfr_exp10
8718 && (fcode
== BUILT_IN_LOG10
8719 || fcode
== BUILT_IN_LOG10F
8720 || fcode
== BUILT_IN_LOG10L
)))
8721 return fold_convert_loc (loc
, type
, CALL_EXPR_ARG (arg
, 0));
8728 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
8729 arguments to the call, and TYPE is its return type.
8730 Return NULL_TREE if no simplification can be made. */
8733 fold_builtin_memchr (location_t loc
, tree arg1
, tree arg2
, tree len
, tree type
)
8735 if (!validate_arg (arg1
, POINTER_TYPE
)
8736 || !validate_arg (arg2
, INTEGER_TYPE
)
8737 || !validate_arg (len
, INTEGER_TYPE
))
8743 if (TREE_CODE (arg2
) != INTEGER_CST
8744 || !tree_fits_uhwi_p (len
))
8747 p1
= c_getstr (arg1
);
8748 if (p1
&& compare_tree_int (len
, strlen (p1
) + 1) <= 0)
8754 if (target_char_cast (arg2
, &c
))
8757 r
= (const char *) memchr (p1
, c
, tree_to_uhwi (len
));
8760 return build_int_cst (TREE_TYPE (arg1
), 0);
8762 tem
= fold_build_pointer_plus_hwi_loc (loc
, arg1
, r
- p1
);
8763 return fold_convert_loc (loc
, type
, tem
);
8769 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8770 Return NULL_TREE if no simplification can be made. */
8773 fold_builtin_memcmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
8775 const char *p1
, *p2
;
8777 if (!validate_arg (arg1
, POINTER_TYPE
)
8778 || !validate_arg (arg2
, POINTER_TYPE
)
8779 || !validate_arg (len
, INTEGER_TYPE
))
8782 /* If the LEN parameter is zero, return zero. */
8783 if (integer_zerop (len
))
8784 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
8787 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8788 if (operand_equal_p (arg1
, arg2
, 0))
8789 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
8791 p1
= c_getstr (arg1
);
8792 p2
= c_getstr (arg2
);
8794 /* If all arguments are constant, and the value of len is not greater
8795 than the lengths of arg1 and arg2, evaluate at compile-time. */
8796 if (tree_fits_uhwi_p (len
) && p1
&& p2
8797 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
8798 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
8800 const int r
= memcmp (p1
, p2
, tree_to_uhwi (len
));
8803 return integer_one_node
;
8805 return integer_minus_one_node
;
8807 return integer_zero_node
;
8810 /* If len parameter is one, return an expression corresponding to
8811 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8812 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
8814 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8815 tree cst_uchar_ptr_node
8816 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8819 = fold_convert_loc (loc
, integer_type_node
,
8820 build1 (INDIRECT_REF
, cst_uchar_node
,
8821 fold_convert_loc (loc
,
8825 = fold_convert_loc (loc
, integer_type_node
,
8826 build1 (INDIRECT_REF
, cst_uchar_node
,
8827 fold_convert_loc (loc
,
8830 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8836 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8837 Return NULL_TREE if no simplification can be made. */
8840 fold_builtin_strcmp (location_t loc
, tree arg1
, tree arg2
)
8842 const char *p1
, *p2
;
8844 if (!validate_arg (arg1
, POINTER_TYPE
)
8845 || !validate_arg (arg2
, POINTER_TYPE
))
8848 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8849 if (operand_equal_p (arg1
, arg2
, 0))
8850 return integer_zero_node
;
8852 p1
= c_getstr (arg1
);
8853 p2
= c_getstr (arg2
);
8857 const int i
= strcmp (p1
, p2
);
8859 return integer_minus_one_node
;
8861 return integer_one_node
;
8863 return integer_zero_node
;
8866 /* If the second arg is "", return *(const unsigned char*)arg1. */
8867 if (p2
&& *p2
== '\0')
8869 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8870 tree cst_uchar_ptr_node
8871 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8873 return fold_convert_loc (loc
, integer_type_node
,
8874 build1 (INDIRECT_REF
, cst_uchar_node
,
8875 fold_convert_loc (loc
,
8880 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8881 if (p1
&& *p1
== '\0')
8883 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8884 tree cst_uchar_ptr_node
8885 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8888 = fold_convert_loc (loc
, integer_type_node
,
8889 build1 (INDIRECT_REF
, cst_uchar_node
,
8890 fold_convert_loc (loc
,
8893 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
8899 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8900 Return NULL_TREE if no simplification can be made. */
8903 fold_builtin_strncmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
8905 const char *p1
, *p2
;
8907 if (!validate_arg (arg1
, POINTER_TYPE
)
8908 || !validate_arg (arg2
, POINTER_TYPE
)
8909 || !validate_arg (len
, INTEGER_TYPE
))
8912 /* If the LEN parameter is zero, return zero. */
8913 if (integer_zerop (len
))
8914 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
8917 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8918 if (operand_equal_p (arg1
, arg2
, 0))
8919 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
8921 p1
= c_getstr (arg1
);
8922 p2
= c_getstr (arg2
);
8924 if (tree_fits_uhwi_p (len
) && p1
&& p2
)
8926 const int i
= strncmp (p1
, p2
, tree_to_uhwi (len
));
8928 return integer_one_node
;
8930 return integer_minus_one_node
;
8932 return integer_zero_node
;
8935 /* If the second arg is "", and the length is greater than zero,
8936 return *(const unsigned char*)arg1. */
8937 if (p2
&& *p2
== '\0'
8938 && TREE_CODE (len
) == INTEGER_CST
8939 && tree_int_cst_sgn (len
) == 1)
8941 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8942 tree cst_uchar_ptr_node
8943 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8945 return fold_convert_loc (loc
, integer_type_node
,
8946 build1 (INDIRECT_REF
, cst_uchar_node
,
8947 fold_convert_loc (loc
,
8952 /* If the first arg is "", and the length is greater than zero,
8953 return -*(const unsigned char*)arg2. */
8954 if (p1
&& *p1
== '\0'
8955 && TREE_CODE (len
) == INTEGER_CST
8956 && tree_int_cst_sgn (len
) == 1)
8958 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8959 tree cst_uchar_ptr_node
8960 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8962 tree temp
= fold_convert_loc (loc
, integer_type_node
,
8963 build1 (INDIRECT_REF
, cst_uchar_node
,
8964 fold_convert_loc (loc
,
8967 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
8970 /* If len parameter is one, return an expression corresponding to
8971 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8972 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
8974 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8975 tree cst_uchar_ptr_node
8976 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8978 tree ind1
= fold_convert_loc (loc
, integer_type_node
,
8979 build1 (INDIRECT_REF
, cst_uchar_node
,
8980 fold_convert_loc (loc
,
8983 tree ind2
= fold_convert_loc (loc
, integer_type_node
,
8984 build1 (INDIRECT_REF
, cst_uchar_node
,
8985 fold_convert_loc (loc
,
8988 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8994 /* Fold function call to builtin signbit, signbitf or signbitl with argument
8995 ARG. Return NULL_TREE if no simplification can be made. */
8998 fold_builtin_signbit (location_t loc
, tree arg
, tree type
)
9000 if (!validate_arg (arg
, REAL_TYPE
))
9003 /* If ARG is a compile-time constant, determine the result. */
9004 if (TREE_CODE (arg
) == REAL_CST
9005 && !TREE_OVERFLOW (arg
))
9009 c
= TREE_REAL_CST (arg
);
9010 return (REAL_VALUE_NEGATIVE (c
)
9011 ? build_one_cst (type
)
9012 : build_zero_cst (type
));
9015 /* If ARG is non-negative, the result is always zero. */
9016 if (tree_expr_nonnegative_p (arg
))
9017 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9019 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9020 if (!HONOR_SIGNED_ZEROS (arg
))
9021 return fold_convert (type
,
9022 fold_build2_loc (loc
, LT_EXPR
, boolean_type_node
, arg
,
9023 build_real (TREE_TYPE (arg
), dconst0
)));
9028 /* Fold function call to builtin copysign, copysignf or copysignl with
9029 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9033 fold_builtin_copysign (location_t loc
, tree fndecl
,
9034 tree arg1
, tree arg2
, tree type
)
9038 if (!validate_arg (arg1
, REAL_TYPE
)
9039 || !validate_arg (arg2
, REAL_TYPE
))
9042 /* copysign(X,X) is X. */
9043 if (operand_equal_p (arg1
, arg2
, 0))
9044 return fold_convert_loc (loc
, type
, arg1
);
9046 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9047 if (TREE_CODE (arg1
) == REAL_CST
9048 && TREE_CODE (arg2
) == REAL_CST
9049 && !TREE_OVERFLOW (arg1
)
9050 && !TREE_OVERFLOW (arg2
))
9052 REAL_VALUE_TYPE c1
, c2
;
9054 c1
= TREE_REAL_CST (arg1
);
9055 c2
= TREE_REAL_CST (arg2
);
9056 /* c1.sign := c2.sign. */
9057 real_copysign (&c1
, &c2
);
9058 return build_real (type
, c1
);
9061 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9062 Remember to evaluate Y for side-effects. */
9063 if (tree_expr_nonnegative_p (arg2
))
9064 return omit_one_operand_loc (loc
, type
,
9065 fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
),
9068 /* Strip sign changing operations for the first argument. */
9069 tem
= fold_strip_sign_ops (arg1
);
9071 return build_call_expr_loc (loc
, fndecl
, 2, tem
, arg2
);
9076 /* Fold a call to builtin isascii with argument ARG. */
9079 fold_builtin_isascii (location_t loc
, tree arg
)
9081 if (!validate_arg (arg
, INTEGER_TYPE
))
9085 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9086 arg
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
9087 build_int_cst (integer_type_node
,
9088 ~ (unsigned HOST_WIDE_INT
) 0x7f));
9089 return fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
,
9090 arg
, integer_zero_node
);
9094 /* Fold a call to builtin toascii with argument ARG. */
9097 fold_builtin_toascii (location_t loc
, tree arg
)
9099 if (!validate_arg (arg
, INTEGER_TYPE
))
9102 /* Transform toascii(c) -> (c & 0x7f). */
9103 return fold_build2_loc (loc
, BIT_AND_EXPR
, integer_type_node
, arg
,
9104 build_int_cst (integer_type_node
, 0x7f));
9107 /* Fold a call to builtin isdigit with argument ARG. */
9110 fold_builtin_isdigit (location_t loc
, tree arg
)
9112 if (!validate_arg (arg
, INTEGER_TYPE
))
9116 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9117 /* According to the C standard, isdigit is unaffected by locale.
9118 However, it definitely is affected by the target character set. */
9119 unsigned HOST_WIDE_INT target_digit0
9120 = lang_hooks
.to_target_charset ('0');
9122 if (target_digit0
== 0)
9125 arg
= fold_convert_loc (loc
, unsigned_type_node
, arg
);
9126 arg
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
9127 build_int_cst (unsigned_type_node
, target_digit0
));
9128 return fold_build2_loc (loc
, LE_EXPR
, integer_type_node
, arg
,
9129 build_int_cst (unsigned_type_node
, 9));
9133 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9136 fold_builtin_fabs (location_t loc
, tree arg
, tree type
)
9138 if (!validate_arg (arg
, REAL_TYPE
))
9141 arg
= fold_convert_loc (loc
, type
, arg
);
9142 if (TREE_CODE (arg
) == REAL_CST
)
9143 return fold_abs_const (arg
, type
);
9144 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9147 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9150 fold_builtin_abs (location_t loc
, tree arg
, tree type
)
9152 if (!validate_arg (arg
, INTEGER_TYPE
))
9155 arg
= fold_convert_loc (loc
, type
, arg
);
9156 if (TREE_CODE (arg
) == INTEGER_CST
)
9157 return fold_abs_const (arg
, type
);
9158 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9161 /* Fold a fma operation with arguments ARG[012]. */
9164 fold_fma (location_t loc ATTRIBUTE_UNUSED
,
9165 tree type
, tree arg0
, tree arg1
, tree arg2
)
9167 if (TREE_CODE (arg0
) == REAL_CST
9168 && TREE_CODE (arg1
) == REAL_CST
9169 && TREE_CODE (arg2
) == REAL_CST
)
9170 return do_mpfr_arg3 (arg0
, arg1
, arg2
, type
, mpfr_fma
);
9175 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
9178 fold_builtin_fma (location_t loc
, tree arg0
, tree arg1
, tree arg2
, tree type
)
9180 if (validate_arg (arg0
, REAL_TYPE
)
9181 && validate_arg (arg1
, REAL_TYPE
)
9182 && validate_arg (arg2
, REAL_TYPE
))
9184 tree tem
= fold_fma (loc
, type
, arg0
, arg1
, arg2
);
9188 /* ??? Only expand to FMA_EXPR if it's directly supported. */
9189 if (optab_handler (fma_optab
, TYPE_MODE (type
)) != CODE_FOR_nothing
)
9190 return fold_build3_loc (loc
, FMA_EXPR
, type
, arg0
, arg1
, arg2
);
9195 /* Fold a call to builtin fmin or fmax. */
9198 fold_builtin_fmin_fmax (location_t loc
, tree arg0
, tree arg1
,
9199 tree type
, bool max
)
9201 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, REAL_TYPE
))
9203 /* Calculate the result when the argument is a constant. */
9204 tree res
= do_mpfr_arg2 (arg0
, arg1
, type
, (max
? mpfr_max
: mpfr_min
));
9209 /* If either argument is NaN, return the other one. Avoid the
9210 transformation if we get (and honor) a signalling NaN. Using
9211 omit_one_operand() ensures we create a non-lvalue. */
9212 if (TREE_CODE (arg0
) == REAL_CST
9213 && real_isnan (&TREE_REAL_CST (arg0
))
9214 && (! HONOR_SNANS (arg0
)
9215 || ! TREE_REAL_CST (arg0
).signalling
))
9216 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
9217 if (TREE_CODE (arg1
) == REAL_CST
9218 && real_isnan (&TREE_REAL_CST (arg1
))
9219 && (! HONOR_SNANS (arg1
)
9220 || ! TREE_REAL_CST (arg1
).signalling
))
9221 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9223 /* Transform fmin/fmax(x,x) -> x. */
9224 if (operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
9225 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9227 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9228 functions to return the numeric arg if the other one is NaN.
9229 These tree codes don't honor that, so only transform if
9230 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9231 handled, so we don't have to worry about it either. */
9232 if (flag_finite_math_only
)
9233 return fold_build2_loc (loc
, (max
? MAX_EXPR
: MIN_EXPR
), type
,
9234 fold_convert_loc (loc
, type
, arg0
),
9235 fold_convert_loc (loc
, type
, arg1
));
9240 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9243 fold_builtin_carg (location_t loc
, tree arg
, tree type
)
9245 if (validate_arg (arg
, COMPLEX_TYPE
)
9246 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
9248 tree atan2_fn
= mathfn_built_in (type
, BUILT_IN_ATAN2
);
9252 tree new_arg
= builtin_save_expr (arg
);
9253 tree r_arg
= fold_build1_loc (loc
, REALPART_EXPR
, type
, new_arg
);
9254 tree i_arg
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, new_arg
);
9255 return build_call_expr_loc (loc
, atan2_fn
, 2, i_arg
, r_arg
);
9262 /* Fold a call to builtin logb/ilogb. */
9265 fold_builtin_logb (location_t loc
, tree arg
, tree rettype
)
9267 if (! validate_arg (arg
, REAL_TYPE
))
9272 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9274 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9280 /* If arg is Inf or NaN and we're logb, return it. */
9281 if (TREE_CODE (rettype
) == REAL_TYPE
)
9283 /* For logb(-Inf) we have to return +Inf. */
9284 if (real_isinf (value
) && real_isneg (value
))
9286 REAL_VALUE_TYPE tem
;
9288 return build_real (rettype
, tem
);
9290 return fold_convert_loc (loc
, rettype
, arg
);
9292 /* Fall through... */
9294 /* Zero may set errno and/or raise an exception for logb, also
9295 for ilogb we don't know FP_ILOGB0. */
9298 /* For normal numbers, proceed iff radix == 2. In GCC,
9299 normalized significands are in the range [0.5, 1.0). We
9300 want the exponent as if they were [1.0, 2.0) so get the
9301 exponent and subtract 1. */
9302 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9303 return fold_convert_loc (loc
, rettype
,
9304 build_int_cst (integer_type_node
,
9305 REAL_EXP (value
)-1));
9313 /* Fold a call to builtin significand, if radix == 2. */
9316 fold_builtin_significand (location_t loc
, tree arg
, tree rettype
)
9318 if (! validate_arg (arg
, REAL_TYPE
))
9323 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9325 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9332 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9333 return fold_convert_loc (loc
, rettype
, arg
);
9335 /* For normal numbers, proceed iff radix == 2. */
9336 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9338 REAL_VALUE_TYPE result
= *value
;
9339 /* In GCC, normalized significands are in the range [0.5,
9340 1.0). We want them to be [1.0, 2.0) so set the
9342 SET_REAL_EXP (&result
, 1);
9343 return build_real (rettype
, result
);
9352 /* Fold a call to builtin frexp, we can assume the base is 2. */
9355 fold_builtin_frexp (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9357 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9362 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9365 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9367 /* Proceed if a valid pointer type was passed in. */
9368 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == integer_type_node
)
9370 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9376 /* For +-0, return (*exp = 0, +-0). */
9377 exp
= integer_zero_node
;
9382 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9383 return omit_one_operand_loc (loc
, rettype
, arg0
, arg1
);
9386 /* Since the frexp function always expects base 2, and in
9387 GCC normalized significands are already in the range
9388 [0.5, 1.0), we have exactly what frexp wants. */
9389 REAL_VALUE_TYPE frac_rvt
= *value
;
9390 SET_REAL_EXP (&frac_rvt
, 0);
9391 frac
= build_real (rettype
, frac_rvt
);
9392 exp
= build_int_cst (integer_type_node
, REAL_EXP (value
));
9399 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9400 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
, exp
);
9401 TREE_SIDE_EFFECTS (arg1
) = 1;
9402 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
, frac
);
9408 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9409 then we can assume the base is two. If it's false, then we have to
9410 check the mode of the TYPE parameter in certain cases. */
9413 fold_builtin_load_exponent (location_t loc
, tree arg0
, tree arg1
,
9414 tree type
, bool ldexp
)
9416 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, INTEGER_TYPE
))
9421 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9422 if (real_zerop (arg0
) || integer_zerop (arg1
)
9423 || (TREE_CODE (arg0
) == REAL_CST
9424 && !real_isfinite (&TREE_REAL_CST (arg0
))))
9425 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9427 /* If both arguments are constant, then try to evaluate it. */
9428 if ((ldexp
|| REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2)
9429 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
9430 && tree_fits_shwi_p (arg1
))
9432 /* Bound the maximum adjustment to twice the range of the
9433 mode's valid exponents. Use abs to ensure the range is
9434 positive as a sanity check. */
9435 const long max_exp_adj
= 2 *
9436 labs (REAL_MODE_FORMAT (TYPE_MODE (type
))->emax
9437 - REAL_MODE_FORMAT (TYPE_MODE (type
))->emin
);
9439 /* Get the user-requested adjustment. */
9440 const HOST_WIDE_INT req_exp_adj
= tree_to_shwi (arg1
);
9442 /* The requested adjustment must be inside this range. This
9443 is a preliminary cap to avoid things like overflow, we
9444 may still fail to compute the result for other reasons. */
9445 if (-max_exp_adj
< req_exp_adj
&& req_exp_adj
< max_exp_adj
)
9447 REAL_VALUE_TYPE initial_result
;
9449 real_ldexp (&initial_result
, &TREE_REAL_CST (arg0
), req_exp_adj
);
9451 /* Ensure we didn't overflow. */
9452 if (! real_isinf (&initial_result
))
9454 const REAL_VALUE_TYPE trunc_result
9455 = real_value_truncate (TYPE_MODE (type
), initial_result
);
9457 /* Only proceed if the target mode can hold the
9459 if (REAL_VALUES_EQUAL (initial_result
, trunc_result
))
9460 return build_real (type
, trunc_result
);
9469 /* Fold a call to builtin modf. */
9472 fold_builtin_modf (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9474 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9479 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9482 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9484 /* Proceed if a valid pointer type was passed in. */
9485 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == TYPE_MAIN_VARIANT (rettype
))
9487 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9488 REAL_VALUE_TYPE trunc
, frac
;
9494 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9495 trunc
= frac
= *value
;
9498 /* For +-Inf, return (*arg1 = arg0, +-0). */
9500 frac
.sign
= value
->sign
;
9504 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9505 real_trunc (&trunc
, VOIDmode
, value
);
9506 real_arithmetic (&frac
, MINUS_EXPR
, value
, &trunc
);
9507 /* If the original number was negative and already
9508 integral, then the fractional part is -0.0. */
9509 if (value
->sign
&& frac
.cl
== rvc_zero
)
9510 frac
.sign
= value
->sign
;
9514 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9515 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
,
9516 build_real (rettype
, trunc
));
9517 TREE_SIDE_EFFECTS (arg1
) = 1;
9518 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
,
9519 build_real (rettype
, frac
));
9525 /* Given a location LOC, an interclass builtin function decl FNDECL
9526 and its single argument ARG, return an folded expression computing
9527 the same, or NULL_TREE if we either couldn't or didn't want to fold
9528 (the latter happen if there's an RTL instruction available). */
9531 fold_builtin_interclass_mathfn (location_t loc
, tree fndecl
, tree arg
)
9535 if (!validate_arg (arg
, REAL_TYPE
))
9538 if (interclass_mathfn_icode (arg
, fndecl
) != CODE_FOR_nothing
)
9541 mode
= TYPE_MODE (TREE_TYPE (arg
));
9543 /* If there is no optab, try generic code. */
9544 switch (DECL_FUNCTION_CODE (fndecl
))
9548 CASE_FLT_FN (BUILT_IN_ISINF
):
9550 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9551 tree
const isgr_fn
= builtin_decl_explicit (BUILT_IN_ISGREATER
);
9552 tree
const type
= TREE_TYPE (arg
);
9556 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9557 real_from_string (&r
, buf
);
9558 result
= build_call_expr (isgr_fn
, 2,
9559 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9560 build_real (type
, r
));
9563 CASE_FLT_FN (BUILT_IN_FINITE
):
9564 case BUILT_IN_ISFINITE
:
9566 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9567 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
9568 tree
const type
= TREE_TYPE (arg
);
9572 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9573 real_from_string (&r
, buf
);
9574 result
= build_call_expr (isle_fn
, 2,
9575 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9576 build_real (type
, r
));
9577 /*result = fold_build2_loc (loc, UNGT_EXPR,
9578 TREE_TYPE (TREE_TYPE (fndecl)),
9579 fold_build1_loc (loc, ABS_EXPR, type, arg),
9580 build_real (type, r));
9581 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9582 TREE_TYPE (TREE_TYPE (fndecl)),
9586 case BUILT_IN_ISNORMAL
:
9588 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9589 islessequal(fabs(x),DBL_MAX). */
9590 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
9591 tree
const isge_fn
= builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL
);
9592 tree
const type
= TREE_TYPE (arg
);
9593 REAL_VALUE_TYPE rmax
, rmin
;
9596 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9597 real_from_string (&rmax
, buf
);
9598 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9599 real_from_string (&rmin
, buf
);
9600 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9601 result
= build_call_expr (isle_fn
, 2, arg
,
9602 build_real (type
, rmax
));
9603 result
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, result
,
9604 build_call_expr (isge_fn
, 2, arg
,
9605 build_real (type
, rmin
)));
9615 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9616 ARG is the argument for the call. */
9619 fold_builtin_classify (location_t loc
, tree fndecl
, tree arg
, int builtin_index
)
9621 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9624 if (!validate_arg (arg
, REAL_TYPE
))
9627 switch (builtin_index
)
9629 case BUILT_IN_ISINF
:
9630 if (!HONOR_INFINITIES (arg
))
9631 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9633 if (TREE_CODE (arg
) == REAL_CST
)
9635 r
= TREE_REAL_CST (arg
);
9636 if (real_isinf (&r
))
9637 return real_compare (GT_EXPR
, &r
, &dconst0
)
9638 ? integer_one_node
: integer_minus_one_node
;
9640 return integer_zero_node
;
9645 case BUILT_IN_ISINF_SIGN
:
9647 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9648 /* In a boolean context, GCC will fold the inner COND_EXPR to
9649 1. So e.g. "if (isinf_sign(x))" would be folded to just
9650 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9651 tree signbit_fn
= mathfn_built_in_1 (TREE_TYPE (arg
), BUILT_IN_SIGNBIT
, 0);
9652 tree isinf_fn
= builtin_decl_explicit (BUILT_IN_ISINF
);
9653 tree tmp
= NULL_TREE
;
9655 arg
= builtin_save_expr (arg
);
9657 if (signbit_fn
&& isinf_fn
)
9659 tree signbit_call
= build_call_expr_loc (loc
, signbit_fn
, 1, arg
);
9660 tree isinf_call
= build_call_expr_loc (loc
, isinf_fn
, 1, arg
);
9662 signbit_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9663 signbit_call
, integer_zero_node
);
9664 isinf_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9665 isinf_call
, integer_zero_node
);
9667 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, signbit_call
,
9668 integer_minus_one_node
, integer_one_node
);
9669 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9677 case BUILT_IN_ISFINITE
:
9678 if (!HONOR_NANS (arg
)
9679 && !HONOR_INFINITIES (arg
))
9680 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
9682 if (TREE_CODE (arg
) == REAL_CST
)
9684 r
= TREE_REAL_CST (arg
);
9685 return real_isfinite (&r
) ? integer_one_node
: integer_zero_node
;
9690 case BUILT_IN_ISNAN
:
9691 if (!HONOR_NANS (arg
))
9692 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9694 if (TREE_CODE (arg
) == REAL_CST
)
9696 r
= TREE_REAL_CST (arg
);
9697 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
9700 arg
= builtin_save_expr (arg
);
9701 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg
, arg
);
9708 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9709 This builtin will generate code to return the appropriate floating
9710 point classification depending on the value of the floating point
9711 number passed in. The possible return values must be supplied as
9712 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9713 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9714 one floating point argument which is "type generic". */
9717 fold_builtin_fpclassify (location_t loc
, tree
*args
, int nargs
)
9719 tree fp_nan
, fp_infinite
, fp_normal
, fp_subnormal
, fp_zero
,
9720 arg
, type
, res
, tmp
;
9725 /* Verify the required arguments in the original call. */
9727 || !validate_arg (args
[0], INTEGER_TYPE
)
9728 || !validate_arg (args
[1], INTEGER_TYPE
)
9729 || !validate_arg (args
[2], INTEGER_TYPE
)
9730 || !validate_arg (args
[3], INTEGER_TYPE
)
9731 || !validate_arg (args
[4], INTEGER_TYPE
)
9732 || !validate_arg (args
[5], REAL_TYPE
))
9736 fp_infinite
= args
[1];
9737 fp_normal
= args
[2];
9738 fp_subnormal
= args
[3];
9741 type
= TREE_TYPE (arg
);
9742 mode
= TYPE_MODE (type
);
9743 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9747 (fabs(x) == Inf ? FP_INFINITE :
9748 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9749 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9751 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9752 build_real (type
, dconst0
));
9753 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9754 tmp
, fp_zero
, fp_subnormal
);
9756 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9757 real_from_string (&r
, buf
);
9758 tmp
= fold_build2_loc (loc
, GE_EXPR
, integer_type_node
,
9759 arg
, build_real (type
, r
));
9760 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, fp_normal
, res
);
9762 if (HONOR_INFINITIES (mode
))
9765 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9766 build_real (type
, r
));
9767 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
,
9771 if (HONOR_NANS (mode
))
9773 tmp
= fold_build2_loc (loc
, ORDERED_EXPR
, integer_type_node
, arg
, arg
);
9774 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, res
, fp_nan
);
9780 /* Fold a call to an unordered comparison function such as
9781 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9782 being called and ARG0 and ARG1 are the arguments for the call.
9783 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9784 the opposite of the desired result. UNORDERED_CODE is used
9785 for modes that can hold NaNs and ORDERED_CODE is used for
9789 fold_builtin_unordered_cmp (location_t loc
, tree fndecl
, tree arg0
, tree arg1
,
9790 enum tree_code unordered_code
,
9791 enum tree_code ordered_code
)
9793 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9794 enum tree_code code
;
9796 enum tree_code code0
, code1
;
9797 tree cmp_type
= NULL_TREE
;
9799 type0
= TREE_TYPE (arg0
);
9800 type1
= TREE_TYPE (arg1
);
9802 code0
= TREE_CODE (type0
);
9803 code1
= TREE_CODE (type1
);
9805 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
9806 /* Choose the wider of two real types. */
9807 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
9809 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
9811 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
9814 arg0
= fold_convert_loc (loc
, cmp_type
, arg0
);
9815 arg1
= fold_convert_loc (loc
, cmp_type
, arg1
);
9817 if (unordered_code
== UNORDERED_EXPR
)
9819 if (!HONOR_NANS (arg0
))
9820 return omit_two_operands_loc (loc
, type
, integer_zero_node
, arg0
, arg1
);
9821 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg0
, arg1
);
9824 code
= HONOR_NANS (arg0
) ? unordered_code
: ordered_code
;
9825 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
,
9826 fold_build2_loc (loc
, code
, type
, arg0
, arg1
));
9829 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
9830 arithmetics if it can never overflow, or into internal functions that
9831 return both result of arithmetics and overflowed boolean flag in
9832 a complex integer result, or some other check for overflow. */
9835 fold_builtin_arith_overflow (location_t loc
, enum built_in_function fcode
,
9836 tree arg0
, tree arg1
, tree arg2
)
9838 enum internal_fn ifn
= IFN_LAST
;
9839 tree type
= TREE_TYPE (TREE_TYPE (arg2
));
9840 tree mem_arg2
= build_fold_indirect_ref_loc (loc
, arg2
);
9843 case BUILT_IN_ADD_OVERFLOW
:
9844 case BUILT_IN_SADD_OVERFLOW
:
9845 case BUILT_IN_SADDL_OVERFLOW
:
9846 case BUILT_IN_SADDLL_OVERFLOW
:
9847 case BUILT_IN_UADD_OVERFLOW
:
9848 case BUILT_IN_UADDL_OVERFLOW
:
9849 case BUILT_IN_UADDLL_OVERFLOW
:
9850 ifn
= IFN_ADD_OVERFLOW
;
9852 case BUILT_IN_SUB_OVERFLOW
:
9853 case BUILT_IN_SSUB_OVERFLOW
:
9854 case BUILT_IN_SSUBL_OVERFLOW
:
9855 case BUILT_IN_SSUBLL_OVERFLOW
:
9856 case BUILT_IN_USUB_OVERFLOW
:
9857 case BUILT_IN_USUBL_OVERFLOW
:
9858 case BUILT_IN_USUBLL_OVERFLOW
:
9859 ifn
= IFN_SUB_OVERFLOW
;
9861 case BUILT_IN_MUL_OVERFLOW
:
9862 case BUILT_IN_SMUL_OVERFLOW
:
9863 case BUILT_IN_SMULL_OVERFLOW
:
9864 case BUILT_IN_SMULLL_OVERFLOW
:
9865 case BUILT_IN_UMUL_OVERFLOW
:
9866 case BUILT_IN_UMULL_OVERFLOW
:
9867 case BUILT_IN_UMULLL_OVERFLOW
:
9868 ifn
= IFN_MUL_OVERFLOW
;
9873 tree ctype
= build_complex_type (type
);
9874 tree call
= build_call_expr_internal_loc (loc
, ifn
, ctype
,
9876 tree tgt
= save_expr (call
);
9877 tree intres
= build1_loc (loc
, REALPART_EXPR
, type
, tgt
);
9878 tree ovfres
= build1_loc (loc
, IMAGPART_EXPR
, type
, tgt
);
9879 ovfres
= fold_convert_loc (loc
, boolean_type_node
, ovfres
);
9881 = fold_build2_loc (loc
, MODIFY_EXPR
, void_type_node
, mem_arg2
, intres
);
9882 return build2_loc (loc
, COMPOUND_EXPR
, boolean_type_node
, store
, ovfres
);
9885 /* Fold a call to built-in function FNDECL with 0 arguments.
9886 This function returns NULL_TREE if no simplification was possible. */
9889 fold_builtin_0 (location_t loc
, tree fndecl
)
9891 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9892 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
9895 CASE_FLT_FN (BUILT_IN_INF
):
9896 case BUILT_IN_INFD32
:
9897 case BUILT_IN_INFD64
:
9898 case BUILT_IN_INFD128
:
9899 return fold_builtin_inf (loc
, type
, true);
9901 CASE_FLT_FN (BUILT_IN_HUGE_VAL
):
9902 return fold_builtin_inf (loc
, type
, false);
9904 case BUILT_IN_CLASSIFY_TYPE
:
9905 return fold_builtin_classify_type (NULL_TREE
);
9913 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9914 This function returns NULL_TREE if no simplification was possible. */
9917 fold_builtin_1 (location_t loc
, tree fndecl
, tree arg0
)
9919 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9920 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
9923 case BUILT_IN_CONSTANT_P
:
9925 tree val
= fold_builtin_constant_p (arg0
);
9927 /* Gimplification will pull the CALL_EXPR for the builtin out of
9928 an if condition. When not optimizing, we'll not CSE it back.
9929 To avoid link error types of regressions, return false now. */
9930 if (!val
&& !optimize
)
9931 val
= integer_zero_node
;
9936 case BUILT_IN_CLASSIFY_TYPE
:
9937 return fold_builtin_classify_type (arg0
);
9939 case BUILT_IN_STRLEN
:
9940 return fold_builtin_strlen (loc
, type
, arg0
);
9942 CASE_FLT_FN (BUILT_IN_FABS
):
9943 case BUILT_IN_FABSD32
:
9944 case BUILT_IN_FABSD64
:
9945 case BUILT_IN_FABSD128
:
9946 return fold_builtin_fabs (loc
, arg0
, type
);
9950 case BUILT_IN_LLABS
:
9951 case BUILT_IN_IMAXABS
:
9952 return fold_builtin_abs (loc
, arg0
, type
);
9954 CASE_FLT_FN (BUILT_IN_CONJ
):
9955 if (validate_arg (arg0
, COMPLEX_TYPE
)
9956 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9957 return fold_build1_loc (loc
, CONJ_EXPR
, type
, arg0
);
9960 CASE_FLT_FN (BUILT_IN_CREAL
):
9961 if (validate_arg (arg0
, COMPLEX_TYPE
)
9962 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9963 return non_lvalue_loc (loc
, fold_build1_loc (loc
, REALPART_EXPR
, type
, arg0
));
9966 CASE_FLT_FN (BUILT_IN_CIMAG
):
9967 if (validate_arg (arg0
, COMPLEX_TYPE
)
9968 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9969 return non_lvalue_loc (loc
, fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg0
));
9972 CASE_FLT_FN (BUILT_IN_CCOS
):
9973 return fold_builtin_ccos (loc
, arg0
, type
, fndecl
, /*hyper=*/ false);
9975 CASE_FLT_FN (BUILT_IN_CCOSH
):
9976 return fold_builtin_ccos (loc
, arg0
, type
, fndecl
, /*hyper=*/ true);
9978 CASE_FLT_FN (BUILT_IN_CPROJ
):
9979 return fold_builtin_cproj (loc
, arg0
, type
);
9981 CASE_FLT_FN (BUILT_IN_CSIN
):
9982 if (validate_arg (arg0
, COMPLEX_TYPE
)
9983 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9984 return do_mpc_arg1 (arg0
, type
, mpc_sin
);
9987 CASE_FLT_FN (BUILT_IN_CSINH
):
9988 if (validate_arg (arg0
, COMPLEX_TYPE
)
9989 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9990 return do_mpc_arg1 (arg0
, type
, mpc_sinh
);
9993 CASE_FLT_FN (BUILT_IN_CTAN
):
9994 if (validate_arg (arg0
, COMPLEX_TYPE
)
9995 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
9996 return do_mpc_arg1 (arg0
, type
, mpc_tan
);
9999 CASE_FLT_FN (BUILT_IN_CTANH
):
10000 if (validate_arg (arg0
, COMPLEX_TYPE
)
10001 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10002 return do_mpc_arg1 (arg0
, type
, mpc_tanh
);
10005 CASE_FLT_FN (BUILT_IN_CLOG
):
10006 if (validate_arg (arg0
, COMPLEX_TYPE
)
10007 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10008 return do_mpc_arg1 (arg0
, type
, mpc_log
);
10011 CASE_FLT_FN (BUILT_IN_CSQRT
):
10012 if (validate_arg (arg0
, COMPLEX_TYPE
)
10013 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10014 return do_mpc_arg1 (arg0
, type
, mpc_sqrt
);
10017 CASE_FLT_FN (BUILT_IN_CASIN
):
10018 if (validate_arg (arg0
, COMPLEX_TYPE
)
10019 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10020 return do_mpc_arg1 (arg0
, type
, mpc_asin
);
10023 CASE_FLT_FN (BUILT_IN_CACOS
):
10024 if (validate_arg (arg0
, COMPLEX_TYPE
)
10025 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10026 return do_mpc_arg1 (arg0
, type
, mpc_acos
);
10029 CASE_FLT_FN (BUILT_IN_CATAN
):
10030 if (validate_arg (arg0
, COMPLEX_TYPE
)
10031 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10032 return do_mpc_arg1 (arg0
, type
, mpc_atan
);
10035 CASE_FLT_FN (BUILT_IN_CASINH
):
10036 if (validate_arg (arg0
, COMPLEX_TYPE
)
10037 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10038 return do_mpc_arg1 (arg0
, type
, mpc_asinh
);
10041 CASE_FLT_FN (BUILT_IN_CACOSH
):
10042 if (validate_arg (arg0
, COMPLEX_TYPE
)
10043 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10044 return do_mpc_arg1 (arg0
, type
, mpc_acosh
);
10047 CASE_FLT_FN (BUILT_IN_CATANH
):
10048 if (validate_arg (arg0
, COMPLEX_TYPE
)
10049 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10050 return do_mpc_arg1 (arg0
, type
, mpc_atanh
);
10053 CASE_FLT_FN (BUILT_IN_CABS
):
10054 return fold_builtin_cabs (loc
, arg0
, type
, fndecl
);
10056 CASE_FLT_FN (BUILT_IN_CARG
):
10057 return fold_builtin_carg (loc
, arg0
, type
);
10059 CASE_FLT_FN (BUILT_IN_SQRT
):
10060 return fold_builtin_sqrt (loc
, arg0
, type
);
10062 CASE_FLT_FN (BUILT_IN_CBRT
):
10063 return fold_builtin_cbrt (loc
, arg0
, type
);
10065 CASE_FLT_FN (BUILT_IN_ASIN
):
10066 if (validate_arg (arg0
, REAL_TYPE
))
10067 return do_mpfr_arg1 (arg0
, type
, mpfr_asin
,
10068 &dconstm1
, &dconst1
, true);
10071 CASE_FLT_FN (BUILT_IN_ACOS
):
10072 if (validate_arg (arg0
, REAL_TYPE
))
10073 return do_mpfr_arg1 (arg0
, type
, mpfr_acos
,
10074 &dconstm1
, &dconst1
, true);
10077 CASE_FLT_FN (BUILT_IN_ATAN
):
10078 if (validate_arg (arg0
, REAL_TYPE
))
10079 return do_mpfr_arg1 (arg0
, type
, mpfr_atan
, NULL
, NULL
, 0);
10082 CASE_FLT_FN (BUILT_IN_ASINH
):
10083 if (validate_arg (arg0
, REAL_TYPE
))
10084 return do_mpfr_arg1 (arg0
, type
, mpfr_asinh
, NULL
, NULL
, 0);
10087 CASE_FLT_FN (BUILT_IN_ACOSH
):
10088 if (validate_arg (arg0
, REAL_TYPE
))
10089 return do_mpfr_arg1 (arg0
, type
, mpfr_acosh
,
10090 &dconst1
, NULL
, true);
10093 CASE_FLT_FN (BUILT_IN_ATANH
):
10094 if (validate_arg (arg0
, REAL_TYPE
))
10095 return do_mpfr_arg1 (arg0
, type
, mpfr_atanh
,
10096 &dconstm1
, &dconst1
, false);
10099 CASE_FLT_FN (BUILT_IN_SIN
):
10100 if (validate_arg (arg0
, REAL_TYPE
))
10101 return do_mpfr_arg1 (arg0
, type
, mpfr_sin
, NULL
, NULL
, 0);
10104 CASE_FLT_FN (BUILT_IN_COS
):
10105 return fold_builtin_cos (loc
, arg0
, type
, fndecl
);
10107 CASE_FLT_FN (BUILT_IN_TAN
):
10108 return fold_builtin_tan (arg0
, type
);
10110 CASE_FLT_FN (BUILT_IN_CEXP
):
10111 return fold_builtin_cexp (loc
, arg0
, type
);
10113 CASE_FLT_FN (BUILT_IN_CEXPI
):
10114 if (validate_arg (arg0
, REAL_TYPE
))
10115 return do_mpfr_sincos (arg0
, NULL_TREE
, NULL_TREE
);
10118 CASE_FLT_FN (BUILT_IN_SINH
):
10119 if (validate_arg (arg0
, REAL_TYPE
))
10120 return do_mpfr_arg1 (arg0
, type
, mpfr_sinh
, NULL
, NULL
, 0);
10123 CASE_FLT_FN (BUILT_IN_COSH
):
10124 return fold_builtin_cosh (loc
, arg0
, type
, fndecl
);
10126 CASE_FLT_FN (BUILT_IN_TANH
):
10127 if (validate_arg (arg0
, REAL_TYPE
))
10128 return do_mpfr_arg1 (arg0
, type
, mpfr_tanh
, NULL
, NULL
, 0);
10131 CASE_FLT_FN (BUILT_IN_ERF
):
10132 if (validate_arg (arg0
, REAL_TYPE
))
10133 return do_mpfr_arg1 (arg0
, type
, mpfr_erf
, NULL
, NULL
, 0);
10136 CASE_FLT_FN (BUILT_IN_ERFC
):
10137 if (validate_arg (arg0
, REAL_TYPE
))
10138 return do_mpfr_arg1 (arg0
, type
, mpfr_erfc
, NULL
, NULL
, 0);
10141 CASE_FLT_FN (BUILT_IN_TGAMMA
):
10142 if (validate_arg (arg0
, REAL_TYPE
))
10143 return do_mpfr_arg1 (arg0
, type
, mpfr_gamma
, NULL
, NULL
, 0);
10146 CASE_FLT_FN (BUILT_IN_EXP
):
10147 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp
);
10149 CASE_FLT_FN (BUILT_IN_EXP2
):
10150 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp2
);
10152 CASE_FLT_FN (BUILT_IN_EXP10
):
10153 CASE_FLT_FN (BUILT_IN_POW10
):
10154 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp10
);
10156 CASE_FLT_FN (BUILT_IN_EXPM1
):
10157 if (validate_arg (arg0
, REAL_TYPE
))
10158 return do_mpfr_arg1 (arg0
, type
, mpfr_expm1
, NULL
, NULL
, 0);
10161 CASE_FLT_FN (BUILT_IN_LOG
):
10162 if (validate_arg (arg0
, REAL_TYPE
))
10163 return do_mpfr_arg1 (arg0
, type
, mpfr_log
, &dconst0
, NULL
, false);
10166 CASE_FLT_FN (BUILT_IN_LOG2
):
10167 if (validate_arg (arg0
, REAL_TYPE
))
10168 return do_mpfr_arg1 (arg0
, type
, mpfr_log2
, &dconst0
, NULL
, false);
10171 CASE_FLT_FN (BUILT_IN_LOG10
):
10172 if (validate_arg (arg0
, REAL_TYPE
))
10173 return do_mpfr_arg1 (arg0
, type
, mpfr_log10
, &dconst0
, NULL
, false);
10176 CASE_FLT_FN (BUILT_IN_LOG1P
):
10177 if (validate_arg (arg0
, REAL_TYPE
))
10178 return do_mpfr_arg1 (arg0
, type
, mpfr_log1p
,
10179 &dconstm1
, NULL
, false);
10182 CASE_FLT_FN (BUILT_IN_J0
):
10183 if (validate_arg (arg0
, REAL_TYPE
))
10184 return do_mpfr_arg1 (arg0
, type
, mpfr_j0
,
10188 CASE_FLT_FN (BUILT_IN_J1
):
10189 if (validate_arg (arg0
, REAL_TYPE
))
10190 return do_mpfr_arg1 (arg0
, type
, mpfr_j1
,
10194 CASE_FLT_FN (BUILT_IN_Y0
):
10195 if (validate_arg (arg0
, REAL_TYPE
))
10196 return do_mpfr_arg1 (arg0
, type
, mpfr_y0
,
10197 &dconst0
, NULL
, false);
10200 CASE_FLT_FN (BUILT_IN_Y1
):
10201 if (validate_arg (arg0
, REAL_TYPE
))
10202 return do_mpfr_arg1 (arg0
, type
, mpfr_y1
,
10203 &dconst0
, NULL
, false);
10206 CASE_FLT_FN (BUILT_IN_NAN
):
10207 case BUILT_IN_NAND32
:
10208 case BUILT_IN_NAND64
:
10209 case BUILT_IN_NAND128
:
10210 return fold_builtin_nan (arg0
, type
, true);
10212 CASE_FLT_FN (BUILT_IN_NANS
):
10213 return fold_builtin_nan (arg0
, type
, false);
10215 CASE_FLT_FN (BUILT_IN_FLOOR
):
10216 return fold_builtin_floor (loc
, fndecl
, arg0
);
10218 CASE_FLT_FN (BUILT_IN_CEIL
):
10219 return fold_builtin_ceil (loc
, fndecl
, arg0
);
10221 CASE_FLT_FN (BUILT_IN_TRUNC
):
10222 return fold_builtin_trunc (loc
, fndecl
, arg0
);
10224 CASE_FLT_FN (BUILT_IN_ROUND
):
10225 return fold_builtin_round (loc
, fndecl
, arg0
);
10227 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
10228 CASE_FLT_FN (BUILT_IN_RINT
):
10229 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg0
);
10231 CASE_FLT_FN (BUILT_IN_ICEIL
):
10232 CASE_FLT_FN (BUILT_IN_LCEIL
):
10233 CASE_FLT_FN (BUILT_IN_LLCEIL
):
10234 CASE_FLT_FN (BUILT_IN_LFLOOR
):
10235 CASE_FLT_FN (BUILT_IN_IFLOOR
):
10236 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
10237 CASE_FLT_FN (BUILT_IN_IROUND
):
10238 CASE_FLT_FN (BUILT_IN_LROUND
):
10239 CASE_FLT_FN (BUILT_IN_LLROUND
):
10240 return fold_builtin_int_roundingfn (loc
, fndecl
, arg0
);
10242 CASE_FLT_FN (BUILT_IN_IRINT
):
10243 CASE_FLT_FN (BUILT_IN_LRINT
):
10244 CASE_FLT_FN (BUILT_IN_LLRINT
):
10245 return fold_fixed_mathfn (loc
, fndecl
, arg0
);
10247 case BUILT_IN_BSWAP16
:
10248 case BUILT_IN_BSWAP32
:
10249 case BUILT_IN_BSWAP64
:
10250 return fold_builtin_bswap (fndecl
, arg0
);
10252 CASE_INT_FN (BUILT_IN_FFS
):
10253 CASE_INT_FN (BUILT_IN_CLZ
):
10254 CASE_INT_FN (BUILT_IN_CTZ
):
10255 CASE_INT_FN (BUILT_IN_CLRSB
):
10256 CASE_INT_FN (BUILT_IN_POPCOUNT
):
10257 CASE_INT_FN (BUILT_IN_PARITY
):
10258 return fold_builtin_bitop (fndecl
, arg0
);
10260 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
10261 return fold_builtin_signbit (loc
, arg0
, type
);
10263 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
10264 return fold_builtin_significand (loc
, arg0
, type
);
10266 CASE_FLT_FN (BUILT_IN_ILOGB
):
10267 CASE_FLT_FN (BUILT_IN_LOGB
):
10268 return fold_builtin_logb (loc
, arg0
, type
);
10270 case BUILT_IN_ISASCII
:
10271 return fold_builtin_isascii (loc
, arg0
);
10273 case BUILT_IN_TOASCII
:
10274 return fold_builtin_toascii (loc
, arg0
);
10276 case BUILT_IN_ISDIGIT
:
10277 return fold_builtin_isdigit (loc
, arg0
);
10279 CASE_FLT_FN (BUILT_IN_FINITE
):
10280 case BUILT_IN_FINITED32
:
10281 case BUILT_IN_FINITED64
:
10282 case BUILT_IN_FINITED128
:
10283 case BUILT_IN_ISFINITE
:
10285 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISFINITE
);
10288 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10291 CASE_FLT_FN (BUILT_IN_ISINF
):
10292 case BUILT_IN_ISINFD32
:
10293 case BUILT_IN_ISINFD64
:
10294 case BUILT_IN_ISINFD128
:
10296 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF
);
10299 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10302 case BUILT_IN_ISNORMAL
:
10303 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10305 case BUILT_IN_ISINF_SIGN
:
10306 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF_SIGN
);
10308 CASE_FLT_FN (BUILT_IN_ISNAN
):
10309 case BUILT_IN_ISNAND32
:
10310 case BUILT_IN_ISNAND64
:
10311 case BUILT_IN_ISNAND128
:
10312 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISNAN
);
10314 case BUILT_IN_FREE
:
10315 if (integer_zerop (arg0
))
10316 return build_empty_stmt (loc
);
10327 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10328 This function returns NULL_TREE if no simplification was possible. */
10331 fold_builtin_2 (location_t loc
, tree fndecl
, tree arg0
, tree arg1
)
10333 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10334 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10338 CASE_FLT_FN (BUILT_IN_JN
):
10339 if (validate_arg (arg0
, INTEGER_TYPE
)
10340 && validate_arg (arg1
, REAL_TYPE
))
10341 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_jn
, NULL
, 0);
10344 CASE_FLT_FN (BUILT_IN_YN
):
10345 if (validate_arg (arg0
, INTEGER_TYPE
)
10346 && validate_arg (arg1
, REAL_TYPE
))
10347 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_yn
,
10351 CASE_FLT_FN (BUILT_IN_DREM
):
10352 CASE_FLT_FN (BUILT_IN_REMAINDER
):
10353 if (validate_arg (arg0
, REAL_TYPE
)
10354 && validate_arg (arg1
, REAL_TYPE
))
10355 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_remainder
);
10358 CASE_FLT_FN_REENT (BUILT_IN_GAMMA
): /* GAMMA_R */
10359 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA
): /* LGAMMA_R */
10360 if (validate_arg (arg0
, REAL_TYPE
)
10361 && validate_arg (arg1
, POINTER_TYPE
))
10362 return do_mpfr_lgamma_r (arg0
, arg1
, type
);
10365 CASE_FLT_FN (BUILT_IN_ATAN2
):
10366 if (validate_arg (arg0
, REAL_TYPE
)
10367 && validate_arg (arg1
, REAL_TYPE
))
10368 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_atan2
);
10371 CASE_FLT_FN (BUILT_IN_FDIM
):
10372 if (validate_arg (arg0
, REAL_TYPE
)
10373 && validate_arg (arg1
, REAL_TYPE
))
10374 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_dim
);
10377 CASE_FLT_FN (BUILT_IN_HYPOT
):
10378 return fold_builtin_hypot (loc
, fndecl
, arg0
, arg1
, type
);
10380 CASE_FLT_FN (BUILT_IN_CPOW
):
10381 if (validate_arg (arg0
, COMPLEX_TYPE
)
10382 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
10383 && validate_arg (arg1
, COMPLEX_TYPE
)
10384 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
)
10385 return do_mpc_arg2 (arg0
, arg1
, type
, /*do_nonfinite=*/ 0, mpc_pow
);
10388 CASE_FLT_FN (BUILT_IN_LDEXP
):
10389 return fold_builtin_load_exponent (loc
, arg0
, arg1
, type
, /*ldexp=*/true);
10390 CASE_FLT_FN (BUILT_IN_SCALBN
):
10391 CASE_FLT_FN (BUILT_IN_SCALBLN
):
10392 return fold_builtin_load_exponent (loc
, arg0
, arg1
,
10393 type
, /*ldexp=*/false);
10395 CASE_FLT_FN (BUILT_IN_FREXP
):
10396 return fold_builtin_frexp (loc
, arg0
, arg1
, type
);
10398 CASE_FLT_FN (BUILT_IN_MODF
):
10399 return fold_builtin_modf (loc
, arg0
, arg1
, type
);
10401 case BUILT_IN_STRSTR
:
10402 return fold_builtin_strstr (loc
, arg0
, arg1
, type
);
10404 case BUILT_IN_STRSPN
:
10405 return fold_builtin_strspn (loc
, arg0
, arg1
);
10407 case BUILT_IN_STRCSPN
:
10408 return fold_builtin_strcspn (loc
, arg0
, arg1
);
10410 case BUILT_IN_STRCHR
:
10411 case BUILT_IN_INDEX
:
10412 return fold_builtin_strchr (loc
, arg0
, arg1
, type
);
10414 case BUILT_IN_STRRCHR
:
10415 case BUILT_IN_RINDEX
:
10416 return fold_builtin_strrchr (loc
, arg0
, arg1
, type
);
10418 case BUILT_IN_STRCMP
:
10419 return fold_builtin_strcmp (loc
, arg0
, arg1
);
10421 case BUILT_IN_STRPBRK
:
10422 return fold_builtin_strpbrk (loc
, arg0
, arg1
, type
);
10424 case BUILT_IN_EXPECT
:
10425 return fold_builtin_expect (loc
, arg0
, arg1
, NULL_TREE
);
10427 CASE_FLT_FN (BUILT_IN_POW
):
10428 return fold_builtin_pow (loc
, fndecl
, arg0
, arg1
, type
);
10430 CASE_FLT_FN (BUILT_IN_POWI
):
10431 return fold_builtin_powi (loc
, fndecl
, arg0
, arg1
, type
);
10433 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
10434 return fold_builtin_copysign (loc
, fndecl
, arg0
, arg1
, type
);
10436 CASE_FLT_FN (BUILT_IN_FMIN
):
10437 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/false);
10439 CASE_FLT_FN (BUILT_IN_FMAX
):
10440 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/true);
10442 case BUILT_IN_ISGREATER
:
10443 return fold_builtin_unordered_cmp (loc
, fndecl
,
10444 arg0
, arg1
, UNLE_EXPR
, LE_EXPR
);
10445 case BUILT_IN_ISGREATEREQUAL
:
10446 return fold_builtin_unordered_cmp (loc
, fndecl
,
10447 arg0
, arg1
, UNLT_EXPR
, LT_EXPR
);
10448 case BUILT_IN_ISLESS
:
10449 return fold_builtin_unordered_cmp (loc
, fndecl
,
10450 arg0
, arg1
, UNGE_EXPR
, GE_EXPR
);
10451 case BUILT_IN_ISLESSEQUAL
:
10452 return fold_builtin_unordered_cmp (loc
, fndecl
,
10453 arg0
, arg1
, UNGT_EXPR
, GT_EXPR
);
10454 case BUILT_IN_ISLESSGREATER
:
10455 return fold_builtin_unordered_cmp (loc
, fndecl
,
10456 arg0
, arg1
, UNEQ_EXPR
, EQ_EXPR
);
10457 case BUILT_IN_ISUNORDERED
:
10458 return fold_builtin_unordered_cmp (loc
, fndecl
,
10459 arg0
, arg1
, UNORDERED_EXPR
,
10462 /* We do the folding for va_start in the expander. */
10463 case BUILT_IN_VA_START
:
10466 case BUILT_IN_OBJECT_SIZE
:
10467 return fold_builtin_object_size (arg0
, arg1
);
10469 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
10470 return fold_builtin_atomic_always_lock_free (arg0
, arg1
);
10472 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
10473 return fold_builtin_atomic_is_lock_free (arg0
, arg1
);
10481 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10483 This function returns NULL_TREE if no simplification was possible. */
10486 fold_builtin_3 (location_t loc
, tree fndecl
,
10487 tree arg0
, tree arg1
, tree arg2
)
10489 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10490 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10494 CASE_FLT_FN (BUILT_IN_SINCOS
):
10495 return fold_builtin_sincos (loc
, arg0
, arg1
, arg2
);
10497 CASE_FLT_FN (BUILT_IN_FMA
):
10498 return fold_builtin_fma (loc
, arg0
, arg1
, arg2
, type
);
10501 CASE_FLT_FN (BUILT_IN_REMQUO
):
10502 if (validate_arg (arg0
, REAL_TYPE
)
10503 && validate_arg (arg1
, REAL_TYPE
)
10504 && validate_arg (arg2
, POINTER_TYPE
))
10505 return do_mpfr_remquo (arg0
, arg1
, arg2
);
10508 case BUILT_IN_STRNCMP
:
10509 return fold_builtin_strncmp (loc
, arg0
, arg1
, arg2
);
10511 case BUILT_IN_MEMCHR
:
10512 return fold_builtin_memchr (loc
, arg0
, arg1
, arg2
, type
);
10514 case BUILT_IN_BCMP
:
10515 case BUILT_IN_MEMCMP
:
10516 return fold_builtin_memcmp (loc
, arg0
, arg1
, arg2
);;
10518 case BUILT_IN_EXPECT
:
10519 return fold_builtin_expect (loc
, arg0
, arg1
, arg2
);
10521 case BUILT_IN_ADD_OVERFLOW
:
10522 case BUILT_IN_SUB_OVERFLOW
:
10523 case BUILT_IN_MUL_OVERFLOW
:
10524 case BUILT_IN_SADD_OVERFLOW
:
10525 case BUILT_IN_SADDL_OVERFLOW
:
10526 case BUILT_IN_SADDLL_OVERFLOW
:
10527 case BUILT_IN_SSUB_OVERFLOW
:
10528 case BUILT_IN_SSUBL_OVERFLOW
:
10529 case BUILT_IN_SSUBLL_OVERFLOW
:
10530 case BUILT_IN_SMUL_OVERFLOW
:
10531 case BUILT_IN_SMULL_OVERFLOW
:
10532 case BUILT_IN_SMULLL_OVERFLOW
:
10533 case BUILT_IN_UADD_OVERFLOW
:
10534 case BUILT_IN_UADDL_OVERFLOW
:
10535 case BUILT_IN_UADDLL_OVERFLOW
:
10536 case BUILT_IN_USUB_OVERFLOW
:
10537 case BUILT_IN_USUBL_OVERFLOW
:
10538 case BUILT_IN_USUBLL_OVERFLOW
:
10539 case BUILT_IN_UMUL_OVERFLOW
:
10540 case BUILT_IN_UMULL_OVERFLOW
:
10541 case BUILT_IN_UMULLL_OVERFLOW
:
10542 return fold_builtin_arith_overflow (loc
, fcode
, arg0
, arg1
, arg2
);
10550 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10551 arguments. IGNORE is true if the result of the
10552 function call is ignored. This function returns NULL_TREE if no
10553 simplification was possible. */
10556 fold_builtin_n (location_t loc
, tree fndecl
, tree
*args
, int nargs
, bool)
10558 tree ret
= NULL_TREE
;
10563 ret
= fold_builtin_0 (loc
, fndecl
);
10566 ret
= fold_builtin_1 (loc
, fndecl
, args
[0]);
10569 ret
= fold_builtin_2 (loc
, fndecl
, args
[0], args
[1]);
10572 ret
= fold_builtin_3 (loc
, fndecl
, args
[0], args
[1], args
[2]);
10575 ret
= fold_builtin_varargs (loc
, fndecl
, args
, nargs
);
10580 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
10581 SET_EXPR_LOCATION (ret
, loc
);
10582 TREE_NO_WARNING (ret
) = 1;
10588 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10589 list ARGS along with N new arguments in NEWARGS. SKIP is the number
10590 of arguments in ARGS to be omitted. OLDNARGS is the number of
10591 elements in ARGS. */
10594 rewrite_call_expr_valist (location_t loc
, int oldnargs
, tree
*args
,
10595 int skip
, tree fndecl
, int n
, va_list newargs
)
10597 int nargs
= oldnargs
- skip
+ n
;
10604 buffer
= XALLOCAVEC (tree
, nargs
);
10605 for (i
= 0; i
< n
; i
++)
10606 buffer
[i
] = va_arg (newargs
, tree
);
10607 for (j
= skip
; j
< oldnargs
; j
++, i
++)
10608 buffer
[i
] = args
[j
];
10611 buffer
= args
+ skip
;
10613 return build_call_expr_loc_array (loc
, fndecl
, nargs
, buffer
);
10616 /* Return true if FNDECL shouldn't be folded right now.
10617 If a built-in function has an inline attribute always_inline
10618 wrapper, defer folding it after always_inline functions have
10619 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10620 might not be performed. */
10623 avoid_folding_inline_builtin (tree fndecl
)
10625 return (DECL_DECLARED_INLINE_P (fndecl
)
10626 && DECL_DISREGARD_INLINE_LIMITS (fndecl
)
10628 && !cfun
->always_inline_functions_inlined
10629 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl
)));
10632 /* A wrapper function for builtin folding that prevents warnings for
10633 "statement without effect" and the like, caused by removing the
10634 call node earlier than the warning is generated. */
10637 fold_call_expr (location_t loc
, tree exp
, bool ignore
)
10639 tree ret
= NULL_TREE
;
10640 tree fndecl
= get_callee_fndecl (exp
);
10642 && TREE_CODE (fndecl
) == FUNCTION_DECL
10643 && DECL_BUILT_IN (fndecl
)
10644 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10645 yet. Defer folding until we see all the arguments
10646 (after inlining). */
10647 && !CALL_EXPR_VA_ARG_PACK (exp
))
10649 int nargs
= call_expr_nargs (exp
);
10651 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10652 instead last argument is __builtin_va_arg_pack (). Defer folding
10653 even in that case, until arguments are finalized. */
10654 if (nargs
&& TREE_CODE (CALL_EXPR_ARG (exp
, nargs
- 1)) == CALL_EXPR
)
10656 tree fndecl2
= get_callee_fndecl (CALL_EXPR_ARG (exp
, nargs
- 1));
10658 && TREE_CODE (fndecl2
) == FUNCTION_DECL
10659 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
10660 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
10664 if (avoid_folding_inline_builtin (fndecl
))
10667 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10668 return targetm
.fold_builtin (fndecl
, call_expr_nargs (exp
),
10669 CALL_EXPR_ARGP (exp
), ignore
);
10672 tree
*args
= CALL_EXPR_ARGP (exp
);
10673 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
10681 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
10682 N arguments are passed in the array ARGARRAY. Return a folded
10683 expression or NULL_TREE if no simplification was possible. */
10686 fold_builtin_call_array (location_t loc
, tree
,
10691 if (TREE_CODE (fn
) != ADDR_EXPR
)
10694 tree fndecl
= TREE_OPERAND (fn
, 0);
10695 if (TREE_CODE (fndecl
) == FUNCTION_DECL
10696 && DECL_BUILT_IN (fndecl
))
10698 /* If last argument is __builtin_va_arg_pack (), arguments to this
10699 function are not finalized yet. Defer folding until they are. */
10700 if (n
&& TREE_CODE (argarray
[n
- 1]) == CALL_EXPR
)
10702 tree fndecl2
= get_callee_fndecl (argarray
[n
- 1]);
10704 && TREE_CODE (fndecl2
) == FUNCTION_DECL
10705 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
10706 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
10709 if (avoid_folding_inline_builtin (fndecl
))
10711 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10712 return targetm
.fold_builtin (fndecl
, n
, argarray
, false);
10714 return fold_builtin_n (loc
, fndecl
, argarray
, n
, false);
10720 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10721 along with N new arguments specified as the "..." parameters. SKIP
10722 is the number of arguments in EXP to be omitted. This function is used
10723 to do varargs-to-varargs transformations. */
10726 rewrite_call_expr (location_t loc
, tree exp
, int skip
, tree fndecl
, int n
, ...)
10732 t
= rewrite_call_expr_valist (loc
, call_expr_nargs (exp
),
10733 CALL_EXPR_ARGP (exp
), skip
, fndecl
, n
, ap
);
10739 /* Validate a single argument ARG against a tree code CODE representing
10743 validate_arg (const_tree arg
, enum tree_code code
)
10747 else if (code
== POINTER_TYPE
)
10748 return POINTER_TYPE_P (TREE_TYPE (arg
));
10749 else if (code
== INTEGER_TYPE
)
10750 return INTEGRAL_TYPE_P (TREE_TYPE (arg
));
10751 return code
== TREE_CODE (TREE_TYPE (arg
));
10754 /* This function validates the types of a function call argument list
10755 against a specified list of tree_codes. If the last specifier is a 0,
10756 that represents an ellipses, otherwise the last specifier must be a
10759 This is the GIMPLE version of validate_arglist. Eventually we want to
10760 completely convert builtins.c to work from GIMPLEs and the tree based
10761 validate_arglist will then be removed. */
10764 validate_gimple_arglist (const gcall
*call
, ...)
10766 enum tree_code code
;
10772 va_start (ap
, call
);
10777 code
= (enum tree_code
) va_arg (ap
, int);
10781 /* This signifies an ellipses, any further arguments are all ok. */
10785 /* This signifies an endlink, if no arguments remain, return
10786 true, otherwise return false. */
10787 res
= (i
== gimple_call_num_args (call
));
10790 /* If no parameters remain or the parameter's code does not
10791 match the specified code, return false. Otherwise continue
10792 checking any remaining arguments. */
10793 arg
= gimple_call_arg (call
, i
++);
10794 if (!validate_arg (arg
, code
))
10801 /* We need gotos here since we can only have one VA_CLOSE in a
10809 /* Default target-specific builtin expander that does nothing. */
10812 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
10813 rtx target ATTRIBUTE_UNUSED
,
10814 rtx subtarget ATTRIBUTE_UNUSED
,
10815 machine_mode mode ATTRIBUTE_UNUSED
,
10816 int ignore ATTRIBUTE_UNUSED
)
10821 /* Returns true is EXP represents data that would potentially reside
10822 in a readonly section. */
10825 readonly_data_expr (tree exp
)
10829 if (TREE_CODE (exp
) != ADDR_EXPR
)
10832 exp
= get_base_address (TREE_OPERAND (exp
, 0));
10836 /* Make sure we call decl_readonly_section only for trees it
10837 can handle (since it returns true for everything it doesn't
10839 if (TREE_CODE (exp
) == STRING_CST
10840 || TREE_CODE (exp
) == CONSTRUCTOR
10841 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
10842 return decl_readonly_section (exp
, 0);
10847 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
10848 to the call, and TYPE is its return type.
10850 Return NULL_TREE if no simplification was possible, otherwise return the
10851 simplified form of the call as a tree.
10853 The simplified form may be a constant or other expression which
10854 computes the same value, but in a more efficient manner (including
10855 calls to other builtin functions).
10857 The call may contain arguments which need to be evaluated, but
10858 which are not useful to determine the result of the call. In
10859 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10860 COMPOUND_EXPR will be an argument which must be evaluated.
10861 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10862 COMPOUND_EXPR in the chain will contain the tree for the simplified
10863 form of the builtin function call. */
10866 fold_builtin_strstr (location_t loc
, tree s1
, tree s2
, tree type
)
10868 if (!validate_arg (s1
, POINTER_TYPE
)
10869 || !validate_arg (s2
, POINTER_TYPE
))
10874 const char *p1
, *p2
;
10876 p2
= c_getstr (s2
);
10880 p1
= c_getstr (s1
);
10883 const char *r
= strstr (p1
, p2
);
10887 return build_int_cst (TREE_TYPE (s1
), 0);
10889 /* Return an offset into the constant string argument. */
10890 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
10891 return fold_convert_loc (loc
, type
, tem
);
10894 /* The argument is const char *, and the result is char *, so we need
10895 a type conversion here to avoid a warning. */
10897 return fold_convert_loc (loc
, type
, s1
);
10902 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
10906 /* New argument list transforming strstr(s1, s2) to
10907 strchr(s1, s2[0]). */
10908 return build_call_expr_loc (loc
, fn
, 2, s1
,
10909 build_int_cst (integer_type_node
, p2
[0]));
10913 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
10914 the call, and TYPE is its return type.
10916 Return NULL_TREE if no simplification was possible, otherwise return the
10917 simplified form of the call as a tree.
10919 The simplified form may be a constant or other expression which
10920 computes the same value, but in a more efficient manner (including
10921 calls to other builtin functions).
10923 The call may contain arguments which need to be evaluated, but
10924 which are not useful to determine the result of the call. In
10925 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10926 COMPOUND_EXPR will be an argument which must be evaluated.
10927 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10928 COMPOUND_EXPR in the chain will contain the tree for the simplified
10929 form of the builtin function call. */
10932 fold_builtin_strchr (location_t loc
, tree s1
, tree s2
, tree type
)
10934 if (!validate_arg (s1
, POINTER_TYPE
)
10935 || !validate_arg (s2
, INTEGER_TYPE
))
10941 if (TREE_CODE (s2
) != INTEGER_CST
)
10944 p1
= c_getstr (s1
);
10951 if (target_char_cast (s2
, &c
))
10954 r
= strchr (p1
, c
);
10957 return build_int_cst (TREE_TYPE (s1
), 0);
10959 /* Return an offset into the constant string argument. */
10960 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
10961 return fold_convert_loc (loc
, type
, tem
);
10967 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
10968 the call, and TYPE is its return type.
10970 Return NULL_TREE if no simplification was possible, otherwise return the
10971 simplified form of the call as a tree.
10973 The simplified form may be a constant or other expression which
10974 computes the same value, but in a more efficient manner (including
10975 calls to other builtin functions).
10977 The call may contain arguments which need to be evaluated, but
10978 which are not useful to determine the result of the call. In
10979 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10980 COMPOUND_EXPR will be an argument which must be evaluated.
10981 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10982 COMPOUND_EXPR in the chain will contain the tree for the simplified
10983 form of the builtin function call. */
10986 fold_builtin_strrchr (location_t loc
, tree s1
, tree s2
, tree type
)
10988 if (!validate_arg (s1
, POINTER_TYPE
)
10989 || !validate_arg (s2
, INTEGER_TYPE
))
10996 if (TREE_CODE (s2
) != INTEGER_CST
)
10999 p1
= c_getstr (s1
);
11006 if (target_char_cast (s2
, &c
))
11009 r
= strrchr (p1
, c
);
11012 return build_int_cst (TREE_TYPE (s1
), 0);
11014 /* Return an offset into the constant string argument. */
11015 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11016 return fold_convert_loc (loc
, type
, tem
);
11019 if (! integer_zerop (s2
))
11022 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11026 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11027 return build_call_expr_loc (loc
, fn
, 2, s1
, s2
);
11031 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11032 to the call, and TYPE is its return type.
11034 Return NULL_TREE if no simplification was possible, otherwise return the
11035 simplified form of the call as a tree.
11037 The simplified form may be a constant or other expression which
11038 computes the same value, but in a more efficient manner (including
11039 calls to other builtin functions).
11041 The call may contain arguments which need to be evaluated, but
11042 which are not useful to determine the result of the call. In
11043 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11044 COMPOUND_EXPR will be an argument which must be evaluated.
11045 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11046 COMPOUND_EXPR in the chain will contain the tree for the simplified
11047 form of the builtin function call. */
11050 fold_builtin_strpbrk (location_t loc
, tree s1
, tree s2
, tree type
)
11052 if (!validate_arg (s1
, POINTER_TYPE
)
11053 || !validate_arg (s2
, POINTER_TYPE
))
11058 const char *p1
, *p2
;
11060 p2
= c_getstr (s2
);
11064 p1
= c_getstr (s1
);
11067 const char *r
= strpbrk (p1
, p2
);
11071 return build_int_cst (TREE_TYPE (s1
), 0);
11073 /* Return an offset into the constant string argument. */
11074 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11075 return fold_convert_loc (loc
, type
, tem
);
11079 /* strpbrk(x, "") == NULL.
11080 Evaluate and ignore s1 in case it had side-effects. */
11081 return omit_one_operand_loc (loc
, TREE_TYPE (s1
), integer_zero_node
, s1
);
11084 return NULL_TREE
; /* Really call strpbrk. */
11086 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11090 /* New argument list transforming strpbrk(s1, s2) to
11091 strchr(s1, s2[0]). */
11092 return build_call_expr_loc (loc
, fn
, 2, s1
,
11093 build_int_cst (integer_type_node
, p2
[0]));
11097 /* Simplify a call to the strspn 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_strspn (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
= strspn (p1
, p2
);
11129 return build_int_cst (size_type_node
, r
);
11132 /* If either argument is "", return NULL_TREE. */
11133 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
11134 /* Evaluate and ignore both arguments in case either one has
11136 return omit_two_operands_loc (loc
, size_type_node
, size_zero_node
,
11142 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11145 Return NULL_TREE if no simplification was possible, otherwise return the
11146 simplified form of the call as a tree.
11148 The simplified form may be a constant or other expression which
11149 computes the same value, but in a more efficient manner (including
11150 calls to other builtin functions).
11152 The call may contain arguments which need to be evaluated, but
11153 which are not useful to determine the result of the call. In
11154 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11155 COMPOUND_EXPR will be an argument which must be evaluated.
11156 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11157 COMPOUND_EXPR in the chain will contain the tree for the simplified
11158 form of the builtin function call. */
11161 fold_builtin_strcspn (location_t loc
, tree s1
, tree s2
)
11163 if (!validate_arg (s1
, POINTER_TYPE
)
11164 || !validate_arg (s2
, POINTER_TYPE
))
11168 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11170 /* If both arguments are constants, evaluate at compile-time. */
11173 const size_t r
= strcspn (p1
, p2
);
11174 return build_int_cst (size_type_node
, r
);
11177 /* If the first argument is "", return NULL_TREE. */
11178 if (p1
&& *p1
== '\0')
11180 /* Evaluate and ignore argument s2 in case it has
11182 return omit_one_operand_loc (loc
, size_type_node
,
11183 size_zero_node
, s2
);
11186 /* If the second argument is "", return __builtin_strlen(s1). */
11187 if (p2
&& *p2
== '\0')
11189 tree fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
11191 /* If the replacement _DECL isn't initialized, don't do the
11196 return build_call_expr_loc (loc
, fn
, 1, s1
);
11202 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11203 produced. False otherwise. This is done so that we don't output the error
11204 or warning twice or three times. */
11207 fold_builtin_next_arg (tree exp
, bool va_start_p
)
11209 tree fntype
= TREE_TYPE (current_function_decl
);
11210 int nargs
= call_expr_nargs (exp
);
11212 /* There is good chance the current input_location points inside the
11213 definition of the va_start macro (perhaps on the token for
11214 builtin) in a system header, so warnings will not be emitted.
11215 Use the location in real source code. */
11216 source_location current_location
=
11217 linemap_unwind_to_first_non_reserved_loc (line_table
, input_location
,
11220 if (!stdarg_p (fntype
))
11222 error ("%<va_start%> used in function with fixed args");
11228 if (va_start_p
&& (nargs
!= 2))
11230 error ("wrong number of arguments to function %<va_start%>");
11233 arg
= CALL_EXPR_ARG (exp
, 1);
11235 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11236 when we checked the arguments and if needed issued a warning. */
11241 /* Evidently an out of date version of <stdarg.h>; can't validate
11242 va_start's second argument, but can still work as intended. */
11243 warning_at (current_location
,
11245 "%<__builtin_next_arg%> called without an argument");
11248 else if (nargs
> 1)
11250 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11253 arg
= CALL_EXPR_ARG (exp
, 0);
11256 if (TREE_CODE (arg
) == SSA_NAME
)
11257 arg
= SSA_NAME_VAR (arg
);
11259 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11260 or __builtin_next_arg (0) the first time we see it, after checking
11261 the arguments and if needed issuing a warning. */
11262 if (!integer_zerop (arg
))
11264 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
11266 /* Strip off all nops for the sake of the comparison. This
11267 is not quite the same as STRIP_NOPS. It does more.
11268 We must also strip off INDIRECT_EXPR for C++ reference
11270 while (CONVERT_EXPR_P (arg
)
11271 || TREE_CODE (arg
) == INDIRECT_REF
)
11272 arg
= TREE_OPERAND (arg
, 0);
11273 if (arg
!= last_parm
)
11275 /* FIXME: Sometimes with the tree optimizers we can get the
11276 not the last argument even though the user used the last
11277 argument. We just warn and set the arg to be the last
11278 argument so that we will get wrong-code because of
11280 warning_at (current_location
,
11282 "second parameter of %<va_start%> not last named argument");
11285 /* Undefined by C99 7.15.1.4p4 (va_start):
11286 "If the parameter parmN is declared with the register storage
11287 class, with a function or array type, or with a type that is
11288 not compatible with the type that results after application of
11289 the default argument promotions, the behavior is undefined."
11291 else if (DECL_REGISTER (arg
))
11293 warning_at (current_location
,
11295 "undefined behaviour when second parameter of "
11296 "%<va_start%> is declared with %<register%> storage");
11299 /* We want to verify the second parameter just once before the tree
11300 optimizers are run and then avoid keeping it in the tree,
11301 as otherwise we could warn even for correct code like:
11302 void foo (int i, ...)
11303 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11305 CALL_EXPR_ARG (exp
, 1) = integer_zero_node
;
11307 CALL_EXPR_ARG (exp
, 0) = integer_zero_node
;
11313 /* Expand a call EXP to __builtin_object_size. */
11316 expand_builtin_object_size (tree exp
)
11319 int object_size_type
;
11320 tree fndecl
= get_callee_fndecl (exp
);
11322 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11324 error ("%Kfirst argument of %D must be a pointer, second integer constant",
11326 expand_builtin_trap ();
11330 ost
= CALL_EXPR_ARG (exp
, 1);
11333 if (TREE_CODE (ost
) != INTEGER_CST
11334 || tree_int_cst_sgn (ost
) < 0
11335 || compare_tree_int (ost
, 3) > 0)
11337 error ("%Klast argument of %D is not integer constant between 0 and 3",
11339 expand_builtin_trap ();
11343 object_size_type
= tree_to_shwi (ost
);
11345 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
11348 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11349 FCODE is the BUILT_IN_* to use.
11350 Return NULL_RTX if we failed; the caller should emit a normal call,
11351 otherwise try to get the result in TARGET, if convenient (and in
11352 mode MODE if that's convenient). */
11355 expand_builtin_memory_chk (tree exp
, rtx target
, machine_mode mode
,
11356 enum built_in_function fcode
)
11358 tree dest
, src
, len
, size
;
11360 if (!validate_arglist (exp
,
11362 fcode
== BUILT_IN_MEMSET_CHK
11363 ? INTEGER_TYPE
: POINTER_TYPE
,
11364 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11367 dest
= CALL_EXPR_ARG (exp
, 0);
11368 src
= CALL_EXPR_ARG (exp
, 1);
11369 len
= CALL_EXPR_ARG (exp
, 2);
11370 size
= CALL_EXPR_ARG (exp
, 3);
11372 if (! tree_fits_uhwi_p (size
))
11375 if (tree_fits_uhwi_p (len
) || integer_all_onesp (size
))
11379 if (! integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
11381 warning_at (tree_nonartificial_location (exp
),
11382 0, "%Kcall to %D will always overflow destination buffer",
11383 exp
, get_callee_fndecl (exp
));
11388 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11389 mem{cpy,pcpy,move,set} is available. */
11392 case BUILT_IN_MEMCPY_CHK
:
11393 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
11395 case BUILT_IN_MEMPCPY_CHK
:
11396 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
11398 case BUILT_IN_MEMMOVE_CHK
:
11399 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
11401 case BUILT_IN_MEMSET_CHK
:
11402 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
11411 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 3, dest
, src
, len
);
11412 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11413 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11414 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11416 else if (fcode
== BUILT_IN_MEMSET_CHK
)
11420 unsigned int dest_align
= get_pointer_alignment (dest
);
11422 /* If DEST is not a pointer type, call the normal function. */
11423 if (dest_align
== 0)
11426 /* If SRC and DEST are the same (and not volatile), do nothing. */
11427 if (operand_equal_p (src
, dest
, 0))
11431 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
11433 /* Evaluate and ignore LEN in case it has side-effects. */
11434 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
11435 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
11438 expr
= fold_build_pointer_plus (dest
, len
);
11439 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
11442 /* __memmove_chk special case. */
11443 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
11445 unsigned int src_align
= get_pointer_alignment (src
);
11447 if (src_align
== 0)
11450 /* If src is categorized for a readonly section we can use
11451 normal __memcpy_chk. */
11452 if (readonly_data_expr (src
))
11454 tree fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
11457 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 4,
11458 dest
, src
, len
, size
);
11459 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11460 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11461 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11468 /* Emit warning if a buffer overflow is detected at compile time. */
11471 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
11475 location_t loc
= tree_nonartificial_location (exp
);
11479 case BUILT_IN_STRCPY_CHK
:
11480 case BUILT_IN_STPCPY_CHK
:
11481 /* For __strcat_chk the warning will be emitted only if overflowing
11482 by at least strlen (dest) + 1 bytes. */
11483 case BUILT_IN_STRCAT_CHK
:
11484 len
= CALL_EXPR_ARG (exp
, 1);
11485 size
= CALL_EXPR_ARG (exp
, 2);
11488 case BUILT_IN_STRNCAT_CHK
:
11489 case BUILT_IN_STRNCPY_CHK
:
11490 case BUILT_IN_STPNCPY_CHK
:
11491 len
= CALL_EXPR_ARG (exp
, 2);
11492 size
= CALL_EXPR_ARG (exp
, 3);
11494 case BUILT_IN_SNPRINTF_CHK
:
11495 case BUILT_IN_VSNPRINTF_CHK
:
11496 len
= CALL_EXPR_ARG (exp
, 1);
11497 size
= CALL_EXPR_ARG (exp
, 3);
11500 gcc_unreachable ();
11506 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
11511 len
= c_strlen (len
, 1);
11512 if (! len
|| ! tree_fits_uhwi_p (len
) || tree_int_cst_lt (len
, size
))
11515 else if (fcode
== BUILT_IN_STRNCAT_CHK
)
11517 tree src
= CALL_EXPR_ARG (exp
, 1);
11518 if (! src
|| ! tree_fits_uhwi_p (len
) || tree_int_cst_lt (len
, size
))
11520 src
= c_strlen (src
, 1);
11521 if (! src
|| ! tree_fits_uhwi_p (src
))
11523 warning_at (loc
, 0, "%Kcall to %D might overflow destination buffer",
11524 exp
, get_callee_fndecl (exp
));
11527 else if (tree_int_cst_lt (src
, size
))
11530 else if (! tree_fits_uhwi_p (len
) || ! tree_int_cst_lt (size
, len
))
11533 warning_at (loc
, 0, "%Kcall to %D will always overflow destination buffer",
11534 exp
, get_callee_fndecl (exp
));
11537 /* Emit warning if a buffer overflow is detected at compile time
11538 in __sprintf_chk/__vsprintf_chk calls. */
11541 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
11543 tree size
, len
, fmt
;
11544 const char *fmt_str
;
11545 int nargs
= call_expr_nargs (exp
);
11547 /* Verify the required arguments in the original call. */
11551 size
= CALL_EXPR_ARG (exp
, 2);
11552 fmt
= CALL_EXPR_ARG (exp
, 3);
11554 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
11557 /* Check whether the format is a literal string constant. */
11558 fmt_str
= c_getstr (fmt
);
11559 if (fmt_str
== NULL
)
11562 if (!init_target_chars ())
11565 /* If the format doesn't contain % args or %%, we know its size. */
11566 if (strchr (fmt_str
, target_percent
) == 0)
11567 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
11568 /* If the format is "%s" and first ... argument is a string literal,
11570 else if (fcode
== BUILT_IN_SPRINTF_CHK
11571 && strcmp (fmt_str
, target_percent_s
) == 0)
11577 arg
= CALL_EXPR_ARG (exp
, 4);
11578 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
11581 len
= c_strlen (arg
, 1);
11582 if (!len
|| ! tree_fits_uhwi_p (len
))
11588 if (! tree_int_cst_lt (len
, size
))
11589 warning_at (tree_nonartificial_location (exp
),
11590 0, "%Kcall to %D will always overflow destination buffer",
11591 exp
, get_callee_fndecl (exp
));
11594 /* Emit warning if a free is called with address of a variable. */
11597 maybe_emit_free_warning (tree exp
)
11599 tree arg
= CALL_EXPR_ARG (exp
, 0);
11602 if (TREE_CODE (arg
) != ADDR_EXPR
)
11605 arg
= get_base_address (TREE_OPERAND (arg
, 0));
11606 if (arg
== NULL
|| INDIRECT_REF_P (arg
) || TREE_CODE (arg
) == MEM_REF
)
11609 if (SSA_VAR_P (arg
))
11610 warning_at (tree_nonartificial_location (exp
), OPT_Wfree_nonheap_object
,
11611 "%Kattempt to free a non-heap object %qD", exp
, arg
);
11613 warning_at (tree_nonartificial_location (exp
), OPT_Wfree_nonheap_object
,
11614 "%Kattempt to free a non-heap object", exp
);
11617 /* Fold a call to __builtin_object_size with arguments PTR and OST,
11621 fold_builtin_object_size (tree ptr
, tree ost
)
11623 unsigned HOST_WIDE_INT bytes
;
11624 int object_size_type
;
11626 if (!validate_arg (ptr
, POINTER_TYPE
)
11627 || !validate_arg (ost
, INTEGER_TYPE
))
11632 if (TREE_CODE (ost
) != INTEGER_CST
11633 || tree_int_cst_sgn (ost
) < 0
11634 || compare_tree_int (ost
, 3) > 0)
11637 object_size_type
= tree_to_shwi (ost
);
11639 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
11640 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
11641 and (size_t) 0 for types 2 and 3. */
11642 if (TREE_SIDE_EFFECTS (ptr
))
11643 return build_int_cst_type (size_type_node
, object_size_type
< 2 ? -1 : 0);
11645 if (TREE_CODE (ptr
) == ADDR_EXPR
)
11647 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
11648 if (wi::fits_to_tree_p (bytes
, size_type_node
))
11649 return build_int_cstu (size_type_node
, bytes
);
11651 else if (TREE_CODE (ptr
) == SSA_NAME
)
11653 /* If object size is not known yet, delay folding until
11654 later. Maybe subsequent passes will help determining
11656 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
11657 if (bytes
!= (unsigned HOST_WIDE_INT
) (object_size_type
< 2 ? -1 : 0)
11658 && wi::fits_to_tree_p (bytes
, size_type_node
))
11659 return build_int_cstu (size_type_node
, bytes
);
11665 /* Builtins with folding operations that operate on "..." arguments
11666 need special handling; we need to store the arguments in a convenient
11667 data structure before attempting any folding. Fortunately there are
11668 only a few builtins that fall into this category. FNDECL is the
11669 function, EXP is the CALL_EXPR for the call. */
11672 fold_builtin_varargs (location_t loc
, tree fndecl
, tree
*args
, int nargs
)
11674 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
11675 tree ret
= NULL_TREE
;
11679 case BUILT_IN_FPCLASSIFY
:
11680 ret
= fold_builtin_fpclassify (loc
, args
, nargs
);
11688 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
11689 SET_EXPR_LOCATION (ret
, loc
);
11690 TREE_NO_WARNING (ret
) = 1;
11696 /* Initialize format string characters in the target charset. */
11699 init_target_chars (void)
11704 target_newline
= lang_hooks
.to_target_charset ('\n');
11705 target_percent
= lang_hooks
.to_target_charset ('%');
11706 target_c
= lang_hooks
.to_target_charset ('c');
11707 target_s
= lang_hooks
.to_target_charset ('s');
11708 if (target_newline
== 0 || target_percent
== 0 || target_c
== 0
11712 target_percent_c
[0] = target_percent
;
11713 target_percent_c
[1] = target_c
;
11714 target_percent_c
[2] = '\0';
11716 target_percent_s
[0] = target_percent
;
11717 target_percent_s
[1] = target_s
;
11718 target_percent_s
[2] = '\0';
11720 target_percent_s_newline
[0] = target_percent
;
11721 target_percent_s_newline
[1] = target_s
;
11722 target_percent_s_newline
[2] = target_newline
;
11723 target_percent_s_newline
[3] = '\0';
11730 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
11731 and no overflow/underflow occurred. INEXACT is true if M was not
11732 exactly calculated. TYPE is the tree type for the result. This
11733 function assumes that you cleared the MPFR flags and then
11734 calculated M to see if anything subsequently set a flag prior to
11735 entering this function. Return NULL_TREE if any checks fail. */
11738 do_mpfr_ckconv (mpfr_srcptr m
, tree type
, int inexact
)
11740 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
11741 overflow/underflow occurred. If -frounding-math, proceed iff the
11742 result of calling FUNC was exact. */
11743 if (mpfr_number_p (m
) && !mpfr_overflow_p () && !mpfr_underflow_p ()
11744 && (!flag_rounding_math
|| !inexact
))
11746 REAL_VALUE_TYPE rr
;
11748 real_from_mpfr (&rr
, m
, type
, GMP_RNDN
);
11749 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
11750 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
11751 but the mpft_t is not, then we underflowed in the
11753 if (real_isfinite (&rr
)
11754 && (rr
.cl
== rvc_zero
) == (mpfr_zero_p (m
) != 0))
11756 REAL_VALUE_TYPE rmode
;
11758 real_convert (&rmode
, TYPE_MODE (type
), &rr
);
11759 /* Proceed iff the specified mode can hold the value. */
11760 if (real_identical (&rmode
, &rr
))
11761 return build_real (type
, rmode
);
11767 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
11768 number and no overflow/underflow occurred. INEXACT is true if M
11769 was not exactly calculated. TYPE is the tree type for the result.
11770 This function assumes that you cleared the MPFR flags and then
11771 calculated M to see if anything subsequently set a flag prior to
11772 entering this function. Return NULL_TREE if any checks fail, if
11773 FORCE_CONVERT is true, then bypass the checks. */
11776 do_mpc_ckconv (mpc_srcptr m
, tree type
, int inexact
, int force_convert
)
11778 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
11779 overflow/underflow occurred. If -frounding-math, proceed iff the
11780 result of calling FUNC was exact. */
11782 || (mpfr_number_p (mpc_realref (m
)) && mpfr_number_p (mpc_imagref (m
))
11783 && !mpfr_overflow_p () && !mpfr_underflow_p ()
11784 && (!flag_rounding_math
|| !inexact
)))
11786 REAL_VALUE_TYPE re
, im
;
11788 real_from_mpfr (&re
, mpc_realref (m
), TREE_TYPE (type
), GMP_RNDN
);
11789 real_from_mpfr (&im
, mpc_imagref (m
), TREE_TYPE (type
), GMP_RNDN
);
11790 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
11791 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
11792 but the mpft_t is not, then we underflowed in the
11795 || (real_isfinite (&re
) && real_isfinite (&im
)
11796 && (re
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_realref (m
)) != 0)
11797 && (im
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_imagref (m
)) != 0)))
11799 REAL_VALUE_TYPE re_mode
, im_mode
;
11801 real_convert (&re_mode
, TYPE_MODE (TREE_TYPE (type
)), &re
);
11802 real_convert (&im_mode
, TYPE_MODE (TREE_TYPE (type
)), &im
);
11803 /* Proceed iff the specified mode can hold the value. */
11805 || (real_identical (&re_mode
, &re
)
11806 && real_identical (&im_mode
, &im
)))
11807 return build_complex (type
, build_real (TREE_TYPE (type
), re_mode
),
11808 build_real (TREE_TYPE (type
), im_mode
));
11814 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
11815 FUNC on it and return the resulting value as a tree with type TYPE.
11816 If MIN and/or MAX are not NULL, then the supplied ARG must be
11817 within those bounds. If INCLUSIVE is true, then MIN/MAX are
11818 acceptable values, otherwise they are not. The mpfr precision is
11819 set to the precision of TYPE. We assume that function FUNC returns
11820 zero if the result could be calculated exactly within the requested
11824 do_mpfr_arg1 (tree arg
, tree type
, int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
11825 const REAL_VALUE_TYPE
*min
, const REAL_VALUE_TYPE
*max
,
11828 tree result
= NULL_TREE
;
11832 /* To proceed, MPFR must exactly represent the target floating point
11833 format, which only happens when the target base equals two. */
11834 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11835 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
11837 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
11839 if (real_isfinite (ra
)
11840 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
))
11841 && (!max
|| real_compare (inclusive
? LE_EXPR
: LT_EXPR
, ra
, max
)))
11843 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11844 const int prec
= fmt
->p
;
11845 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11849 mpfr_init2 (m
, prec
);
11850 mpfr_from_real (m
, ra
, GMP_RNDN
);
11851 mpfr_clear_flags ();
11852 inexact
= func (m
, m
, rnd
);
11853 result
= do_mpfr_ckconv (m
, type
, inexact
);
11861 /* If argument ARG is a REAL_CST, call the two-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_arg2 (tree arg1
, tree arg2
, tree type
,
11869 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
11871 tree result
= NULL_TREE
;
11876 /* To proceed, MPFR must exactly represent the target floating point
11877 format, which only happens when the target base equals two. */
11878 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11879 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
11880 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
11882 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
11883 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
11885 if (real_isfinite (ra1
) && real_isfinite (ra2
))
11887 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11888 const int prec
= fmt
->p
;
11889 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11893 mpfr_inits2 (prec
, m1
, m2
, NULL
);
11894 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
11895 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
11896 mpfr_clear_flags ();
11897 inexact
= func (m1
, m1
, m2
, rnd
);
11898 result
= do_mpfr_ckconv (m1
, type
, inexact
);
11899 mpfr_clears (m1
, m2
, NULL
);
11906 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
11907 FUNC on it and return the resulting value as a tree with type TYPE.
11908 The mpfr precision is set to the precision of TYPE. We assume that
11909 function FUNC returns zero if the result could be calculated
11910 exactly within the requested precision. */
11913 do_mpfr_arg3 (tree arg1
, tree arg2
, tree arg3
, tree type
,
11914 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
11916 tree result
= NULL_TREE
;
11922 /* To proceed, MPFR must exactly represent the target floating point
11923 format, which only happens when the target base equals two. */
11924 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11925 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
11926 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
)
11927 && TREE_CODE (arg3
) == REAL_CST
&& !TREE_OVERFLOW (arg3
))
11929 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
11930 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
11931 const REAL_VALUE_TYPE
*const ra3
= &TREE_REAL_CST (arg3
);
11933 if (real_isfinite (ra1
) && real_isfinite (ra2
) && real_isfinite (ra3
))
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
;
11941 mpfr_inits2 (prec
, m1
, m2
, m3
, NULL
);
11942 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
11943 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
11944 mpfr_from_real (m3
, ra3
, GMP_RNDN
);
11945 mpfr_clear_flags ();
11946 inexact
= func (m1
, m1
, m2
, m3
, rnd
);
11947 result
= do_mpfr_ckconv (m1
, type
, inexact
);
11948 mpfr_clears (m1
, m2
, m3
, NULL
);
11955 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
11956 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
11957 If ARG_SINP and ARG_COSP are NULL then the result is returned
11958 as a complex value.
11959 The type is taken from the type of ARG and is used for setting the
11960 precision of the calculation and results. */
11963 do_mpfr_sincos (tree arg
, tree arg_sinp
, tree arg_cosp
)
11965 tree
const type
= TREE_TYPE (arg
);
11966 tree result
= NULL_TREE
;
11970 /* To proceed, MPFR must exactly represent the target floating point
11971 format, which only happens when the target base equals two. */
11972 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11973 && TREE_CODE (arg
) == REAL_CST
11974 && !TREE_OVERFLOW (arg
))
11976 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
11978 if (real_isfinite (ra
))
11980 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11981 const int prec
= fmt
->p
;
11982 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
11983 tree result_s
, result_c
;
11987 mpfr_inits2 (prec
, m
, ms
, mc
, NULL
);
11988 mpfr_from_real (m
, ra
, GMP_RNDN
);
11989 mpfr_clear_flags ();
11990 inexact
= mpfr_sin_cos (ms
, mc
, m
, rnd
);
11991 result_s
= do_mpfr_ckconv (ms
, type
, inexact
);
11992 result_c
= do_mpfr_ckconv (mc
, type
, inexact
);
11993 mpfr_clears (m
, ms
, mc
, NULL
);
11994 if (result_s
&& result_c
)
11996 /* If we are to return in a complex value do so. */
11997 if (!arg_sinp
&& !arg_cosp
)
11998 return build_complex (build_complex_type (type
),
11999 result_c
, result_s
);
12001 /* Dereference the sin/cos pointer arguments. */
12002 arg_sinp
= build_fold_indirect_ref (arg_sinp
);
12003 arg_cosp
= build_fold_indirect_ref (arg_cosp
);
12004 /* Proceed if valid pointer type were passed in. */
12005 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp
)) == TYPE_MAIN_VARIANT (type
)
12006 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp
)) == TYPE_MAIN_VARIANT (type
))
12008 /* Set the values. */
12009 result_s
= fold_build2 (MODIFY_EXPR
, type
, arg_sinp
,
12011 TREE_SIDE_EFFECTS (result_s
) = 1;
12012 result_c
= fold_build2 (MODIFY_EXPR
, type
, arg_cosp
,
12014 TREE_SIDE_EFFECTS (result_c
) = 1;
12015 /* Combine the assignments into a compound expr. */
12016 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
12017 result_s
, result_c
));
12025 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
12026 two-argument mpfr order N Bessel function FUNC on them and return
12027 the resulting value as a tree with type TYPE. The mpfr precision
12028 is set to the precision of TYPE. We assume that function FUNC
12029 returns zero if the result could be calculated exactly within the
12030 requested precision. */
12032 do_mpfr_bessel_n (tree arg1
, tree arg2
, tree type
,
12033 int (*func
)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
12034 const REAL_VALUE_TYPE
*min
, bool inclusive
)
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_fits_shwi_p (arg1
)
12045 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
12047 const HOST_WIDE_INT n
= tree_to_shwi (arg1
);
12048 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg2
);
12051 && real_isfinite (ra
)
12052 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
)))
12054 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
12055 const int prec
= fmt
->p
;
12056 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12060 mpfr_init2 (m
, prec
);
12061 mpfr_from_real (m
, ra
, GMP_RNDN
);
12062 mpfr_clear_flags ();
12063 inexact
= func (m
, n
, m
, rnd
);
12064 result
= do_mpfr_ckconv (m
, type
, inexact
);
12072 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
12073 the pointer *(ARG_QUO) and return the result. The type is taken
12074 from the type of ARG0 and is used for setting the precision of the
12075 calculation and results. */
12078 do_mpfr_remquo (tree arg0
, tree arg1
, tree arg_quo
)
12080 tree
const type
= TREE_TYPE (arg0
);
12081 tree result
= NULL_TREE
;
12086 /* To proceed, MPFR must exactly represent the target floating point
12087 format, which only happens when the target base equals two. */
12088 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
12089 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
12090 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
))
12092 const REAL_VALUE_TYPE
*const ra0
= TREE_REAL_CST_PTR (arg0
);
12093 const REAL_VALUE_TYPE
*const ra1
= TREE_REAL_CST_PTR (arg1
);
12095 if (real_isfinite (ra0
) && real_isfinite (ra1
))
12097 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
12098 const int prec
= fmt
->p
;
12099 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12104 mpfr_inits2 (prec
, m0
, m1
, NULL
);
12105 mpfr_from_real (m0
, ra0
, GMP_RNDN
);
12106 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
12107 mpfr_clear_flags ();
12108 mpfr_remquo (m0
, &integer_quo
, m0
, m1
, rnd
);
12109 /* Remquo is independent of the rounding mode, so pass
12110 inexact=0 to do_mpfr_ckconv(). */
12111 result_rem
= do_mpfr_ckconv (m0
, type
, /*inexact=*/ 0);
12112 mpfr_clears (m0
, m1
, NULL
);
12115 /* MPFR calculates quo in the host's long so it may
12116 return more bits in quo than the target int can hold
12117 if sizeof(host long) > sizeof(target int). This can
12118 happen even for native compilers in LP64 mode. In
12119 these cases, modulo the quo value with the largest
12120 number that the target int can hold while leaving one
12121 bit for the sign. */
12122 if (sizeof (integer_quo
) * CHAR_BIT
> INT_TYPE_SIZE
)
12123 integer_quo
%= (long)(1UL << (INT_TYPE_SIZE
- 1));
12125 /* Dereference the quo pointer argument. */
12126 arg_quo
= build_fold_indirect_ref (arg_quo
);
12127 /* Proceed iff a valid pointer type was passed in. */
12128 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo
)) == integer_type_node
)
12130 /* Set the value. */
12132 = fold_build2 (MODIFY_EXPR
, TREE_TYPE (arg_quo
), arg_quo
,
12133 build_int_cst (TREE_TYPE (arg_quo
),
12135 TREE_SIDE_EFFECTS (result_quo
) = 1;
12136 /* Combine the quo assignment with the rem. */
12137 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
12138 result_quo
, result_rem
));
12146 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
12147 resulting value as a tree with type TYPE. The mpfr precision is
12148 set to the precision of TYPE. We assume that this mpfr function
12149 returns zero if the result could be calculated exactly within the
12150 requested precision. In addition, the integer pointer represented
12151 by ARG_SG will be dereferenced and set to the appropriate signgam
12155 do_mpfr_lgamma_r (tree arg
, tree arg_sg
, tree type
)
12157 tree result
= NULL_TREE
;
12161 /* To proceed, MPFR must exactly represent the target floating point
12162 format, which only happens when the target base equals two. Also
12163 verify ARG is a constant and that ARG_SG is an int pointer. */
12164 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
12165 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
)
12166 && TREE_CODE (TREE_TYPE (arg_sg
)) == POINTER_TYPE
12167 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg
))) == integer_type_node
)
12169 const REAL_VALUE_TYPE
*const ra
= TREE_REAL_CST_PTR (arg
);
12171 /* In addition to NaN and Inf, the argument cannot be zero or a
12172 negative integer. */
12173 if (real_isfinite (ra
)
12174 && ra
->cl
!= rvc_zero
12175 && !(real_isneg (ra
) && real_isinteger (ra
, TYPE_MODE (type
))))
12177 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
12178 const int prec
= fmt
->p
;
12179 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12184 mpfr_init2 (m
, prec
);
12185 mpfr_from_real (m
, ra
, GMP_RNDN
);
12186 mpfr_clear_flags ();
12187 inexact
= mpfr_lgamma (m
, &sg
, m
, rnd
);
12188 result_lg
= do_mpfr_ckconv (m
, type
, inexact
);
12194 /* Dereference the arg_sg pointer argument. */
12195 arg_sg
= build_fold_indirect_ref (arg_sg
);
12196 /* Assign the signgam value into *arg_sg. */
12197 result_sg
= fold_build2 (MODIFY_EXPR
,
12198 TREE_TYPE (arg_sg
), arg_sg
,
12199 build_int_cst (TREE_TYPE (arg_sg
), sg
));
12200 TREE_SIDE_EFFECTS (result_sg
) = 1;
12201 /* Combine the signgam assignment with the lgamma result. */
12202 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
12203 result_sg
, result_lg
));
12211 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
12212 function FUNC on it and return the resulting value as a tree with
12213 type TYPE. The mpfr precision is set to the precision of TYPE. We
12214 assume that function FUNC returns zero if the result could be
12215 calculated exactly within the requested precision. */
12218 do_mpc_arg1 (tree arg
, tree type
, int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
))
12220 tree result
= NULL_TREE
;
12224 /* To proceed, MPFR must exactly represent the target floating point
12225 format, which only happens when the target base equals two. */
12226 if (TREE_CODE (arg
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg
)
12227 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
12228 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg
))))->b
== 2)
12230 const REAL_VALUE_TYPE
*const re
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
12231 const REAL_VALUE_TYPE
*const im
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
12233 if (real_isfinite (re
) && real_isfinite (im
))
12235 const struct real_format
*const fmt
=
12236 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
12237 const int prec
= fmt
->p
;
12238 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12239 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
12243 mpc_init2 (m
, prec
);
12244 mpfr_from_real (mpc_realref (m
), re
, rnd
);
12245 mpfr_from_real (mpc_imagref (m
), im
, rnd
);
12246 mpfr_clear_flags ();
12247 inexact
= func (m
, m
, crnd
);
12248 result
= do_mpc_ckconv (m
, type
, inexact
, /*force_convert=*/ 0);
12256 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
12257 mpc function FUNC on it and return the resulting value as a tree
12258 with type TYPE. The mpfr precision is set to the precision of
12259 TYPE. We assume that function FUNC returns zero if the result
12260 could be calculated exactly within the requested precision. If
12261 DO_NONFINITE is true, then fold expressions containing Inf or NaN
12262 in the arguments and/or results. */
12265 do_mpc_arg2 (tree arg0
, tree arg1
, tree type
, int do_nonfinite
,
12266 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
))
12268 tree result
= NULL_TREE
;
12273 /* To proceed, MPFR must exactly represent the target floating point
12274 format, which only happens when the target base equals two. */
12275 if (TREE_CODE (arg0
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg0
)
12276 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
12277 && TREE_CODE (arg1
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg1
)
12278 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
12279 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0
))))->b
== 2)
12281 const REAL_VALUE_TYPE
*const re0
= TREE_REAL_CST_PTR (TREE_REALPART (arg0
));
12282 const REAL_VALUE_TYPE
*const im0
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg0
));
12283 const REAL_VALUE_TYPE
*const re1
= TREE_REAL_CST_PTR (TREE_REALPART (arg1
));
12284 const REAL_VALUE_TYPE
*const im1
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg1
));
12287 || (real_isfinite (re0
) && real_isfinite (im0
)
12288 && real_isfinite (re1
) && real_isfinite (im1
)))
12290 const struct real_format
*const fmt
=
12291 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
12292 const int prec
= fmt
->p
;
12293 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
12294 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
12298 mpc_init2 (m0
, prec
);
12299 mpc_init2 (m1
, prec
);
12300 mpfr_from_real (mpc_realref (m0
), re0
, rnd
);
12301 mpfr_from_real (mpc_imagref (m0
), im0
, rnd
);
12302 mpfr_from_real (mpc_realref (m1
), re1
, rnd
);
12303 mpfr_from_real (mpc_imagref (m1
), im1
, rnd
);
12304 mpfr_clear_flags ();
12305 inexact
= func (m0
, m0
, m1
, crnd
);
12306 result
= do_mpc_ckconv (m0
, type
, inexact
, do_nonfinite
);
12315 /* A wrapper function for builtin folding that prevents warnings for
12316 "statement without effect" and the like, caused by removing the
12317 call node earlier than the warning is generated. */
12320 fold_call_stmt (gcall
*stmt
, bool ignore
)
12322 tree ret
= NULL_TREE
;
12323 tree fndecl
= gimple_call_fndecl (stmt
);
12324 location_t loc
= gimple_location (stmt
);
12326 && TREE_CODE (fndecl
) == FUNCTION_DECL
12327 && DECL_BUILT_IN (fndecl
)
12328 && !gimple_call_va_arg_pack_p (stmt
))
12330 int nargs
= gimple_call_num_args (stmt
);
12331 tree
*args
= (nargs
> 0
12332 ? gimple_call_arg_ptr (stmt
, 0)
12333 : &error_mark_node
);
12335 if (avoid_folding_inline_builtin (fndecl
))
12337 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
12339 return targetm
.fold_builtin (fndecl
, nargs
, args
, ignore
);
12343 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
12346 /* Propagate location information from original call to
12347 expansion of builtin. Otherwise things like
12348 maybe_emit_chk_warning, that operate on the expansion
12349 of a builtin, will use the wrong location information. */
12350 if (gimple_has_location (stmt
))
12352 tree realret
= ret
;
12353 if (TREE_CODE (ret
) == NOP_EXPR
)
12354 realret
= TREE_OPERAND (ret
, 0);
12355 if (CAN_HAVE_LOCATION_P (realret
)
12356 && !EXPR_HAS_LOCATION (realret
))
12357 SET_EXPR_LOCATION (realret
, loc
);
12367 /* Look up the function in builtin_decl that corresponds to DECL
12368 and set ASMSPEC as its user assembler name. DECL must be a
12369 function decl that declares a builtin. */
12372 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
12375 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
12376 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
12379 builtin
= builtin_decl_explicit (DECL_FUNCTION_CODE (decl
));
12380 set_user_assembler_name (builtin
, asmspec
);
12381 switch (DECL_FUNCTION_CODE (decl
))
12383 case BUILT_IN_MEMCPY
:
12384 init_block_move_fn (asmspec
);
12385 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
12387 case BUILT_IN_MEMSET
:
12388 init_block_clear_fn (asmspec
);
12389 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
12391 case BUILT_IN_MEMMOVE
:
12392 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
12394 case BUILT_IN_MEMCMP
:
12395 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
12397 case BUILT_IN_ABORT
:
12398 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
12401 if (INT_TYPE_SIZE
< BITS_PER_WORD
)
12403 set_user_assembler_libfunc ("ffs", asmspec
);
12404 set_optab_libfunc (ffs_optab
, mode_for_size (INT_TYPE_SIZE
,
12405 MODE_INT
, 0), "ffs");
12413 /* Return true if DECL is a builtin that expands to a constant or similarly
12416 is_simple_builtin (tree decl
)
12418 if (decl
&& DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
12419 switch (DECL_FUNCTION_CODE (decl
))
12421 /* Builtins that expand to constants. */
12422 case BUILT_IN_CONSTANT_P
:
12423 case BUILT_IN_EXPECT
:
12424 case BUILT_IN_OBJECT_SIZE
:
12425 case BUILT_IN_UNREACHABLE
:
12426 /* Simple register moves or loads from stack. */
12427 case BUILT_IN_ASSUME_ALIGNED
:
12428 case BUILT_IN_RETURN_ADDRESS
:
12429 case BUILT_IN_EXTRACT_RETURN_ADDR
:
12430 case BUILT_IN_FROB_RETURN_ADDR
:
12431 case BUILT_IN_RETURN
:
12432 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
12433 case BUILT_IN_FRAME_ADDRESS
:
12434 case BUILT_IN_VA_END
:
12435 case BUILT_IN_STACK_SAVE
:
12436 case BUILT_IN_STACK_RESTORE
:
12437 /* Exception state returns or moves registers around. */
12438 case BUILT_IN_EH_FILTER
:
12439 case BUILT_IN_EH_POINTER
:
12440 case BUILT_IN_EH_COPY_VALUES
:
12450 /* Return true if DECL is a builtin that is not expensive, i.e., they are
12451 most probably expanded inline into reasonably simple code. This is a
12452 superset of is_simple_builtin. */
12454 is_inexpensive_builtin (tree decl
)
12458 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_MD
)
12460 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
12461 switch (DECL_FUNCTION_CODE (decl
))
12464 case BUILT_IN_ALLOCA
:
12465 case BUILT_IN_ALLOCA_WITH_ALIGN
:
12466 case BUILT_IN_BSWAP16
:
12467 case BUILT_IN_BSWAP32
:
12468 case BUILT_IN_BSWAP64
:
12470 case BUILT_IN_CLZIMAX
:
12471 case BUILT_IN_CLZL
:
12472 case BUILT_IN_CLZLL
:
12474 case BUILT_IN_CTZIMAX
:
12475 case BUILT_IN_CTZL
:
12476 case BUILT_IN_CTZLL
:
12478 case BUILT_IN_FFSIMAX
:
12479 case BUILT_IN_FFSL
:
12480 case BUILT_IN_FFSLL
:
12481 case BUILT_IN_IMAXABS
:
12482 case BUILT_IN_FINITE
:
12483 case BUILT_IN_FINITEF
:
12484 case BUILT_IN_FINITEL
:
12485 case BUILT_IN_FINITED32
:
12486 case BUILT_IN_FINITED64
:
12487 case BUILT_IN_FINITED128
:
12488 case BUILT_IN_FPCLASSIFY
:
12489 case BUILT_IN_ISFINITE
:
12490 case BUILT_IN_ISINF_SIGN
:
12491 case BUILT_IN_ISINF
:
12492 case BUILT_IN_ISINFF
:
12493 case BUILT_IN_ISINFL
:
12494 case BUILT_IN_ISINFD32
:
12495 case BUILT_IN_ISINFD64
:
12496 case BUILT_IN_ISINFD128
:
12497 case BUILT_IN_ISNAN
:
12498 case BUILT_IN_ISNANF
:
12499 case BUILT_IN_ISNANL
:
12500 case BUILT_IN_ISNAND32
:
12501 case BUILT_IN_ISNAND64
:
12502 case BUILT_IN_ISNAND128
:
12503 case BUILT_IN_ISNORMAL
:
12504 case BUILT_IN_ISGREATER
:
12505 case BUILT_IN_ISGREATEREQUAL
:
12506 case BUILT_IN_ISLESS
:
12507 case BUILT_IN_ISLESSEQUAL
:
12508 case BUILT_IN_ISLESSGREATER
:
12509 case BUILT_IN_ISUNORDERED
:
12510 case BUILT_IN_VA_ARG_PACK
:
12511 case BUILT_IN_VA_ARG_PACK_LEN
:
12512 case BUILT_IN_VA_COPY
:
12513 case BUILT_IN_TRAP
:
12514 case BUILT_IN_SAVEREGS
:
12515 case BUILT_IN_POPCOUNTL
:
12516 case BUILT_IN_POPCOUNTLL
:
12517 case BUILT_IN_POPCOUNTIMAX
:
12518 case BUILT_IN_POPCOUNT
:
12519 case BUILT_IN_PARITYL
:
12520 case BUILT_IN_PARITYLL
:
12521 case BUILT_IN_PARITYIMAX
:
12522 case BUILT_IN_PARITY
:
12523 case BUILT_IN_LABS
:
12524 case BUILT_IN_LLABS
:
12525 case BUILT_IN_PREFETCH
:
12526 case BUILT_IN_ACC_ON_DEVICE
:
12530 return is_simple_builtin (decl
);