1 /* Expand builtin functions.
2 Copyright (C) 1988-2014 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"
27 #include "stringpool.h"
28 #include "stor-layout.h"
31 #include "tree-object-size.h"
33 #include "basic-block.h"
34 #include "tree-ssa-alias.h"
35 #include "internal-fn.h"
36 #include "gimple-expr.h"
41 #include "hard-reg-set.h"
44 #include "insn-config.h"
50 #include "typeclass.h"
54 #include "langhooks.h"
55 #include "tree-ssanames.h"
57 #include "value-prof.h"
58 #include "diagnostic-core.h"
64 static tree
do_mpc_arg1 (tree
, tree
, int (*)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
));
66 struct target_builtins default_target_builtins
;
68 struct target_builtins
*this_target_builtins
= &default_target_builtins
;
71 /* Define the names of the builtin function types and codes. */
72 const char *const built_in_class_names
[BUILT_IN_LAST
]
73 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
75 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
76 const char * built_in_names
[(int) END_BUILTINS
] =
78 #include "builtins.def"
82 /* Setup an array of _DECL trees, make sure each element is
83 initialized to NULL_TREE. */
84 builtin_info_type builtin_info
;
86 /* Non-zero if __builtin_constant_p should be folded right away. */
87 bool force_folding_builtin_constant_p
;
89 static const char *c_getstr (tree
);
90 static rtx
c_readstr (const char *, enum machine_mode
);
91 static int target_char_cast (tree
, char *);
92 static rtx
get_memory_rtx (tree
, tree
);
93 static int apply_args_size (void);
94 static int apply_result_size (void);
95 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
96 static rtx
result_vector (int, rtx
);
98 static void expand_builtin_update_setjmp_buf (rtx
);
99 static void expand_builtin_prefetch (tree
);
100 static rtx
expand_builtin_apply_args (void);
101 static rtx
expand_builtin_apply_args_1 (void);
102 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
103 static void expand_builtin_return (rtx
);
104 static enum type_class
type_to_class (tree
);
105 static rtx
expand_builtin_classify_type (tree
);
106 static void expand_errno_check (tree
, rtx
);
107 static rtx
expand_builtin_mathfn (tree
, rtx
, rtx
);
108 static rtx
expand_builtin_mathfn_2 (tree
, rtx
, rtx
);
109 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
110 static rtx
expand_builtin_mathfn_ternary (tree
, rtx
, rtx
);
111 static rtx
expand_builtin_interclass_mathfn (tree
, rtx
);
112 static rtx
expand_builtin_sincos (tree
);
113 static rtx
expand_builtin_cexpi (tree
, rtx
);
114 static rtx
expand_builtin_int_roundingfn (tree
, rtx
);
115 static rtx
expand_builtin_int_roundingfn_2 (tree
, rtx
);
116 static rtx
expand_builtin_next_arg (void);
117 static rtx
expand_builtin_va_start (tree
);
118 static rtx
expand_builtin_va_end (tree
);
119 static rtx
expand_builtin_va_copy (tree
);
120 static rtx
expand_builtin_memcmp (tree
, rtx
, enum machine_mode
);
121 static rtx
expand_builtin_strcmp (tree
, rtx
);
122 static rtx
expand_builtin_strncmp (tree
, rtx
, enum machine_mode
);
123 static rtx
builtin_memcpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
124 static rtx
expand_builtin_memcpy (tree
, rtx
);
125 static rtx
expand_builtin_mempcpy (tree
, rtx
, enum machine_mode
);
126 static rtx
expand_builtin_mempcpy_args (tree
, tree
, tree
, rtx
,
127 enum machine_mode
, int);
128 static rtx
expand_builtin_strcpy (tree
, rtx
);
129 static rtx
expand_builtin_strcpy_args (tree
, tree
, rtx
);
130 static rtx
expand_builtin_stpcpy (tree
, rtx
, enum machine_mode
);
131 static rtx
expand_builtin_strncpy (tree
, rtx
);
132 static rtx
builtin_memset_gen_str (void *, HOST_WIDE_INT
, enum machine_mode
);
133 static rtx
expand_builtin_memset (tree
, rtx
, enum machine_mode
);
134 static rtx
expand_builtin_memset_args (tree
, tree
, tree
, rtx
, enum machine_mode
, tree
);
135 static rtx
expand_builtin_bzero (tree
);
136 static rtx
expand_builtin_strlen (tree
, rtx
, enum machine_mode
);
137 static rtx
expand_builtin_alloca (tree
, bool);
138 static rtx
expand_builtin_unop (enum machine_mode
, tree
, rtx
, rtx
, optab
);
139 static rtx
expand_builtin_frame_address (tree
, tree
);
140 static tree
stabilize_va_list_loc (location_t
, tree
, int);
141 static rtx
expand_builtin_expect (tree
, rtx
);
142 static tree
fold_builtin_constant_p (tree
);
143 static tree
fold_builtin_classify_type (tree
);
144 static tree
fold_builtin_strlen (location_t
, tree
, tree
);
145 static tree
fold_builtin_inf (location_t
, tree
, int);
146 static tree
fold_builtin_nan (tree
, tree
, int);
147 static tree
rewrite_call_expr (location_t
, tree
, int, tree
, int, ...);
148 static bool validate_arg (const_tree
, enum tree_code code
);
149 static bool integer_valued_real_p (tree
);
150 static tree
fold_trunc_transparent_mathfn (location_t
, tree
, tree
);
151 static bool readonly_data_expr (tree
);
152 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
153 static rtx
expand_builtin_signbit (tree
, rtx
);
154 static tree
fold_builtin_sqrt (location_t
, tree
, tree
);
155 static tree
fold_builtin_cbrt (location_t
, tree
, tree
);
156 static tree
fold_builtin_pow (location_t
, tree
, tree
, tree
, tree
);
157 static tree
fold_builtin_powi (location_t
, tree
, tree
, tree
, tree
);
158 static tree
fold_builtin_cos (location_t
, tree
, tree
, tree
);
159 static tree
fold_builtin_cosh (location_t
, tree
, tree
, tree
);
160 static tree
fold_builtin_tan (tree
, tree
);
161 static tree
fold_builtin_trunc (location_t
, tree
, tree
);
162 static tree
fold_builtin_floor (location_t
, tree
, tree
);
163 static tree
fold_builtin_ceil (location_t
, tree
, tree
);
164 static tree
fold_builtin_round (location_t
, tree
, tree
);
165 static tree
fold_builtin_int_roundingfn (location_t
, tree
, tree
);
166 static tree
fold_builtin_bitop (tree
, tree
);
167 static tree
fold_builtin_memory_op (location_t
, tree
, tree
, tree
, tree
, bool, int);
168 static tree
fold_builtin_strchr (location_t
, tree
, tree
, tree
);
169 static tree
fold_builtin_memchr (location_t
, tree
, tree
, tree
, tree
);
170 static tree
fold_builtin_memcmp (location_t
, tree
, tree
, tree
);
171 static tree
fold_builtin_strcmp (location_t
, tree
, tree
);
172 static tree
fold_builtin_strncmp (location_t
, tree
, tree
, tree
);
173 static tree
fold_builtin_signbit (location_t
, tree
, tree
);
174 static tree
fold_builtin_copysign (location_t
, tree
, tree
, tree
, tree
);
175 static tree
fold_builtin_isascii (location_t
, tree
);
176 static tree
fold_builtin_toascii (location_t
, tree
);
177 static tree
fold_builtin_isdigit (location_t
, tree
);
178 static tree
fold_builtin_fabs (location_t
, tree
, tree
);
179 static tree
fold_builtin_abs (location_t
, tree
, tree
);
180 static tree
fold_builtin_unordered_cmp (location_t
, tree
, tree
, tree
, enum tree_code
,
182 static tree
fold_builtin_n (location_t
, tree
, tree
*, int, bool);
183 static tree
fold_builtin_0 (location_t
, tree
, bool);
184 static tree
fold_builtin_1 (location_t
, tree
, tree
, bool);
185 static tree
fold_builtin_2 (location_t
, tree
, tree
, tree
, bool);
186 static tree
fold_builtin_3 (location_t
, tree
, tree
, tree
, tree
, bool);
187 static tree
fold_builtin_4 (location_t
, tree
, tree
, tree
, tree
, tree
, bool);
188 static tree
fold_builtin_varargs (location_t
, tree
, tree
, bool);
190 static tree
fold_builtin_strpbrk (location_t
, tree
, tree
, tree
);
191 static tree
fold_builtin_strstr (location_t
, tree
, tree
, tree
);
192 static tree
fold_builtin_strrchr (location_t
, tree
, tree
, tree
);
193 static tree
fold_builtin_strncat (location_t
, tree
, tree
, tree
);
194 static tree
fold_builtin_strspn (location_t
, tree
, tree
);
195 static tree
fold_builtin_strcspn (location_t
, tree
, tree
);
196 static tree
fold_builtin_sprintf (location_t
, tree
, tree
, tree
, int);
197 static tree
fold_builtin_snprintf (location_t
, tree
, tree
, tree
, tree
, int);
199 static rtx
expand_builtin_object_size (tree
);
200 static rtx
expand_builtin_memory_chk (tree
, rtx
, enum machine_mode
,
201 enum built_in_function
);
202 static void maybe_emit_chk_warning (tree
, enum built_in_function
);
203 static void maybe_emit_sprintf_chk_warning (tree
, enum built_in_function
);
204 static void maybe_emit_free_warning (tree
);
205 static tree
fold_builtin_object_size (tree
, tree
);
206 static tree
fold_builtin_strcat_chk (location_t
, tree
, tree
, tree
, tree
);
207 static tree
fold_builtin_strncat_chk (location_t
, tree
, tree
, tree
, tree
, tree
);
208 static tree
fold_builtin_sprintf_chk (location_t
, tree
, enum built_in_function
);
209 static tree
fold_builtin_printf (location_t
, tree
, tree
, tree
, bool, enum built_in_function
);
210 static tree
fold_builtin_fprintf (location_t
, tree
, tree
, tree
, tree
, bool,
211 enum built_in_function
);
212 static bool init_target_chars (void);
214 static unsigned HOST_WIDE_INT target_newline
;
215 static unsigned HOST_WIDE_INT target_percent
;
216 static unsigned HOST_WIDE_INT target_c
;
217 static unsigned HOST_WIDE_INT target_s
;
218 static char target_percent_c
[3];
219 static char target_percent_s
[3];
220 static char target_percent_s_newline
[4];
221 static tree
do_mpfr_arg1 (tree
, tree
, int (*)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
222 const REAL_VALUE_TYPE
*, const REAL_VALUE_TYPE
*, bool);
223 static tree
do_mpfr_arg2 (tree
, tree
, tree
,
224 int (*)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
));
225 static tree
do_mpfr_arg3 (tree
, tree
, tree
, tree
,
226 int (*)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
));
227 static tree
do_mpfr_sincos (tree
, tree
, tree
);
228 static tree
do_mpfr_bessel_n (tree
, tree
, tree
,
229 int (*)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
230 const REAL_VALUE_TYPE
*, bool);
231 static tree
do_mpfr_remquo (tree
, tree
, tree
);
232 static tree
do_mpfr_lgamma_r (tree
, tree
, tree
);
233 static void expand_builtin_sync_synchronize (void);
235 /* Return true if NAME starts with __builtin_ or __sync_. */
238 is_builtin_name (const char *name
)
240 if (strncmp (name
, "__builtin_", 10) == 0)
242 if (strncmp (name
, "__sync_", 7) == 0)
244 if (strncmp (name
, "__atomic_", 9) == 0)
247 && (!strcmp (name
, "__cilkrts_detach")
248 || !strcmp (name
, "__cilkrts_pop_frame")))
254 /* Return true if DECL is a function symbol representing a built-in. */
257 is_builtin_fn (tree decl
)
259 return TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
);
262 /* By default we assume that c99 functions are present at the runtime,
263 but sincos is not. */
265 default_libc_has_function (enum function_class fn_class
)
267 if (fn_class
== function_c94
268 || fn_class
== function_c99_misc
269 || fn_class
== function_c99_math_complex
)
276 gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED
)
282 no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED
)
287 /* Return true if NODE should be considered for inline expansion regardless
288 of the optimization level. This means whenever a function is invoked with
289 its "internal" name, which normally contains the prefix "__builtin". */
292 called_as_built_in (tree node
)
294 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
295 we want the name used to call the function, not the name it
297 const char *name
= IDENTIFIER_POINTER (DECL_NAME (node
));
298 return is_builtin_name (name
);
301 /* Compute values M and N such that M divides (address of EXP - N) and such
302 that N < M. If these numbers can be determined, store M in alignp and N in
303 *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to
304 *alignp and any bit-offset to *bitposp.
306 Note that the address (and thus the alignment) computed here is based
307 on the address to which a symbol resolves, whereas DECL_ALIGN is based
308 on the address at which an object is actually located. These two
309 addresses are not always the same. For example, on ARM targets,
310 the address &foo of a Thumb function foo() has the lowest bit set,
311 whereas foo() itself starts on an even address.
313 If ADDR_P is true we are taking the address of the memory reference EXP
314 and thus cannot rely on the access taking place. */
317 get_object_alignment_2 (tree exp
, unsigned int *alignp
,
318 unsigned HOST_WIDE_INT
*bitposp
, bool addr_p
)
320 HOST_WIDE_INT bitsize
, bitpos
;
322 enum machine_mode mode
;
323 int unsignedp
, volatilep
;
324 unsigned int align
= BITS_PER_UNIT
;
325 bool known_alignment
= false;
327 /* Get the innermost object and the constant (bitpos) and possibly
328 variable (offset) offset of the access. */
329 exp
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
330 &mode
, &unsignedp
, &volatilep
, true);
332 /* Extract alignment information from the innermost object and
333 possibly adjust bitpos and offset. */
334 if (TREE_CODE (exp
) == FUNCTION_DECL
)
336 /* Function addresses can encode extra information besides their
337 alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
338 allows the low bit to be used as a virtual bit, we know
339 that the address itself must be at least 2-byte aligned. */
340 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
)
341 align
= 2 * BITS_PER_UNIT
;
343 else if (TREE_CODE (exp
) == LABEL_DECL
)
345 else if (TREE_CODE (exp
) == CONST_DECL
)
347 /* The alignment of a CONST_DECL is determined by its initializer. */
348 exp
= DECL_INITIAL (exp
);
349 align
= TYPE_ALIGN (TREE_TYPE (exp
));
350 #ifdef CONSTANT_ALIGNMENT
351 if (CONSTANT_CLASS_P (exp
))
352 align
= (unsigned) CONSTANT_ALIGNMENT (exp
, align
);
354 known_alignment
= true;
356 else if (DECL_P (exp
))
358 align
= DECL_ALIGN (exp
);
359 known_alignment
= true;
361 else if (TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
363 align
= TYPE_ALIGN (TREE_TYPE (exp
));
365 else if (TREE_CODE (exp
) == INDIRECT_REF
366 || TREE_CODE (exp
) == MEM_REF
367 || TREE_CODE (exp
) == TARGET_MEM_REF
)
369 tree addr
= TREE_OPERAND (exp
, 0);
371 unsigned HOST_WIDE_INT ptr_bitpos
;
373 if (TREE_CODE (addr
) == BIT_AND_EXPR
374 && TREE_CODE (TREE_OPERAND (addr
, 1)) == INTEGER_CST
)
376 align
= (TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1))
377 & -TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1)));
378 align
*= BITS_PER_UNIT
;
379 addr
= TREE_OPERAND (addr
, 0);
383 = get_pointer_alignment_1 (addr
, &ptr_align
, &ptr_bitpos
);
384 align
= MAX (ptr_align
, align
);
386 /* The alignment of the pointer operand in a TARGET_MEM_REF
387 has to take the variable offset parts into account. */
388 if (TREE_CODE (exp
) == TARGET_MEM_REF
)
392 unsigned HOST_WIDE_INT step
= 1;
394 step
= TREE_INT_CST_LOW (TMR_STEP (exp
));
395 align
= MIN (align
, (step
& -step
) * BITS_PER_UNIT
);
397 if (TMR_INDEX2 (exp
))
398 align
= BITS_PER_UNIT
;
399 known_alignment
= false;
402 /* When EXP is an actual memory reference then we can use
403 TYPE_ALIGN of a pointer indirection to derive alignment.
404 Do so only if get_pointer_alignment_1 did not reveal absolute
405 alignment knowledge and if using that alignment would
406 improve the situation. */
407 if (!addr_p
&& !known_alignment
408 && TYPE_ALIGN (TREE_TYPE (exp
)) > align
)
409 align
= TYPE_ALIGN (TREE_TYPE (exp
));
412 /* Else adjust bitpos accordingly. */
413 bitpos
+= ptr_bitpos
;
414 if (TREE_CODE (exp
) == MEM_REF
415 || TREE_CODE (exp
) == TARGET_MEM_REF
)
416 bitpos
+= mem_ref_offset (exp
).low
* BITS_PER_UNIT
;
419 else if (TREE_CODE (exp
) == STRING_CST
)
421 /* STRING_CST are the only constant objects we allow to be not
422 wrapped inside a CONST_DECL. */
423 align
= TYPE_ALIGN (TREE_TYPE (exp
));
424 #ifdef CONSTANT_ALIGNMENT
425 if (CONSTANT_CLASS_P (exp
))
426 align
= (unsigned) CONSTANT_ALIGNMENT (exp
, align
);
428 known_alignment
= true;
431 /* If there is a non-constant offset part extract the maximum
432 alignment that can prevail. */
435 unsigned int trailing_zeros
= tree_ctz (offset
);
436 if (trailing_zeros
< HOST_BITS_PER_INT
)
438 unsigned int inner
= (1U << trailing_zeros
) * BITS_PER_UNIT
;
440 align
= MIN (align
, inner
);
445 *bitposp
= bitpos
& (*alignp
- 1);
446 return known_alignment
;
449 /* For a memory reference expression EXP compute values M and N such that M
450 divides (&EXP - N) and such that N < M. If these numbers can be determined,
451 store M in alignp and N in *BITPOSP and return true. Otherwise return false
452 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
455 get_object_alignment_1 (tree exp
, unsigned int *alignp
,
456 unsigned HOST_WIDE_INT
*bitposp
)
458 return get_object_alignment_2 (exp
, alignp
, bitposp
, false);
461 /* Return the alignment in bits of EXP, an object. */
464 get_object_alignment (tree exp
)
466 unsigned HOST_WIDE_INT bitpos
= 0;
469 get_object_alignment_1 (exp
, &align
, &bitpos
);
471 /* align and bitpos now specify known low bits of the pointer.
472 ptr & (align - 1) == bitpos. */
475 align
= (bitpos
& -bitpos
);
479 /* For a pointer valued expression EXP compute values M and N such that M
480 divides (EXP - N) and such that N < M. If these numbers can be determined,
481 store M in alignp and N in *BITPOSP and return true. Return false if
482 the results are just a conservative approximation.
484 If EXP is not a pointer, false is returned too. */
487 get_pointer_alignment_1 (tree exp
, unsigned int *alignp
,
488 unsigned HOST_WIDE_INT
*bitposp
)
492 if (TREE_CODE (exp
) == ADDR_EXPR
)
493 return get_object_alignment_2 (TREE_OPERAND (exp
, 0),
494 alignp
, bitposp
, true);
495 else if (TREE_CODE (exp
) == SSA_NAME
496 && POINTER_TYPE_P (TREE_TYPE (exp
)))
498 unsigned int ptr_align
, ptr_misalign
;
499 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (exp
);
501 if (pi
&& get_ptr_info_alignment (pi
, &ptr_align
, &ptr_misalign
))
503 *bitposp
= ptr_misalign
* BITS_PER_UNIT
;
504 *alignp
= ptr_align
* BITS_PER_UNIT
;
505 /* We cannot really tell whether this result is an approximation. */
511 *alignp
= BITS_PER_UNIT
;
515 else if (TREE_CODE (exp
) == INTEGER_CST
)
517 *alignp
= BIGGEST_ALIGNMENT
;
518 *bitposp
= ((TREE_INT_CST_LOW (exp
) * BITS_PER_UNIT
)
519 & (BIGGEST_ALIGNMENT
- 1));
524 *alignp
= BITS_PER_UNIT
;
528 /* Return the alignment in bits of EXP, a pointer valued expression.
529 The alignment returned is, by default, the alignment of the thing that
530 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
532 Otherwise, look at the expression to see if we can do better, i.e., if the
533 expression is actually pointing at an object whose alignment is tighter. */
536 get_pointer_alignment (tree exp
)
538 unsigned HOST_WIDE_INT bitpos
= 0;
541 get_pointer_alignment_1 (exp
, &align
, &bitpos
);
543 /* align and bitpos now specify known low bits of the pointer.
544 ptr & (align - 1) == bitpos. */
547 align
= (bitpos
& -bitpos
);
552 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
553 way, because it could contain a zero byte in the middle.
554 TREE_STRING_LENGTH is the size of the character array, not the string.
556 ONLY_VALUE should be nonzero if the result is not going to be emitted
557 into the instruction stream and zero if it is going to be expanded.
558 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
559 is returned, otherwise NULL, since
560 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
561 evaluate the side-effects.
563 The value returned is of type `ssizetype'.
565 Unfortunately, string_constant can't access the values of const char
566 arrays with initializers, so neither can we do so here. */
569 c_strlen (tree src
, int only_value
)
572 HOST_WIDE_INT offset
;
578 if (TREE_CODE (src
) == COND_EXPR
579 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
583 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
584 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
585 if (tree_int_cst_equal (len1
, len2
))
589 if (TREE_CODE (src
) == COMPOUND_EXPR
590 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
591 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
593 loc
= EXPR_LOC_OR_LOC (src
, input_location
);
595 src
= string_constant (src
, &offset_node
);
599 max
= TREE_STRING_LENGTH (src
) - 1;
600 ptr
= TREE_STRING_POINTER (src
);
602 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
604 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
605 compute the offset to the following null if we don't know where to
606 start searching for it. */
609 for (i
= 0; i
< max
; i
++)
613 /* We don't know the starting offset, but we do know that the string
614 has no internal zero bytes. We can assume that the offset falls
615 within the bounds of the string; otherwise, the programmer deserves
616 what he gets. Subtract the offset from the length of the string,
617 and return that. This would perhaps not be valid if we were dealing
618 with named arrays in addition to literal string constants. */
620 return size_diffop_loc (loc
, size_int (max
), offset_node
);
623 /* We have a known offset into the string. Start searching there for
624 a null character if we can represent it as a single HOST_WIDE_INT. */
625 if (offset_node
== 0)
627 else if (! tree_fits_shwi_p (offset_node
))
630 offset
= tree_to_shwi (offset_node
);
632 /* If the offset is known to be out of bounds, warn, and call strlen at
634 if (offset
< 0 || offset
> max
)
636 /* Suppress multiple warnings for propagated constant strings. */
637 if (! TREE_NO_WARNING (src
))
639 warning_at (loc
, 0, "offset outside bounds of constant string");
640 TREE_NO_WARNING (src
) = 1;
645 /* Use strlen to search for the first zero byte. Since any strings
646 constructed with build_string will have nulls appended, we win even
647 if we get handed something like (char[4])"abcd".
649 Since OFFSET is our starting index into the string, no further
650 calculation is needed. */
651 return ssize_int (strlen (ptr
+ offset
));
654 /* Return a char pointer for a C string if it is a string constant
655 or sum of string constant and integer constant. */
662 src
= string_constant (src
, &offset_node
);
666 if (offset_node
== 0)
667 return TREE_STRING_POINTER (src
);
668 else if (!tree_fits_uhwi_p (offset_node
)
669 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
672 return TREE_STRING_POINTER (src
) + tree_to_uhwi (offset_node
);
675 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
676 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
679 c_readstr (const char *str
, enum machine_mode mode
)
685 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
690 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
693 if (WORDS_BIG_ENDIAN
)
694 j
= GET_MODE_SIZE (mode
) - i
- 1;
695 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
696 && GET_MODE_SIZE (mode
) >= UNITS_PER_WORD
)
697 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
699 gcc_assert (j
< HOST_BITS_PER_DOUBLE_INT
);
702 ch
= (unsigned char) str
[i
];
703 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
705 return immed_double_const (c
[0], c
[1], mode
);
708 /* Cast a target constant CST to target CHAR and if that value fits into
709 host char type, return zero and put that value into variable pointed to by
713 target_char_cast (tree cst
, char *p
)
715 unsigned HOST_WIDE_INT val
, hostval
;
717 if (TREE_CODE (cst
) != INTEGER_CST
718 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
721 val
= TREE_INT_CST_LOW (cst
);
722 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
723 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
726 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
727 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
736 /* Similar to save_expr, but assumes that arbitrary code is not executed
737 in between the multiple evaluations. In particular, we assume that a
738 non-addressable local variable will not be modified. */
741 builtin_save_expr (tree exp
)
743 if (TREE_CODE (exp
) == SSA_NAME
744 || (TREE_ADDRESSABLE (exp
) == 0
745 && (TREE_CODE (exp
) == PARM_DECL
746 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
)))))
749 return save_expr (exp
);
752 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
753 times to get the address of either a higher stack frame, or a return
754 address located within it (depending on FNDECL_CODE). */
757 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
761 #ifdef INITIAL_FRAME_ADDRESS_RTX
762 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
766 /* For a zero count with __builtin_return_address, we don't care what
767 frame address we return, because target-specific definitions will
768 override us. Therefore frame pointer elimination is OK, and using
769 the soft frame pointer is OK.
771 For a nonzero count, or a zero count with __builtin_frame_address,
772 we require a stable offset from the current frame pointer to the
773 previous one, so we must use the hard frame pointer, and
774 we must disable frame pointer elimination. */
775 if (count
== 0 && fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
776 tem
= frame_pointer_rtx
;
779 tem
= hard_frame_pointer_rtx
;
781 /* Tell reload not to eliminate the frame pointer. */
782 crtl
->accesses_prior_frames
= 1;
786 /* Some machines need special handling before we can access
787 arbitrary frames. For example, on the SPARC, we must first flush
788 all register windows to the stack. */
789 #ifdef SETUP_FRAME_ADDRESSES
791 SETUP_FRAME_ADDRESSES ();
794 /* On the SPARC, the return address is not in the frame, it is in a
795 register. There is no way to access it off of the current frame
796 pointer, but it can be accessed off the previous frame pointer by
797 reading the value from the register window save area. */
798 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
799 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
803 /* Scan back COUNT frames to the specified frame. */
804 for (i
= 0; i
< count
; i
++)
806 /* Assume the dynamic chain pointer is in the word that the
807 frame address points to, unless otherwise specified. */
808 #ifdef DYNAMIC_CHAIN_ADDRESS
809 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
811 tem
= memory_address (Pmode
, tem
);
812 tem
= gen_frame_mem (Pmode
, tem
);
813 tem
= copy_to_reg (tem
);
816 /* For __builtin_frame_address, return what we've got. But, on
817 the SPARC for example, we may have to add a bias. */
818 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
819 #ifdef FRAME_ADDR_RTX
820 return FRAME_ADDR_RTX (tem
);
825 /* For __builtin_return_address, get the return address from that frame. */
826 #ifdef RETURN_ADDR_RTX
827 tem
= RETURN_ADDR_RTX (count
, tem
);
829 tem
= memory_address (Pmode
,
830 plus_constant (Pmode
, tem
, GET_MODE_SIZE (Pmode
)));
831 tem
= gen_frame_mem (Pmode
, tem
);
836 /* Alias set used for setjmp buffer. */
837 static alias_set_type setjmp_alias_set
= -1;
839 /* Construct the leading half of a __builtin_setjmp call. Control will
840 return to RECEIVER_LABEL. This is also called directly by the SJLJ
841 exception handling code. */
844 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
846 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
850 if (setjmp_alias_set
== -1)
851 setjmp_alias_set
= new_alias_set ();
853 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
855 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
857 /* We store the frame pointer and the address of receiver_label in
858 the buffer and use the rest of it for the stack save area, which
859 is machine-dependent. */
861 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
862 set_mem_alias_set (mem
, setjmp_alias_set
);
863 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
865 mem
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
866 GET_MODE_SIZE (Pmode
))),
867 set_mem_alias_set (mem
, setjmp_alias_set
);
869 emit_move_insn (validize_mem (mem
),
870 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
872 stack_save
= gen_rtx_MEM (sa_mode
,
873 plus_constant (Pmode
, buf_addr
,
874 2 * GET_MODE_SIZE (Pmode
)));
875 set_mem_alias_set (stack_save
, setjmp_alias_set
);
876 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
878 /* If there is further processing to do, do it. */
879 #ifdef HAVE_builtin_setjmp_setup
880 if (HAVE_builtin_setjmp_setup
)
881 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
884 /* We have a nonlocal label. */
885 cfun
->has_nonlocal_label
= 1;
888 /* Construct the trailing part of a __builtin_setjmp call. This is
889 also called directly by the SJLJ exception handling code.
890 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
893 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
897 /* Mark the FP as used when we get here, so we have to make sure it's
898 marked as used by this function. */
899 emit_use (hard_frame_pointer_rtx
);
901 /* Mark the static chain as clobbered here so life information
902 doesn't get messed up for it. */
903 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
904 if (chain
&& REG_P (chain
))
905 emit_clobber (chain
);
907 /* Now put in the code to restore the frame pointer, and argument
908 pointer, if needed. */
909 #ifdef HAVE_nonlocal_goto
910 if (! HAVE_nonlocal_goto
)
913 /* First adjust our frame pointer to its actual value. It was
914 previously set to the start of the virtual area corresponding to
915 the stacked variables when we branched here and now needs to be
916 adjusted to the actual hardware fp value.
918 Assignments to virtual registers are converted by
919 instantiate_virtual_regs into the corresponding assignment
920 to the underlying register (fp in this case) that makes
921 the original assignment true.
922 So the following insn will actually be decrementing fp by
923 STARTING_FRAME_OFFSET. */
924 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
926 /* Restoring the frame pointer also modifies the hard frame pointer.
927 Mark it used (so that the previous assignment remains live once
928 the frame pointer is eliminated) and clobbered (to represent the
929 implicit update from the assignment). */
930 emit_use (hard_frame_pointer_rtx
);
931 emit_clobber (hard_frame_pointer_rtx
);
934 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
935 if (fixed_regs
[ARG_POINTER_REGNUM
])
937 #ifdef ELIMINABLE_REGS
938 /* If the argument pointer can be eliminated in favor of the
939 frame pointer, we don't need to restore it. We assume here
940 that if such an elimination is present, it can always be used.
941 This is the case on all known machines; if we don't make this
942 assumption, we do unnecessary saving on many machines. */
944 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
946 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
947 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
948 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
951 if (i
== ARRAY_SIZE (elim_regs
))
954 /* Now restore our arg pointer from the address at which it
955 was saved in our stack frame. */
956 emit_move_insn (crtl
->args
.internal_arg_pointer
,
957 copy_to_reg (get_arg_pointer_save_area ()));
962 #ifdef HAVE_builtin_setjmp_receiver
963 if (receiver_label
!= NULL
&& HAVE_builtin_setjmp_receiver
)
964 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
967 #ifdef HAVE_nonlocal_goto_receiver
968 if (HAVE_nonlocal_goto_receiver
)
969 emit_insn (gen_nonlocal_goto_receiver ());
974 /* We must not allow the code we just generated to be reordered by
975 scheduling. Specifically, the update of the frame pointer must
976 happen immediately, not later. */
977 emit_insn (gen_blockage ());
980 /* __builtin_longjmp is passed a pointer to an array of five words (not
981 all will be used on all machines). It operates similarly to the C
982 library function of the same name, but is more efficient. Much of
983 the code below is copied from the handling of non-local gotos. */
986 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
988 rtx fp
, lab
, stack
, insn
, last
;
989 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
991 /* DRAP is needed for stack realign if longjmp is expanded to current
993 if (SUPPORTS_STACK_ALIGNMENT
)
994 crtl
->need_drap
= true;
996 if (setjmp_alias_set
== -1)
997 setjmp_alias_set
= new_alias_set ();
999 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
1001 buf_addr
= force_reg (Pmode
, buf_addr
);
1003 /* We require that the user must pass a second argument of 1, because
1004 that is what builtin_setjmp will return. */
1005 gcc_assert (value
== const1_rtx
);
1007 last
= get_last_insn ();
1008 #ifdef HAVE_builtin_longjmp
1009 if (HAVE_builtin_longjmp
)
1010 emit_insn (gen_builtin_longjmp (buf_addr
));
1014 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
1015 lab
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
1016 GET_MODE_SIZE (Pmode
)));
1018 stack
= gen_rtx_MEM (sa_mode
, plus_constant (Pmode
, buf_addr
,
1019 2 * GET_MODE_SIZE (Pmode
)));
1020 set_mem_alias_set (fp
, setjmp_alias_set
);
1021 set_mem_alias_set (lab
, setjmp_alias_set
);
1022 set_mem_alias_set (stack
, setjmp_alias_set
);
1024 /* Pick up FP, label, and SP from the block and jump. This code is
1025 from expand_goto in stmt.c; see there for detailed comments. */
1026 #ifdef HAVE_nonlocal_goto
1027 if (HAVE_nonlocal_goto
)
1028 /* We have to pass a value to the nonlocal_goto pattern that will
1029 get copied into the static_chain pointer, but it does not matter
1030 what that value is, because builtin_setjmp does not use it. */
1031 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
1035 lab
= copy_to_reg (lab
);
1037 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1038 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1040 emit_move_insn (hard_frame_pointer_rtx
, fp
);
1041 emit_stack_restore (SAVE_NONLOCAL
, stack
);
1043 emit_use (hard_frame_pointer_rtx
);
1044 emit_use (stack_pointer_rtx
);
1045 emit_indirect_jump (lab
);
1049 /* Search backwards and mark the jump insn as a non-local goto.
1050 Note that this precludes the use of __builtin_longjmp to a
1051 __builtin_setjmp target in the same function. However, we've
1052 already cautioned the user that these functions are for
1053 internal exception handling use only. */
1054 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1056 gcc_assert (insn
!= last
);
1060 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1063 else if (CALL_P (insn
))
1069 more_const_call_expr_args_p (const const_call_expr_arg_iterator
*iter
)
1071 return (iter
->i
< iter
->n
);
1074 /* This function validates the types of a function call argument list
1075 against a specified list of tree_codes. If the last specifier is a 0,
1076 that represents an ellipses, otherwise the last specifier must be a
1080 validate_arglist (const_tree callexpr
, ...)
1082 enum tree_code code
;
1085 const_call_expr_arg_iterator iter
;
1088 va_start (ap
, callexpr
);
1089 init_const_call_expr_arg_iterator (callexpr
, &iter
);
1093 code
= (enum tree_code
) va_arg (ap
, int);
1097 /* This signifies an ellipses, any further arguments are all ok. */
1101 /* This signifies an endlink, if no arguments remain, return
1102 true, otherwise return false. */
1103 res
= !more_const_call_expr_args_p (&iter
);
1106 /* If no parameters remain or the parameter's code does not
1107 match the specified code, return false. Otherwise continue
1108 checking any remaining arguments. */
1109 arg
= next_const_call_expr_arg (&iter
);
1110 if (!validate_arg (arg
, code
))
1117 /* We need gotos here since we can only have one VA_CLOSE in a
1125 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1126 and the address of the save area. */
1129 expand_builtin_nonlocal_goto (tree exp
)
1131 tree t_label
, t_save_area
;
1132 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
1134 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1137 t_label
= CALL_EXPR_ARG (exp
, 0);
1138 t_save_area
= CALL_EXPR_ARG (exp
, 1);
1140 r_label
= expand_normal (t_label
);
1141 r_label
= convert_memory_address (Pmode
, r_label
);
1142 r_save_area
= expand_normal (t_save_area
);
1143 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
1144 /* Copy the address of the save location to a register just in case it was
1145 based on the frame pointer. */
1146 r_save_area
= copy_to_reg (r_save_area
);
1147 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
1148 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
1149 plus_constant (Pmode
, r_save_area
,
1150 GET_MODE_SIZE (Pmode
)));
1152 crtl
->has_nonlocal_goto
= 1;
1154 #ifdef HAVE_nonlocal_goto
1155 /* ??? We no longer need to pass the static chain value, afaik. */
1156 if (HAVE_nonlocal_goto
)
1157 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
1161 r_label
= copy_to_reg (r_label
);
1163 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1164 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1166 /* Restore frame pointer for containing function. */
1167 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
1168 emit_stack_restore (SAVE_NONLOCAL
, r_sp
);
1170 /* USE of hard_frame_pointer_rtx added for consistency;
1171 not clear if really needed. */
1172 emit_use (hard_frame_pointer_rtx
);
1173 emit_use (stack_pointer_rtx
);
1175 /* If the architecture is using a GP register, we must
1176 conservatively assume that the target function makes use of it.
1177 The prologue of functions with nonlocal gotos must therefore
1178 initialize the GP register to the appropriate value, and we
1179 must then make sure that this value is live at the point
1180 of the jump. (Note that this doesn't necessarily apply
1181 to targets with a nonlocal_goto pattern; they are free
1182 to implement it in their own way. Note also that this is
1183 a no-op if the GP register is a global invariant.) */
1184 if ((unsigned) PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
1185 && fixed_regs
[PIC_OFFSET_TABLE_REGNUM
])
1186 emit_use (pic_offset_table_rtx
);
1188 emit_indirect_jump (r_label
);
1191 /* Search backwards to the jump insn and mark it as a
1193 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1197 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1200 else if (CALL_P (insn
))
1207 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1208 (not all will be used on all machines) that was passed to __builtin_setjmp.
1209 It updates the stack pointer in that block to correspond to the current
1213 expand_builtin_update_setjmp_buf (rtx buf_addr
)
1215 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
1217 = gen_rtx_MEM (sa_mode
,
1220 plus_constant (Pmode
, buf_addr
,
1221 2 * GET_MODE_SIZE (Pmode
))));
1223 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
1226 /* Expand a call to __builtin_prefetch. For a target that does not support
1227 data prefetch, evaluate the memory address argument in case it has side
1231 expand_builtin_prefetch (tree exp
)
1233 tree arg0
, arg1
, arg2
;
1237 if (!validate_arglist (exp
, POINTER_TYPE
, 0))
1240 arg0
= CALL_EXPR_ARG (exp
, 0);
1242 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1243 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1245 nargs
= call_expr_nargs (exp
);
1247 arg1
= CALL_EXPR_ARG (exp
, 1);
1249 arg1
= integer_zero_node
;
1251 arg2
= CALL_EXPR_ARG (exp
, 2);
1253 arg2
= integer_three_node
;
1255 /* Argument 0 is an address. */
1256 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
1258 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1259 if (TREE_CODE (arg1
) != INTEGER_CST
)
1261 error ("second argument to %<__builtin_prefetch%> must be a constant");
1262 arg1
= integer_zero_node
;
1264 op1
= expand_normal (arg1
);
1265 /* Argument 1 must be either zero or one. */
1266 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
1268 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1273 /* Argument 2 (locality) must be a compile-time constant int. */
1274 if (TREE_CODE (arg2
) != INTEGER_CST
)
1276 error ("third argument to %<__builtin_prefetch%> must be a constant");
1277 arg2
= integer_zero_node
;
1279 op2
= expand_normal (arg2
);
1280 /* Argument 2 must be 0, 1, 2, or 3. */
1281 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
1283 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1287 #ifdef HAVE_prefetch
1290 struct expand_operand ops
[3];
1292 create_address_operand (&ops
[0], op0
);
1293 create_integer_operand (&ops
[1], INTVAL (op1
));
1294 create_integer_operand (&ops
[2], INTVAL (op2
));
1295 if (maybe_expand_insn (CODE_FOR_prefetch
, 3, ops
))
1300 /* Don't do anything with direct references to volatile memory, but
1301 generate code to handle other side effects. */
1302 if (!MEM_P (op0
) && side_effects_p (op0
))
1306 /* Get a MEM rtx for expression EXP which is the address of an operand
1307 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1308 the maximum length of the block of memory that might be accessed or
1312 get_memory_rtx (tree exp
, tree len
)
1314 tree orig_exp
= exp
;
1317 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1318 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1319 if (TREE_CODE (exp
) == SAVE_EXPR
&& !SAVE_EXPR_RESOLVED_P (exp
))
1320 exp
= TREE_OPERAND (exp
, 0);
1322 addr
= expand_expr (orig_exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1323 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1325 /* Get an expression we can use to find the attributes to assign to MEM.
1326 First remove any nops. */
1327 while (CONVERT_EXPR_P (exp
)
1328 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1329 exp
= TREE_OPERAND (exp
, 0);
1331 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1332 (as builtin stringops may alias with anything). */
1333 exp
= fold_build2 (MEM_REF
,
1334 build_array_type (char_type_node
,
1335 build_range_type (sizetype
,
1336 size_one_node
, len
)),
1337 exp
, build_int_cst (ptr_type_node
, 0));
1339 /* If the MEM_REF has no acceptable address, try to get the base object
1340 from the original address we got, and build an all-aliasing
1341 unknown-sized access to that one. */
1342 if (is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
1343 set_mem_attributes (mem
, exp
, 0);
1344 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
1345 && (exp
= get_base_address (TREE_OPERAND (TREE_OPERAND (exp
, 0),
1348 exp
= build_fold_addr_expr (exp
);
1349 exp
= fold_build2 (MEM_REF
,
1350 build_array_type (char_type_node
,
1351 build_range_type (sizetype
,
1354 exp
, build_int_cst (ptr_type_node
, 0));
1355 set_mem_attributes (mem
, exp
, 0);
1357 set_mem_alias_set (mem
, 0);
1361 /* Built-in functions to perform an untyped call and return. */
1363 #define apply_args_mode \
1364 (this_target_builtins->x_apply_args_mode)
1365 #define apply_result_mode \
1366 (this_target_builtins->x_apply_result_mode)
1368 /* Return the size required for the block returned by __builtin_apply_args,
1369 and initialize apply_args_mode. */
1372 apply_args_size (void)
1374 static int size
= -1;
1377 enum machine_mode mode
;
1379 /* The values computed by this function never change. */
1382 /* The first value is the incoming arg-pointer. */
1383 size
= GET_MODE_SIZE (Pmode
);
1385 /* The second value is the structure value address unless this is
1386 passed as an "invisible" first argument. */
1387 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1388 size
+= GET_MODE_SIZE (Pmode
);
1390 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1391 if (FUNCTION_ARG_REGNO_P (regno
))
1393 mode
= targetm
.calls
.get_raw_arg_mode (regno
);
1395 gcc_assert (mode
!= VOIDmode
);
1397 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1398 if (size
% align
!= 0)
1399 size
= CEIL (size
, align
) * align
;
1400 size
+= GET_MODE_SIZE (mode
);
1401 apply_args_mode
[regno
] = mode
;
1405 apply_args_mode
[regno
] = VOIDmode
;
1411 /* Return the size required for the block returned by __builtin_apply,
1412 and initialize apply_result_mode. */
1415 apply_result_size (void)
1417 static int size
= -1;
1419 enum machine_mode mode
;
1421 /* The values computed by this function never change. */
1426 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1427 if (targetm
.calls
.function_value_regno_p (regno
))
1429 mode
= targetm
.calls
.get_raw_result_mode (regno
);
1431 gcc_assert (mode
!= VOIDmode
);
1433 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1434 if (size
% align
!= 0)
1435 size
= CEIL (size
, align
) * align
;
1436 size
+= GET_MODE_SIZE (mode
);
1437 apply_result_mode
[regno
] = mode
;
1440 apply_result_mode
[regno
] = VOIDmode
;
1442 /* Allow targets that use untyped_call and untyped_return to override
1443 the size so that machine-specific information can be stored here. */
1444 #ifdef APPLY_RESULT_SIZE
1445 size
= APPLY_RESULT_SIZE
;
1451 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1452 /* Create a vector describing the result block RESULT. If SAVEP is true,
1453 the result block is used to save the values; otherwise it is used to
1454 restore the values. */
1457 result_vector (int savep
, rtx result
)
1459 int regno
, size
, align
, nelts
;
1460 enum machine_mode mode
;
1462 rtx
*savevec
= XALLOCAVEC (rtx
, FIRST_PSEUDO_REGISTER
);
1465 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1466 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1468 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1469 if (size
% align
!= 0)
1470 size
= CEIL (size
, align
) * align
;
1471 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1472 mem
= adjust_address (result
, mode
, size
);
1473 savevec
[nelts
++] = (savep
1474 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1475 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1476 size
+= GET_MODE_SIZE (mode
);
1478 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1480 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1482 /* Save the state required to perform an untyped call with the same
1483 arguments as were passed to the current function. */
1486 expand_builtin_apply_args_1 (void)
1489 int size
, align
, regno
;
1490 enum machine_mode mode
;
1491 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1493 /* Create a block where the arg-pointer, structure value address,
1494 and argument registers can be saved. */
1495 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1497 /* Walk past the arg-pointer and structure value address. */
1498 size
= GET_MODE_SIZE (Pmode
);
1499 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1500 size
+= GET_MODE_SIZE (Pmode
);
1502 /* Save each register used in calling a function to the block. */
1503 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1504 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1506 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1507 if (size
% align
!= 0)
1508 size
= CEIL (size
, align
) * align
;
1510 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1512 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1513 size
+= GET_MODE_SIZE (mode
);
1516 /* Save the arg pointer to the block. */
1517 tem
= copy_to_reg (crtl
->args
.internal_arg_pointer
);
1518 #ifdef STACK_GROWS_DOWNWARD
1519 /* We need the pointer as the caller actually passed them to us, not
1520 as we might have pretended they were passed. Make sure it's a valid
1521 operand, as emit_move_insn isn't expected to handle a PLUS. */
1523 = force_operand (plus_constant (Pmode
, tem
, crtl
->args
.pretend_args_size
),
1526 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1528 size
= GET_MODE_SIZE (Pmode
);
1530 /* Save the structure value address unless this is passed as an
1531 "invisible" first argument. */
1532 if (struct_incoming_value
)
1534 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1535 copy_to_reg (struct_incoming_value
));
1536 size
+= GET_MODE_SIZE (Pmode
);
1539 /* Return the address of the block. */
1540 return copy_addr_to_reg (XEXP (registers
, 0));
1543 /* __builtin_apply_args returns block of memory allocated on
1544 the stack into which is stored the arg pointer, structure
1545 value address, static chain, and all the registers that might
1546 possibly be used in performing a function call. The code is
1547 moved to the start of the function so the incoming values are
1551 expand_builtin_apply_args (void)
1553 /* Don't do __builtin_apply_args more than once in a function.
1554 Save the result of the first call and reuse it. */
1555 if (apply_args_value
!= 0)
1556 return apply_args_value
;
1558 /* When this function is called, it means that registers must be
1559 saved on entry to this function. So we migrate the
1560 call to the first insn of this function. */
1565 temp
= expand_builtin_apply_args_1 ();
1569 apply_args_value
= temp
;
1571 /* Put the insns after the NOTE that starts the function.
1572 If this is inside a start_sequence, make the outer-level insn
1573 chain current, so the code is placed at the start of the
1574 function. If internal_arg_pointer is a non-virtual pseudo,
1575 it needs to be placed after the function that initializes
1577 push_topmost_sequence ();
1578 if (REG_P (crtl
->args
.internal_arg_pointer
)
1579 && REGNO (crtl
->args
.internal_arg_pointer
) > LAST_VIRTUAL_REGISTER
)
1580 emit_insn_before (seq
, parm_birth_insn
);
1582 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1583 pop_topmost_sequence ();
1588 /* Perform an untyped call and save the state required to perform an
1589 untyped return of whatever value was returned by the given function. */
1592 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1594 int size
, align
, regno
;
1595 enum machine_mode mode
;
1596 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1597 rtx old_stack_level
= 0;
1598 rtx call_fusage
= 0;
1599 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1601 arguments
= convert_memory_address (Pmode
, arguments
);
1603 /* Create a block where the return registers can be saved. */
1604 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1606 /* Fetch the arg pointer from the ARGUMENTS block. */
1607 incoming_args
= gen_reg_rtx (Pmode
);
1608 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1609 #ifndef STACK_GROWS_DOWNWARD
1610 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1611 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1614 /* Push a new argument block and copy the arguments. Do not allow
1615 the (potential) memcpy call below to interfere with our stack
1617 do_pending_stack_adjust ();
1620 /* Save the stack with nonlocal if available. */
1621 #ifdef HAVE_save_stack_nonlocal
1622 if (HAVE_save_stack_nonlocal
)
1623 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
);
1626 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
1628 /* Allocate a block of memory onto the stack and copy the memory
1629 arguments to the outgoing arguments address. We can pass TRUE
1630 as the 4th argument because we just saved the stack pointer
1631 and will restore it right after the call. */
1632 allocate_dynamic_stack_space (argsize
, 0, BIGGEST_ALIGNMENT
, true);
1634 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1635 may have already set current_function_calls_alloca to true.
1636 current_function_calls_alloca won't be set if argsize is zero,
1637 so we have to guarantee need_drap is true here. */
1638 if (SUPPORTS_STACK_ALIGNMENT
)
1639 crtl
->need_drap
= true;
1641 dest
= virtual_outgoing_args_rtx
;
1642 #ifndef STACK_GROWS_DOWNWARD
1643 if (CONST_INT_P (argsize
))
1644 dest
= plus_constant (Pmode
, dest
, -INTVAL (argsize
));
1646 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1648 dest
= gen_rtx_MEM (BLKmode
, dest
);
1649 set_mem_align (dest
, PARM_BOUNDARY
);
1650 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1651 set_mem_align (src
, PARM_BOUNDARY
);
1652 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1654 /* Refer to the argument block. */
1656 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1657 set_mem_align (arguments
, PARM_BOUNDARY
);
1659 /* Walk past the arg-pointer and structure value address. */
1660 size
= GET_MODE_SIZE (Pmode
);
1662 size
+= GET_MODE_SIZE (Pmode
);
1664 /* Restore each of the registers previously saved. Make USE insns
1665 for each of these registers for use in making the call. */
1666 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1667 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1669 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1670 if (size
% align
!= 0)
1671 size
= CEIL (size
, align
) * align
;
1672 reg
= gen_rtx_REG (mode
, regno
);
1673 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1674 use_reg (&call_fusage
, reg
);
1675 size
+= GET_MODE_SIZE (mode
);
1678 /* Restore the structure value address unless this is passed as an
1679 "invisible" first argument. */
1680 size
= GET_MODE_SIZE (Pmode
);
1683 rtx value
= gen_reg_rtx (Pmode
);
1684 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1685 emit_move_insn (struct_value
, value
);
1686 if (REG_P (struct_value
))
1687 use_reg (&call_fusage
, struct_value
);
1688 size
+= GET_MODE_SIZE (Pmode
);
1691 /* All arguments and registers used for the call are set up by now! */
1692 function
= prepare_call_address (NULL
, function
, NULL
, &call_fusage
, 0, 0);
1694 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1695 and we don't want to load it into a register as an optimization,
1696 because prepare_call_address already did it if it should be done. */
1697 if (GET_CODE (function
) != SYMBOL_REF
)
1698 function
= memory_address (FUNCTION_MODE
, function
);
1700 /* Generate the actual call instruction and save the return value. */
1701 #ifdef HAVE_untyped_call
1702 if (HAVE_untyped_call
)
1703 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1704 result
, result_vector (1, result
)));
1707 #ifdef HAVE_call_value
1708 if (HAVE_call_value
)
1712 /* Locate the unique return register. It is not possible to
1713 express a call that sets more than one return register using
1714 call_value; use untyped_call for that. In fact, untyped_call
1715 only needs to save the return registers in the given block. */
1716 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1717 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1719 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1721 valreg
= gen_rtx_REG (mode
, regno
);
1724 emit_call_insn (GEN_CALL_VALUE (valreg
,
1725 gen_rtx_MEM (FUNCTION_MODE
, function
),
1726 const0_rtx
, NULL_RTX
, const0_rtx
));
1728 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1734 /* Find the CALL insn we just emitted, and attach the register usage
1736 call_insn
= last_call_insn ();
1737 add_function_usage_to (call_insn
, call_fusage
);
1739 /* Restore the stack. */
1740 #ifdef HAVE_save_stack_nonlocal
1741 if (HAVE_save_stack_nonlocal
)
1742 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
);
1745 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
1746 fixup_args_size_notes (call_insn
, get_last_insn (), 0);
1750 /* Return the address of the result block. */
1751 result
= copy_addr_to_reg (XEXP (result
, 0));
1752 return convert_memory_address (ptr_mode
, result
);
1755 /* Perform an untyped return. */
1758 expand_builtin_return (rtx result
)
1760 int size
, align
, regno
;
1761 enum machine_mode mode
;
1763 rtx call_fusage
= 0;
1765 result
= convert_memory_address (Pmode
, result
);
1767 apply_result_size ();
1768 result
= gen_rtx_MEM (BLKmode
, result
);
1770 #ifdef HAVE_untyped_return
1771 if (HAVE_untyped_return
)
1773 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1779 /* Restore the return value and note that each value is used. */
1781 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1782 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1784 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1785 if (size
% align
!= 0)
1786 size
= CEIL (size
, align
) * align
;
1787 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1788 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1790 push_to_sequence (call_fusage
);
1792 call_fusage
= get_insns ();
1794 size
+= GET_MODE_SIZE (mode
);
1797 /* Put the USE insns before the return. */
1798 emit_insn (call_fusage
);
1800 /* Return whatever values was restored by jumping directly to the end
1802 expand_naked_return ();
1805 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1807 static enum type_class
1808 type_to_class (tree type
)
1810 switch (TREE_CODE (type
))
1812 case VOID_TYPE
: return void_type_class
;
1813 case INTEGER_TYPE
: return integer_type_class
;
1814 case ENUMERAL_TYPE
: return enumeral_type_class
;
1815 case BOOLEAN_TYPE
: return boolean_type_class
;
1816 case POINTER_TYPE
: return pointer_type_class
;
1817 case REFERENCE_TYPE
: return reference_type_class
;
1818 case OFFSET_TYPE
: return offset_type_class
;
1819 case REAL_TYPE
: return real_type_class
;
1820 case COMPLEX_TYPE
: return complex_type_class
;
1821 case FUNCTION_TYPE
: return function_type_class
;
1822 case METHOD_TYPE
: return method_type_class
;
1823 case RECORD_TYPE
: return record_type_class
;
1825 case QUAL_UNION_TYPE
: return union_type_class
;
1826 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1827 ? string_type_class
: array_type_class
);
1828 case LANG_TYPE
: return lang_type_class
;
1829 default: return no_type_class
;
1833 /* Expand a call EXP to __builtin_classify_type. */
1836 expand_builtin_classify_type (tree exp
)
1838 if (call_expr_nargs (exp
))
1839 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))));
1840 return GEN_INT (no_type_class
);
1843 /* This helper macro, meant to be used in mathfn_built_in below,
1844 determines which among a set of three builtin math functions is
1845 appropriate for a given type mode. The `F' and `L' cases are
1846 automatically generated from the `double' case. */
1847 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1848 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1849 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1850 fcodel = BUILT_IN_MATHFN##L ; break;
1851 /* Similar to above, but appends _R after any F/L suffix. */
1852 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1853 case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1854 fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1855 fcodel = BUILT_IN_MATHFN##L_R ; break;
1857 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1858 if available. If IMPLICIT is true use the implicit builtin declaration,
1859 otherwise use the explicit declaration. If we can't do the conversion,
1863 mathfn_built_in_1 (tree type
, enum built_in_function fn
, bool implicit_p
)
1865 enum built_in_function fcode
, fcodef
, fcodel
, fcode2
;
1869 CASE_MATHFN (BUILT_IN_ACOS
)
1870 CASE_MATHFN (BUILT_IN_ACOSH
)
1871 CASE_MATHFN (BUILT_IN_ASIN
)
1872 CASE_MATHFN (BUILT_IN_ASINH
)
1873 CASE_MATHFN (BUILT_IN_ATAN
)
1874 CASE_MATHFN (BUILT_IN_ATAN2
)
1875 CASE_MATHFN (BUILT_IN_ATANH
)
1876 CASE_MATHFN (BUILT_IN_CBRT
)
1877 CASE_MATHFN (BUILT_IN_CEIL
)
1878 CASE_MATHFN (BUILT_IN_CEXPI
)
1879 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1880 CASE_MATHFN (BUILT_IN_COS
)
1881 CASE_MATHFN (BUILT_IN_COSH
)
1882 CASE_MATHFN (BUILT_IN_DREM
)
1883 CASE_MATHFN (BUILT_IN_ERF
)
1884 CASE_MATHFN (BUILT_IN_ERFC
)
1885 CASE_MATHFN (BUILT_IN_EXP
)
1886 CASE_MATHFN (BUILT_IN_EXP10
)
1887 CASE_MATHFN (BUILT_IN_EXP2
)
1888 CASE_MATHFN (BUILT_IN_EXPM1
)
1889 CASE_MATHFN (BUILT_IN_FABS
)
1890 CASE_MATHFN (BUILT_IN_FDIM
)
1891 CASE_MATHFN (BUILT_IN_FLOOR
)
1892 CASE_MATHFN (BUILT_IN_FMA
)
1893 CASE_MATHFN (BUILT_IN_FMAX
)
1894 CASE_MATHFN (BUILT_IN_FMIN
)
1895 CASE_MATHFN (BUILT_IN_FMOD
)
1896 CASE_MATHFN (BUILT_IN_FREXP
)
1897 CASE_MATHFN (BUILT_IN_GAMMA
)
1898 CASE_MATHFN_REENT (BUILT_IN_GAMMA
) /* GAMMA_R */
1899 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1900 CASE_MATHFN (BUILT_IN_HYPOT
)
1901 CASE_MATHFN (BUILT_IN_ILOGB
)
1902 CASE_MATHFN (BUILT_IN_ICEIL
)
1903 CASE_MATHFN (BUILT_IN_IFLOOR
)
1904 CASE_MATHFN (BUILT_IN_INF
)
1905 CASE_MATHFN (BUILT_IN_IRINT
)
1906 CASE_MATHFN (BUILT_IN_IROUND
)
1907 CASE_MATHFN (BUILT_IN_ISINF
)
1908 CASE_MATHFN (BUILT_IN_J0
)
1909 CASE_MATHFN (BUILT_IN_J1
)
1910 CASE_MATHFN (BUILT_IN_JN
)
1911 CASE_MATHFN (BUILT_IN_LCEIL
)
1912 CASE_MATHFN (BUILT_IN_LDEXP
)
1913 CASE_MATHFN (BUILT_IN_LFLOOR
)
1914 CASE_MATHFN (BUILT_IN_LGAMMA
)
1915 CASE_MATHFN_REENT (BUILT_IN_LGAMMA
) /* LGAMMA_R */
1916 CASE_MATHFN (BUILT_IN_LLCEIL
)
1917 CASE_MATHFN (BUILT_IN_LLFLOOR
)
1918 CASE_MATHFN (BUILT_IN_LLRINT
)
1919 CASE_MATHFN (BUILT_IN_LLROUND
)
1920 CASE_MATHFN (BUILT_IN_LOG
)
1921 CASE_MATHFN (BUILT_IN_LOG10
)
1922 CASE_MATHFN (BUILT_IN_LOG1P
)
1923 CASE_MATHFN (BUILT_IN_LOG2
)
1924 CASE_MATHFN (BUILT_IN_LOGB
)
1925 CASE_MATHFN (BUILT_IN_LRINT
)
1926 CASE_MATHFN (BUILT_IN_LROUND
)
1927 CASE_MATHFN (BUILT_IN_MODF
)
1928 CASE_MATHFN (BUILT_IN_NAN
)
1929 CASE_MATHFN (BUILT_IN_NANS
)
1930 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1931 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1932 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1933 CASE_MATHFN (BUILT_IN_POW
)
1934 CASE_MATHFN (BUILT_IN_POWI
)
1935 CASE_MATHFN (BUILT_IN_POW10
)
1936 CASE_MATHFN (BUILT_IN_REMAINDER
)
1937 CASE_MATHFN (BUILT_IN_REMQUO
)
1938 CASE_MATHFN (BUILT_IN_RINT
)
1939 CASE_MATHFN (BUILT_IN_ROUND
)
1940 CASE_MATHFN (BUILT_IN_SCALB
)
1941 CASE_MATHFN (BUILT_IN_SCALBLN
)
1942 CASE_MATHFN (BUILT_IN_SCALBN
)
1943 CASE_MATHFN (BUILT_IN_SIGNBIT
)
1944 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1945 CASE_MATHFN (BUILT_IN_SIN
)
1946 CASE_MATHFN (BUILT_IN_SINCOS
)
1947 CASE_MATHFN (BUILT_IN_SINH
)
1948 CASE_MATHFN (BUILT_IN_SQRT
)
1949 CASE_MATHFN (BUILT_IN_TAN
)
1950 CASE_MATHFN (BUILT_IN_TANH
)
1951 CASE_MATHFN (BUILT_IN_TGAMMA
)
1952 CASE_MATHFN (BUILT_IN_TRUNC
)
1953 CASE_MATHFN (BUILT_IN_Y0
)
1954 CASE_MATHFN (BUILT_IN_Y1
)
1955 CASE_MATHFN (BUILT_IN_YN
)
1961 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1963 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1965 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1970 if (implicit_p
&& !builtin_decl_implicit_p (fcode2
))
1973 return builtin_decl_explicit (fcode2
);
1976 /* Like mathfn_built_in_1(), but always use the implicit array. */
1979 mathfn_built_in (tree type
, enum built_in_function fn
)
1981 return mathfn_built_in_1 (type
, fn
, /*implicit=*/ 1);
1984 /* If errno must be maintained, expand the RTL to check if the result,
1985 TARGET, of a built-in function call, EXP, is NaN, and if so set
1989 expand_errno_check (tree exp
, rtx target
)
1991 rtx lab
= gen_label_rtx ();
1993 /* Test the result; if it is NaN, set errno=EDOM because
1994 the argument was not in the domain. */
1995 do_compare_rtx_and_jump (target
, target
, EQ
, 0, GET_MODE (target
),
1996 NULL_RTX
, NULL_RTX
, lab
,
1997 /* The jump is very likely. */
1998 REG_BR_PROB_BASE
- (REG_BR_PROB_BASE
/ 2000 - 1));
2001 /* If this built-in doesn't throw an exception, set errno directly. */
2002 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp
), 0)))
2004 #ifdef GEN_ERRNO_RTX
2005 rtx errno_rtx
= GEN_ERRNO_RTX
;
2008 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
2010 emit_move_insn (errno_rtx
,
2011 gen_int_mode (TARGET_EDOM
, GET_MODE (errno_rtx
)));
2017 /* Make sure the library call isn't expanded as a tail call. */
2018 CALL_EXPR_TAILCALL (exp
) = 0;
2020 /* We can't set errno=EDOM directly; let the library call do it.
2021 Pop the arguments right away in case the call gets deleted. */
2023 expand_call (exp
, target
, 0);
2028 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
2029 Return NULL_RTX if a normal call should be emitted rather than expanding
2030 the function in-line. EXP is the expression that is a call to the builtin
2031 function; if convenient, the result should be placed in TARGET.
2032 SUBTARGET may be used as the target for computing one of EXP's operands. */
2035 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
2037 optab builtin_optab
;
2039 tree fndecl
= get_callee_fndecl (exp
);
2040 enum machine_mode mode
;
2041 bool errno_set
= false;
2042 bool try_widening
= false;
2045 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2048 arg
= CALL_EXPR_ARG (exp
, 0);
2050 switch (DECL_FUNCTION_CODE (fndecl
))
2052 CASE_FLT_FN (BUILT_IN_SQRT
):
2053 errno_set
= ! tree_expr_nonnegative_p (arg
);
2054 try_widening
= true;
2055 builtin_optab
= sqrt_optab
;
2057 CASE_FLT_FN (BUILT_IN_EXP
):
2058 errno_set
= true; builtin_optab
= exp_optab
; break;
2059 CASE_FLT_FN (BUILT_IN_EXP10
):
2060 CASE_FLT_FN (BUILT_IN_POW10
):
2061 errno_set
= true; builtin_optab
= exp10_optab
; break;
2062 CASE_FLT_FN (BUILT_IN_EXP2
):
2063 errno_set
= true; builtin_optab
= exp2_optab
; break;
2064 CASE_FLT_FN (BUILT_IN_EXPM1
):
2065 errno_set
= true; builtin_optab
= expm1_optab
; break;
2066 CASE_FLT_FN (BUILT_IN_LOGB
):
2067 errno_set
= true; builtin_optab
= logb_optab
; break;
2068 CASE_FLT_FN (BUILT_IN_LOG
):
2069 errno_set
= true; builtin_optab
= log_optab
; break;
2070 CASE_FLT_FN (BUILT_IN_LOG10
):
2071 errno_set
= true; builtin_optab
= log10_optab
; break;
2072 CASE_FLT_FN (BUILT_IN_LOG2
):
2073 errno_set
= true; builtin_optab
= log2_optab
; break;
2074 CASE_FLT_FN (BUILT_IN_LOG1P
):
2075 errno_set
= true; builtin_optab
= log1p_optab
; break;
2076 CASE_FLT_FN (BUILT_IN_ASIN
):
2077 builtin_optab
= asin_optab
; break;
2078 CASE_FLT_FN (BUILT_IN_ACOS
):
2079 builtin_optab
= acos_optab
; break;
2080 CASE_FLT_FN (BUILT_IN_TAN
):
2081 builtin_optab
= tan_optab
; break;
2082 CASE_FLT_FN (BUILT_IN_ATAN
):
2083 builtin_optab
= atan_optab
; break;
2084 CASE_FLT_FN (BUILT_IN_FLOOR
):
2085 builtin_optab
= floor_optab
; break;
2086 CASE_FLT_FN (BUILT_IN_CEIL
):
2087 builtin_optab
= ceil_optab
; break;
2088 CASE_FLT_FN (BUILT_IN_TRUNC
):
2089 builtin_optab
= btrunc_optab
; break;
2090 CASE_FLT_FN (BUILT_IN_ROUND
):
2091 builtin_optab
= round_optab
; break;
2092 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
2093 builtin_optab
= nearbyint_optab
;
2094 if (flag_trapping_math
)
2096 /* Else fallthrough and expand as rint. */
2097 CASE_FLT_FN (BUILT_IN_RINT
):
2098 builtin_optab
= rint_optab
; break;
2099 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
2100 builtin_optab
= significand_optab
; break;
2105 /* Make a suitable register to place result in. */
2106 mode
= TYPE_MODE (TREE_TYPE (exp
));
2108 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2111 /* Before working hard, check whether the instruction is available, but try
2112 to widen the mode for specific operations. */
2113 if ((optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
2114 || (try_widening
&& !excess_precision_type (TREE_TYPE (exp
))))
2115 && (!errno_set
|| !optimize_insn_for_size_p ()))
2117 rtx result
= gen_reg_rtx (mode
);
2119 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2120 need to expand the argument again. This way, we will not perform
2121 side-effects more the once. */
2122 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2124 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2128 /* Compute into RESULT.
2129 Set RESULT to wherever the result comes back. */
2130 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2135 expand_errno_check (exp
, result
);
2137 /* Output the entire sequence. */
2138 insns
= get_insns ();
2144 /* If we were unable to expand via the builtin, stop the sequence
2145 (without outputting the insns) and call to the library function
2146 with the stabilized argument list. */
2150 return expand_call (exp
, target
, target
== const0_rtx
);
2153 /* Expand a call to the builtin binary math functions (pow and atan2).
2154 Return NULL_RTX if a normal call should be emitted rather than expanding the
2155 function in-line. EXP is the expression that is a call to the builtin
2156 function; if convenient, the result should be placed in TARGET.
2157 SUBTARGET may be used as the target for computing one of EXP's
2161 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
2163 optab builtin_optab
;
2164 rtx op0
, op1
, insns
, result
;
2165 int op1_type
= REAL_TYPE
;
2166 tree fndecl
= get_callee_fndecl (exp
);
2168 enum machine_mode mode
;
2169 bool errno_set
= true;
2171 switch (DECL_FUNCTION_CODE (fndecl
))
2173 CASE_FLT_FN (BUILT_IN_SCALBN
):
2174 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2175 CASE_FLT_FN (BUILT_IN_LDEXP
):
2176 op1_type
= INTEGER_TYPE
;
2181 if (!validate_arglist (exp
, REAL_TYPE
, op1_type
, VOID_TYPE
))
2184 arg0
= CALL_EXPR_ARG (exp
, 0);
2185 arg1
= CALL_EXPR_ARG (exp
, 1);
2187 switch (DECL_FUNCTION_CODE (fndecl
))
2189 CASE_FLT_FN (BUILT_IN_POW
):
2190 builtin_optab
= pow_optab
; break;
2191 CASE_FLT_FN (BUILT_IN_ATAN2
):
2192 builtin_optab
= atan2_optab
; break;
2193 CASE_FLT_FN (BUILT_IN_SCALB
):
2194 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2196 builtin_optab
= scalb_optab
; break;
2197 CASE_FLT_FN (BUILT_IN_SCALBN
):
2198 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2199 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp
)))->b
!= 2)
2201 /* Fall through... */
2202 CASE_FLT_FN (BUILT_IN_LDEXP
):
2203 builtin_optab
= ldexp_optab
; break;
2204 CASE_FLT_FN (BUILT_IN_FMOD
):
2205 builtin_optab
= fmod_optab
; break;
2206 CASE_FLT_FN (BUILT_IN_REMAINDER
):
2207 CASE_FLT_FN (BUILT_IN_DREM
):
2208 builtin_optab
= remainder_optab
; break;
2213 /* Make a suitable register to place result in. */
2214 mode
= TYPE_MODE (TREE_TYPE (exp
));
2216 /* Before working hard, check whether the instruction is available. */
2217 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2220 result
= gen_reg_rtx (mode
);
2222 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2225 if (errno_set
&& optimize_insn_for_size_p ())
2228 /* Always stabilize the argument list. */
2229 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2230 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2232 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2233 op1
= expand_normal (arg1
);
2237 /* Compute into RESULT.
2238 Set RESULT to wherever the result comes back. */
2239 result
= expand_binop (mode
, builtin_optab
, op0
, op1
,
2240 result
, 0, OPTAB_DIRECT
);
2242 /* If we were unable to expand via the builtin, stop the sequence
2243 (without outputting the insns) and call to the library function
2244 with the stabilized argument list. */
2248 return expand_call (exp
, target
, target
== const0_rtx
);
2252 expand_errno_check (exp
, result
);
2254 /* Output the entire sequence. */
2255 insns
= get_insns ();
2262 /* Expand a call to the builtin trinary math functions (fma).
2263 Return NULL_RTX if a normal call should be emitted rather than expanding the
2264 function in-line. EXP is the expression that is a call to the builtin
2265 function; if convenient, the result should be placed in TARGET.
2266 SUBTARGET may be used as the target for computing one of EXP's
2270 expand_builtin_mathfn_ternary (tree exp
, rtx target
, rtx subtarget
)
2272 optab builtin_optab
;
2273 rtx op0
, op1
, op2
, insns
, result
;
2274 tree fndecl
= get_callee_fndecl (exp
);
2275 tree arg0
, arg1
, arg2
;
2276 enum machine_mode mode
;
2278 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2281 arg0
= CALL_EXPR_ARG (exp
, 0);
2282 arg1
= CALL_EXPR_ARG (exp
, 1);
2283 arg2
= CALL_EXPR_ARG (exp
, 2);
2285 switch (DECL_FUNCTION_CODE (fndecl
))
2287 CASE_FLT_FN (BUILT_IN_FMA
):
2288 builtin_optab
= fma_optab
; break;
2293 /* Make a suitable register to place result in. */
2294 mode
= TYPE_MODE (TREE_TYPE (exp
));
2296 /* Before working hard, check whether the instruction is available. */
2297 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2300 result
= gen_reg_rtx (mode
);
2302 /* Always stabilize the argument list. */
2303 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2304 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2305 CALL_EXPR_ARG (exp
, 2) = arg2
= builtin_save_expr (arg2
);
2307 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2308 op1
= expand_normal (arg1
);
2309 op2
= expand_normal (arg2
);
2313 /* Compute into RESULT.
2314 Set RESULT to wherever the result comes back. */
2315 result
= expand_ternary_op (mode
, builtin_optab
, op0
, op1
, op2
,
2318 /* If we were unable to expand via the builtin, stop the sequence
2319 (without outputting the insns) and call to the library function
2320 with the stabilized argument list. */
2324 return expand_call (exp
, target
, target
== const0_rtx
);
2327 /* Output the entire sequence. */
2328 insns
= get_insns ();
2335 /* Expand a call to the builtin sin and cos math functions.
2336 Return NULL_RTX if a normal call should be emitted rather than expanding the
2337 function in-line. EXP is the expression that is a call to the builtin
2338 function; if convenient, the result should be placed in TARGET.
2339 SUBTARGET may be used as the target for computing one of EXP's
2343 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2345 optab builtin_optab
;
2347 tree fndecl
= get_callee_fndecl (exp
);
2348 enum machine_mode mode
;
2351 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2354 arg
= CALL_EXPR_ARG (exp
, 0);
2356 switch (DECL_FUNCTION_CODE (fndecl
))
2358 CASE_FLT_FN (BUILT_IN_SIN
):
2359 CASE_FLT_FN (BUILT_IN_COS
):
2360 builtin_optab
= sincos_optab
; break;
2365 /* Make a suitable register to place result in. */
2366 mode
= TYPE_MODE (TREE_TYPE (exp
));
2368 /* Check if sincos insn is available, otherwise fallback
2369 to sin or cos insn. */
2370 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2371 switch (DECL_FUNCTION_CODE (fndecl
))
2373 CASE_FLT_FN (BUILT_IN_SIN
):
2374 builtin_optab
= sin_optab
; break;
2375 CASE_FLT_FN (BUILT_IN_COS
):
2376 builtin_optab
= cos_optab
; break;
2381 /* Before working hard, check whether the instruction is available. */
2382 if (optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
)
2384 rtx result
= gen_reg_rtx (mode
);
2386 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2387 need to expand the argument again. This way, we will not perform
2388 side-effects more the once. */
2389 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2391 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2395 /* Compute into RESULT.
2396 Set RESULT to wherever the result comes back. */
2397 if (builtin_optab
== sincos_optab
)
2401 switch (DECL_FUNCTION_CODE (fndecl
))
2403 CASE_FLT_FN (BUILT_IN_SIN
):
2404 ok
= expand_twoval_unop (builtin_optab
, op0
, 0, result
, 0);
2406 CASE_FLT_FN (BUILT_IN_COS
):
2407 ok
= expand_twoval_unop (builtin_optab
, op0
, result
, 0, 0);
2415 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2419 /* Output the entire sequence. */
2420 insns
= get_insns ();
2426 /* If we were unable to expand via the builtin, stop the sequence
2427 (without outputting the insns) and call to the library function
2428 with the stabilized argument list. */
2432 return expand_call (exp
, target
, target
== const0_rtx
);
2435 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2436 return an RTL instruction code that implements the functionality.
2437 If that isn't possible or available return CODE_FOR_nothing. */
2439 static enum insn_code
2440 interclass_mathfn_icode (tree arg
, tree fndecl
)
2442 bool errno_set
= false;
2443 optab builtin_optab
= unknown_optab
;
2444 enum machine_mode mode
;
2446 switch (DECL_FUNCTION_CODE (fndecl
))
2448 CASE_FLT_FN (BUILT_IN_ILOGB
):
2449 errno_set
= true; builtin_optab
= ilogb_optab
; break;
2450 CASE_FLT_FN (BUILT_IN_ISINF
):
2451 builtin_optab
= isinf_optab
; break;
2452 case BUILT_IN_ISNORMAL
:
2453 case BUILT_IN_ISFINITE
:
2454 CASE_FLT_FN (BUILT_IN_FINITE
):
2455 case BUILT_IN_FINITED32
:
2456 case BUILT_IN_FINITED64
:
2457 case BUILT_IN_FINITED128
:
2458 case BUILT_IN_ISINFD32
:
2459 case BUILT_IN_ISINFD64
:
2460 case BUILT_IN_ISINFD128
:
2461 /* These builtins have no optabs (yet). */
2467 /* There's no easy way to detect the case we need to set EDOM. */
2468 if (flag_errno_math
&& errno_set
)
2469 return CODE_FOR_nothing
;
2471 /* Optab mode depends on the mode of the input argument. */
2472 mode
= TYPE_MODE (TREE_TYPE (arg
));
2475 return optab_handler (builtin_optab
, mode
);
2476 return CODE_FOR_nothing
;
2479 /* Expand a call to one of the builtin math functions that operate on
2480 floating point argument and output an integer result (ilogb, isinf,
2482 Return 0 if a normal call should be emitted rather than expanding the
2483 function in-line. EXP is the expression that is a call to the builtin
2484 function; if convenient, the result should be placed in TARGET. */
2487 expand_builtin_interclass_mathfn (tree exp
, rtx target
)
2489 enum insn_code icode
= CODE_FOR_nothing
;
2491 tree fndecl
= get_callee_fndecl (exp
);
2492 enum machine_mode mode
;
2495 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2498 arg
= CALL_EXPR_ARG (exp
, 0);
2499 icode
= interclass_mathfn_icode (arg
, fndecl
);
2500 mode
= TYPE_MODE (TREE_TYPE (arg
));
2502 if (icode
!= CODE_FOR_nothing
)
2504 struct expand_operand ops
[1];
2505 rtx last
= get_last_insn ();
2506 tree orig_arg
= arg
;
2508 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2509 need to expand the argument again. This way, we will not perform
2510 side-effects more the once. */
2511 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2513 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2515 if (mode
!= GET_MODE (op0
))
2516 op0
= convert_to_mode (mode
, op0
, 0);
2518 create_output_operand (&ops
[0], target
, TYPE_MODE (TREE_TYPE (exp
)));
2519 if (maybe_legitimize_operands (icode
, 0, 1, ops
)
2520 && maybe_emit_unop_insn (icode
, ops
[0].value
, op0
, UNKNOWN
))
2521 return ops
[0].value
;
2523 delete_insns_since (last
);
2524 CALL_EXPR_ARG (exp
, 0) = orig_arg
;
2530 /* Expand a call to the builtin sincos math function.
2531 Return NULL_RTX if a normal call should be emitted rather than expanding the
2532 function in-line. EXP is the expression that is a call to the builtin
2536 expand_builtin_sincos (tree exp
)
2538 rtx op0
, op1
, op2
, target1
, target2
;
2539 enum machine_mode mode
;
2540 tree arg
, sinp
, cosp
;
2542 location_t loc
= EXPR_LOCATION (exp
);
2543 tree alias_type
, alias_off
;
2545 if (!validate_arglist (exp
, REAL_TYPE
,
2546 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2549 arg
= CALL_EXPR_ARG (exp
, 0);
2550 sinp
= CALL_EXPR_ARG (exp
, 1);
2551 cosp
= CALL_EXPR_ARG (exp
, 2);
2553 /* Make a suitable register to place result in. */
2554 mode
= TYPE_MODE (TREE_TYPE (arg
));
2556 /* Check if sincos insn is available, otherwise emit the call. */
2557 if (optab_handler (sincos_optab
, mode
) == CODE_FOR_nothing
)
2560 target1
= gen_reg_rtx (mode
);
2561 target2
= gen_reg_rtx (mode
);
2563 op0
= expand_normal (arg
);
2564 alias_type
= build_pointer_type_for_mode (TREE_TYPE (arg
), ptr_mode
, true);
2565 alias_off
= build_int_cst (alias_type
, 0);
2566 op1
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2568 op2
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2571 /* Compute into target1 and target2.
2572 Set TARGET to wherever the result comes back. */
2573 result
= expand_twoval_unop (sincos_optab
, op0
, target2
, target1
, 0);
2574 gcc_assert (result
);
2576 /* Move target1 and target2 to the memory locations indicated
2578 emit_move_insn (op1
, target1
);
2579 emit_move_insn (op2
, target2
);
2584 /* Expand a call to the internal cexpi builtin to the sincos math function.
2585 EXP is the expression that is a call to the builtin function; if convenient,
2586 the result should be placed in TARGET. */
2589 expand_builtin_cexpi (tree exp
, rtx target
)
2591 tree fndecl
= get_callee_fndecl (exp
);
2593 enum machine_mode mode
;
2595 location_t loc
= EXPR_LOCATION (exp
);
2597 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2600 arg
= CALL_EXPR_ARG (exp
, 0);
2601 type
= TREE_TYPE (arg
);
2602 mode
= TYPE_MODE (TREE_TYPE (arg
));
2604 /* Try expanding via a sincos optab, fall back to emitting a libcall
2605 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2606 is only generated from sincos, cexp or if we have either of them. */
2607 if (optab_handler (sincos_optab
, mode
) != CODE_FOR_nothing
)
2609 op1
= gen_reg_rtx (mode
);
2610 op2
= gen_reg_rtx (mode
);
2612 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2614 /* Compute into op1 and op2. */
2615 expand_twoval_unop (sincos_optab
, op0
, op2
, op1
, 0);
2617 else if (targetm
.libc_has_function (function_sincos
))
2619 tree call
, fn
= NULL_TREE
;
2623 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2624 fn
= builtin_decl_explicit (BUILT_IN_SINCOSF
);
2625 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2626 fn
= builtin_decl_explicit (BUILT_IN_SINCOS
);
2627 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2628 fn
= builtin_decl_explicit (BUILT_IN_SINCOSL
);
2632 op1
= assign_temp (TREE_TYPE (arg
), 1, 1);
2633 op2
= assign_temp (TREE_TYPE (arg
), 1, 1);
2634 op1a
= copy_addr_to_reg (XEXP (op1
, 0));
2635 op2a
= copy_addr_to_reg (XEXP (op2
, 0));
2636 top1
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op1a
);
2637 top2
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op2a
);
2639 /* Make sure not to fold the sincos call again. */
2640 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2641 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn
)),
2642 call
, 3, arg
, top1
, top2
));
2646 tree call
, fn
= NULL_TREE
, narg
;
2647 tree ctype
= build_complex_type (type
);
2649 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2650 fn
= builtin_decl_explicit (BUILT_IN_CEXPF
);
2651 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2652 fn
= builtin_decl_explicit (BUILT_IN_CEXP
);
2653 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2654 fn
= builtin_decl_explicit (BUILT_IN_CEXPL
);
2658 /* If we don't have a decl for cexp create one. This is the
2659 friendliest fallback if the user calls __builtin_cexpi
2660 without full target C99 function support. */
2661 if (fn
== NULL_TREE
)
2664 const char *name
= NULL
;
2666 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2668 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2670 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2673 fntype
= build_function_type_list (ctype
, ctype
, NULL_TREE
);
2674 fn
= build_fn_decl (name
, fntype
);
2677 narg
= fold_build2_loc (loc
, COMPLEX_EXPR
, ctype
,
2678 build_real (type
, dconst0
), arg
);
2680 /* Make sure not to fold the cexp call again. */
2681 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2682 return expand_expr (build_call_nary (ctype
, call
, 1, narg
),
2683 target
, VOIDmode
, EXPAND_NORMAL
);
2686 /* Now build the proper return type. */
2687 return expand_expr (build2 (COMPLEX_EXPR
, build_complex_type (type
),
2688 make_tree (TREE_TYPE (arg
), op2
),
2689 make_tree (TREE_TYPE (arg
), op1
)),
2690 target
, VOIDmode
, EXPAND_NORMAL
);
2693 /* Conveniently construct a function call expression. FNDECL names the
2694 function to be called, N is the number of arguments, and the "..."
2695 parameters are the argument expressions. Unlike build_call_exr
2696 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2699 build_call_nofold_loc (location_t loc
, tree fndecl
, int n
, ...)
2702 tree fntype
= TREE_TYPE (fndecl
);
2703 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
2706 fn
= build_call_valist (TREE_TYPE (fntype
), fn
, n
, ap
);
2708 SET_EXPR_LOCATION (fn
, loc
);
2712 /* Expand a call to one of the builtin rounding functions gcc defines
2713 as an extension (lfloor and lceil). As these are gcc extensions we
2714 do not need to worry about setting errno to EDOM.
2715 If expanding via optab fails, lower expression to (int)(floor(x)).
2716 EXP is the expression that is a call to the builtin function;
2717 if convenient, the result should be placed in TARGET. */
2720 expand_builtin_int_roundingfn (tree exp
, rtx target
)
2722 convert_optab builtin_optab
;
2723 rtx op0
, insns
, tmp
;
2724 tree fndecl
= get_callee_fndecl (exp
);
2725 enum built_in_function fallback_fn
;
2726 tree fallback_fndecl
;
2727 enum machine_mode mode
;
2730 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2733 arg
= CALL_EXPR_ARG (exp
, 0);
2735 switch (DECL_FUNCTION_CODE (fndecl
))
2737 CASE_FLT_FN (BUILT_IN_ICEIL
):
2738 CASE_FLT_FN (BUILT_IN_LCEIL
):
2739 CASE_FLT_FN (BUILT_IN_LLCEIL
):
2740 builtin_optab
= lceil_optab
;
2741 fallback_fn
= BUILT_IN_CEIL
;
2744 CASE_FLT_FN (BUILT_IN_IFLOOR
):
2745 CASE_FLT_FN (BUILT_IN_LFLOOR
):
2746 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
2747 builtin_optab
= lfloor_optab
;
2748 fallback_fn
= BUILT_IN_FLOOR
;
2755 /* Make a suitable register to place result in. */
2756 mode
= TYPE_MODE (TREE_TYPE (exp
));
2758 target
= gen_reg_rtx (mode
);
2760 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2761 need to expand the argument again. This way, we will not perform
2762 side-effects more the once. */
2763 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2765 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2769 /* Compute into TARGET. */
2770 if (expand_sfix_optab (target
, op0
, builtin_optab
))
2772 /* Output the entire sequence. */
2773 insns
= get_insns ();
2779 /* If we were unable to expand via the builtin, stop the sequence
2780 (without outputting the insns). */
2783 /* Fall back to floating point rounding optab. */
2784 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
2786 /* For non-C99 targets we may end up without a fallback fndecl here
2787 if the user called __builtin_lfloor directly. In this case emit
2788 a call to the floor/ceil variants nevertheless. This should result
2789 in the best user experience for not full C99 targets. */
2790 if (fallback_fndecl
== NULL_TREE
)
2793 const char *name
= NULL
;
2795 switch (DECL_FUNCTION_CODE (fndecl
))
2797 case BUILT_IN_ICEIL
:
2798 case BUILT_IN_LCEIL
:
2799 case BUILT_IN_LLCEIL
:
2802 case BUILT_IN_ICEILF
:
2803 case BUILT_IN_LCEILF
:
2804 case BUILT_IN_LLCEILF
:
2807 case BUILT_IN_ICEILL
:
2808 case BUILT_IN_LCEILL
:
2809 case BUILT_IN_LLCEILL
:
2812 case BUILT_IN_IFLOOR
:
2813 case BUILT_IN_LFLOOR
:
2814 case BUILT_IN_LLFLOOR
:
2817 case BUILT_IN_IFLOORF
:
2818 case BUILT_IN_LFLOORF
:
2819 case BUILT_IN_LLFLOORF
:
2822 case BUILT_IN_IFLOORL
:
2823 case BUILT_IN_LFLOORL
:
2824 case BUILT_IN_LLFLOORL
:
2831 fntype
= build_function_type_list (TREE_TYPE (arg
),
2832 TREE_TYPE (arg
), NULL_TREE
);
2833 fallback_fndecl
= build_fn_decl (name
, fntype
);
2836 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
), fallback_fndecl
, 1, arg
);
2838 tmp
= expand_normal (exp
);
2839 tmp
= maybe_emit_group_store (tmp
, TREE_TYPE (exp
));
2841 /* Truncate the result of floating point optab to integer
2842 via expand_fix (). */
2843 target
= gen_reg_rtx (mode
);
2844 expand_fix (target
, tmp
, 0);
2849 /* Expand a call to one of the builtin math functions doing integer
2851 Return 0 if a normal call should be emitted rather than expanding the
2852 function in-line. EXP is the expression that is a call to the builtin
2853 function; if convenient, the result should be placed in TARGET. */
2856 expand_builtin_int_roundingfn_2 (tree exp
, rtx target
)
2858 convert_optab builtin_optab
;
2860 tree fndecl
= get_callee_fndecl (exp
);
2862 enum machine_mode mode
;
2863 enum built_in_function fallback_fn
= BUILT_IN_NONE
;
2865 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2868 arg
= CALL_EXPR_ARG (exp
, 0);
2870 switch (DECL_FUNCTION_CODE (fndecl
))
2872 CASE_FLT_FN (BUILT_IN_IRINT
):
2873 fallback_fn
= BUILT_IN_LRINT
;
2875 CASE_FLT_FN (BUILT_IN_LRINT
):
2876 CASE_FLT_FN (BUILT_IN_LLRINT
):
2877 builtin_optab
= lrint_optab
;
2880 CASE_FLT_FN (BUILT_IN_IROUND
):
2881 fallback_fn
= BUILT_IN_LROUND
;
2883 CASE_FLT_FN (BUILT_IN_LROUND
):
2884 CASE_FLT_FN (BUILT_IN_LLROUND
):
2885 builtin_optab
= lround_optab
;
2892 /* There's no easy way to detect the case we need to set EDOM. */
2893 if (flag_errno_math
&& fallback_fn
== BUILT_IN_NONE
)
2896 /* Make a suitable register to place result in. */
2897 mode
= TYPE_MODE (TREE_TYPE (exp
));
2899 /* There's no easy way to detect the case we need to set EDOM. */
2900 if (!flag_errno_math
)
2902 rtx result
= gen_reg_rtx (mode
);
2904 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2905 need to expand the argument again. This way, we will not perform
2906 side-effects more the once. */
2907 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2909 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
2913 if (expand_sfix_optab (result
, op0
, builtin_optab
))
2915 /* Output the entire sequence. */
2916 insns
= get_insns ();
2922 /* If we were unable to expand via the builtin, stop the sequence
2923 (without outputting the insns) and call to the library function
2924 with the stabilized argument list. */
2928 if (fallback_fn
!= BUILT_IN_NONE
)
2930 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2931 targets, (int) round (x) should never be transformed into
2932 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2933 a call to lround in the hope that the target provides at least some
2934 C99 functions. This should result in the best user experience for
2935 not full C99 targets. */
2936 tree fallback_fndecl
= mathfn_built_in_1 (TREE_TYPE (arg
),
2939 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
),
2940 fallback_fndecl
, 1, arg
);
2942 target
= expand_call (exp
, NULL_RTX
, target
== const0_rtx
);
2943 target
= maybe_emit_group_store (target
, TREE_TYPE (exp
));
2944 return convert_to_mode (mode
, target
, 0);
2947 return expand_call (exp
, target
, target
== const0_rtx
);
2950 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2951 a normal call should be emitted rather than expanding the function
2952 in-line. EXP is the expression that is a call to the builtin
2953 function; if convenient, the result should be placed in TARGET. */
2956 expand_builtin_powi (tree exp
, rtx target
)
2960 enum machine_mode mode
;
2961 enum machine_mode mode2
;
2963 if (! validate_arglist (exp
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2966 arg0
= CALL_EXPR_ARG (exp
, 0);
2967 arg1
= CALL_EXPR_ARG (exp
, 1);
2968 mode
= TYPE_MODE (TREE_TYPE (exp
));
2970 /* Emit a libcall to libgcc. */
2972 /* Mode of the 2nd argument must match that of an int. */
2973 mode2
= mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0);
2975 if (target
== NULL_RTX
)
2976 target
= gen_reg_rtx (mode
);
2978 op0
= expand_expr (arg0
, NULL_RTX
, mode
, EXPAND_NORMAL
);
2979 if (GET_MODE (op0
) != mode
)
2980 op0
= convert_to_mode (mode
, op0
, 0);
2981 op1
= expand_expr (arg1
, NULL_RTX
, mode2
, EXPAND_NORMAL
);
2982 if (GET_MODE (op1
) != mode2
)
2983 op1
= convert_to_mode (mode2
, op1
, 0);
2985 target
= emit_library_call_value (optab_libfunc (powi_optab
, mode
),
2986 target
, LCT_CONST
, mode
, 2,
2987 op0
, mode
, op1
, mode2
);
2992 /* Expand expression EXP which is a call to the strlen builtin. Return
2993 NULL_RTX if we failed the caller should emit a normal call, otherwise
2994 try to get the result in TARGET, if convenient. */
2997 expand_builtin_strlen (tree exp
, rtx target
,
2998 enum machine_mode target_mode
)
3000 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
3004 struct expand_operand ops
[4];
3007 tree src
= CALL_EXPR_ARG (exp
, 0);
3008 rtx src_reg
, before_strlen
;
3009 enum machine_mode insn_mode
= target_mode
;
3010 enum insn_code icode
= CODE_FOR_nothing
;
3013 /* If the length can be computed at compile-time, return it. */
3014 len
= c_strlen (src
, 0);
3016 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3018 /* If the length can be computed at compile-time and is constant
3019 integer, but there are side-effects in src, evaluate
3020 src for side-effects, then return len.
3021 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3022 can be optimized into: i++; x = 3; */
3023 len
= c_strlen (src
, 1);
3024 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
3026 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3027 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3030 align
= get_pointer_alignment (src
) / BITS_PER_UNIT
;
3032 /* If SRC is not a pointer type, don't do this operation inline. */
3036 /* Bail out if we can't compute strlen in the right mode. */
3037 while (insn_mode
!= VOIDmode
)
3039 icode
= optab_handler (strlen_optab
, insn_mode
);
3040 if (icode
!= CODE_FOR_nothing
)
3043 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
3045 if (insn_mode
== VOIDmode
)
3048 /* Make a place to hold the source address. We will not expand
3049 the actual source until we are sure that the expansion will
3050 not fail -- there are trees that cannot be expanded twice. */
3051 src_reg
= gen_reg_rtx (Pmode
);
3053 /* Mark the beginning of the strlen sequence so we can emit the
3054 source operand later. */
3055 before_strlen
= get_last_insn ();
3057 create_output_operand (&ops
[0], target
, insn_mode
);
3058 create_fixed_operand (&ops
[1], gen_rtx_MEM (BLKmode
, src_reg
));
3059 create_integer_operand (&ops
[2], 0);
3060 create_integer_operand (&ops
[3], align
);
3061 if (!maybe_expand_insn (icode
, 4, ops
))
3064 /* Now that we are assured of success, expand the source. */
3066 pat
= expand_expr (src
, src_reg
, Pmode
, EXPAND_NORMAL
);
3069 #ifdef POINTERS_EXTEND_UNSIGNED
3070 if (GET_MODE (pat
) != Pmode
)
3071 pat
= convert_to_mode (Pmode
, pat
,
3072 POINTERS_EXTEND_UNSIGNED
);
3074 emit_move_insn (src_reg
, pat
);
3080 emit_insn_after (pat
, before_strlen
);
3082 emit_insn_before (pat
, get_insns ());
3084 /* Return the value in the proper mode for this function. */
3085 if (GET_MODE (ops
[0].value
) == target_mode
)
3086 target
= ops
[0].value
;
3087 else if (target
!= 0)
3088 convert_move (target
, ops
[0].value
, 0);
3090 target
= convert_to_mode (target_mode
, ops
[0].value
, 0);
3096 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3097 bytes from constant string DATA + OFFSET and return it as target
3101 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
3102 enum machine_mode mode
)
3104 const char *str
= (const char *) data
;
3106 gcc_assert (offset
>= 0
3107 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
3108 <= strlen (str
) + 1));
3110 return c_readstr (str
+ offset
, mode
);
3113 /* LEN specify length of the block of memcpy/memset operation.
3114 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
3115 In some cases we can make very likely guess on max size, then we
3116 set it into PROBABLE_MAX_SIZE. */
3119 determine_block_size (tree len
, rtx len_rtx
,
3120 unsigned HOST_WIDE_INT
*min_size
,
3121 unsigned HOST_WIDE_INT
*max_size
,
3122 unsigned HOST_WIDE_INT
*probable_max_size
)
3124 if (CONST_INT_P (len_rtx
))
3126 *min_size
= *max_size
= *probable_max_size
= UINTVAL (len_rtx
);
3131 double_int min
, max
;
3132 enum value_range_type range_type
= VR_UNDEFINED
;
3134 /* Determine bounds from the type. */
3135 if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len
))))
3136 *min_size
= tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len
)));
3139 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len
))))
3140 *probable_max_size
= *max_size
3141 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len
)));
3143 *probable_max_size
= *max_size
= GET_MODE_MASK (GET_MODE (len_rtx
));
3145 if (TREE_CODE (len
) == SSA_NAME
)
3146 range_type
= get_range_info (len
, &min
, &max
);
3147 if (range_type
== VR_RANGE
)
3149 if (min
.fits_uhwi () && *min_size
< min
.to_uhwi ())
3150 *min_size
= min
.to_uhwi ();
3151 if (max
.fits_uhwi () && *max_size
> max
.to_uhwi ())
3152 *probable_max_size
= *max_size
= max
.to_uhwi ();
3154 else if (range_type
== VR_ANTI_RANGE
)
3156 /* Anti range 0...N lets us to determine minimal size to N+1. */
3159 if ((max
+ double_int_one
).fits_uhwi ())
3160 *min_size
= (max
+ double_int_one
).to_uhwi ();
3168 Produce anti range allowing negative values of N. We still
3169 can use the information and make a guess that N is not negative.
3171 else if (!max
.ule (double_int_one
.lshift (30))
3172 && min
.fits_uhwi ())
3173 *probable_max_size
= min
.to_uhwi () - 1;
3176 gcc_checking_assert (*max_size
<=
3177 (unsigned HOST_WIDE_INT
)
3178 GET_MODE_MASK (GET_MODE (len_rtx
)));
3181 /* Expand a call EXP to the memcpy builtin.
3182 Return NULL_RTX if we failed, the caller should emit a normal call,
3183 otherwise try to get the result in TARGET, if convenient (and in
3184 mode MODE if that's convenient). */
3187 expand_builtin_memcpy (tree exp
, rtx target
)
3189 if (!validate_arglist (exp
,
3190 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3194 tree dest
= CALL_EXPR_ARG (exp
, 0);
3195 tree src
= CALL_EXPR_ARG (exp
, 1);
3196 tree len
= CALL_EXPR_ARG (exp
, 2);
3197 const char *src_str
;
3198 unsigned int src_align
= get_pointer_alignment (src
);
3199 unsigned int dest_align
= get_pointer_alignment (dest
);
3200 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
3201 HOST_WIDE_INT expected_size
= -1;
3202 unsigned int expected_align
= 0;
3203 unsigned HOST_WIDE_INT min_size
;
3204 unsigned HOST_WIDE_INT max_size
;
3205 unsigned HOST_WIDE_INT probable_max_size
;
3207 /* If DEST is not a pointer type, call the normal function. */
3208 if (dest_align
== 0)
3211 /* If either SRC is not a pointer type, don't do this
3212 operation in-line. */
3216 if (currently_expanding_gimple_stmt
)
3217 stringop_block_profile (currently_expanding_gimple_stmt
,
3218 &expected_align
, &expected_size
);
3220 if (expected_align
< dest_align
)
3221 expected_align
= dest_align
;
3222 dest_mem
= get_memory_rtx (dest
, len
);
3223 set_mem_align (dest_mem
, dest_align
);
3224 len_rtx
= expand_normal (len
);
3225 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3226 &probable_max_size
);
3227 src_str
= c_getstr (src
);
3229 /* If SRC is a string constant and block move would be done
3230 by pieces, we can avoid loading the string from memory
3231 and only stored the computed constants. */
3233 && CONST_INT_P (len_rtx
)
3234 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3235 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3236 CONST_CAST (char *, src_str
),
3239 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3240 builtin_memcpy_read_str
,
3241 CONST_CAST (char *, src_str
),
3242 dest_align
, false, 0);
3243 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3244 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3248 src_mem
= get_memory_rtx (src
, len
);
3249 set_mem_align (src_mem
, src_align
);
3251 /* Copy word part most expediently. */
3252 dest_addr
= emit_block_move_hints (dest_mem
, src_mem
, len_rtx
,
3253 CALL_EXPR_TAILCALL (exp
)
3254 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3255 expected_align
, expected_size
,
3256 min_size
, max_size
, probable_max_size
);
3260 dest_addr
= force_operand (XEXP (dest_mem
, 0), target
);
3261 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3267 /* Expand a call EXP to the mempcpy builtin.
3268 Return NULL_RTX if we failed; the caller should emit a normal call,
3269 otherwise try to get the result in TARGET, if convenient (and in
3270 mode MODE if that's convenient). If ENDP is 0 return the
3271 destination pointer, if ENDP is 1 return the end pointer ala
3272 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3276 expand_builtin_mempcpy (tree exp
, rtx target
, enum machine_mode mode
)
3278 if (!validate_arglist (exp
,
3279 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3283 tree dest
= CALL_EXPR_ARG (exp
, 0);
3284 tree src
= CALL_EXPR_ARG (exp
, 1);
3285 tree len
= CALL_EXPR_ARG (exp
, 2);
3286 return expand_builtin_mempcpy_args (dest
, src
, len
,
3287 target
, mode
, /*endp=*/ 1);
3291 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3292 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3293 so that this can also be called without constructing an actual CALL_EXPR.
3294 The other arguments and return value are the same as for
3295 expand_builtin_mempcpy. */
3298 expand_builtin_mempcpy_args (tree dest
, tree src
, tree len
,
3299 rtx target
, enum machine_mode mode
, int endp
)
3301 /* If return value is ignored, transform mempcpy into memcpy. */
3302 if (target
== const0_rtx
&& builtin_decl_implicit_p (BUILT_IN_MEMCPY
))
3304 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3305 tree result
= build_call_nofold_loc (UNKNOWN_LOCATION
, fn
, 3,
3307 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3311 const char *src_str
;
3312 unsigned int src_align
= get_pointer_alignment (src
);
3313 unsigned int dest_align
= get_pointer_alignment (dest
);
3314 rtx dest_mem
, src_mem
, len_rtx
;
3316 /* If either SRC or DEST is not a pointer type, don't do this
3317 operation in-line. */
3318 if (dest_align
== 0 || src_align
== 0)
3321 /* If LEN is not constant, call the normal function. */
3322 if (! tree_fits_uhwi_p (len
))
3325 len_rtx
= expand_normal (len
);
3326 src_str
= c_getstr (src
);
3328 /* If SRC is a string constant and block move would be done
3329 by pieces, we can avoid loading the string from memory
3330 and only stored the computed constants. */
3332 && CONST_INT_P (len_rtx
)
3333 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
3334 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3335 CONST_CAST (char *, src_str
),
3338 dest_mem
= get_memory_rtx (dest
, len
);
3339 set_mem_align (dest_mem
, dest_align
);
3340 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3341 builtin_memcpy_read_str
,
3342 CONST_CAST (char *, src_str
),
3343 dest_align
, false, endp
);
3344 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3345 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3349 if (CONST_INT_P (len_rtx
)
3350 && can_move_by_pieces (INTVAL (len_rtx
),
3351 MIN (dest_align
, src_align
)))
3353 dest_mem
= get_memory_rtx (dest
, len
);
3354 set_mem_align (dest_mem
, dest_align
);
3355 src_mem
= get_memory_rtx (src
, len
);
3356 set_mem_align (src_mem
, src_align
);
3357 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
3358 MIN (dest_align
, src_align
), endp
);
3359 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3360 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3369 # define HAVE_movstr 0
3370 # define CODE_FOR_movstr CODE_FOR_nothing
3373 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3374 we failed, the caller should emit a normal call, otherwise try to
3375 get the result in TARGET, if convenient. If ENDP is 0 return the
3376 destination pointer, if ENDP is 1 return the end pointer ala
3377 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3381 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3383 struct expand_operand ops
[3];
3390 dest_mem
= get_memory_rtx (dest
, NULL
);
3391 src_mem
= get_memory_rtx (src
, NULL
);
3394 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3395 dest_mem
= replace_equiv_address (dest_mem
, target
);
3398 create_output_operand (&ops
[0], endp
? target
: NULL_RTX
, Pmode
);
3399 create_fixed_operand (&ops
[1], dest_mem
);
3400 create_fixed_operand (&ops
[2], src_mem
);
3401 if (!maybe_expand_insn (CODE_FOR_movstr
, 3, ops
))
3404 if (endp
&& target
!= const0_rtx
)
3406 target
= ops
[0].value
;
3407 /* movstr is supposed to set end to the address of the NUL
3408 terminator. If the caller requested a mempcpy-like return value,
3412 rtx tem
= plus_constant (GET_MODE (target
),
3413 gen_lowpart (GET_MODE (target
), target
), 1);
3414 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3420 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3421 NULL_RTX if we failed the caller should emit a normal call, otherwise
3422 try to get the result in TARGET, if convenient (and in mode MODE if that's
3426 expand_builtin_strcpy (tree exp
, rtx target
)
3428 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3430 tree dest
= CALL_EXPR_ARG (exp
, 0);
3431 tree src
= CALL_EXPR_ARG (exp
, 1);
3432 return expand_builtin_strcpy_args (dest
, src
, target
);
3437 /* Helper function to do the actual work for expand_builtin_strcpy. The
3438 arguments to the builtin_strcpy call DEST and SRC are broken out
3439 so that this can also be called without constructing an actual CALL_EXPR.
3440 The other arguments and return value are the same as for
3441 expand_builtin_strcpy. */
3444 expand_builtin_strcpy_args (tree dest
, tree src
, rtx target
)
3446 return expand_movstr (dest
, src
, target
, /*endp=*/0);
3449 /* Expand a call EXP to the stpcpy builtin.
3450 Return NULL_RTX if we failed the caller should emit a normal call,
3451 otherwise try to get the result in TARGET, if convenient (and in
3452 mode MODE if that's convenient). */
3455 expand_builtin_stpcpy (tree exp
, rtx target
, enum machine_mode mode
)
3458 location_t loc
= EXPR_LOCATION (exp
);
3460 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3463 dst
= CALL_EXPR_ARG (exp
, 0);
3464 src
= CALL_EXPR_ARG (exp
, 1);
3466 /* If return value is ignored, transform stpcpy into strcpy. */
3467 if (target
== const0_rtx
&& builtin_decl_implicit (BUILT_IN_STRCPY
))
3469 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3470 tree result
= build_call_nofold_loc (loc
, fn
, 2, dst
, src
);
3471 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3478 /* Ensure we get an actual string whose length can be evaluated at
3479 compile-time, not an expression containing a string. This is
3480 because the latter will potentially produce pessimized code
3481 when used to produce the return value. */
3482 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3483 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3485 lenp1
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
3486 ret
= expand_builtin_mempcpy_args (dst
, src
, lenp1
,
3487 target
, mode
, /*endp=*/2);
3492 if (TREE_CODE (len
) == INTEGER_CST
)
3494 rtx len_rtx
= expand_normal (len
);
3496 if (CONST_INT_P (len_rtx
))
3498 ret
= expand_builtin_strcpy_args (dst
, src
, target
);
3504 if (mode
!= VOIDmode
)
3505 target
= gen_reg_rtx (mode
);
3507 target
= gen_reg_rtx (GET_MODE (ret
));
3509 if (GET_MODE (target
) != GET_MODE (ret
))
3510 ret
= gen_lowpart (GET_MODE (target
), ret
);
3512 ret
= plus_constant (GET_MODE (ret
), ret
, INTVAL (len_rtx
));
3513 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3521 return expand_movstr (dst
, src
, target
, /*endp=*/2);
3525 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3526 bytes from constant string DATA + OFFSET and return it as target
3530 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3531 enum machine_mode mode
)
3533 const char *str
= (const char *) data
;
3535 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3538 return c_readstr (str
+ offset
, mode
);
3541 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3542 NULL_RTX if we failed the caller should emit a normal call. */
3545 expand_builtin_strncpy (tree exp
, rtx target
)
3547 location_t loc
= EXPR_LOCATION (exp
);
3549 if (validate_arglist (exp
,
3550 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3552 tree dest
= CALL_EXPR_ARG (exp
, 0);
3553 tree src
= CALL_EXPR_ARG (exp
, 1);
3554 tree len
= CALL_EXPR_ARG (exp
, 2);
3555 tree slen
= c_strlen (src
, 1);
3557 /* We must be passed a constant len and src parameter. */
3558 if (!tree_fits_uhwi_p (len
) || !slen
|| !tree_fits_uhwi_p (slen
))
3561 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
3563 /* We're required to pad with trailing zeros if the requested
3564 len is greater than strlen(s2)+1. In that case try to
3565 use store_by_pieces, if it fails, punt. */
3566 if (tree_int_cst_lt (slen
, len
))
3568 unsigned int dest_align
= get_pointer_alignment (dest
);
3569 const char *p
= c_getstr (src
);
3572 if (!p
|| dest_align
== 0 || !tree_fits_uhwi_p (len
)
3573 || !can_store_by_pieces (tree_to_uhwi (len
),
3574 builtin_strncpy_read_str
,
3575 CONST_CAST (char *, p
),
3579 dest_mem
= get_memory_rtx (dest
, len
);
3580 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3581 builtin_strncpy_read_str
,
3582 CONST_CAST (char *, p
), dest_align
, false, 0);
3583 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3584 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3591 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3592 bytes from constant string DATA + OFFSET and return it as target
3596 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3597 enum machine_mode mode
)
3599 const char *c
= (const char *) data
;
3600 char *p
= XALLOCAVEC (char, GET_MODE_SIZE (mode
));
3602 memset (p
, *c
, GET_MODE_SIZE (mode
));
3604 return c_readstr (p
, mode
);
3607 /* Callback routine for store_by_pieces. Return the RTL of a register
3608 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3609 char value given in the RTL register data. For example, if mode is
3610 4 bytes wide, return the RTL for 0x01010101*data. */
3613 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3614 enum machine_mode mode
)
3620 size
= GET_MODE_SIZE (mode
);
3624 p
= XALLOCAVEC (char, size
);
3625 memset (p
, 1, size
);
3626 coeff
= c_readstr (p
, mode
);
3628 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3629 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3630 return force_reg (mode
, target
);
3633 /* Expand expression EXP, which is a call to the memset builtin. Return
3634 NULL_RTX if we failed the caller should emit a normal call, otherwise
3635 try to get the result in TARGET, if convenient (and in mode MODE if that's
3639 expand_builtin_memset (tree exp
, rtx target
, enum machine_mode mode
)
3641 if (!validate_arglist (exp
,
3642 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3646 tree dest
= CALL_EXPR_ARG (exp
, 0);
3647 tree val
= CALL_EXPR_ARG (exp
, 1);
3648 tree len
= CALL_EXPR_ARG (exp
, 2);
3649 return expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
3653 /* Helper function to do the actual work for expand_builtin_memset. The
3654 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3655 so that this can also be called without constructing an actual CALL_EXPR.
3656 The other arguments and return value are the same as for
3657 expand_builtin_memset. */
3660 expand_builtin_memset_args (tree dest
, tree val
, tree len
,
3661 rtx target
, enum machine_mode mode
, tree orig_exp
)
3664 enum built_in_function fcode
;
3665 enum machine_mode val_mode
;
3667 unsigned int dest_align
;
3668 rtx dest_mem
, dest_addr
, len_rtx
;
3669 HOST_WIDE_INT expected_size
= -1;
3670 unsigned int expected_align
= 0;
3671 unsigned HOST_WIDE_INT min_size
;
3672 unsigned HOST_WIDE_INT max_size
;
3673 unsigned HOST_WIDE_INT probable_max_size
;
3675 dest_align
= get_pointer_alignment (dest
);
3677 /* If DEST is not a pointer type, don't do this operation in-line. */
3678 if (dest_align
== 0)
3681 if (currently_expanding_gimple_stmt
)
3682 stringop_block_profile (currently_expanding_gimple_stmt
,
3683 &expected_align
, &expected_size
);
3685 if (expected_align
< dest_align
)
3686 expected_align
= dest_align
;
3688 /* If the LEN parameter is zero, return DEST. */
3689 if (integer_zerop (len
))
3691 /* Evaluate and ignore VAL in case it has side-effects. */
3692 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3693 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3696 /* Stabilize the arguments in case we fail. */
3697 dest
= builtin_save_expr (dest
);
3698 val
= builtin_save_expr (val
);
3699 len
= builtin_save_expr (len
);
3701 len_rtx
= expand_normal (len
);
3702 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3703 &probable_max_size
);
3704 dest_mem
= get_memory_rtx (dest
, len
);
3705 val_mode
= TYPE_MODE (unsigned_char_type_node
);
3707 if (TREE_CODE (val
) != INTEGER_CST
)
3711 val_rtx
= expand_normal (val
);
3712 val_rtx
= convert_to_mode (val_mode
, val_rtx
, 0);
3714 /* Assume that we can memset by pieces if we can store
3715 * the coefficients by pieces (in the required modes).
3716 * We can't pass builtin_memset_gen_str as that emits RTL. */
3718 if (tree_fits_uhwi_p (len
)
3719 && can_store_by_pieces (tree_to_uhwi (len
),
3720 builtin_memset_read_str
, &c
, dest_align
,
3723 val_rtx
= force_reg (val_mode
, val_rtx
);
3724 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3725 builtin_memset_gen_str
, val_rtx
, dest_align
,
3728 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, val_rtx
,
3729 dest_align
, expected_align
,
3730 expected_size
, min_size
, max_size
,
3734 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3735 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3739 if (target_char_cast (val
, &c
))
3744 if (tree_fits_uhwi_p (len
)
3745 && can_store_by_pieces (tree_to_uhwi (len
),
3746 builtin_memset_read_str
, &c
, dest_align
,
3748 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
3749 builtin_memset_read_str
, &c
, dest_align
, true, 0);
3750 else if (!set_storage_via_setmem (dest_mem
, len_rtx
,
3751 gen_int_mode (c
, val_mode
),
3752 dest_align
, expected_align
,
3753 expected_size
, min_size
, max_size
,
3757 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3758 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3762 set_mem_align (dest_mem
, dest_align
);
3763 dest_addr
= clear_storage_hints (dest_mem
, len_rtx
,
3764 CALL_EXPR_TAILCALL (orig_exp
)
3765 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
3766 expected_align
, expected_size
,
3772 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3773 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3779 fndecl
= get_callee_fndecl (orig_exp
);
3780 fcode
= DECL_FUNCTION_CODE (fndecl
);
3781 if (fcode
== BUILT_IN_MEMSET
)
3782 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 3,
3784 else if (fcode
== BUILT_IN_BZERO
)
3785 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 2,
3789 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
3790 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
3791 return expand_call (fn
, target
, target
== const0_rtx
);
3794 /* Expand expression EXP, which is a call to the bzero builtin. Return
3795 NULL_RTX if we failed the caller should emit a normal call. */
3798 expand_builtin_bzero (tree exp
)
3801 location_t loc
= EXPR_LOCATION (exp
);
3803 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3806 dest
= CALL_EXPR_ARG (exp
, 0);
3807 size
= CALL_EXPR_ARG (exp
, 1);
3809 /* New argument list transforming bzero(ptr x, int y) to
3810 memset(ptr x, int 0, size_t y). This is done this way
3811 so that if it isn't expanded inline, we fallback to
3812 calling bzero instead of memset. */
3814 return expand_builtin_memset_args (dest
, integer_zero_node
,
3815 fold_convert_loc (loc
,
3816 size_type_node
, size
),
3817 const0_rtx
, VOIDmode
, exp
);
3820 /* Expand expression EXP, which is a call to the memcmp built-in function.
3821 Return NULL_RTX if we failed and the caller should emit a normal call,
3822 otherwise try to get the result in TARGET, if convenient (and in mode
3823 MODE, if that's convenient). */
3826 expand_builtin_memcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
3827 ATTRIBUTE_UNUSED
enum machine_mode mode
)
3829 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
3831 if (!validate_arglist (exp
,
3832 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3835 /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3836 implementing memcmp because it will stop if it encounters two
3838 #if defined HAVE_cmpmemsi
3840 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3843 tree arg1
= CALL_EXPR_ARG (exp
, 0);
3844 tree arg2
= CALL_EXPR_ARG (exp
, 1);
3845 tree len
= CALL_EXPR_ARG (exp
, 2);
3847 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
3848 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
3849 enum machine_mode insn_mode
;
3852 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3856 /* If we don't have POINTER_TYPE, call the function. */
3857 if (arg1_align
== 0 || arg2_align
== 0)
3860 /* Make a place to write the result of the instruction. */
3863 && REG_P (result
) && GET_MODE (result
) == insn_mode
3864 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3865 result
= gen_reg_rtx (insn_mode
);
3867 arg1_rtx
= get_memory_rtx (arg1
, len
);
3868 arg2_rtx
= get_memory_rtx (arg2
, len
);
3869 arg3_rtx
= expand_normal (fold_convert_loc (loc
, sizetype
, len
));
3871 /* Set MEM_SIZE as appropriate. */
3872 if (CONST_INT_P (arg3_rtx
))
3874 set_mem_size (arg1_rtx
, INTVAL (arg3_rtx
));
3875 set_mem_size (arg2_rtx
, INTVAL (arg3_rtx
));
3879 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3880 GEN_INT (MIN (arg1_align
, arg2_align
)));
3887 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE
,
3888 TYPE_MODE (integer_type_node
), 3,
3889 XEXP (arg1_rtx
, 0), Pmode
,
3890 XEXP (arg2_rtx
, 0), Pmode
,
3891 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
3892 TYPE_UNSIGNED (sizetype
)),
3893 TYPE_MODE (sizetype
));
3895 /* Return the value in the proper mode for this function. */
3896 mode
= TYPE_MODE (TREE_TYPE (exp
));
3897 if (GET_MODE (result
) == mode
)
3899 else if (target
!= 0)
3901 convert_move (target
, result
, 0);
3905 return convert_to_mode (mode
, result
, 0);
3907 #endif /* HAVE_cmpmemsi. */
3912 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
3913 if we failed the caller should emit a normal call, otherwise try to get
3914 the result in TARGET, if convenient. */
3917 expand_builtin_strcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
)
3919 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3922 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3923 if (direct_optab_handler (cmpstr_optab
, SImode
) != CODE_FOR_nothing
3924 || direct_optab_handler (cmpstrn_optab
, SImode
) != CODE_FOR_nothing
)
3926 rtx arg1_rtx
, arg2_rtx
;
3927 rtx result
, insn
= NULL_RTX
;
3929 tree arg1
= CALL_EXPR_ARG (exp
, 0);
3930 tree arg2
= CALL_EXPR_ARG (exp
, 1);
3932 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
3933 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
3935 /* If we don't have POINTER_TYPE, call the function. */
3936 if (arg1_align
== 0 || arg2_align
== 0)
3939 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
3940 arg1
= builtin_save_expr (arg1
);
3941 arg2
= builtin_save_expr (arg2
);
3943 arg1_rtx
= get_memory_rtx (arg1
, NULL
);
3944 arg2_rtx
= get_memory_rtx (arg2
, NULL
);
3946 #ifdef HAVE_cmpstrsi
3947 /* Try to call cmpstrsi. */
3950 enum machine_mode insn_mode
3951 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3953 /* Make a place to write the result of the instruction. */
3956 && REG_P (result
) && GET_MODE (result
) == insn_mode
3957 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3958 result
= gen_reg_rtx (insn_mode
);
3960 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
,
3961 GEN_INT (MIN (arg1_align
, arg2_align
)));
3964 #ifdef HAVE_cmpstrnsi
3965 /* Try to determine at least one length and call cmpstrnsi. */
3966 if (!insn
&& HAVE_cmpstrnsi
)
3971 enum machine_mode insn_mode
3972 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3973 tree len1
= c_strlen (arg1
, 1);
3974 tree len2
= c_strlen (arg2
, 1);
3977 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3979 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3981 /* If we don't have a constant length for the first, use the length
3982 of the second, if we know it. We don't require a constant for
3983 this case; some cost analysis could be done if both are available
3984 but neither is constant. For now, assume they're equally cheap,
3985 unless one has side effects. If both strings have constant lengths,
3992 else if (TREE_SIDE_EFFECTS (len1
))
3994 else if (TREE_SIDE_EFFECTS (len2
))
3996 else if (TREE_CODE (len1
) != INTEGER_CST
)
3998 else if (TREE_CODE (len2
) != INTEGER_CST
)
4000 else if (tree_int_cst_lt (len1
, len2
))
4005 /* If both arguments have side effects, we cannot optimize. */
4006 if (!len
|| TREE_SIDE_EFFECTS (len
))
4009 arg3_rtx
= expand_normal (len
);
4011 /* Make a place to write the result of the instruction. */
4014 && REG_P (result
) && GET_MODE (result
) == insn_mode
4015 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4016 result
= gen_reg_rtx (insn_mode
);
4018 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4019 GEN_INT (MIN (arg1_align
, arg2_align
)));
4025 enum machine_mode mode
;
4028 /* Return the value in the proper mode for this function. */
4029 mode
= TYPE_MODE (TREE_TYPE (exp
));
4030 if (GET_MODE (result
) == mode
)
4033 return convert_to_mode (mode
, result
, 0);
4034 convert_move (target
, result
, 0);
4038 /* Expand the library call ourselves using a stabilized argument
4039 list to avoid re-evaluating the function's arguments twice. */
4040 #ifdef HAVE_cmpstrnsi
4043 fndecl
= get_callee_fndecl (exp
);
4044 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 2, arg1
, arg2
);
4045 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4046 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4047 return expand_call (fn
, target
, target
== const0_rtx
);
4053 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4054 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4055 the result in TARGET, if convenient. */
4058 expand_builtin_strncmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
4059 ATTRIBUTE_UNUSED
enum machine_mode mode
)
4061 location_t loc ATTRIBUTE_UNUSED
= EXPR_LOCATION (exp
);
4063 if (!validate_arglist (exp
,
4064 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4067 /* If c_strlen can determine an expression for one of the string
4068 lengths, and it doesn't have side effects, then emit cmpstrnsi
4069 using length MIN(strlen(string)+1, arg3). */
4070 #ifdef HAVE_cmpstrnsi
4073 tree len
, len1
, len2
;
4074 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
4077 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4078 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4079 tree arg3
= CALL_EXPR_ARG (exp
, 2);
4081 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4082 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4083 enum machine_mode insn_mode
4084 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
4086 len1
= c_strlen (arg1
, 1);
4087 len2
= c_strlen (arg2
, 1);
4090 len1
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len1
);
4092 len2
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len2
);
4094 /* If we don't have a constant length for the first, use the length
4095 of the second, if we know it. We don't require a constant for
4096 this case; some cost analysis could be done if both are available
4097 but neither is constant. For now, assume they're equally cheap,
4098 unless one has side effects. If both strings have constant lengths,
4105 else if (TREE_SIDE_EFFECTS (len1
))
4107 else if (TREE_SIDE_EFFECTS (len2
))
4109 else if (TREE_CODE (len1
) != INTEGER_CST
)
4111 else if (TREE_CODE (len2
) != INTEGER_CST
)
4113 else if (tree_int_cst_lt (len1
, len2
))
4118 /* If both arguments have side effects, we cannot optimize. */
4119 if (!len
|| TREE_SIDE_EFFECTS (len
))
4122 /* The actual new length parameter is MIN(len,arg3). */
4123 len
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (len
), len
,
4124 fold_convert_loc (loc
, TREE_TYPE (len
), arg3
));
4126 /* If we don't have POINTER_TYPE, call the function. */
4127 if (arg1_align
== 0 || arg2_align
== 0)
4130 /* Make a place to write the result of the instruction. */
4133 && REG_P (result
) && GET_MODE (result
) == insn_mode
4134 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
4135 result
= gen_reg_rtx (insn_mode
);
4137 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4138 arg1
= builtin_save_expr (arg1
);
4139 arg2
= builtin_save_expr (arg2
);
4140 len
= builtin_save_expr (len
);
4142 arg1_rtx
= get_memory_rtx (arg1
, len
);
4143 arg2_rtx
= get_memory_rtx (arg2
, len
);
4144 arg3_rtx
= expand_normal (len
);
4145 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
4146 GEN_INT (MIN (arg1_align
, arg2_align
)));
4151 /* Return the value in the proper mode for this function. */
4152 mode
= TYPE_MODE (TREE_TYPE (exp
));
4153 if (GET_MODE (result
) == mode
)
4156 return convert_to_mode (mode
, result
, 0);
4157 convert_move (target
, result
, 0);
4161 /* Expand the library call ourselves using a stabilized argument
4162 list to avoid re-evaluating the function's arguments twice. */
4163 fndecl
= get_callee_fndecl (exp
);
4164 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 3,
4166 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4167 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4168 return expand_call (fn
, target
, target
== const0_rtx
);
4174 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4175 if that's convenient. */
4178 expand_builtin_saveregs (void)
4182 /* Don't do __builtin_saveregs more than once in a function.
4183 Save the result of the first call and reuse it. */
4184 if (saveregs_value
!= 0)
4185 return saveregs_value
;
4187 /* When this function is called, it means that registers must be
4188 saved on entry to this function. So we migrate the call to the
4189 first insn of this function. */
4193 /* Do whatever the machine needs done in this case. */
4194 val
= targetm
.calls
.expand_builtin_saveregs ();
4199 saveregs_value
= val
;
4201 /* Put the insns after the NOTE that starts the function. If this
4202 is inside a start_sequence, make the outer-level insn chain current, so
4203 the code is placed at the start of the function. */
4204 push_topmost_sequence ();
4205 emit_insn_after (seq
, entry_of_function ());
4206 pop_topmost_sequence ();
4211 /* Expand a call to __builtin_next_arg. */
4214 expand_builtin_next_arg (void)
4216 /* Checking arguments is already done in fold_builtin_next_arg
4217 that must be called before this function. */
4218 return expand_binop (ptr_mode
, add_optab
,
4219 crtl
->args
.internal_arg_pointer
,
4220 crtl
->args
.arg_offset_rtx
,
4221 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4224 /* Make it easier for the backends by protecting the valist argument
4225 from multiple evaluations. */
4228 stabilize_va_list_loc (location_t loc
, tree valist
, int needs_lvalue
)
4230 tree vatype
= targetm
.canonical_va_list_type (TREE_TYPE (valist
));
4232 /* The current way of determining the type of valist is completely
4233 bogus. We should have the information on the va builtin instead. */
4235 vatype
= targetm
.fn_abi_va_list (cfun
->decl
);
4237 if (TREE_CODE (vatype
) == ARRAY_TYPE
)
4239 if (TREE_SIDE_EFFECTS (valist
))
4240 valist
= save_expr (valist
);
4242 /* For this case, the backends will be expecting a pointer to
4243 vatype, but it's possible we've actually been given an array
4244 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4246 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4248 tree p1
= build_pointer_type (TREE_TYPE (vatype
));
4249 valist
= build_fold_addr_expr_with_type_loc (loc
, valist
, p1
);
4254 tree pt
= build_pointer_type (vatype
);
4258 if (! TREE_SIDE_EFFECTS (valist
))
4261 valist
= fold_build1_loc (loc
, ADDR_EXPR
, pt
, valist
);
4262 TREE_SIDE_EFFECTS (valist
) = 1;
4265 if (TREE_SIDE_EFFECTS (valist
))
4266 valist
= save_expr (valist
);
4267 valist
= fold_build2_loc (loc
, MEM_REF
,
4268 vatype
, valist
, build_int_cst (pt
, 0));
4274 /* The "standard" definition of va_list is void*. */
4277 std_build_builtin_va_list (void)
4279 return ptr_type_node
;
4282 /* The "standard" abi va_list is va_list_type_node. */
4285 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED
)
4287 return va_list_type_node
;
4290 /* The "standard" type of va_list is va_list_type_node. */
4293 std_canonical_va_list_type (tree type
)
4297 if (INDIRECT_REF_P (type
))
4298 type
= TREE_TYPE (type
);
4299 else if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (TREE_TYPE (type
)))
4300 type
= TREE_TYPE (type
);
4301 wtype
= va_list_type_node
;
4303 /* Treat structure va_list types. */
4304 if (TREE_CODE (wtype
) == RECORD_TYPE
&& POINTER_TYPE_P (htype
))
4305 htype
= TREE_TYPE (htype
);
4306 else if (TREE_CODE (wtype
) == ARRAY_TYPE
)
4308 /* If va_list is an array type, the argument may have decayed
4309 to a pointer type, e.g. by being passed to another function.
4310 In that case, unwrap both types so that we can compare the
4311 underlying records. */
4312 if (TREE_CODE (htype
) == ARRAY_TYPE
4313 || POINTER_TYPE_P (htype
))
4315 wtype
= TREE_TYPE (wtype
);
4316 htype
= TREE_TYPE (htype
);
4319 if (TYPE_MAIN_VARIANT (wtype
) == TYPE_MAIN_VARIANT (htype
))
4320 return va_list_type_node
;
4325 /* The "standard" implementation of va_start: just assign `nextarg' to
4329 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4331 rtx va_r
= expand_expr (valist
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4332 convert_move (va_r
, nextarg
, 0);
4335 /* Expand EXP, a call to __builtin_va_start. */
4338 expand_builtin_va_start (tree exp
)
4342 location_t loc
= EXPR_LOCATION (exp
);
4344 if (call_expr_nargs (exp
) < 2)
4346 error_at (loc
, "too few arguments to function %<va_start%>");
4350 if (fold_builtin_next_arg (exp
, true))
4353 nextarg
= expand_builtin_next_arg ();
4354 valist
= stabilize_va_list_loc (loc
, CALL_EXPR_ARG (exp
, 0), 1);
4356 if (targetm
.expand_builtin_va_start
)
4357 targetm
.expand_builtin_va_start (valist
, nextarg
);
4359 std_expand_builtin_va_start (valist
, nextarg
);
4364 /* Expand EXP, a call to __builtin_va_end. */
4367 expand_builtin_va_end (tree exp
)
4369 tree valist
= CALL_EXPR_ARG (exp
, 0);
4371 /* Evaluate for side effects, if needed. I hate macros that don't
4373 if (TREE_SIDE_EFFECTS (valist
))
4374 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4379 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4380 builtin rather than just as an assignment in stdarg.h because of the
4381 nastiness of array-type va_list types. */
4384 expand_builtin_va_copy (tree exp
)
4387 location_t loc
= EXPR_LOCATION (exp
);
4389 dst
= CALL_EXPR_ARG (exp
, 0);
4390 src
= CALL_EXPR_ARG (exp
, 1);
4392 dst
= stabilize_va_list_loc (loc
, dst
, 1);
4393 src
= stabilize_va_list_loc (loc
, src
, 0);
4395 gcc_assert (cfun
!= NULL
&& cfun
->decl
!= NULL_TREE
);
4397 if (TREE_CODE (targetm
.fn_abi_va_list (cfun
->decl
)) != ARRAY_TYPE
)
4399 t
= build2 (MODIFY_EXPR
, targetm
.fn_abi_va_list (cfun
->decl
), dst
, src
);
4400 TREE_SIDE_EFFECTS (t
) = 1;
4401 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4405 rtx dstb
, srcb
, size
;
4407 /* Evaluate to pointers. */
4408 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4409 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4410 size
= expand_expr (TYPE_SIZE_UNIT (targetm
.fn_abi_va_list (cfun
->decl
)),
4411 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
4413 dstb
= convert_memory_address (Pmode
, dstb
);
4414 srcb
= convert_memory_address (Pmode
, srcb
);
4416 /* "Dereference" to BLKmode memories. */
4417 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4418 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4419 set_mem_align (dstb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4420 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4421 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4422 set_mem_align (srcb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
4425 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4431 /* Expand a call to one of the builtin functions __builtin_frame_address or
4432 __builtin_return_address. */
4435 expand_builtin_frame_address (tree fndecl
, tree exp
)
4437 /* The argument must be a nonnegative integer constant.
4438 It counts the number of frames to scan up the stack.
4439 The value is the return address saved in that frame. */
4440 if (call_expr_nargs (exp
) == 0)
4441 /* Warning about missing arg was already issued. */
4443 else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp
, 0)))
4445 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4446 error ("invalid argument to %<__builtin_frame_address%>");
4448 error ("invalid argument to %<__builtin_return_address%>");
4454 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4455 tree_to_uhwi (CALL_EXPR_ARG (exp
, 0)));
4457 /* Some ports cannot access arbitrary stack frames. */
4460 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4461 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4463 warning (0, "unsupported argument to %<__builtin_return_address%>");
4467 /* For __builtin_frame_address, return what we've got. */
4468 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4472 && ! CONSTANT_P (tem
))
4473 tem
= copy_addr_to_reg (tem
);
4478 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4479 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4480 is the same as for allocate_dynamic_stack_space. */
4483 expand_builtin_alloca (tree exp
, bool cannot_accumulate
)
4489 bool alloca_with_align
= (DECL_FUNCTION_CODE (get_callee_fndecl (exp
))
4490 == BUILT_IN_ALLOCA_WITH_ALIGN
);
4493 = (alloca_with_align
4494 ? validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
4495 : validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
));
4500 /* Compute the argument. */
4501 op0
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4503 /* Compute the alignment. */
4504 align
= (alloca_with_align
4505 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp
, 1))
4506 : BIGGEST_ALIGNMENT
);
4508 /* Allocate the desired space. */
4509 result
= allocate_dynamic_stack_space (op0
, 0, align
, cannot_accumulate
);
4510 result
= convert_memory_address (ptr_mode
, result
);
4515 /* Expand a call to bswap builtin in EXP.
4516 Return NULL_RTX if a normal call should be emitted rather than expanding the
4517 function in-line. If convenient, the result should be placed in TARGET.
4518 SUBTARGET may be used as the target for computing one of EXP's operands. */
4521 expand_builtin_bswap (enum machine_mode target_mode
, tree exp
, rtx target
,
4527 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4530 arg
= CALL_EXPR_ARG (exp
, 0);
4531 op0
= expand_expr (arg
,
4532 subtarget
&& GET_MODE (subtarget
) == target_mode
4533 ? subtarget
: NULL_RTX
,
4534 target_mode
, EXPAND_NORMAL
);
4535 if (GET_MODE (op0
) != target_mode
)
4536 op0
= convert_to_mode (target_mode
, op0
, 1);
4538 target
= expand_unop (target_mode
, bswap_optab
, op0
, target
, 1);
4540 gcc_assert (target
);
4542 return convert_to_mode (target_mode
, target
, 1);
4545 /* Expand a call to a unary builtin in EXP.
4546 Return NULL_RTX if a normal call should be emitted rather than expanding the
4547 function in-line. If convenient, the result should be placed in TARGET.
4548 SUBTARGET may be used as the target for computing one of EXP's operands. */
4551 expand_builtin_unop (enum machine_mode target_mode
, tree exp
, rtx target
,
4552 rtx subtarget
, optab op_optab
)
4556 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
4559 /* Compute the argument. */
4560 op0
= expand_expr (CALL_EXPR_ARG (exp
, 0),
4562 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0)))
4563 == GET_MODE (subtarget
))) ? subtarget
: NULL_RTX
,
4564 VOIDmode
, EXPAND_NORMAL
);
4565 /* Compute op, into TARGET if possible.
4566 Set TARGET to wherever the result comes back. */
4567 target
= expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))),
4568 op_optab
, op0
, target
, op_optab
!= clrsb_optab
);
4569 gcc_assert (target
);
4571 return convert_to_mode (target_mode
, target
, 0);
4574 /* Expand a call to __builtin_expect. We just return our argument
4575 as the builtin_expect semantic should've been already executed by
4576 tree branch prediction pass. */
4579 expand_builtin_expect (tree exp
, rtx target
)
4583 if (call_expr_nargs (exp
) < 2)
4585 arg
= CALL_EXPR_ARG (exp
, 0);
4587 target
= expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
4588 /* When guessing was done, the hints should be already stripped away. */
4589 gcc_assert (!flag_guess_branch_prob
4590 || optimize
== 0 || seen_error ());
4594 /* Expand a call to __builtin_assume_aligned. We just return our first
4595 argument as the builtin_assume_aligned semantic should've been already
4599 expand_builtin_assume_aligned (tree exp
, rtx target
)
4601 if (call_expr_nargs (exp
) < 2)
4603 target
= expand_expr (CALL_EXPR_ARG (exp
, 0), target
, VOIDmode
,
4605 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 1))
4606 && (call_expr_nargs (exp
) < 3
4607 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 2))));
4612 expand_builtin_trap (void)
4617 rtx insn
= emit_insn (gen_trap ());
4618 /* For trap insns when not accumulating outgoing args force
4619 REG_ARGS_SIZE note to prevent crossjumping of calls with
4620 different args sizes. */
4621 if (!ACCUMULATE_OUTGOING_ARGS
)
4622 add_reg_note (insn
, REG_ARGS_SIZE
, GEN_INT (stack_pointer_delta
));
4626 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4630 /* Expand a call to __builtin_unreachable. We do nothing except emit
4631 a barrier saying that control flow will not pass here.
4633 It is the responsibility of the program being compiled to ensure
4634 that control flow does never reach __builtin_unreachable. */
4636 expand_builtin_unreachable (void)
4641 /* Expand EXP, a call to fabs, fabsf or fabsl.
4642 Return NULL_RTX if a normal call should be emitted rather than expanding
4643 the function inline. If convenient, the result should be placed
4644 in TARGET. SUBTARGET may be used as the target for computing
4648 expand_builtin_fabs (tree exp
, rtx target
, rtx subtarget
)
4650 enum machine_mode mode
;
4654 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
4657 arg
= CALL_EXPR_ARG (exp
, 0);
4658 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
4659 mode
= TYPE_MODE (TREE_TYPE (arg
));
4660 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
4661 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4664 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4665 Return NULL is a normal call should be emitted rather than expanding the
4666 function inline. If convenient, the result should be placed in TARGET.
4667 SUBTARGET may be used as the target for computing the operand. */
4670 expand_builtin_copysign (tree exp
, rtx target
, rtx subtarget
)
4675 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
4678 arg
= CALL_EXPR_ARG (exp
, 0);
4679 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
4681 arg
= CALL_EXPR_ARG (exp
, 1);
4682 op1
= expand_normal (arg
);
4684 return expand_copysign (op0
, op1
, target
);
4687 /* Create a new constant string literal and return a char* pointer to it.
4688 The STRING_CST value is the LEN characters at STR. */
4690 build_string_literal (int len
, const char *str
)
4692 tree t
, elem
, index
, type
;
4694 t
= build_string (len
, str
);
4695 elem
= build_type_variant (char_type_node
, 1, 0);
4696 index
= build_index_type (size_int (len
- 1));
4697 type
= build_array_type (elem
, index
);
4698 TREE_TYPE (t
) = type
;
4699 TREE_CONSTANT (t
) = 1;
4700 TREE_READONLY (t
) = 1;
4701 TREE_STATIC (t
) = 1;
4703 type
= build_pointer_type (elem
);
4704 t
= build1 (ADDR_EXPR
, type
,
4705 build4 (ARRAY_REF
, elem
,
4706 t
, integer_zero_node
, NULL_TREE
, NULL_TREE
));
4710 /* Expand a call to __builtin___clear_cache. */
4713 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED
)
4715 #ifndef HAVE_clear_cache
4716 #ifdef CLEAR_INSN_CACHE
4717 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4718 does something. Just do the default expansion to a call to
4722 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4723 does nothing. There is no need to call it. Do nothing. */
4725 #endif /* CLEAR_INSN_CACHE */
4727 /* We have a "clear_cache" insn, and it will handle everything. */
4729 rtx begin_rtx
, end_rtx
;
4731 /* We must not expand to a library call. If we did, any
4732 fallback library function in libgcc that might contain a call to
4733 __builtin___clear_cache() would recurse infinitely. */
4734 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4736 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4740 if (HAVE_clear_cache
)
4742 struct expand_operand ops
[2];
4744 begin
= CALL_EXPR_ARG (exp
, 0);
4745 begin_rtx
= expand_expr (begin
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4747 end
= CALL_EXPR_ARG (exp
, 1);
4748 end_rtx
= expand_expr (end
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4750 create_address_operand (&ops
[0], begin_rtx
);
4751 create_address_operand (&ops
[1], end_rtx
);
4752 if (maybe_expand_insn (CODE_FOR_clear_cache
, 2, ops
))
4756 #endif /* HAVE_clear_cache */
4759 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
4762 round_trampoline_addr (rtx tramp
)
4764 rtx temp
, addend
, mask
;
4766 /* If we don't need too much alignment, we'll have been guaranteed
4767 proper alignment by get_trampoline_type. */
4768 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
4771 /* Round address up to desired boundary. */
4772 temp
= gen_reg_rtx (Pmode
);
4773 addend
= gen_int_mode (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1, Pmode
);
4774 mask
= gen_int_mode (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
, Pmode
);
4776 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
4777 temp
, 0, OPTAB_LIB_WIDEN
);
4778 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
4779 temp
, 0, OPTAB_LIB_WIDEN
);
4785 expand_builtin_init_trampoline (tree exp
, bool onstack
)
4787 tree t_tramp
, t_func
, t_chain
;
4788 rtx m_tramp
, r_tramp
, r_chain
, tmp
;
4790 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
,
4791 POINTER_TYPE
, VOID_TYPE
))
4794 t_tramp
= CALL_EXPR_ARG (exp
, 0);
4795 t_func
= CALL_EXPR_ARG (exp
, 1);
4796 t_chain
= CALL_EXPR_ARG (exp
, 2);
4798 r_tramp
= expand_normal (t_tramp
);
4799 m_tramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
4800 MEM_NOTRAP_P (m_tramp
) = 1;
4802 /* If ONSTACK, the TRAMP argument should be the address of a field
4803 within the local function's FRAME decl. Either way, let's see if
4804 we can fill in the MEM_ATTRs for this memory. */
4805 if (TREE_CODE (t_tramp
) == ADDR_EXPR
)
4806 set_mem_attributes (m_tramp
, TREE_OPERAND (t_tramp
, 0), true);
4808 /* Creator of a heap trampoline is responsible for making sure the
4809 address is aligned to at least STACK_BOUNDARY. Normally malloc
4810 will ensure this anyhow. */
4811 tmp
= round_trampoline_addr (r_tramp
);
4814 m_tramp
= change_address (m_tramp
, BLKmode
, tmp
);
4815 set_mem_align (m_tramp
, TRAMPOLINE_ALIGNMENT
);
4816 set_mem_size (m_tramp
, TRAMPOLINE_SIZE
);
4819 /* The FUNC argument should be the address of the nested function.
4820 Extract the actual function decl to pass to the hook. */
4821 gcc_assert (TREE_CODE (t_func
) == ADDR_EXPR
);
4822 t_func
= TREE_OPERAND (t_func
, 0);
4823 gcc_assert (TREE_CODE (t_func
) == FUNCTION_DECL
);
4825 r_chain
= expand_normal (t_chain
);
4827 /* Generate insns to initialize the trampoline. */
4828 targetm
.calls
.trampoline_init (m_tramp
, t_func
, r_chain
);
4832 trampolines_created
= 1;
4834 warning_at (DECL_SOURCE_LOCATION (t_func
), OPT_Wtrampolines
,
4835 "trampoline generated for nested function %qD", t_func
);
4842 expand_builtin_adjust_trampoline (tree exp
)
4846 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
4849 tramp
= expand_normal (CALL_EXPR_ARG (exp
, 0));
4850 tramp
= round_trampoline_addr (tramp
);
4851 if (targetm
.calls
.trampoline_adjust_address
)
4852 tramp
= targetm
.calls
.trampoline_adjust_address (tramp
);
4857 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4858 function. The function first checks whether the back end provides
4859 an insn to implement signbit for the respective mode. If not, it
4860 checks whether the floating point format of the value is such that
4861 the sign bit can be extracted. If that is not the case, the
4862 function returns NULL_RTX to indicate that a normal call should be
4863 emitted rather than expanding the function in-line. EXP is the
4864 expression that is a call to the builtin function; if convenient,
4865 the result should be placed in TARGET. */
4867 expand_builtin_signbit (tree exp
, rtx target
)
4869 const struct real_format
*fmt
;
4870 enum machine_mode fmode
, imode
, rmode
;
4873 enum insn_code icode
;
4875 location_t loc
= EXPR_LOCATION (exp
);
4877 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
4880 arg
= CALL_EXPR_ARG (exp
, 0);
4881 fmode
= TYPE_MODE (TREE_TYPE (arg
));
4882 rmode
= TYPE_MODE (TREE_TYPE (exp
));
4883 fmt
= REAL_MODE_FORMAT (fmode
);
4885 arg
= builtin_save_expr (arg
);
4887 /* Expand the argument yielding a RTX expression. */
4888 temp
= expand_normal (arg
);
4890 /* Check if the back end provides an insn that handles signbit for the
4892 icode
= optab_handler (signbit_optab
, fmode
);
4893 if (icode
!= CODE_FOR_nothing
)
4895 rtx last
= get_last_insn ();
4896 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
4897 if (maybe_emit_unop_insn (icode
, target
, temp
, UNKNOWN
))
4899 delete_insns_since (last
);
4902 /* For floating point formats without a sign bit, implement signbit
4904 bitpos
= fmt
->signbit_ro
;
4907 /* But we can't do this if the format supports signed zero. */
4908 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
4911 arg
= fold_build2_loc (loc
, LT_EXPR
, TREE_TYPE (exp
), arg
,
4912 build_real (TREE_TYPE (arg
), dconst0
));
4913 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
4916 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
4918 imode
= int_mode_for_mode (fmode
);
4919 if (imode
== BLKmode
)
4921 temp
= gen_lowpart (imode
, temp
);
4926 /* Handle targets with different FP word orders. */
4927 if (FLOAT_WORDS_BIG_ENDIAN
)
4928 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
4930 word
= bitpos
/ BITS_PER_WORD
;
4931 temp
= operand_subword_force (temp
, word
, fmode
);
4932 bitpos
= bitpos
% BITS_PER_WORD
;
4935 /* Force the intermediate word_mode (or narrower) result into a
4936 register. This avoids attempting to create paradoxical SUBREGs
4937 of floating point modes below. */
4938 temp
= force_reg (imode
, temp
);
4940 /* If the bitpos is within the "result mode" lowpart, the operation
4941 can be implement with a single bitwise AND. Otherwise, we need
4942 a right shift and an AND. */
4944 if (bitpos
< GET_MODE_BITSIZE (rmode
))
4946 double_int mask
= double_int_zero
.set_bit (bitpos
);
4948 if (GET_MODE_SIZE (imode
) > GET_MODE_SIZE (rmode
))
4949 temp
= gen_lowpart (rmode
, temp
);
4950 temp
= expand_binop (rmode
, and_optab
, temp
,
4951 immed_double_int_const (mask
, rmode
),
4952 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
4956 /* Perform a logical right shift to place the signbit in the least
4957 significant bit, then truncate the result to the desired mode
4958 and mask just this bit. */
4959 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
, bitpos
, NULL_RTX
, 1);
4960 temp
= gen_lowpart (rmode
, temp
);
4961 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
4962 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
4968 /* Expand fork or exec calls. TARGET is the desired target of the
4969 call. EXP is the call. FN is the
4970 identificator of the actual function. IGNORE is nonzero if the
4971 value is to be ignored. */
4974 expand_builtin_fork_or_exec (tree fn
, tree exp
, rtx target
, int ignore
)
4979 /* If we are not profiling, just call the function. */
4980 if (!profile_arc_flag
)
4983 /* Otherwise call the wrapper. This should be equivalent for the rest of
4984 compiler, so the code does not diverge, and the wrapper may run the
4985 code necessary for keeping the profiling sane. */
4987 switch (DECL_FUNCTION_CODE (fn
))
4990 id
= get_identifier ("__gcov_fork");
4993 case BUILT_IN_EXECL
:
4994 id
= get_identifier ("__gcov_execl");
4997 case BUILT_IN_EXECV
:
4998 id
= get_identifier ("__gcov_execv");
5001 case BUILT_IN_EXECLP
:
5002 id
= get_identifier ("__gcov_execlp");
5005 case BUILT_IN_EXECLE
:
5006 id
= get_identifier ("__gcov_execle");
5009 case BUILT_IN_EXECVP
:
5010 id
= get_identifier ("__gcov_execvp");
5013 case BUILT_IN_EXECVE
:
5014 id
= get_identifier ("__gcov_execve");
5021 decl
= build_decl (DECL_SOURCE_LOCATION (fn
),
5022 FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5023 DECL_EXTERNAL (decl
) = 1;
5024 TREE_PUBLIC (decl
) = 1;
5025 DECL_ARTIFICIAL (decl
) = 1;
5026 TREE_NOTHROW (decl
) = 1;
5027 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5028 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5029 call
= rewrite_call_expr (EXPR_LOCATION (exp
), exp
, 0, decl
, 0);
5030 return expand_call (call
, target
, ignore
);
5035 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5036 the pointer in these functions is void*, the tree optimizers may remove
5037 casts. The mode computed in expand_builtin isn't reliable either, due
5038 to __sync_bool_compare_and_swap.
5040 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5041 group of builtins. This gives us log2 of the mode size. */
5043 static inline enum machine_mode
5044 get_builtin_sync_mode (int fcode_diff
)
5046 /* The size is not negotiable, so ask not to get BLKmode in return
5047 if the target indicates that a smaller size would be better. */
5048 return mode_for_size (BITS_PER_UNIT
<< fcode_diff
, MODE_INT
, 0);
5051 /* Expand the memory expression LOC and return the appropriate memory operand
5052 for the builtin_sync operations. */
5055 get_builtin_sync_mem (tree loc
, enum machine_mode mode
)
5059 addr
= expand_expr (loc
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
5060 addr
= convert_memory_address (Pmode
, addr
);
5062 /* Note that we explicitly do not want any alias information for this
5063 memory, so that we kill all other live memories. Otherwise we don't
5064 satisfy the full barrier semantics of the intrinsic. */
5065 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5067 /* The alignment needs to be at least according to that of the mode. */
5068 set_mem_align (mem
, MAX (GET_MODE_ALIGNMENT (mode
),
5069 get_pointer_alignment (loc
)));
5070 set_mem_alias_set (mem
, ALIAS_SET_MEMORY_BARRIER
);
5071 MEM_VOLATILE_P (mem
) = 1;
5076 /* Make sure an argument is in the right mode.
5077 EXP is the tree argument.
5078 MODE is the mode it should be in. */
5081 expand_expr_force_mode (tree exp
, enum machine_mode mode
)
5084 enum machine_mode old_mode
;
5086 val
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_NORMAL
);
5087 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5088 of CONST_INTs, where we know the old_mode only from the call argument. */
5090 old_mode
= GET_MODE (val
);
5091 if (old_mode
== VOIDmode
)
5092 old_mode
= TYPE_MODE (TREE_TYPE (exp
));
5093 val
= convert_modes (mode
, old_mode
, val
, 1);
5098 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5099 EXP is the CALL_EXPR. CODE is the rtx code
5100 that corresponds to the arithmetic or logical operation from the name;
5101 an exception here is that NOT actually means NAND. TARGET is an optional
5102 place for us to store the results; AFTER is true if this is the
5103 fetch_and_xxx form. */
5106 expand_builtin_sync_operation (enum machine_mode mode
, tree exp
,
5107 enum rtx_code code
, bool after
,
5111 location_t loc
= EXPR_LOCATION (exp
);
5113 if (code
== NOT
&& warn_sync_nand
)
5115 tree fndecl
= get_callee_fndecl (exp
);
5116 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5118 static bool warned_f_a_n
, warned_n_a_f
;
5122 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
5123 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
5124 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
5125 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
5126 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
5130 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N
);
5131 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5132 warned_f_a_n
= true;
5135 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
5136 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
5137 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
5138 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
5139 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
5143 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N
);
5144 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
5145 warned_n_a_f
= true;
5153 /* Expand the operands. */
5154 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5155 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5157 return expand_atomic_fetch_op (target
, mem
, val
, code
, MEMMODEL_SEQ_CST
,
5161 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5162 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5163 true if this is the boolean form. TARGET is a place for us to store the
5164 results; this is NOT optional if IS_BOOL is true. */
5167 expand_builtin_compare_and_swap (enum machine_mode mode
, tree exp
,
5168 bool is_bool
, rtx target
)
5170 rtx old_val
, new_val
, mem
;
5173 /* Expand the operands. */
5174 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5175 old_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5176 new_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
5178 pbool
= poval
= NULL
;
5179 if (target
!= const0_rtx
)
5186 if (!expand_atomic_compare_and_swap (pbool
, poval
, mem
, old_val
, new_val
,
5187 false, MEMMODEL_SEQ_CST
,
5194 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5195 general form is actually an atomic exchange, and some targets only
5196 support a reduced form with the second argument being a constant 1.
5197 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5201 expand_builtin_sync_lock_test_and_set (enum machine_mode mode
, tree exp
,
5206 /* Expand the operands. */
5207 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5208 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5210 return expand_sync_lock_test_and_set (target
, mem
, val
);
5213 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5216 expand_builtin_sync_lock_release (enum machine_mode mode
, tree exp
)
5220 /* Expand the operands. */
5221 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5223 expand_atomic_store (mem
, const0_rtx
, MEMMODEL_RELEASE
, true);
5226 /* Given an integer representing an ``enum memmodel'', verify its
5227 correctness and return the memory model enum. */
5229 static enum memmodel
5230 get_memmodel (tree exp
)
5233 unsigned HOST_WIDE_INT val
;
5235 /* If the parameter is not a constant, it's a run time value so we'll just
5236 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5237 if (TREE_CODE (exp
) != INTEGER_CST
)
5238 return MEMMODEL_SEQ_CST
;
5240 op
= expand_normal (exp
);
5243 if (targetm
.memmodel_check
)
5244 val
= targetm
.memmodel_check (val
);
5245 else if (val
& ~MEMMODEL_MASK
)
5247 warning (OPT_Winvalid_memory_model
,
5248 "Unknown architecture specifier in memory model to builtin.");
5249 return MEMMODEL_SEQ_CST
;
5252 if ((INTVAL (op
) & MEMMODEL_MASK
) >= MEMMODEL_LAST
)
5254 warning (OPT_Winvalid_memory_model
,
5255 "invalid memory model argument to builtin");
5256 return MEMMODEL_SEQ_CST
;
5259 return (enum memmodel
) val
;
5262 /* Expand the __atomic_exchange intrinsic:
5263 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5264 EXP is the CALL_EXPR.
5265 TARGET is an optional place for us to store the results. */
5268 expand_builtin_atomic_exchange (enum machine_mode mode
, tree exp
, rtx target
)
5271 enum memmodel model
;
5273 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5274 if ((model
& MEMMODEL_MASK
) == MEMMODEL_CONSUME
)
5276 error ("invalid memory model for %<__atomic_exchange%>");
5280 if (!flag_inline_atomics
)
5283 /* Expand the operands. */
5284 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5285 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5287 return expand_atomic_exchange (target
, mem
, val
, model
);
5290 /* Expand the __atomic_compare_exchange intrinsic:
5291 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5292 TYPE desired, BOOL weak,
5293 enum memmodel success,
5294 enum memmodel failure)
5295 EXP is the CALL_EXPR.
5296 TARGET is an optional place for us to store the results. */
5299 expand_builtin_atomic_compare_exchange (enum machine_mode mode
, tree exp
,
5302 rtx expect
, desired
, mem
, oldval
, label
;
5303 enum memmodel success
, failure
;
5307 success
= get_memmodel (CALL_EXPR_ARG (exp
, 4));
5308 failure
= get_memmodel (CALL_EXPR_ARG (exp
, 5));
5310 if ((failure
& MEMMODEL_MASK
) == MEMMODEL_RELEASE
5311 || (failure
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
5313 error ("invalid failure memory model for %<__atomic_compare_exchange%>");
5317 if (failure
> success
)
5319 error ("failure memory model cannot be stronger than success "
5320 "memory model for %<__atomic_compare_exchange%>");
5324 if (!flag_inline_atomics
)
5327 /* Expand the operands. */
5328 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5330 expect
= expand_normal (CALL_EXPR_ARG (exp
, 1));
5331 expect
= convert_memory_address (Pmode
, expect
);
5332 expect
= gen_rtx_MEM (mode
, expect
);
5333 desired
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
5335 weak
= CALL_EXPR_ARG (exp
, 3);
5337 if (tree_fits_shwi_p (weak
) && tree_to_shwi (weak
) != 0)
5340 if (target
== const0_rtx
)
5343 /* Lest the rtl backend create a race condition with an imporoper store
5344 to memory, always create a new pseudo for OLDVAL. */
5347 if (!expand_atomic_compare_and_swap (&target
, &oldval
, mem
, expect
, desired
,
5348 is_weak
, success
, failure
))
5351 /* Conditionally store back to EXPECT, lest we create a race condition
5352 with an improper store to memory. */
5353 /* ??? With a rearrangement of atomics at the gimple level, we can handle
5354 the normal case where EXPECT is totally private, i.e. a register. At
5355 which point the store can be unconditional. */
5356 label
= gen_label_rtx ();
5357 emit_cmp_and_jump_insns (target
, const0_rtx
, NE
, NULL
, VOIDmode
, 1, label
);
5358 emit_move_insn (expect
, oldval
);
5364 /* Expand the __atomic_load intrinsic:
5365 TYPE __atomic_load (TYPE *object, enum memmodel)
5366 EXP is the CALL_EXPR.
5367 TARGET is an optional place for us to store the results. */
5370 expand_builtin_atomic_load (enum machine_mode mode
, tree exp
, rtx target
)
5373 enum memmodel model
;
5375 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5376 if ((model
& MEMMODEL_MASK
) == MEMMODEL_RELEASE
5377 || (model
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
5379 error ("invalid memory model for %<__atomic_load%>");
5383 if (!flag_inline_atomics
)
5386 /* Expand the operand. */
5387 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5389 return expand_atomic_load (target
, mem
, model
);
5393 /* Expand the __atomic_store intrinsic:
5394 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5395 EXP is the CALL_EXPR.
5396 TARGET is an optional place for us to store the results. */
5399 expand_builtin_atomic_store (enum machine_mode mode
, tree exp
)
5402 enum memmodel model
;
5404 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5405 if ((model
& MEMMODEL_MASK
) != MEMMODEL_RELAXED
5406 && (model
& MEMMODEL_MASK
) != MEMMODEL_SEQ_CST
5407 && (model
& MEMMODEL_MASK
) != MEMMODEL_RELEASE
)
5409 error ("invalid memory model for %<__atomic_store%>");
5413 if (!flag_inline_atomics
)
5416 /* Expand the operands. */
5417 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5418 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5420 return expand_atomic_store (mem
, val
, model
, false);
5423 /* Expand the __atomic_fetch_XXX intrinsic:
5424 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5425 EXP is the CALL_EXPR.
5426 TARGET is an optional place for us to store the results.
5427 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5428 FETCH_AFTER is true if returning the result of the operation.
5429 FETCH_AFTER is false if returning the value before the operation.
5430 IGNORE is true if the result is not used.
5431 EXT_CALL is the correct builtin for an external call if this cannot be
5432 resolved to an instruction sequence. */
5435 expand_builtin_atomic_fetch_op (enum machine_mode mode
, tree exp
, rtx target
,
5436 enum rtx_code code
, bool fetch_after
,
5437 bool ignore
, enum built_in_function ext_call
)
5440 enum memmodel model
;
5444 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
5446 /* Expand the operands. */
5447 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5448 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
5450 /* Only try generating instructions if inlining is turned on. */
5451 if (flag_inline_atomics
)
5453 ret
= expand_atomic_fetch_op (target
, mem
, val
, code
, model
, fetch_after
);
5458 /* Return if a different routine isn't needed for the library call. */
5459 if (ext_call
== BUILT_IN_NONE
)
5462 /* Change the call to the specified function. */
5463 fndecl
= get_callee_fndecl (exp
);
5464 addr
= CALL_EXPR_FN (exp
);
5467 gcc_assert (TREE_OPERAND (addr
, 0) == fndecl
);
5468 TREE_OPERAND (addr
, 0) = builtin_decl_explicit (ext_call
);
5470 /* Expand the call here so we can emit trailing code. */
5471 ret
= expand_call (exp
, target
, ignore
);
5473 /* Replace the original function just in case it matters. */
5474 TREE_OPERAND (addr
, 0) = fndecl
;
5476 /* Then issue the arithmetic correction to return the right result. */
5481 ret
= expand_simple_binop (mode
, AND
, ret
, val
, NULL_RTX
, true,
5483 ret
= expand_simple_unop (mode
, NOT
, ret
, target
, true);
5486 ret
= expand_simple_binop (mode
, code
, ret
, val
, target
, true,
5493 #ifndef HAVE_atomic_clear
5494 # define HAVE_atomic_clear 0
5495 # define gen_atomic_clear(x,y) (gcc_unreachable (), NULL_RTX)
5498 /* Expand an atomic clear operation.
5499 void _atomic_clear (BOOL *obj, enum memmodel)
5500 EXP is the call expression. */
5503 expand_builtin_atomic_clear (tree exp
)
5505 enum machine_mode mode
;
5507 enum memmodel model
;
5509 mode
= mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0);
5510 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5511 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5513 if ((model
& MEMMODEL_MASK
) == MEMMODEL_ACQUIRE
5514 || (model
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
5516 error ("invalid memory model for %<__atomic_store%>");
5520 if (HAVE_atomic_clear
)
5522 emit_insn (gen_atomic_clear (mem
, model
));
5526 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5527 Failing that, a store is issued by __atomic_store. The only way this can
5528 fail is if the bool type is larger than a word size. Unlikely, but
5529 handle it anyway for completeness. Assume a single threaded model since
5530 there is no atomic support in this case, and no barriers are required. */
5531 ret
= expand_atomic_store (mem
, const0_rtx
, model
, true);
5533 emit_move_insn (mem
, const0_rtx
);
5537 /* Expand an atomic test_and_set operation.
5538 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5539 EXP is the call expression. */
5542 expand_builtin_atomic_test_and_set (tree exp
, rtx target
)
5545 enum memmodel model
;
5546 enum machine_mode mode
;
5548 mode
= mode_for_size (BOOL_TYPE_SIZE
, MODE_INT
, 0);
5549 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
5550 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
5552 return expand_atomic_test_and_set (target
, mem
, model
);
5556 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5557 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
5560 fold_builtin_atomic_always_lock_free (tree arg0
, tree arg1
)
5563 enum machine_mode mode
;
5564 unsigned int mode_align
, type_align
;
5566 if (TREE_CODE (arg0
) != INTEGER_CST
)
5569 size
= INTVAL (expand_normal (arg0
)) * BITS_PER_UNIT
;
5570 mode
= mode_for_size (size
, MODE_INT
, 0);
5571 mode_align
= GET_MODE_ALIGNMENT (mode
);
5573 if (TREE_CODE (arg1
) == INTEGER_CST
&& INTVAL (expand_normal (arg1
)) == 0)
5574 type_align
= mode_align
;
5577 tree ttype
= TREE_TYPE (arg1
);
5579 /* This function is usually invoked and folded immediately by the front
5580 end before anything else has a chance to look at it. The pointer
5581 parameter at this point is usually cast to a void *, so check for that
5582 and look past the cast. */
5583 if (TREE_CODE (arg1
) == NOP_EXPR
&& POINTER_TYPE_P (ttype
)
5584 && VOID_TYPE_P (TREE_TYPE (ttype
)))
5585 arg1
= TREE_OPERAND (arg1
, 0);
5587 ttype
= TREE_TYPE (arg1
);
5588 gcc_assert (POINTER_TYPE_P (ttype
));
5590 /* Get the underlying type of the object. */
5591 ttype
= TREE_TYPE (ttype
);
5592 type_align
= TYPE_ALIGN (ttype
);
5595 /* If the object has smaller alignment, the the lock free routines cannot
5597 if (type_align
< mode_align
)
5598 return boolean_false_node
;
5600 /* Check if a compare_and_swap pattern exists for the mode which represents
5601 the required size. The pattern is not allowed to fail, so the existence
5602 of the pattern indicates support is present. */
5603 if (can_compare_and_swap_p (mode
, true))
5604 return boolean_true_node
;
5606 return boolean_false_node
;
5609 /* Return true if the parameters to call EXP represent an object which will
5610 always generate lock free instructions. The first argument represents the
5611 size of the object, and the second parameter is a pointer to the object
5612 itself. If NULL is passed for the object, then the result is based on
5613 typical alignment for an object of the specified size. Otherwise return
5617 expand_builtin_atomic_always_lock_free (tree exp
)
5620 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5621 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5623 if (TREE_CODE (arg0
) != INTEGER_CST
)
5625 error ("non-constant argument 1 to __atomic_always_lock_free");
5629 size
= fold_builtin_atomic_always_lock_free (arg0
, arg1
);
5630 if (size
== boolean_true_node
)
5635 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5636 is lock free on this architecture. */
5639 fold_builtin_atomic_is_lock_free (tree arg0
, tree arg1
)
5641 if (!flag_inline_atomics
)
5644 /* If it isn't always lock free, don't generate a result. */
5645 if (fold_builtin_atomic_always_lock_free (arg0
, arg1
) == boolean_true_node
)
5646 return boolean_true_node
;
5651 /* Return true if the parameters to call EXP represent an object which will
5652 always generate lock free instructions. The first argument represents the
5653 size of the object, and the second parameter is a pointer to the object
5654 itself. If NULL is passed for the object, then the result is based on
5655 typical alignment for an object of the specified size. Otherwise return
5659 expand_builtin_atomic_is_lock_free (tree exp
)
5662 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5663 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5665 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
5667 error ("non-integer argument 1 to __atomic_is_lock_free");
5671 if (!flag_inline_atomics
)
5674 /* If the value is known at compile time, return the RTX for it. */
5675 size
= fold_builtin_atomic_is_lock_free (arg0
, arg1
);
5676 if (size
== boolean_true_node
)
5682 /* Expand the __atomic_thread_fence intrinsic:
5683 void __atomic_thread_fence (enum memmodel)
5684 EXP is the CALL_EXPR. */
5687 expand_builtin_atomic_thread_fence (tree exp
)
5689 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
5690 expand_mem_thread_fence (model
);
5693 /* Expand the __atomic_signal_fence intrinsic:
5694 void __atomic_signal_fence (enum memmodel)
5695 EXP is the CALL_EXPR. */
5698 expand_builtin_atomic_signal_fence (tree exp
)
5700 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
5701 expand_mem_signal_fence (model
);
5704 /* Expand the __sync_synchronize intrinsic. */
5707 expand_builtin_sync_synchronize (void)
5709 expand_mem_thread_fence (MEMMODEL_SEQ_CST
);
5713 expand_builtin_thread_pointer (tree exp
, rtx target
)
5715 enum insn_code icode
;
5716 if (!validate_arglist (exp
, VOID_TYPE
))
5718 icode
= direct_optab_handler (get_thread_pointer_optab
, Pmode
);
5719 if (icode
!= CODE_FOR_nothing
)
5721 struct expand_operand op
;
5722 /* If the target is not sutitable then create a new target. */
5723 if (target
== NULL_RTX
5725 || GET_MODE (target
) != Pmode
)
5726 target
= gen_reg_rtx (Pmode
);
5727 create_output_operand (&op
, target
, Pmode
);
5728 expand_insn (icode
, 1, &op
);
5731 error ("__builtin_thread_pointer is not supported on this target");
5736 expand_builtin_set_thread_pointer (tree exp
)
5738 enum insn_code icode
;
5739 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5741 icode
= direct_optab_handler (set_thread_pointer_optab
, Pmode
);
5742 if (icode
!= CODE_FOR_nothing
)
5744 struct expand_operand op
;
5745 rtx val
= expand_expr (CALL_EXPR_ARG (exp
, 0), NULL_RTX
,
5746 Pmode
, EXPAND_NORMAL
);
5747 create_input_operand (&op
, val
, Pmode
);
5748 expand_insn (icode
, 1, &op
);
5751 error ("__builtin_set_thread_pointer is not supported on this target");
5755 /* Emit code to restore the current value of stack. */
5758 expand_stack_restore (tree var
)
5760 rtx prev
, sa
= expand_normal (var
);
5762 sa
= convert_memory_address (Pmode
, sa
);
5764 prev
= get_last_insn ();
5765 emit_stack_restore (SAVE_BLOCK
, sa
);
5766 fixup_args_size_notes (prev
, get_last_insn (), 0);
5770 /* Emit code to save the current value of stack. */
5773 expand_stack_save (void)
5777 do_pending_stack_adjust ();
5778 emit_stack_save (SAVE_BLOCK
, &ret
);
5782 /* Expand an expression EXP that calls a built-in function,
5783 with result going to TARGET if that's convenient
5784 (and in mode MODE if that's convenient).
5785 SUBTARGET may be used as the target for computing one of EXP's operands.
5786 IGNORE is nonzero if the value is to be ignored. */
5789 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5792 tree fndecl
= get_callee_fndecl (exp
);
5793 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5794 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5797 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5798 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5800 /* When not optimizing, generate calls to library functions for a certain
5803 && !called_as_built_in (fndecl
)
5804 && fcode
!= BUILT_IN_FORK
5805 && fcode
!= BUILT_IN_EXECL
5806 && fcode
!= BUILT_IN_EXECV
5807 && fcode
!= BUILT_IN_EXECLP
5808 && fcode
!= BUILT_IN_EXECLE
5809 && fcode
!= BUILT_IN_EXECVP
5810 && fcode
!= BUILT_IN_EXECVE
5811 && fcode
!= BUILT_IN_ALLOCA
5812 && fcode
!= BUILT_IN_ALLOCA_WITH_ALIGN
5813 && fcode
!= BUILT_IN_FREE
)
5814 return expand_call (exp
, target
, ignore
);
5816 /* The built-in function expanders test for target == const0_rtx
5817 to determine whether the function's result will be ignored. */
5819 target
= const0_rtx
;
5821 /* If the result of a pure or const built-in function is ignored, and
5822 none of its arguments are volatile, we can avoid expanding the
5823 built-in call and just evaluate the arguments for side-effects. */
5824 if (target
== const0_rtx
5825 && ((flags
= flags_from_decl_or_type (fndecl
)) & (ECF_CONST
| ECF_PURE
))
5826 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
5828 bool volatilep
= false;
5830 call_expr_arg_iterator iter
;
5832 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
5833 if (TREE_THIS_VOLATILE (arg
))
5841 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
5842 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5849 CASE_FLT_FN (BUILT_IN_FABS
):
5850 case BUILT_IN_FABSD32
:
5851 case BUILT_IN_FABSD64
:
5852 case BUILT_IN_FABSD128
:
5853 target
= expand_builtin_fabs (exp
, target
, subtarget
);
5858 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
5859 target
= expand_builtin_copysign (exp
, target
, subtarget
);
5864 /* Just do a normal library call if we were unable to fold
5866 CASE_FLT_FN (BUILT_IN_CABS
):
5869 CASE_FLT_FN (BUILT_IN_EXP
):
5870 CASE_FLT_FN (BUILT_IN_EXP10
):
5871 CASE_FLT_FN (BUILT_IN_POW10
):
5872 CASE_FLT_FN (BUILT_IN_EXP2
):
5873 CASE_FLT_FN (BUILT_IN_EXPM1
):
5874 CASE_FLT_FN (BUILT_IN_LOGB
):
5875 CASE_FLT_FN (BUILT_IN_LOG
):
5876 CASE_FLT_FN (BUILT_IN_LOG10
):
5877 CASE_FLT_FN (BUILT_IN_LOG2
):
5878 CASE_FLT_FN (BUILT_IN_LOG1P
):
5879 CASE_FLT_FN (BUILT_IN_TAN
):
5880 CASE_FLT_FN (BUILT_IN_ASIN
):
5881 CASE_FLT_FN (BUILT_IN_ACOS
):
5882 CASE_FLT_FN (BUILT_IN_ATAN
):
5883 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
5884 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5885 because of possible accuracy problems. */
5886 if (! flag_unsafe_math_optimizations
)
5888 CASE_FLT_FN (BUILT_IN_SQRT
):
5889 CASE_FLT_FN (BUILT_IN_FLOOR
):
5890 CASE_FLT_FN (BUILT_IN_CEIL
):
5891 CASE_FLT_FN (BUILT_IN_TRUNC
):
5892 CASE_FLT_FN (BUILT_IN_ROUND
):
5893 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
5894 CASE_FLT_FN (BUILT_IN_RINT
):
5895 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5900 CASE_FLT_FN (BUILT_IN_FMA
):
5901 target
= expand_builtin_mathfn_ternary (exp
, target
, subtarget
);
5906 CASE_FLT_FN (BUILT_IN_ILOGB
):
5907 if (! flag_unsafe_math_optimizations
)
5909 CASE_FLT_FN (BUILT_IN_ISINF
):
5910 CASE_FLT_FN (BUILT_IN_FINITE
):
5911 case BUILT_IN_ISFINITE
:
5912 case BUILT_IN_ISNORMAL
:
5913 target
= expand_builtin_interclass_mathfn (exp
, target
);
5918 CASE_FLT_FN (BUILT_IN_ICEIL
):
5919 CASE_FLT_FN (BUILT_IN_LCEIL
):
5920 CASE_FLT_FN (BUILT_IN_LLCEIL
):
5921 CASE_FLT_FN (BUILT_IN_LFLOOR
):
5922 CASE_FLT_FN (BUILT_IN_IFLOOR
):
5923 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
5924 target
= expand_builtin_int_roundingfn (exp
, target
);
5929 CASE_FLT_FN (BUILT_IN_IRINT
):
5930 CASE_FLT_FN (BUILT_IN_LRINT
):
5931 CASE_FLT_FN (BUILT_IN_LLRINT
):
5932 CASE_FLT_FN (BUILT_IN_IROUND
):
5933 CASE_FLT_FN (BUILT_IN_LROUND
):
5934 CASE_FLT_FN (BUILT_IN_LLROUND
):
5935 target
= expand_builtin_int_roundingfn_2 (exp
, target
);
5940 CASE_FLT_FN (BUILT_IN_POWI
):
5941 target
= expand_builtin_powi (exp
, target
);
5946 CASE_FLT_FN (BUILT_IN_ATAN2
):
5947 CASE_FLT_FN (BUILT_IN_LDEXP
):
5948 CASE_FLT_FN (BUILT_IN_SCALB
):
5949 CASE_FLT_FN (BUILT_IN_SCALBN
):
5950 CASE_FLT_FN (BUILT_IN_SCALBLN
):
5951 if (! flag_unsafe_math_optimizations
)
5954 CASE_FLT_FN (BUILT_IN_FMOD
):
5955 CASE_FLT_FN (BUILT_IN_REMAINDER
):
5956 CASE_FLT_FN (BUILT_IN_DREM
):
5957 CASE_FLT_FN (BUILT_IN_POW
):
5958 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5963 CASE_FLT_FN (BUILT_IN_CEXPI
):
5964 target
= expand_builtin_cexpi (exp
, target
);
5965 gcc_assert (target
);
5968 CASE_FLT_FN (BUILT_IN_SIN
):
5969 CASE_FLT_FN (BUILT_IN_COS
):
5970 if (! flag_unsafe_math_optimizations
)
5972 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5977 CASE_FLT_FN (BUILT_IN_SINCOS
):
5978 if (! flag_unsafe_math_optimizations
)
5980 target
= expand_builtin_sincos (exp
);
5985 case BUILT_IN_APPLY_ARGS
:
5986 return expand_builtin_apply_args ();
5988 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5989 FUNCTION with a copy of the parameters described by
5990 ARGUMENTS, and ARGSIZE. It returns a block of memory
5991 allocated on the stack into which is stored all the registers
5992 that might possibly be used for returning the result of a
5993 function. ARGUMENTS is the value returned by
5994 __builtin_apply_args. ARGSIZE is the number of bytes of
5995 arguments that must be copied. ??? How should this value be
5996 computed? We'll also need a safe worst case value for varargs
5998 case BUILT_IN_APPLY
:
5999 if (!validate_arglist (exp
, POINTER_TYPE
,
6000 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
6001 && !validate_arglist (exp
, REFERENCE_TYPE
,
6002 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6008 ops
[0] = expand_normal (CALL_EXPR_ARG (exp
, 0));
6009 ops
[1] = expand_normal (CALL_EXPR_ARG (exp
, 1));
6010 ops
[2] = expand_normal (CALL_EXPR_ARG (exp
, 2));
6012 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
6015 /* __builtin_return (RESULT) causes the function to return the
6016 value described by RESULT. RESULT is address of the block of
6017 memory returned by __builtin_apply. */
6018 case BUILT_IN_RETURN
:
6019 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6020 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp
, 0)));
6023 case BUILT_IN_SAVEREGS
:
6024 return expand_builtin_saveregs ();
6026 case BUILT_IN_VA_ARG_PACK
:
6027 /* All valid uses of __builtin_va_arg_pack () are removed during
6029 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp
);
6032 case BUILT_IN_VA_ARG_PACK_LEN
:
6033 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6035 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp
);
6038 /* Return the address of the first anonymous stack arg. */
6039 case BUILT_IN_NEXT_ARG
:
6040 if (fold_builtin_next_arg (exp
, false))
6042 return expand_builtin_next_arg ();
6044 case BUILT_IN_CLEAR_CACHE
:
6045 target
= expand_builtin___clear_cache (exp
);
6050 case BUILT_IN_CLASSIFY_TYPE
:
6051 return expand_builtin_classify_type (exp
);
6053 case BUILT_IN_CONSTANT_P
:
6056 case BUILT_IN_FRAME_ADDRESS
:
6057 case BUILT_IN_RETURN_ADDRESS
:
6058 return expand_builtin_frame_address (fndecl
, exp
);
6060 /* Returns the address of the area where the structure is returned.
6062 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
6063 if (call_expr_nargs (exp
) != 0
6064 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
6065 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
6068 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
6070 case BUILT_IN_ALLOCA
:
6071 case BUILT_IN_ALLOCA_WITH_ALIGN
:
6072 /* If the allocation stems from the declaration of a variable-sized
6073 object, it cannot accumulate. */
6074 target
= expand_builtin_alloca (exp
, CALL_ALLOCA_FOR_VAR_P (exp
));
6079 case BUILT_IN_STACK_SAVE
:
6080 return expand_stack_save ();
6082 case BUILT_IN_STACK_RESTORE
:
6083 expand_stack_restore (CALL_EXPR_ARG (exp
, 0));
6086 case BUILT_IN_BSWAP16
:
6087 case BUILT_IN_BSWAP32
:
6088 case BUILT_IN_BSWAP64
:
6089 target
= expand_builtin_bswap (target_mode
, exp
, target
, subtarget
);
6094 CASE_INT_FN (BUILT_IN_FFS
):
6095 target
= expand_builtin_unop (target_mode
, exp
, target
,
6096 subtarget
, ffs_optab
);
6101 CASE_INT_FN (BUILT_IN_CLZ
):
6102 target
= expand_builtin_unop (target_mode
, exp
, target
,
6103 subtarget
, clz_optab
);
6108 CASE_INT_FN (BUILT_IN_CTZ
):
6109 target
= expand_builtin_unop (target_mode
, exp
, target
,
6110 subtarget
, ctz_optab
);
6115 CASE_INT_FN (BUILT_IN_CLRSB
):
6116 target
= expand_builtin_unop (target_mode
, exp
, target
,
6117 subtarget
, clrsb_optab
);
6122 CASE_INT_FN (BUILT_IN_POPCOUNT
):
6123 target
= expand_builtin_unop (target_mode
, exp
, target
,
6124 subtarget
, popcount_optab
);
6129 CASE_INT_FN (BUILT_IN_PARITY
):
6130 target
= expand_builtin_unop (target_mode
, exp
, target
,
6131 subtarget
, parity_optab
);
6136 case BUILT_IN_STRLEN
:
6137 target
= expand_builtin_strlen (exp
, target
, target_mode
);
6142 case BUILT_IN_STRCPY
:
6143 target
= expand_builtin_strcpy (exp
, target
);
6148 case BUILT_IN_STRNCPY
:
6149 target
= expand_builtin_strncpy (exp
, target
);
6154 case BUILT_IN_STPCPY
:
6155 target
= expand_builtin_stpcpy (exp
, target
, mode
);
6160 case BUILT_IN_MEMCPY
:
6161 target
= expand_builtin_memcpy (exp
, target
);
6166 case BUILT_IN_MEMPCPY
:
6167 target
= expand_builtin_mempcpy (exp
, target
, mode
);
6172 case BUILT_IN_MEMSET
:
6173 target
= expand_builtin_memset (exp
, target
, mode
);
6178 case BUILT_IN_BZERO
:
6179 target
= expand_builtin_bzero (exp
);
6184 case BUILT_IN_STRCMP
:
6185 target
= expand_builtin_strcmp (exp
, target
);
6190 case BUILT_IN_STRNCMP
:
6191 target
= expand_builtin_strncmp (exp
, target
, mode
);
6197 case BUILT_IN_MEMCMP
:
6198 target
= expand_builtin_memcmp (exp
, target
, mode
);
6203 case BUILT_IN_SETJMP
:
6204 /* This should have been lowered to the builtins below. */
6207 case BUILT_IN_SETJMP_SETUP
:
6208 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6209 and the receiver label. */
6210 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
6212 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6213 VOIDmode
, EXPAND_NORMAL
);
6214 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 1), 0);
6215 rtx label_r
= label_rtx (label
);
6217 /* This is copied from the handling of non-local gotos. */
6218 expand_builtin_setjmp_setup (buf_addr
, label_r
);
6219 nonlocal_goto_handler_labels
6220 = gen_rtx_EXPR_LIST (VOIDmode
, label_r
,
6221 nonlocal_goto_handler_labels
);
6222 /* ??? Do not let expand_label treat us as such since we would
6223 not want to be both on the list of non-local labels and on
6224 the list of forced labels. */
6225 FORCED_LABEL (label
) = 0;
6230 case BUILT_IN_SETJMP_RECEIVER
:
6231 /* __builtin_setjmp_receiver is passed the receiver label. */
6232 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6234 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 0), 0);
6235 rtx label_r
= label_rtx (label
);
6237 expand_builtin_setjmp_receiver (label_r
);
6242 /* __builtin_longjmp is passed a pointer to an array of five words.
6243 It's similar to the C library longjmp function but works with
6244 __builtin_setjmp above. */
6245 case BUILT_IN_LONGJMP
:
6246 if (validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6248 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
6249 VOIDmode
, EXPAND_NORMAL
);
6250 rtx value
= expand_normal (CALL_EXPR_ARG (exp
, 1));
6252 if (value
!= const1_rtx
)
6254 error ("%<__builtin_longjmp%> second argument must be 1");
6258 expand_builtin_longjmp (buf_addr
, value
);
6263 case BUILT_IN_NONLOCAL_GOTO
:
6264 target
= expand_builtin_nonlocal_goto (exp
);
6269 /* This updates the setjmp buffer that is its argument with the value
6270 of the current stack pointer. */
6271 case BUILT_IN_UPDATE_SETJMP_BUF
:
6272 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6275 = expand_normal (CALL_EXPR_ARG (exp
, 0));
6277 expand_builtin_update_setjmp_buf (buf_addr
);
6283 expand_builtin_trap ();
6286 case BUILT_IN_UNREACHABLE
:
6287 expand_builtin_unreachable ();
6290 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
6291 case BUILT_IN_SIGNBITD32
:
6292 case BUILT_IN_SIGNBITD64
:
6293 case BUILT_IN_SIGNBITD128
:
6294 target
= expand_builtin_signbit (exp
, target
);
6299 /* Various hooks for the DWARF 2 __throw routine. */
6300 case BUILT_IN_UNWIND_INIT
:
6301 expand_builtin_unwind_init ();
6303 case BUILT_IN_DWARF_CFA
:
6304 return virtual_cfa_rtx
;
6305 #ifdef DWARF2_UNWIND_INFO
6306 case BUILT_IN_DWARF_SP_COLUMN
:
6307 return expand_builtin_dwarf_sp_column ();
6308 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6309 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp
, 0));
6312 case BUILT_IN_FROB_RETURN_ADDR
:
6313 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp
, 0));
6314 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6315 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp
, 0));
6316 case BUILT_IN_EH_RETURN
:
6317 expand_builtin_eh_return (CALL_EXPR_ARG (exp
, 0),
6318 CALL_EXPR_ARG (exp
, 1));
6320 #ifdef EH_RETURN_DATA_REGNO
6321 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6322 return expand_builtin_eh_return_data_regno (exp
);
6324 case BUILT_IN_EXTEND_POINTER
:
6325 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp
, 0));
6326 case BUILT_IN_EH_POINTER
:
6327 return expand_builtin_eh_pointer (exp
);
6328 case BUILT_IN_EH_FILTER
:
6329 return expand_builtin_eh_filter (exp
);
6330 case BUILT_IN_EH_COPY_VALUES
:
6331 return expand_builtin_eh_copy_values (exp
);
6333 case BUILT_IN_VA_START
:
6334 return expand_builtin_va_start (exp
);
6335 case BUILT_IN_VA_END
:
6336 return expand_builtin_va_end (exp
);
6337 case BUILT_IN_VA_COPY
:
6338 return expand_builtin_va_copy (exp
);
6339 case BUILT_IN_EXPECT
:
6340 return expand_builtin_expect (exp
, target
);
6341 case BUILT_IN_ASSUME_ALIGNED
:
6342 return expand_builtin_assume_aligned (exp
, target
);
6343 case BUILT_IN_PREFETCH
:
6344 expand_builtin_prefetch (exp
);
6347 case BUILT_IN_INIT_TRAMPOLINE
:
6348 return expand_builtin_init_trampoline (exp
, true);
6349 case BUILT_IN_INIT_HEAP_TRAMPOLINE
:
6350 return expand_builtin_init_trampoline (exp
, false);
6351 case BUILT_IN_ADJUST_TRAMPOLINE
:
6352 return expand_builtin_adjust_trampoline (exp
);
6355 case BUILT_IN_EXECL
:
6356 case BUILT_IN_EXECV
:
6357 case BUILT_IN_EXECLP
:
6358 case BUILT_IN_EXECLE
:
6359 case BUILT_IN_EXECVP
:
6360 case BUILT_IN_EXECVE
:
6361 target
= expand_builtin_fork_or_exec (fndecl
, exp
, target
, ignore
);
6366 case BUILT_IN_SYNC_FETCH_AND_ADD_1
:
6367 case BUILT_IN_SYNC_FETCH_AND_ADD_2
:
6368 case BUILT_IN_SYNC_FETCH_AND_ADD_4
:
6369 case BUILT_IN_SYNC_FETCH_AND_ADD_8
:
6370 case BUILT_IN_SYNC_FETCH_AND_ADD_16
:
6371 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_ADD_1
);
6372 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, false, target
);
6377 case BUILT_IN_SYNC_FETCH_AND_SUB_1
:
6378 case BUILT_IN_SYNC_FETCH_AND_SUB_2
:
6379 case BUILT_IN_SYNC_FETCH_AND_SUB_4
:
6380 case BUILT_IN_SYNC_FETCH_AND_SUB_8
:
6381 case BUILT_IN_SYNC_FETCH_AND_SUB_16
:
6382 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_SUB_1
);
6383 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, false, target
);
6388 case BUILT_IN_SYNC_FETCH_AND_OR_1
:
6389 case BUILT_IN_SYNC_FETCH_AND_OR_2
:
6390 case BUILT_IN_SYNC_FETCH_AND_OR_4
:
6391 case BUILT_IN_SYNC_FETCH_AND_OR_8
:
6392 case BUILT_IN_SYNC_FETCH_AND_OR_16
:
6393 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_OR_1
);
6394 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, false, target
);
6399 case BUILT_IN_SYNC_FETCH_AND_AND_1
:
6400 case BUILT_IN_SYNC_FETCH_AND_AND_2
:
6401 case BUILT_IN_SYNC_FETCH_AND_AND_4
:
6402 case BUILT_IN_SYNC_FETCH_AND_AND_8
:
6403 case BUILT_IN_SYNC_FETCH_AND_AND_16
:
6404 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_AND_1
);
6405 target
= expand_builtin_sync_operation (mode
, exp
, AND
, false, target
);
6410 case BUILT_IN_SYNC_FETCH_AND_XOR_1
:
6411 case BUILT_IN_SYNC_FETCH_AND_XOR_2
:
6412 case BUILT_IN_SYNC_FETCH_AND_XOR_4
:
6413 case BUILT_IN_SYNC_FETCH_AND_XOR_8
:
6414 case BUILT_IN_SYNC_FETCH_AND_XOR_16
:
6415 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_XOR_1
);
6416 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, false, target
);
6421 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
6422 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
6423 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
6424 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
6425 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
6426 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_NAND_1
);
6427 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, false, target
);
6432 case BUILT_IN_SYNC_ADD_AND_FETCH_1
:
6433 case BUILT_IN_SYNC_ADD_AND_FETCH_2
:
6434 case BUILT_IN_SYNC_ADD_AND_FETCH_4
:
6435 case BUILT_IN_SYNC_ADD_AND_FETCH_8
:
6436 case BUILT_IN_SYNC_ADD_AND_FETCH_16
:
6437 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_ADD_AND_FETCH_1
);
6438 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, true, target
);
6443 case BUILT_IN_SYNC_SUB_AND_FETCH_1
:
6444 case BUILT_IN_SYNC_SUB_AND_FETCH_2
:
6445 case BUILT_IN_SYNC_SUB_AND_FETCH_4
:
6446 case BUILT_IN_SYNC_SUB_AND_FETCH_8
:
6447 case BUILT_IN_SYNC_SUB_AND_FETCH_16
:
6448 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_SUB_AND_FETCH_1
);
6449 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, true, target
);
6454 case BUILT_IN_SYNC_OR_AND_FETCH_1
:
6455 case BUILT_IN_SYNC_OR_AND_FETCH_2
:
6456 case BUILT_IN_SYNC_OR_AND_FETCH_4
:
6457 case BUILT_IN_SYNC_OR_AND_FETCH_8
:
6458 case BUILT_IN_SYNC_OR_AND_FETCH_16
:
6459 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_OR_AND_FETCH_1
);
6460 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, true, target
);
6465 case BUILT_IN_SYNC_AND_AND_FETCH_1
:
6466 case BUILT_IN_SYNC_AND_AND_FETCH_2
:
6467 case BUILT_IN_SYNC_AND_AND_FETCH_4
:
6468 case BUILT_IN_SYNC_AND_AND_FETCH_8
:
6469 case BUILT_IN_SYNC_AND_AND_FETCH_16
:
6470 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_AND_AND_FETCH_1
);
6471 target
= expand_builtin_sync_operation (mode
, exp
, AND
, true, target
);
6476 case BUILT_IN_SYNC_XOR_AND_FETCH_1
:
6477 case BUILT_IN_SYNC_XOR_AND_FETCH_2
:
6478 case BUILT_IN_SYNC_XOR_AND_FETCH_4
:
6479 case BUILT_IN_SYNC_XOR_AND_FETCH_8
:
6480 case BUILT_IN_SYNC_XOR_AND_FETCH_16
:
6481 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_XOR_AND_FETCH_1
);
6482 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, true, target
);
6487 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
6488 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
6489 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
6490 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
6491 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
6492 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_NAND_AND_FETCH_1
);
6493 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, true, target
);
6498 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
:
6499 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2
:
6500 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4
:
6501 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8
:
6502 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16
:
6503 if (mode
== VOIDmode
)
6504 mode
= TYPE_MODE (boolean_type_node
);
6505 if (!target
|| !register_operand (target
, mode
))
6506 target
= gen_reg_rtx (mode
);
6508 mode
= get_builtin_sync_mode
6509 (fcode
- BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
);
6510 target
= expand_builtin_compare_and_swap (mode
, exp
, true, target
);
6515 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
:
6516 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2
:
6517 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4
:
6518 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8
:
6519 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16
:
6520 mode
= get_builtin_sync_mode
6521 (fcode
- BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
);
6522 target
= expand_builtin_compare_and_swap (mode
, exp
, false, target
);
6527 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
:
6528 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2
:
6529 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4
:
6530 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8
:
6531 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16
:
6532 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
);
6533 target
= expand_builtin_sync_lock_test_and_set (mode
, exp
, target
);
6538 case BUILT_IN_SYNC_LOCK_RELEASE_1
:
6539 case BUILT_IN_SYNC_LOCK_RELEASE_2
:
6540 case BUILT_IN_SYNC_LOCK_RELEASE_4
:
6541 case BUILT_IN_SYNC_LOCK_RELEASE_8
:
6542 case BUILT_IN_SYNC_LOCK_RELEASE_16
:
6543 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_RELEASE_1
);
6544 expand_builtin_sync_lock_release (mode
, exp
);
6547 case BUILT_IN_SYNC_SYNCHRONIZE
:
6548 expand_builtin_sync_synchronize ();
6551 case BUILT_IN_ATOMIC_EXCHANGE_1
:
6552 case BUILT_IN_ATOMIC_EXCHANGE_2
:
6553 case BUILT_IN_ATOMIC_EXCHANGE_4
:
6554 case BUILT_IN_ATOMIC_EXCHANGE_8
:
6555 case BUILT_IN_ATOMIC_EXCHANGE_16
:
6556 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_EXCHANGE_1
);
6557 target
= expand_builtin_atomic_exchange (mode
, exp
, target
);
6562 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
6563 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
6564 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
6565 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
6566 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
6568 unsigned int nargs
, z
;
6569 vec
<tree
, va_gc
> *vec
;
6572 get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
);
6573 target
= expand_builtin_atomic_compare_exchange (mode
, exp
, target
);
6577 /* If this is turned into an external library call, the weak parameter
6578 must be dropped to match the expected parameter list. */
6579 nargs
= call_expr_nargs (exp
);
6580 vec_alloc (vec
, nargs
- 1);
6581 for (z
= 0; z
< 3; z
++)
6582 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
6583 /* Skip the boolean weak parameter. */
6584 for (z
= 4; z
< 6; z
++)
6585 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
6586 exp
= build_call_vec (TREE_TYPE (exp
), CALL_EXPR_FN (exp
), vec
);
6590 case BUILT_IN_ATOMIC_LOAD_1
:
6591 case BUILT_IN_ATOMIC_LOAD_2
:
6592 case BUILT_IN_ATOMIC_LOAD_4
:
6593 case BUILT_IN_ATOMIC_LOAD_8
:
6594 case BUILT_IN_ATOMIC_LOAD_16
:
6595 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_LOAD_1
);
6596 target
= expand_builtin_atomic_load (mode
, exp
, target
);
6601 case BUILT_IN_ATOMIC_STORE_1
:
6602 case BUILT_IN_ATOMIC_STORE_2
:
6603 case BUILT_IN_ATOMIC_STORE_4
:
6604 case BUILT_IN_ATOMIC_STORE_8
:
6605 case BUILT_IN_ATOMIC_STORE_16
:
6606 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_STORE_1
);
6607 target
= expand_builtin_atomic_store (mode
, exp
);
6612 case BUILT_IN_ATOMIC_ADD_FETCH_1
:
6613 case BUILT_IN_ATOMIC_ADD_FETCH_2
:
6614 case BUILT_IN_ATOMIC_ADD_FETCH_4
:
6615 case BUILT_IN_ATOMIC_ADD_FETCH_8
:
6616 case BUILT_IN_ATOMIC_ADD_FETCH_16
:
6618 enum built_in_function lib
;
6619 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
);
6620 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_ADD_1
+
6621 (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
));
6622 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, true,
6628 case BUILT_IN_ATOMIC_SUB_FETCH_1
:
6629 case BUILT_IN_ATOMIC_SUB_FETCH_2
:
6630 case BUILT_IN_ATOMIC_SUB_FETCH_4
:
6631 case BUILT_IN_ATOMIC_SUB_FETCH_8
:
6632 case BUILT_IN_ATOMIC_SUB_FETCH_16
:
6634 enum built_in_function lib
;
6635 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
);
6636 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_SUB_1
+
6637 (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
));
6638 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, true,
6644 case BUILT_IN_ATOMIC_AND_FETCH_1
:
6645 case BUILT_IN_ATOMIC_AND_FETCH_2
:
6646 case BUILT_IN_ATOMIC_AND_FETCH_4
:
6647 case BUILT_IN_ATOMIC_AND_FETCH_8
:
6648 case BUILT_IN_ATOMIC_AND_FETCH_16
:
6650 enum built_in_function lib
;
6651 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
);
6652 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_AND_1
+
6653 (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
));
6654 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, true,
6660 case BUILT_IN_ATOMIC_NAND_FETCH_1
:
6661 case BUILT_IN_ATOMIC_NAND_FETCH_2
:
6662 case BUILT_IN_ATOMIC_NAND_FETCH_4
:
6663 case BUILT_IN_ATOMIC_NAND_FETCH_8
:
6664 case BUILT_IN_ATOMIC_NAND_FETCH_16
:
6666 enum built_in_function lib
;
6667 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
);
6668 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_NAND_1
+
6669 (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
));
6670 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, true,
6676 case BUILT_IN_ATOMIC_XOR_FETCH_1
:
6677 case BUILT_IN_ATOMIC_XOR_FETCH_2
:
6678 case BUILT_IN_ATOMIC_XOR_FETCH_4
:
6679 case BUILT_IN_ATOMIC_XOR_FETCH_8
:
6680 case BUILT_IN_ATOMIC_XOR_FETCH_16
:
6682 enum built_in_function lib
;
6683 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
);
6684 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_XOR_1
+
6685 (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
));
6686 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, true,
6692 case BUILT_IN_ATOMIC_OR_FETCH_1
:
6693 case BUILT_IN_ATOMIC_OR_FETCH_2
:
6694 case BUILT_IN_ATOMIC_OR_FETCH_4
:
6695 case BUILT_IN_ATOMIC_OR_FETCH_8
:
6696 case BUILT_IN_ATOMIC_OR_FETCH_16
:
6698 enum built_in_function lib
;
6699 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
);
6700 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_OR_1
+
6701 (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
));
6702 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, true,
6708 case BUILT_IN_ATOMIC_FETCH_ADD_1
:
6709 case BUILT_IN_ATOMIC_FETCH_ADD_2
:
6710 case BUILT_IN_ATOMIC_FETCH_ADD_4
:
6711 case BUILT_IN_ATOMIC_FETCH_ADD_8
:
6712 case BUILT_IN_ATOMIC_FETCH_ADD_16
:
6713 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_ADD_1
);
6714 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, false,
6715 ignore
, BUILT_IN_NONE
);
6720 case BUILT_IN_ATOMIC_FETCH_SUB_1
:
6721 case BUILT_IN_ATOMIC_FETCH_SUB_2
:
6722 case BUILT_IN_ATOMIC_FETCH_SUB_4
:
6723 case BUILT_IN_ATOMIC_FETCH_SUB_8
:
6724 case BUILT_IN_ATOMIC_FETCH_SUB_16
:
6725 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_SUB_1
);
6726 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, false,
6727 ignore
, BUILT_IN_NONE
);
6732 case BUILT_IN_ATOMIC_FETCH_AND_1
:
6733 case BUILT_IN_ATOMIC_FETCH_AND_2
:
6734 case BUILT_IN_ATOMIC_FETCH_AND_4
:
6735 case BUILT_IN_ATOMIC_FETCH_AND_8
:
6736 case BUILT_IN_ATOMIC_FETCH_AND_16
:
6737 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_AND_1
);
6738 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, false,
6739 ignore
, BUILT_IN_NONE
);
6744 case BUILT_IN_ATOMIC_FETCH_NAND_1
:
6745 case BUILT_IN_ATOMIC_FETCH_NAND_2
:
6746 case BUILT_IN_ATOMIC_FETCH_NAND_4
:
6747 case BUILT_IN_ATOMIC_FETCH_NAND_8
:
6748 case BUILT_IN_ATOMIC_FETCH_NAND_16
:
6749 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_NAND_1
);
6750 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, false,
6751 ignore
, BUILT_IN_NONE
);
6756 case BUILT_IN_ATOMIC_FETCH_XOR_1
:
6757 case BUILT_IN_ATOMIC_FETCH_XOR_2
:
6758 case BUILT_IN_ATOMIC_FETCH_XOR_4
:
6759 case BUILT_IN_ATOMIC_FETCH_XOR_8
:
6760 case BUILT_IN_ATOMIC_FETCH_XOR_16
:
6761 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_XOR_1
);
6762 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, false,
6763 ignore
, BUILT_IN_NONE
);
6768 case BUILT_IN_ATOMIC_FETCH_OR_1
:
6769 case BUILT_IN_ATOMIC_FETCH_OR_2
:
6770 case BUILT_IN_ATOMIC_FETCH_OR_4
:
6771 case BUILT_IN_ATOMIC_FETCH_OR_8
:
6772 case BUILT_IN_ATOMIC_FETCH_OR_16
:
6773 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_OR_1
);
6774 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, false,
6775 ignore
, BUILT_IN_NONE
);
6780 case BUILT_IN_ATOMIC_TEST_AND_SET
:
6781 return expand_builtin_atomic_test_and_set (exp
, target
);
6783 case BUILT_IN_ATOMIC_CLEAR
:
6784 return expand_builtin_atomic_clear (exp
);
6786 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
6787 return expand_builtin_atomic_always_lock_free (exp
);
6789 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
6790 target
= expand_builtin_atomic_is_lock_free (exp
);
6795 case BUILT_IN_ATOMIC_THREAD_FENCE
:
6796 expand_builtin_atomic_thread_fence (exp
);
6799 case BUILT_IN_ATOMIC_SIGNAL_FENCE
:
6800 expand_builtin_atomic_signal_fence (exp
);
6803 case BUILT_IN_OBJECT_SIZE
:
6804 return expand_builtin_object_size (exp
);
6806 case BUILT_IN_MEMCPY_CHK
:
6807 case BUILT_IN_MEMPCPY_CHK
:
6808 case BUILT_IN_MEMMOVE_CHK
:
6809 case BUILT_IN_MEMSET_CHK
:
6810 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
6815 case BUILT_IN_STRCPY_CHK
:
6816 case BUILT_IN_STPCPY_CHK
:
6817 case BUILT_IN_STRNCPY_CHK
:
6818 case BUILT_IN_STPNCPY_CHK
:
6819 case BUILT_IN_STRCAT_CHK
:
6820 case BUILT_IN_STRNCAT_CHK
:
6821 case BUILT_IN_SNPRINTF_CHK
:
6822 case BUILT_IN_VSNPRINTF_CHK
:
6823 maybe_emit_chk_warning (exp
, fcode
);
6826 case BUILT_IN_SPRINTF_CHK
:
6827 case BUILT_IN_VSPRINTF_CHK
:
6828 maybe_emit_sprintf_chk_warning (exp
, fcode
);
6832 if (warn_free_nonheap_object
)
6833 maybe_emit_free_warning (exp
);
6836 case BUILT_IN_THREAD_POINTER
:
6837 return expand_builtin_thread_pointer (exp
, target
);
6839 case BUILT_IN_SET_THREAD_POINTER
:
6840 expand_builtin_set_thread_pointer (exp
);
6843 case BUILT_IN_CILK_DETACH
:
6844 expand_builtin_cilk_detach (exp
);
6847 case BUILT_IN_CILK_POP_FRAME
:
6848 expand_builtin_cilk_pop_frame (exp
);
6851 default: /* just do library call, if unknown builtin */
6855 /* The switch statement above can drop through to cause the function
6856 to be called normally. */
6857 return expand_call (exp
, target
, ignore
);
6860 /* Determine whether a tree node represents a call to a built-in
6861 function. If the tree T is a call to a built-in function with
6862 the right number of arguments of the appropriate types, return
6863 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6864 Otherwise the return value is END_BUILTINS. */
6866 enum built_in_function
6867 builtin_mathfn_code (const_tree t
)
6869 const_tree fndecl
, arg
, parmlist
;
6870 const_tree argtype
, parmtype
;
6871 const_call_expr_arg_iterator iter
;
6873 if (TREE_CODE (t
) != CALL_EXPR
6874 || TREE_CODE (CALL_EXPR_FN (t
)) != ADDR_EXPR
)
6875 return END_BUILTINS
;
6877 fndecl
= get_callee_fndecl (t
);
6878 if (fndecl
== NULL_TREE
6879 || TREE_CODE (fndecl
) != FUNCTION_DECL
6880 || ! DECL_BUILT_IN (fndecl
)
6881 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6882 return END_BUILTINS
;
6884 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6885 init_const_call_expr_arg_iterator (t
, &iter
);
6886 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
6888 /* If a function doesn't take a variable number of arguments,
6889 the last element in the list will have type `void'. */
6890 parmtype
= TREE_VALUE (parmlist
);
6891 if (VOID_TYPE_P (parmtype
))
6893 if (more_const_call_expr_args_p (&iter
))
6894 return END_BUILTINS
;
6895 return DECL_FUNCTION_CODE (fndecl
);
6898 if (! more_const_call_expr_args_p (&iter
))
6899 return END_BUILTINS
;
6901 arg
= next_const_call_expr_arg (&iter
);
6902 argtype
= TREE_TYPE (arg
);
6904 if (SCALAR_FLOAT_TYPE_P (parmtype
))
6906 if (! SCALAR_FLOAT_TYPE_P (argtype
))
6907 return END_BUILTINS
;
6909 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
6911 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
6912 return END_BUILTINS
;
6914 else if (POINTER_TYPE_P (parmtype
))
6916 if (! POINTER_TYPE_P (argtype
))
6917 return END_BUILTINS
;
6919 else if (INTEGRAL_TYPE_P (parmtype
))
6921 if (! INTEGRAL_TYPE_P (argtype
))
6922 return END_BUILTINS
;
6925 return END_BUILTINS
;
6928 /* Variable-length argument list. */
6929 return DECL_FUNCTION_CODE (fndecl
);
6932 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6933 evaluate to a constant. */
6936 fold_builtin_constant_p (tree arg
)
6938 /* We return 1 for a numeric type that's known to be a constant
6939 value at compile-time or for an aggregate type that's a
6940 literal constant. */
6943 /* If we know this is a constant, emit the constant of one. */
6944 if (CONSTANT_CLASS_P (arg
)
6945 || (TREE_CODE (arg
) == CONSTRUCTOR
6946 && TREE_CONSTANT (arg
)))
6947 return integer_one_node
;
6948 if (TREE_CODE (arg
) == ADDR_EXPR
)
6950 tree op
= TREE_OPERAND (arg
, 0);
6951 if (TREE_CODE (op
) == STRING_CST
6952 || (TREE_CODE (op
) == ARRAY_REF
6953 && integer_zerop (TREE_OPERAND (op
, 1))
6954 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
6955 return integer_one_node
;
6958 /* If this expression has side effects, show we don't know it to be a
6959 constant. Likewise if it's a pointer or aggregate type since in
6960 those case we only want literals, since those are only optimized
6961 when generating RTL, not later.
6962 And finally, if we are compiling an initializer, not code, we
6963 need to return a definite result now; there's not going to be any
6964 more optimization done. */
6965 if (TREE_SIDE_EFFECTS (arg
)
6966 || AGGREGATE_TYPE_P (TREE_TYPE (arg
))
6967 || POINTER_TYPE_P (TREE_TYPE (arg
))
6969 || folding_initializer
6970 || force_folding_builtin_constant_p
)
6971 return integer_zero_node
;
6976 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6977 return it as a truthvalue. */
6980 build_builtin_expect_predicate (location_t loc
, tree pred
, tree expected
,
6983 tree fn
, arg_types
, pred_type
, expected_type
, call_expr
, ret_type
;
6985 fn
= builtin_decl_explicit (BUILT_IN_EXPECT
);
6986 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
6987 ret_type
= TREE_TYPE (TREE_TYPE (fn
));
6988 pred_type
= TREE_VALUE (arg_types
);
6989 expected_type
= TREE_VALUE (TREE_CHAIN (arg_types
));
6991 pred
= fold_convert_loc (loc
, pred_type
, pred
);
6992 expected
= fold_convert_loc (loc
, expected_type
, expected
);
6993 call_expr
= build_call_expr_loc (loc
, fn
, predictor
? 3 : 2, pred
, expected
,
6996 return build2 (NE_EXPR
, TREE_TYPE (pred
), call_expr
,
6997 build_int_cst (ret_type
, 0));
7000 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
7001 NULL_TREE if no simplification is possible. */
7004 fold_builtin_expect (location_t loc
, tree arg0
, tree arg1
, tree arg2
)
7006 tree inner
, fndecl
, inner_arg0
;
7007 enum tree_code code
;
7009 /* Distribute the expected value over short-circuiting operators.
7010 See through the cast from truthvalue_type_node to long. */
7012 while (TREE_CODE (inner_arg0
) == NOP_EXPR
7013 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0
))
7014 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0
, 0))))
7015 inner_arg0
= TREE_OPERAND (inner_arg0
, 0);
7017 /* If this is a builtin_expect within a builtin_expect keep the
7018 inner one. See through a comparison against a constant. It
7019 might have been added to create a thruthvalue. */
7022 if (COMPARISON_CLASS_P (inner
)
7023 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
)
7024 inner
= TREE_OPERAND (inner
, 0);
7026 if (TREE_CODE (inner
) == CALL_EXPR
7027 && (fndecl
= get_callee_fndecl (inner
))
7028 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7029 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
)
7033 code
= TREE_CODE (inner
);
7034 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
7036 tree op0
= TREE_OPERAND (inner
, 0);
7037 tree op1
= TREE_OPERAND (inner
, 1);
7039 op0
= build_builtin_expect_predicate (loc
, op0
, arg1
, arg2
);
7040 op1
= build_builtin_expect_predicate (loc
, op1
, arg1
, arg2
);
7041 inner
= build2 (code
, TREE_TYPE (inner
), op0
, op1
);
7043 return fold_convert_loc (loc
, TREE_TYPE (arg0
), inner
);
7046 /* If the argument isn't invariant then there's nothing else we can do. */
7047 if (!TREE_CONSTANT (inner_arg0
))
7050 /* If we expect that a comparison against the argument will fold to
7051 a constant return the constant. In practice, this means a true
7052 constant or the address of a non-weak symbol. */
7055 if (TREE_CODE (inner
) == ADDR_EXPR
)
7059 inner
= TREE_OPERAND (inner
, 0);
7061 while (TREE_CODE (inner
) == COMPONENT_REF
7062 || TREE_CODE (inner
) == ARRAY_REF
);
7063 if ((TREE_CODE (inner
) == VAR_DECL
7064 || TREE_CODE (inner
) == FUNCTION_DECL
)
7065 && DECL_WEAK (inner
))
7069 /* Otherwise, ARG0 already has the proper type for the return value. */
7073 /* Fold a call to __builtin_classify_type with argument ARG. */
7076 fold_builtin_classify_type (tree arg
)
7079 return build_int_cst (integer_type_node
, no_type_class
);
7081 return build_int_cst (integer_type_node
, type_to_class (TREE_TYPE (arg
)));
7084 /* Fold a call to __builtin_strlen with argument ARG. */
7087 fold_builtin_strlen (location_t loc
, tree type
, tree arg
)
7089 if (!validate_arg (arg
, POINTER_TYPE
))
7093 tree len
= c_strlen (arg
, 0);
7096 return fold_convert_loc (loc
, type
, len
);
7102 /* Fold a call to __builtin_inf or __builtin_huge_val. */
7105 fold_builtin_inf (location_t loc
, tree type
, int warn
)
7107 REAL_VALUE_TYPE real
;
7109 /* __builtin_inff is intended to be usable to define INFINITY on all
7110 targets. If an infinity is not available, INFINITY expands "to a
7111 positive constant of type float that overflows at translation
7112 time", footnote "In this case, using INFINITY will violate the
7113 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7114 Thus we pedwarn to ensure this constraint violation is
7116 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
7117 pedwarn (loc
, 0, "target format does not support infinity");
7120 return build_real (type
, real
);
7123 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
7126 fold_builtin_nan (tree arg
, tree type
, int quiet
)
7128 REAL_VALUE_TYPE real
;
7131 if (!validate_arg (arg
, POINTER_TYPE
))
7133 str
= c_getstr (arg
);
7137 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
7140 return build_real (type
, real
);
7143 /* Return true if the floating point expression T has an integer value.
7144 We also allow +Inf, -Inf and NaN to be considered integer values. */
7147 integer_valued_real_p (tree t
)
7149 switch (TREE_CODE (t
))
7156 return integer_valued_real_p (TREE_OPERAND (t
, 0));
7161 return integer_valued_real_p (TREE_OPERAND (t
, 1));
7168 return integer_valued_real_p (TREE_OPERAND (t
, 0))
7169 && integer_valued_real_p (TREE_OPERAND (t
, 1));
7172 return integer_valued_real_p (TREE_OPERAND (t
, 1))
7173 && integer_valued_real_p (TREE_OPERAND (t
, 2));
7176 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
7180 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
7181 if (TREE_CODE (type
) == INTEGER_TYPE
)
7183 if (TREE_CODE (type
) == REAL_TYPE
)
7184 return integer_valued_real_p (TREE_OPERAND (t
, 0));
7189 switch (builtin_mathfn_code (t
))
7191 CASE_FLT_FN (BUILT_IN_CEIL
):
7192 CASE_FLT_FN (BUILT_IN_FLOOR
):
7193 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
7194 CASE_FLT_FN (BUILT_IN_RINT
):
7195 CASE_FLT_FN (BUILT_IN_ROUND
):
7196 CASE_FLT_FN (BUILT_IN_TRUNC
):
7199 CASE_FLT_FN (BUILT_IN_FMIN
):
7200 CASE_FLT_FN (BUILT_IN_FMAX
):
7201 return integer_valued_real_p (CALL_EXPR_ARG (t
, 0))
7202 && integer_valued_real_p (CALL_EXPR_ARG (t
, 1));
7215 /* FNDECL is assumed to be a builtin where truncation can be propagated
7216 across (for instance floor((double)f) == (double)floorf (f).
7217 Do the transformation for a call with argument ARG. */
7220 fold_trunc_transparent_mathfn (location_t loc
, tree fndecl
, tree arg
)
7222 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7224 if (!validate_arg (arg
, REAL_TYPE
))
7227 /* Integer rounding functions are idempotent. */
7228 if (fcode
== builtin_mathfn_code (arg
))
7231 /* If argument is already integer valued, and we don't need to worry
7232 about setting errno, there's no need to perform rounding. */
7233 if (! flag_errno_math
&& integer_valued_real_p (arg
))
7238 tree arg0
= strip_float_extensions (arg
);
7239 tree ftype
= TREE_TYPE (TREE_TYPE (fndecl
));
7240 tree newtype
= TREE_TYPE (arg0
);
7243 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
7244 && (decl
= mathfn_built_in (newtype
, fcode
)))
7245 return fold_convert_loc (loc
, ftype
,
7246 build_call_expr_loc (loc
, decl
, 1,
7247 fold_convert_loc (loc
,
7254 /* FNDECL is assumed to be builtin which can narrow the FP type of
7255 the argument, for instance lround((double)f) -> lroundf (f).
7256 Do the transformation for a call with argument ARG. */
7259 fold_fixed_mathfn (location_t loc
, tree fndecl
, tree arg
)
7261 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7263 if (!validate_arg (arg
, REAL_TYPE
))
7266 /* If argument is already integer valued, and we don't need to worry
7267 about setting errno, there's no need to perform rounding. */
7268 if (! flag_errno_math
&& integer_valued_real_p (arg
))
7269 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
7270 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
7274 tree ftype
= TREE_TYPE (arg
);
7275 tree arg0
= strip_float_extensions (arg
);
7276 tree newtype
= TREE_TYPE (arg0
);
7279 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
7280 && (decl
= mathfn_built_in (newtype
, fcode
)))
7281 return build_call_expr_loc (loc
, decl
, 1,
7282 fold_convert_loc (loc
, newtype
, arg0
));
7285 /* Canonicalize iround (x) to lround (x) on ILP32 targets where
7286 sizeof (int) == sizeof (long). */
7287 if (TYPE_PRECISION (integer_type_node
)
7288 == TYPE_PRECISION (long_integer_type_node
))
7290 tree newfn
= NULL_TREE
;
7293 CASE_FLT_FN (BUILT_IN_ICEIL
):
7294 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
7297 CASE_FLT_FN (BUILT_IN_IFLOOR
):
7298 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
7301 CASE_FLT_FN (BUILT_IN_IROUND
):
7302 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7305 CASE_FLT_FN (BUILT_IN_IRINT
):
7306 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7315 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7316 return fold_convert_loc (loc
,
7317 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7321 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7322 sizeof (long long) == sizeof (long). */
7323 if (TYPE_PRECISION (long_long_integer_type_node
)
7324 == TYPE_PRECISION (long_integer_type_node
))
7326 tree newfn
= NULL_TREE
;
7329 CASE_FLT_FN (BUILT_IN_LLCEIL
):
7330 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LCEIL
);
7333 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7334 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LFLOOR
);
7337 CASE_FLT_FN (BUILT_IN_LLROUND
):
7338 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LROUND
);
7341 CASE_FLT_FN (BUILT_IN_LLRINT
):
7342 newfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_LRINT
);
7351 tree newcall
= build_call_expr_loc (loc
, newfn
, 1, arg
);
7352 return fold_convert_loc (loc
,
7353 TREE_TYPE (TREE_TYPE (fndecl
)), newcall
);
7360 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7361 return type. Return NULL_TREE if no simplification can be made. */
7364 fold_builtin_cabs (location_t loc
, tree arg
, tree type
, tree fndecl
)
7368 if (!validate_arg (arg
, COMPLEX_TYPE
)
7369 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7372 /* Calculate the result when the argument is a constant. */
7373 if (TREE_CODE (arg
) == COMPLEX_CST
7374 && (res
= do_mpfr_arg2 (TREE_REALPART (arg
), TREE_IMAGPART (arg
),
7378 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7380 tree real
= TREE_OPERAND (arg
, 0);
7381 tree imag
= TREE_OPERAND (arg
, 1);
7383 /* If either part is zero, cabs is fabs of the other. */
7384 if (real_zerop (real
))
7385 return fold_build1_loc (loc
, ABS_EXPR
, type
, imag
);
7386 if (real_zerop (imag
))
7387 return fold_build1_loc (loc
, ABS_EXPR
, type
, real
);
7389 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7390 if (flag_unsafe_math_optimizations
7391 && operand_equal_p (real
, imag
, OEP_PURE_SAME
))
7393 const REAL_VALUE_TYPE sqrt2_trunc
7394 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
7396 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7397 fold_build1_loc (loc
, ABS_EXPR
, type
, real
),
7398 build_real (type
, sqrt2_trunc
));
7402 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7403 if (TREE_CODE (arg
) == NEGATE_EXPR
7404 || TREE_CODE (arg
) == CONJ_EXPR
)
7405 return build_call_expr_loc (loc
, fndecl
, 1, TREE_OPERAND (arg
, 0));
7407 /* Don't do this when optimizing for size. */
7408 if (flag_unsafe_math_optimizations
7409 && optimize
&& optimize_function_for_speed_p (cfun
))
7411 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7413 if (sqrtfn
!= NULL_TREE
)
7415 tree rpart
, ipart
, result
;
7417 arg
= builtin_save_expr (arg
);
7419 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, type
, arg
);
7420 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg
);
7422 rpart
= builtin_save_expr (rpart
);
7423 ipart
= builtin_save_expr (ipart
);
7425 result
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
7426 fold_build2_loc (loc
, MULT_EXPR
, type
,
7428 fold_build2_loc (loc
, MULT_EXPR
, type
,
7431 return build_call_expr_loc (loc
, sqrtfn
, 1, result
);
7438 /* Build a complex (inf +- 0i) for the result of cproj. TYPE is the
7439 complex tree type of the result. If NEG is true, the imaginary
7440 zero is negative. */
7443 build_complex_cproj (tree type
, bool neg
)
7445 REAL_VALUE_TYPE rinf
, rzero
= dconst0
;
7449 return build_complex (type
, build_real (TREE_TYPE (type
), rinf
),
7450 build_real (TREE_TYPE (type
), rzero
));
7453 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the
7454 return type. Return NULL_TREE if no simplification can be made. */
7457 fold_builtin_cproj (location_t loc
, tree arg
, tree type
)
7459 if (!validate_arg (arg
, COMPLEX_TYPE
)
7460 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
7463 /* If there are no infinities, return arg. */
7464 if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type
))))
7465 return non_lvalue_loc (loc
, arg
);
7467 /* Calculate the result when the argument is a constant. */
7468 if (TREE_CODE (arg
) == COMPLEX_CST
)
7470 const REAL_VALUE_TYPE
*real
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
7471 const REAL_VALUE_TYPE
*imag
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
7473 if (real_isinf (real
) || real_isinf (imag
))
7474 return build_complex_cproj (type
, imag
->sign
);
7478 else if (TREE_CODE (arg
) == COMPLEX_EXPR
)
7480 tree real
= TREE_OPERAND (arg
, 0);
7481 tree imag
= TREE_OPERAND (arg
, 1);
7486 /* If the real part is inf and the imag part is known to be
7487 nonnegative, return (inf + 0i). Remember side-effects are
7488 possible in the imag part. */
7489 if (TREE_CODE (real
) == REAL_CST
7490 && real_isinf (TREE_REAL_CST_PTR (real
))
7491 && tree_expr_nonnegative_p (imag
))
7492 return omit_one_operand_loc (loc
, type
,
7493 build_complex_cproj (type
, false),
7496 /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7497 Remember side-effects are possible in the real part. */
7498 if (TREE_CODE (imag
) == REAL_CST
7499 && real_isinf (TREE_REAL_CST_PTR (imag
)))
7501 omit_one_operand_loc (loc
, type
,
7502 build_complex_cproj (type
, TREE_REAL_CST_PTR
7503 (imag
)->sign
), arg
);
7509 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7510 Return NULL_TREE if no simplification can be made. */
7513 fold_builtin_sqrt (location_t loc
, tree arg
, tree type
)
7516 enum built_in_function fcode
;
7519 if (!validate_arg (arg
, REAL_TYPE
))
7522 /* Calculate the result when the argument is a constant. */
7523 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_sqrt
, &dconst0
, NULL
, true)))
7526 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7527 fcode
= builtin_mathfn_code (arg
);
7528 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
7530 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7531 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7532 CALL_EXPR_ARG (arg
, 0),
7533 build_real (type
, dconsthalf
));
7534 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7537 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7538 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
7540 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7544 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7546 /* The inner root was either sqrt or cbrt. */
7547 /* This was a conditional expression but it triggered a bug
7549 REAL_VALUE_TYPE dconstroot
;
7550 if (BUILTIN_SQRT_P (fcode
))
7551 dconstroot
= dconsthalf
;
7553 dconstroot
= dconst_third ();
7555 /* Adjust for the outer root. */
7556 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7557 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7558 tree_root
= build_real (type
, dconstroot
);
7559 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7563 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7564 if (flag_unsafe_math_optimizations
7565 && (fcode
== BUILT_IN_POW
7566 || fcode
== BUILT_IN_POWF
7567 || fcode
== BUILT_IN_POWL
))
7569 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7570 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7571 tree arg1
= CALL_EXPR_ARG (arg
, 1);
7573 if (!tree_expr_nonnegative_p (arg0
))
7574 arg0
= build1 (ABS_EXPR
, type
, arg0
);
7575 narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
7576 build_real (type
, dconsthalf
));
7577 return build_call_expr_loc (loc
, powfn
, 2, arg0
, narg1
);
7583 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7584 Return NULL_TREE if no simplification can be made. */
7587 fold_builtin_cbrt (location_t loc
, tree arg
, tree type
)
7589 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7592 if (!validate_arg (arg
, REAL_TYPE
))
7595 /* Calculate the result when the argument is a constant. */
7596 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cbrt
, NULL
, NULL
, 0)))
7599 if (flag_unsafe_math_optimizations
)
7601 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7602 if (BUILTIN_EXPONENT_P (fcode
))
7604 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7605 const REAL_VALUE_TYPE third_trunc
=
7606 real_value_truncate (TYPE_MODE (type
), dconst_third ());
7607 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
7608 CALL_EXPR_ARG (arg
, 0),
7609 build_real (type
, third_trunc
));
7610 return build_call_expr_loc (loc
, expfn
, 1, arg
);
7613 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7614 if (BUILTIN_SQRT_P (fcode
))
7616 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7620 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7622 REAL_VALUE_TYPE dconstroot
= dconst_third ();
7624 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7625 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7626 tree_root
= build_real (type
, dconstroot
);
7627 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7631 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7632 if (BUILTIN_CBRT_P (fcode
))
7634 tree arg0
= CALL_EXPR_ARG (arg
, 0);
7635 if (tree_expr_nonnegative_p (arg0
))
7637 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7642 REAL_VALUE_TYPE dconstroot
;
7644 real_arithmetic (&dconstroot
, MULT_EXPR
,
7645 dconst_third_ptr (), dconst_third_ptr ());
7646 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7647 tree_root
= build_real (type
, dconstroot
);
7648 return build_call_expr_loc (loc
, powfn
, 2, arg0
, tree_root
);
7653 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7654 if (fcode
== BUILT_IN_POW
7655 || fcode
== BUILT_IN_POWF
7656 || fcode
== BUILT_IN_POWL
)
7658 tree arg00
= CALL_EXPR_ARG (arg
, 0);
7659 tree arg01
= CALL_EXPR_ARG (arg
, 1);
7660 if (tree_expr_nonnegative_p (arg00
))
7662 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg
), 0);
7663 const REAL_VALUE_TYPE dconstroot
7664 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
7665 tree narg01
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
,
7666 build_real (type
, dconstroot
));
7667 return build_call_expr_loc (loc
, powfn
, 2, arg00
, narg01
);
7674 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7675 TYPE is the type of the return value. Return NULL_TREE if no
7676 simplification can be made. */
7679 fold_builtin_cos (location_t loc
,
7680 tree arg
, tree type
, tree fndecl
)
7684 if (!validate_arg (arg
, REAL_TYPE
))
7687 /* Calculate the result when the argument is a constant. */
7688 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cos
, NULL
, NULL
, 0)))
7691 /* Optimize cos(-x) into cos (x). */
7692 if ((narg
= fold_strip_sign_ops (arg
)))
7693 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7698 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7699 Return NULL_TREE if no simplification can be made. */
7702 fold_builtin_cosh (location_t loc
, tree arg
, tree type
, tree fndecl
)
7704 if (validate_arg (arg
, REAL_TYPE
))
7708 /* Calculate the result when the argument is a constant. */
7709 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_cosh
, NULL
, NULL
, 0)))
7712 /* Optimize cosh(-x) into cosh (x). */
7713 if ((narg
= fold_strip_sign_ops (arg
)))
7714 return build_call_expr_loc (loc
, fndecl
, 1, narg
);
7720 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7721 argument ARG. TYPE is the type of the return value. Return
7722 NULL_TREE if no simplification can be made. */
7725 fold_builtin_ccos (location_t loc
, tree arg
, tree type
, tree fndecl
,
7728 if (validate_arg (arg
, COMPLEX_TYPE
)
7729 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
7733 /* Calculate the result when the argument is a constant. */
7734 if ((tmp
= do_mpc_arg1 (arg
, type
, (hyper
? mpc_cosh
: mpc_cos
))))
7737 /* Optimize fn(-x) into fn(x). */
7738 if ((tmp
= fold_strip_sign_ops (arg
)))
7739 return build_call_expr_loc (loc
, fndecl
, 1, tmp
);
7745 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7746 Return NULL_TREE if no simplification can be made. */
7749 fold_builtin_tan (tree arg
, tree type
)
7751 enum built_in_function fcode
;
7754 if (!validate_arg (arg
, REAL_TYPE
))
7757 /* Calculate the result when the argument is a constant. */
7758 if ((res
= do_mpfr_arg1 (arg
, type
, mpfr_tan
, NULL
, NULL
, 0)))
7761 /* Optimize tan(atan(x)) = x. */
7762 fcode
= builtin_mathfn_code (arg
);
7763 if (flag_unsafe_math_optimizations
7764 && (fcode
== BUILT_IN_ATAN
7765 || fcode
== BUILT_IN_ATANF
7766 || fcode
== BUILT_IN_ATANL
))
7767 return CALL_EXPR_ARG (arg
, 0);
7772 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7773 NULL_TREE if no simplification can be made. */
7776 fold_builtin_sincos (location_t loc
,
7777 tree arg0
, tree arg1
, tree arg2
)
7782 if (!validate_arg (arg0
, REAL_TYPE
)
7783 || !validate_arg (arg1
, POINTER_TYPE
)
7784 || !validate_arg (arg2
, POINTER_TYPE
))
7787 type
= TREE_TYPE (arg0
);
7789 /* Calculate the result when the argument is a constant. */
7790 if ((res
= do_mpfr_sincos (arg0
, arg1
, arg2
)))
7793 /* Canonicalize sincos to cexpi. */
7794 if (!targetm
.libc_has_function (function_c99_math_complex
))
7796 fn
= mathfn_built_in (type
, BUILT_IN_CEXPI
);
7800 call
= build_call_expr_loc (loc
, fn
, 1, arg0
);
7801 call
= builtin_save_expr (call
);
7803 return build2 (COMPOUND_EXPR
, void_type_node
,
7804 build2 (MODIFY_EXPR
, void_type_node
,
7805 build_fold_indirect_ref_loc (loc
, arg1
),
7806 build1 (IMAGPART_EXPR
, type
, call
)),
7807 build2 (MODIFY_EXPR
, void_type_node
,
7808 build_fold_indirect_ref_loc (loc
, arg2
),
7809 build1 (REALPART_EXPR
, type
, call
)));
7812 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7813 NULL_TREE if no simplification can be made. */
7816 fold_builtin_cexp (location_t loc
, tree arg0
, tree type
)
7819 tree realp
, imagp
, ifn
;
7822 if (!validate_arg (arg0
, COMPLEX_TYPE
)
7823 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) != REAL_TYPE
)
7826 /* Calculate the result when the argument is a constant. */
7827 if ((res
= do_mpc_arg1 (arg0
, type
, mpc_exp
)))
7830 rtype
= TREE_TYPE (TREE_TYPE (arg0
));
7832 /* In case we can figure out the real part of arg0 and it is constant zero
7834 if (!targetm
.libc_has_function (function_c99_math_complex
))
7836 ifn
= mathfn_built_in (rtype
, BUILT_IN_CEXPI
);
7840 if ((realp
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
))
7841 && real_zerop (realp
))
7843 tree narg
= fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
7844 return build_call_expr_loc (loc
, ifn
, 1, narg
);
7847 /* In case we can easily decompose real and imaginary parts split cexp
7848 to exp (r) * cexpi (i). */
7849 if (flag_unsafe_math_optimizations
7852 tree rfn
, rcall
, icall
;
7854 rfn
= mathfn_built_in (rtype
, BUILT_IN_EXP
);
7858 imagp
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
7862 icall
= build_call_expr_loc (loc
, ifn
, 1, imagp
);
7863 icall
= builtin_save_expr (icall
);
7864 rcall
= build_call_expr_loc (loc
, rfn
, 1, realp
);
7865 rcall
= builtin_save_expr (rcall
);
7866 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
7867 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
7869 fold_build1_loc (loc
, REALPART_EXPR
,
7871 fold_build2_loc (loc
, MULT_EXPR
, rtype
,
7873 fold_build1_loc (loc
, IMAGPART_EXPR
,
7880 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7881 Return NULL_TREE if no simplification can be made. */
7884 fold_builtin_trunc (location_t loc
, tree fndecl
, tree arg
)
7886 if (!validate_arg (arg
, REAL_TYPE
))
7889 /* Optimize trunc of constant value. */
7890 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7892 REAL_VALUE_TYPE r
, x
;
7893 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7895 x
= TREE_REAL_CST (arg
);
7896 real_trunc (&r
, TYPE_MODE (type
), &x
);
7897 return build_real (type
, r
);
7900 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7903 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7904 Return NULL_TREE if no simplification can be made. */
7907 fold_builtin_floor (location_t loc
, tree fndecl
, tree arg
)
7909 if (!validate_arg (arg
, REAL_TYPE
))
7912 /* Optimize floor of constant value. */
7913 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7917 x
= TREE_REAL_CST (arg
);
7918 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7920 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7923 real_floor (&r
, TYPE_MODE (type
), &x
);
7924 return build_real (type
, r
);
7928 /* Fold floor (x) where x is nonnegative to trunc (x). */
7929 if (tree_expr_nonnegative_p (arg
))
7931 tree truncfn
= mathfn_built_in (TREE_TYPE (arg
), BUILT_IN_TRUNC
);
7933 return build_call_expr_loc (loc
, truncfn
, 1, arg
);
7936 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7939 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7940 Return NULL_TREE if no simplification can be made. */
7943 fold_builtin_ceil (location_t loc
, tree fndecl
, tree arg
)
7945 if (!validate_arg (arg
, REAL_TYPE
))
7948 /* Optimize ceil of constant value. */
7949 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7953 x
= TREE_REAL_CST (arg
);
7954 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7956 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7959 real_ceil (&r
, TYPE_MODE (type
), &x
);
7960 return build_real (type
, r
);
7964 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7967 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7968 Return NULL_TREE if no simplification can be made. */
7971 fold_builtin_round (location_t loc
, tree fndecl
, tree arg
)
7973 if (!validate_arg (arg
, REAL_TYPE
))
7976 /* Optimize round of constant value. */
7977 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
7981 x
= TREE_REAL_CST (arg
);
7982 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7984 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7987 real_round (&r
, TYPE_MODE (type
), &x
);
7988 return build_real (type
, r
);
7992 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg
);
7995 /* Fold function call to builtin lround, lroundf or lroundl (or the
7996 corresponding long long versions) and other rounding functions. ARG
7997 is the argument to the call. Return NULL_TREE if no simplification
8001 fold_builtin_int_roundingfn (location_t loc
, tree fndecl
, tree arg
)
8003 if (!validate_arg (arg
, REAL_TYPE
))
8006 /* Optimize lround of constant value. */
8007 if (TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
8009 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
8011 if (real_isfinite (&x
))
8013 tree itype
= TREE_TYPE (TREE_TYPE (fndecl
));
8014 tree ftype
= TREE_TYPE (arg
);
8018 switch (DECL_FUNCTION_CODE (fndecl
))
8020 CASE_FLT_FN (BUILT_IN_IFLOOR
):
8021 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8022 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8023 real_floor (&r
, TYPE_MODE (ftype
), &x
);
8026 CASE_FLT_FN (BUILT_IN_ICEIL
):
8027 CASE_FLT_FN (BUILT_IN_LCEIL
):
8028 CASE_FLT_FN (BUILT_IN_LLCEIL
):
8029 real_ceil (&r
, TYPE_MODE (ftype
), &x
);
8032 CASE_FLT_FN (BUILT_IN_IROUND
):
8033 CASE_FLT_FN (BUILT_IN_LROUND
):
8034 CASE_FLT_FN (BUILT_IN_LLROUND
):
8035 real_round (&r
, TYPE_MODE (ftype
), &x
);
8042 real_to_integer2 ((HOST_WIDE_INT
*)&val
.low
, &val
.high
, &r
);
8043 if (double_int_fits_to_tree_p (itype
, val
))
8044 return double_int_to_tree (itype
, val
);
8048 switch (DECL_FUNCTION_CODE (fndecl
))
8050 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8051 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8052 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
8053 if (tree_expr_nonnegative_p (arg
))
8054 return fold_build1_loc (loc
, FIX_TRUNC_EXPR
,
8055 TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
8060 return fold_fixed_mathfn (loc
, fndecl
, arg
);
8063 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8064 and their long and long long variants (i.e. ffsl and ffsll). ARG is
8065 the argument to the call. Return NULL_TREE if no simplification can
8069 fold_builtin_bitop (tree fndecl
, tree arg
)
8071 if (!validate_arg (arg
, INTEGER_TYPE
))
8074 /* Optimize for constant argument. */
8075 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
8077 HOST_WIDE_INT hi
, width
, result
;
8078 unsigned HOST_WIDE_INT lo
;
8081 type
= TREE_TYPE (arg
);
8082 width
= TYPE_PRECISION (type
);
8083 lo
= TREE_INT_CST_LOW (arg
);
8085 /* Clear all the bits that are beyond the type's precision. */
8086 if (width
> HOST_BITS_PER_WIDE_INT
)
8088 hi
= TREE_INT_CST_HIGH (arg
);
8089 if (width
< HOST_BITS_PER_DOUBLE_INT
)
8090 hi
&= ~(HOST_WIDE_INT_M1U
<< (width
- HOST_BITS_PER_WIDE_INT
));
8095 if (width
< HOST_BITS_PER_WIDE_INT
)
8096 lo
&= ~(HOST_WIDE_INT_M1U
<< width
);
8099 switch (DECL_FUNCTION_CODE (fndecl
))
8101 CASE_INT_FN (BUILT_IN_FFS
):
8103 result
= ffs_hwi (lo
);
8105 result
= HOST_BITS_PER_WIDE_INT
+ ffs_hwi (hi
);
8110 CASE_INT_FN (BUILT_IN_CLZ
):
8112 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
8114 result
= width
- floor_log2 (lo
) - 1;
8115 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
8119 CASE_INT_FN (BUILT_IN_CTZ
):
8121 result
= ctz_hwi (lo
);
8123 result
= HOST_BITS_PER_WIDE_INT
+ ctz_hwi (hi
);
8124 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
8128 CASE_INT_FN (BUILT_IN_CLRSB
):
8129 if (width
> 2 * HOST_BITS_PER_WIDE_INT
)
8131 if (width
> HOST_BITS_PER_WIDE_INT
8132 && (hi
& ((unsigned HOST_WIDE_INT
) 1
8133 << (width
- HOST_BITS_PER_WIDE_INT
- 1))) != 0)
8135 hi
= ~hi
& ~(HOST_WIDE_INT_M1U
8136 << (width
- HOST_BITS_PER_WIDE_INT
- 1));
8139 else if (width
<= HOST_BITS_PER_WIDE_INT
8140 && (lo
& ((unsigned HOST_WIDE_INT
) 1 << (width
- 1))) != 0)
8141 lo
= ~lo
& ~(HOST_WIDE_INT_M1U
<< (width
- 1));
8143 result
= width
- floor_log2 (hi
) - 2 - HOST_BITS_PER_WIDE_INT
;
8145 result
= width
- floor_log2 (lo
) - 2;
8150 CASE_INT_FN (BUILT_IN_POPCOUNT
):
8153 result
++, lo
&= lo
- 1;
8155 result
++, hi
&= (unsigned HOST_WIDE_INT
) hi
- 1;
8158 CASE_INT_FN (BUILT_IN_PARITY
):
8161 result
++, lo
&= lo
- 1;
8163 result
++, hi
&= (unsigned HOST_WIDE_INT
) hi
- 1;
8171 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), result
);
8177 /* Fold function call to builtin_bswap and the short, long and long long
8178 variants. Return NULL_TREE if no simplification can be made. */
8180 fold_builtin_bswap (tree fndecl
, tree arg
)
8182 if (! validate_arg (arg
, INTEGER_TYPE
))
8185 /* Optimize constant value. */
8186 if (TREE_CODE (arg
) == INTEGER_CST
&& !TREE_OVERFLOW (arg
))
8188 HOST_WIDE_INT hi
, width
, r_hi
= 0;
8189 unsigned HOST_WIDE_INT lo
, r_lo
= 0;
8190 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8192 width
= TYPE_PRECISION (type
);
8193 lo
= TREE_INT_CST_LOW (arg
);
8194 hi
= TREE_INT_CST_HIGH (arg
);
8196 switch (DECL_FUNCTION_CODE (fndecl
))
8198 case BUILT_IN_BSWAP16
:
8199 case BUILT_IN_BSWAP32
:
8200 case BUILT_IN_BSWAP64
:
8204 for (s
= 0; s
< width
; s
+= 8)
8206 int d
= width
- s
- 8;
8207 unsigned HOST_WIDE_INT byte
;
8209 if (s
< HOST_BITS_PER_WIDE_INT
)
8210 byte
= (lo
>> s
) & 0xff;
8212 byte
= (hi
>> (s
- HOST_BITS_PER_WIDE_INT
)) & 0xff;
8214 if (d
< HOST_BITS_PER_WIDE_INT
)
8217 r_hi
|= byte
<< (d
- HOST_BITS_PER_WIDE_INT
);
8227 if (width
< HOST_BITS_PER_WIDE_INT
)
8228 return build_int_cst (type
, r_lo
);
8230 return build_int_cst_wide (type
, r_lo
, r_hi
);
8236 /* A subroutine of fold_builtin to fold the various logarithmic
8237 functions. Return NULL_TREE if no simplification can me made.
8238 FUNC is the corresponding MPFR logarithm function. */
8241 fold_builtin_logarithm (location_t loc
, tree fndecl
, tree arg
,
8242 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
))
8244 if (validate_arg (arg
, REAL_TYPE
))
8246 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8248 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
8250 /* Calculate the result when the argument is a constant. */
8251 if ((res
= do_mpfr_arg1 (arg
, type
, func
, &dconst0
, NULL
, false)))
8254 /* Special case, optimize logN(expN(x)) = x. */
8255 if (flag_unsafe_math_optimizations
8256 && ((func
== mpfr_log
8257 && (fcode
== BUILT_IN_EXP
8258 || fcode
== BUILT_IN_EXPF
8259 || fcode
== BUILT_IN_EXPL
))
8260 || (func
== mpfr_log2
8261 && (fcode
== BUILT_IN_EXP2
8262 || fcode
== BUILT_IN_EXP2F
8263 || fcode
== BUILT_IN_EXP2L
))
8264 || (func
== mpfr_log10
&& (BUILTIN_EXP10_P (fcode
)))))
8265 return fold_convert_loc (loc
, type
, CALL_EXPR_ARG (arg
, 0));
8267 /* Optimize logN(func()) for various exponential functions. We
8268 want to determine the value "x" and the power "exponent" in
8269 order to transform logN(x**exponent) into exponent*logN(x). */
8270 if (flag_unsafe_math_optimizations
)
8272 tree exponent
= 0, x
= 0;
8276 CASE_FLT_FN (BUILT_IN_EXP
):
8277 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
8278 x
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
8280 exponent
= CALL_EXPR_ARG (arg
, 0);
8282 CASE_FLT_FN (BUILT_IN_EXP2
):
8283 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
8284 x
= build_real (type
, dconst2
);
8285 exponent
= CALL_EXPR_ARG (arg
, 0);
8287 CASE_FLT_FN (BUILT_IN_EXP10
):
8288 CASE_FLT_FN (BUILT_IN_POW10
):
8289 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
8291 REAL_VALUE_TYPE dconst10
;
8292 real_from_integer (&dconst10
, VOIDmode
, 10, 0, 0);
8293 x
= build_real (type
, dconst10
);
8295 exponent
= CALL_EXPR_ARG (arg
, 0);
8297 CASE_FLT_FN (BUILT_IN_SQRT
):
8298 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
8299 x
= CALL_EXPR_ARG (arg
, 0);
8300 exponent
= build_real (type
, dconsthalf
);
8302 CASE_FLT_FN (BUILT_IN_CBRT
):
8303 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
8304 x
= CALL_EXPR_ARG (arg
, 0);
8305 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
8308 CASE_FLT_FN (BUILT_IN_POW
):
8309 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
8310 x
= CALL_EXPR_ARG (arg
, 0);
8311 exponent
= CALL_EXPR_ARG (arg
, 1);
8317 /* Now perform the optimization. */
8320 tree logfn
= build_call_expr_loc (loc
, fndecl
, 1, x
);
8321 return fold_build2_loc (loc
, MULT_EXPR
, type
, exponent
, logfn
);
8329 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8330 NULL_TREE if no simplification can be made. */
8333 fold_builtin_hypot (location_t loc
, tree fndecl
,
8334 tree arg0
, tree arg1
, tree type
)
8336 tree res
, narg0
, narg1
;
8338 if (!validate_arg (arg0
, REAL_TYPE
)
8339 || !validate_arg (arg1
, REAL_TYPE
))
8342 /* Calculate the result when the argument is a constant. */
8343 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_hypot
)))
8346 /* If either argument to hypot has a negate or abs, strip that off.
8347 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8348 narg0
= fold_strip_sign_ops (arg0
);
8349 narg1
= fold_strip_sign_ops (arg1
);
8352 return build_call_expr_loc (loc
, fndecl
, 2, narg0
? narg0
: arg0
,
8353 narg1
? narg1
: arg1
);
8356 /* If either argument is zero, hypot is fabs of the other. */
8357 if (real_zerop (arg0
))
8358 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
);
8359 else if (real_zerop (arg1
))
8360 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
);
8362 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8363 if (flag_unsafe_math_optimizations
8364 && operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
8366 const REAL_VALUE_TYPE sqrt2_trunc
8367 = real_value_truncate (TYPE_MODE (type
), dconst_sqrt2 ());
8368 return fold_build2_loc (loc
, MULT_EXPR
, type
,
8369 fold_build1_loc (loc
, ABS_EXPR
, type
, arg0
),
8370 build_real (type
, sqrt2_trunc
));
8377 /* Fold a builtin function call to pow, powf, or powl. Return
8378 NULL_TREE if no simplification can be made. */
8380 fold_builtin_pow (location_t loc
, tree fndecl
, tree arg0
, tree arg1
, tree type
)
8384 if (!validate_arg (arg0
, REAL_TYPE
)
8385 || !validate_arg (arg1
, REAL_TYPE
))
8388 /* Calculate the result when the argument is a constant. */
8389 if ((res
= do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_pow
)))
8392 /* Optimize pow(1.0,y) = 1.0. */
8393 if (real_onep (arg0
))
8394 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8396 if (TREE_CODE (arg1
) == REAL_CST
8397 && !TREE_OVERFLOW (arg1
))
8399 REAL_VALUE_TYPE cint
;
8403 c
= TREE_REAL_CST (arg1
);
8405 /* Optimize pow(x,0.0) = 1.0. */
8406 if (REAL_VALUES_EQUAL (c
, dconst0
))
8407 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8410 /* Optimize pow(x,1.0) = x. */
8411 if (REAL_VALUES_EQUAL (c
, dconst1
))
8414 /* Optimize pow(x,-1.0) = 1.0/x. */
8415 if (REAL_VALUES_EQUAL (c
, dconstm1
))
8416 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8417 build_real (type
, dconst1
), arg0
);
8419 /* Optimize pow(x,0.5) = sqrt(x). */
8420 if (flag_unsafe_math_optimizations
8421 && REAL_VALUES_EQUAL (c
, dconsthalf
))
8423 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
8425 if (sqrtfn
!= NULL_TREE
)
8426 return build_call_expr_loc (loc
, sqrtfn
, 1, arg0
);
8429 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8430 if (flag_unsafe_math_optimizations
)
8432 const REAL_VALUE_TYPE dconstroot
8433 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8435 if (REAL_VALUES_EQUAL (c
, dconstroot
))
8437 tree cbrtfn
= mathfn_built_in (type
, BUILT_IN_CBRT
);
8438 if (cbrtfn
!= NULL_TREE
)
8439 return build_call_expr_loc (loc
, cbrtfn
, 1, arg0
);
8443 /* Check for an integer exponent. */
8444 n
= real_to_integer (&c
);
8445 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
8446 if (real_identical (&c
, &cint
))
8448 /* Attempt to evaluate pow at compile-time, unless this should
8449 raise an exception. */
8450 if (TREE_CODE (arg0
) == REAL_CST
8451 && !TREE_OVERFLOW (arg0
)
8453 || (!flag_trapping_math
&& !flag_errno_math
)
8454 || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
), dconst0
)))
8459 x
= TREE_REAL_CST (arg0
);
8460 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
8461 if (flag_unsafe_math_optimizations
|| !inexact
)
8462 return build_real (type
, x
);
8465 /* Strip sign ops from even integer powers. */
8466 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
8468 tree narg0
= fold_strip_sign_ops (arg0
);
8470 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, arg1
);
8475 if (flag_unsafe_math_optimizations
)
8477 const enum built_in_function fcode
= builtin_mathfn_code (arg0
);
8479 /* Optimize pow(expN(x),y) = expN(x*y). */
8480 if (BUILTIN_EXPONENT_P (fcode
))
8482 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
8483 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8484 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg
, arg1
);
8485 return build_call_expr_loc (loc
, expfn
, 1, arg
);
8488 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8489 if (BUILTIN_SQRT_P (fcode
))
8491 tree narg0
= CALL_EXPR_ARG (arg0
, 0);
8492 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8493 build_real (type
, dconsthalf
));
8494 return build_call_expr_loc (loc
, fndecl
, 2, narg0
, narg1
);
8497 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8498 if (BUILTIN_CBRT_P (fcode
))
8500 tree arg
= CALL_EXPR_ARG (arg0
, 0);
8501 if (tree_expr_nonnegative_p (arg
))
8503 const REAL_VALUE_TYPE dconstroot
8504 = real_value_truncate (TYPE_MODE (type
), dconst_third ());
8505 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg1
,
8506 build_real (type
, dconstroot
));
8507 return build_call_expr_loc (loc
, fndecl
, 2, arg
, narg1
);
8511 /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative. */
8512 if (fcode
== BUILT_IN_POW
8513 || fcode
== BUILT_IN_POWF
8514 || fcode
== BUILT_IN_POWL
)
8516 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
8517 if (tree_expr_nonnegative_p (arg00
))
8519 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
8520 tree narg1
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg01
, arg1
);
8521 return build_call_expr_loc (loc
, fndecl
, 2, arg00
, narg1
);
8529 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8530 Return NULL_TREE if no simplification can be made. */
8532 fold_builtin_powi (location_t loc
, tree fndecl ATTRIBUTE_UNUSED
,
8533 tree arg0
, tree arg1
, tree type
)
8535 if (!validate_arg (arg0
, REAL_TYPE
)
8536 || !validate_arg (arg1
, INTEGER_TYPE
))
8539 /* Optimize pow(1.0,y) = 1.0. */
8540 if (real_onep (arg0
))
8541 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
), arg1
);
8543 if (tree_fits_shwi_p (arg1
))
8545 HOST_WIDE_INT c
= tree_to_shwi (arg1
);
8547 /* Evaluate powi at compile-time. */
8548 if (TREE_CODE (arg0
) == REAL_CST
8549 && !TREE_OVERFLOW (arg0
))
8552 x
= TREE_REAL_CST (arg0
);
8553 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
8554 return build_real (type
, x
);
8557 /* Optimize pow(x,0) = 1.0. */
8559 return omit_one_operand_loc (loc
, type
, build_real (type
, dconst1
),
8562 /* Optimize pow(x,1) = x. */
8566 /* Optimize pow(x,-1) = 1.0/x. */
8568 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
8569 build_real (type
, dconst1
), arg0
);
8575 /* A subroutine of fold_builtin to fold the various exponent
8576 functions. Return NULL_TREE if no simplification can be made.
8577 FUNC is the corresponding MPFR exponent function. */
8580 fold_builtin_exponent (location_t loc
, tree fndecl
, tree arg
,
8581 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
))
8583 if (validate_arg (arg
, REAL_TYPE
))
8585 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8588 /* Calculate the result when the argument is a constant. */
8589 if ((res
= do_mpfr_arg1 (arg
, type
, func
, NULL
, NULL
, 0)))
8592 /* Optimize expN(logN(x)) = x. */
8593 if (flag_unsafe_math_optimizations
)
8595 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
8597 if ((func
== mpfr_exp
8598 && (fcode
== BUILT_IN_LOG
8599 || fcode
== BUILT_IN_LOGF
8600 || fcode
== BUILT_IN_LOGL
))
8601 || (func
== mpfr_exp2
8602 && (fcode
== BUILT_IN_LOG2
8603 || fcode
== BUILT_IN_LOG2F
8604 || fcode
== BUILT_IN_LOG2L
))
8605 || (func
== mpfr_exp10
8606 && (fcode
== BUILT_IN_LOG10
8607 || fcode
== BUILT_IN_LOG10F
8608 || fcode
== BUILT_IN_LOG10L
)))
8609 return fold_convert_loc (loc
, type
, CALL_EXPR_ARG (arg
, 0));
8616 /* Return true if VAR is a VAR_DECL or a component thereof. */
8619 var_decl_component_p (tree var
)
8622 while (handled_component_p (inner
))
8623 inner
= TREE_OPERAND (inner
, 0);
8624 return SSA_VAR_P (inner
);
8627 /* Fold function call to builtin memset. Return
8628 NULL_TREE if no simplification can be made. */
8631 fold_builtin_memset (location_t loc
, tree dest
, tree c
, tree len
,
8632 tree type
, bool ignore
)
8634 tree var
, ret
, etype
;
8635 unsigned HOST_WIDE_INT length
, cval
;
8637 if (! validate_arg (dest
, POINTER_TYPE
)
8638 || ! validate_arg (c
, INTEGER_TYPE
)
8639 || ! validate_arg (len
, INTEGER_TYPE
))
8642 if (! tree_fits_uhwi_p (len
))
8645 /* If the LEN parameter is zero, return DEST. */
8646 if (integer_zerop (len
))
8647 return omit_one_operand_loc (loc
, type
, dest
, c
);
8649 if (TREE_CODE (c
) != INTEGER_CST
|| TREE_SIDE_EFFECTS (dest
))
8654 if (TREE_CODE (var
) != ADDR_EXPR
)
8657 var
= TREE_OPERAND (var
, 0);
8658 if (TREE_THIS_VOLATILE (var
))
8661 etype
= TREE_TYPE (var
);
8662 if (TREE_CODE (etype
) == ARRAY_TYPE
)
8663 etype
= TREE_TYPE (etype
);
8665 if (!INTEGRAL_TYPE_P (etype
)
8666 && !POINTER_TYPE_P (etype
))
8669 if (! var_decl_component_p (var
))
8672 length
= tree_to_uhwi (len
);
8673 if (GET_MODE_SIZE (TYPE_MODE (etype
)) != length
8674 || get_pointer_alignment (dest
) / BITS_PER_UNIT
< length
)
8677 if (length
> HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
)
8680 if (integer_zerop (c
))
8684 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8 || HOST_BITS_PER_WIDE_INT
> 64)
8687 cval
= TREE_INT_CST_LOW (c
);
8691 cval
|= (cval
<< 31) << 1;
8694 ret
= build_int_cst_type (etype
, cval
);
8695 var
= build_fold_indirect_ref_loc (loc
,
8696 fold_convert_loc (loc
,
8697 build_pointer_type (etype
),
8699 ret
= build2 (MODIFY_EXPR
, etype
, var
, ret
);
8703 return omit_one_operand_loc (loc
, type
, dest
, ret
);
8706 /* Fold function call to builtin memset. Return
8707 NULL_TREE if no simplification can be made. */
8710 fold_builtin_bzero (location_t loc
, tree dest
, tree size
, bool ignore
)
8712 if (! validate_arg (dest
, POINTER_TYPE
)
8713 || ! validate_arg (size
, INTEGER_TYPE
))
8719 /* New argument list transforming bzero(ptr x, int y) to
8720 memset(ptr x, int 0, size_t y). This is done this way
8721 so that if it isn't expanded inline, we fallback to
8722 calling bzero instead of memset. */
8724 return fold_builtin_memset (loc
, dest
, integer_zero_node
,
8725 fold_convert_loc (loc
, size_type_node
, size
),
8726 void_type_node
, ignore
);
8729 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8730 NULL_TREE if no simplification can be made.
8731 If ENDP is 0, return DEST (like memcpy).
8732 If ENDP is 1, return DEST+LEN (like mempcpy).
8733 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8734 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8738 fold_builtin_memory_op (location_t loc
, tree dest
, tree src
,
8739 tree len
, tree type
, bool ignore
, int endp
)
8741 tree destvar
, srcvar
, expr
;
8743 if (! validate_arg (dest
, POINTER_TYPE
)
8744 || ! validate_arg (src
, POINTER_TYPE
)
8745 || ! validate_arg (len
, INTEGER_TYPE
))
8748 /* If the LEN parameter is zero, return DEST. */
8749 if (integer_zerop (len
))
8750 return omit_one_operand_loc (loc
, type
, dest
, src
);
8752 /* If SRC and DEST are the same (and not volatile), return
8753 DEST{,+LEN,+LEN-1}. */
8754 if (operand_equal_p (src
, dest
, 0))
8758 tree srctype
, desttype
;
8759 unsigned int src_align
, dest_align
;
8764 src_align
= get_pointer_alignment (src
);
8765 dest_align
= get_pointer_alignment (dest
);
8767 /* Both DEST and SRC must be pointer types.
8768 ??? This is what old code did. Is the testing for pointer types
8771 If either SRC is readonly or length is 1, we can use memcpy. */
8772 if (!dest_align
|| !src_align
)
8774 if (readonly_data_expr (src
)
8775 || (tree_fits_uhwi_p (len
)
8776 && (MIN (src_align
, dest_align
) / BITS_PER_UNIT
8777 >= tree_to_uhwi (len
))))
8779 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
8782 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
8785 /* If *src and *dest can't overlap, optimize into memcpy as well. */
8786 if (TREE_CODE (src
) == ADDR_EXPR
8787 && TREE_CODE (dest
) == ADDR_EXPR
)
8789 tree src_base
, dest_base
, fn
;
8790 HOST_WIDE_INT src_offset
= 0, dest_offset
= 0;
8791 HOST_WIDE_INT size
= -1;
8792 HOST_WIDE_INT maxsize
= -1;
8794 srcvar
= TREE_OPERAND (src
, 0);
8795 src_base
= get_ref_base_and_extent (srcvar
, &src_offset
,
8797 destvar
= TREE_OPERAND (dest
, 0);
8798 dest_base
= get_ref_base_and_extent (destvar
, &dest_offset
,
8800 if (tree_fits_uhwi_p (len
))
8801 maxsize
= tree_to_uhwi (len
);
8804 src_offset
/= BITS_PER_UNIT
;
8805 dest_offset
/= BITS_PER_UNIT
;
8806 if (SSA_VAR_P (src_base
)
8807 && SSA_VAR_P (dest_base
))
8809 if (operand_equal_p (src_base
, dest_base
, 0)
8810 && ranges_overlap_p (src_offset
, maxsize
,
8811 dest_offset
, maxsize
))
8814 else if (TREE_CODE (src_base
) == MEM_REF
8815 && TREE_CODE (dest_base
) == MEM_REF
)
8818 if (! operand_equal_p (TREE_OPERAND (src_base
, 0),
8819 TREE_OPERAND (dest_base
, 0), 0))
8821 off
= mem_ref_offset (src_base
) +
8822 double_int::from_shwi (src_offset
);
8823 if (!off
.fits_shwi ())
8825 src_offset
= off
.low
;
8826 off
= mem_ref_offset (dest_base
) +
8827 double_int::from_shwi (dest_offset
);
8828 if (!off
.fits_shwi ())
8830 dest_offset
= off
.low
;
8831 if (ranges_overlap_p (src_offset
, maxsize
,
8832 dest_offset
, maxsize
))
8838 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
8841 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
8844 /* If the destination and source do not alias optimize into
8846 if ((is_gimple_min_invariant (dest
)
8847 || TREE_CODE (dest
) == SSA_NAME
)
8848 && (is_gimple_min_invariant (src
)
8849 || TREE_CODE (src
) == SSA_NAME
))
8852 ao_ref_init_from_ptr_and_size (&destr
, dest
, len
);
8853 ao_ref_init_from_ptr_and_size (&srcr
, src
, len
);
8854 if (!refs_may_alias_p_1 (&destr
, &srcr
, false))
8857 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
8860 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
8867 if (!tree_fits_shwi_p (len
))
8870 This logic lose for arguments like (type *)malloc (sizeof (type)),
8871 since we strip the casts of up to VOID return value from malloc.
8872 Perhaps we ought to inherit type from non-VOID argument here? */
8875 if (!POINTER_TYPE_P (TREE_TYPE (src
))
8876 || !POINTER_TYPE_P (TREE_TYPE (dest
)))
8878 /* In the following try to find a type that is most natural to be
8879 used for the memcpy source and destination and that allows
8880 the most optimization when memcpy is turned into a plain assignment
8881 using that type. In theory we could always use a char[len] type
8882 but that only gains us that the destination and source possibly
8883 no longer will have their address taken. */
8884 /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */
8885 if (TREE_CODE (src
) == POINTER_PLUS_EXPR
)
8887 tree tem
= TREE_OPERAND (src
, 0);
8889 if (tem
!= TREE_OPERAND (src
, 0))
8890 src
= build1 (NOP_EXPR
, TREE_TYPE (tem
), src
);
8892 if (TREE_CODE (dest
) == POINTER_PLUS_EXPR
)
8894 tree tem
= TREE_OPERAND (dest
, 0);
8896 if (tem
!= TREE_OPERAND (dest
, 0))
8897 dest
= build1 (NOP_EXPR
, TREE_TYPE (tem
), dest
);
8899 srctype
= TREE_TYPE (TREE_TYPE (src
));
8900 if (TREE_CODE (srctype
) == ARRAY_TYPE
8901 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
8903 srctype
= TREE_TYPE (srctype
);
8905 src
= build1 (NOP_EXPR
, build_pointer_type (srctype
), src
);
8907 desttype
= TREE_TYPE (TREE_TYPE (dest
));
8908 if (TREE_CODE (desttype
) == ARRAY_TYPE
8909 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
8911 desttype
= TREE_TYPE (desttype
);
8913 dest
= build1 (NOP_EXPR
, build_pointer_type (desttype
), dest
);
8915 if (TREE_ADDRESSABLE (srctype
)
8916 || TREE_ADDRESSABLE (desttype
))
8919 /* Make sure we are not copying using a floating-point mode or
8920 a type whose size possibly does not match its precision. */
8921 if (FLOAT_MODE_P (TYPE_MODE (desttype
))
8922 || TREE_CODE (desttype
) == BOOLEAN_TYPE
8923 || TREE_CODE (desttype
) == ENUMERAL_TYPE
)
8924 desttype
= bitwise_type_for_mode (TYPE_MODE (desttype
));
8925 if (FLOAT_MODE_P (TYPE_MODE (srctype
))
8926 || TREE_CODE (srctype
) == BOOLEAN_TYPE
8927 || TREE_CODE (srctype
) == ENUMERAL_TYPE
)
8928 srctype
= bitwise_type_for_mode (TYPE_MODE (srctype
));
8936 src_align
= get_pointer_alignment (src
);
8937 dest_align
= get_pointer_alignment (dest
);
8938 if (dest_align
< TYPE_ALIGN (desttype
)
8939 || src_align
< TYPE_ALIGN (srctype
))
8943 dest
= builtin_save_expr (dest
);
8945 /* Build accesses at offset zero with a ref-all character type. */
8946 off0
= build_int_cst (build_pointer_type_for_mode (char_type_node
,
8947 ptr_mode
, true), 0);
8950 STRIP_NOPS (destvar
);
8951 if (TREE_CODE (destvar
) == ADDR_EXPR
8952 && var_decl_component_p (TREE_OPERAND (destvar
, 0))
8953 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
8954 destvar
= fold_build2 (MEM_REF
, desttype
, destvar
, off0
);
8956 destvar
= NULL_TREE
;
8959 STRIP_NOPS (srcvar
);
8960 if (TREE_CODE (srcvar
) == ADDR_EXPR
8961 && var_decl_component_p (TREE_OPERAND (srcvar
, 0))
8962 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
8965 || src_align
>= TYPE_ALIGN (desttype
))
8966 srcvar
= fold_build2 (MEM_REF
, destvar
? desttype
: srctype
,
8968 else if (!STRICT_ALIGNMENT
)
8970 srctype
= build_aligned_type (TYPE_MAIN_VARIANT (desttype
),
8972 srcvar
= fold_build2 (MEM_REF
, srctype
, srcvar
, off0
);
8980 if (srcvar
== NULL_TREE
&& destvar
== NULL_TREE
)
8983 if (srcvar
== NULL_TREE
)
8986 if (src_align
>= TYPE_ALIGN (desttype
))
8987 srcvar
= fold_build2 (MEM_REF
, desttype
, src
, off0
);
8990 if (STRICT_ALIGNMENT
)
8992 srctype
= build_aligned_type (TYPE_MAIN_VARIANT (desttype
),
8994 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
8997 else if (destvar
== NULL_TREE
)
9000 if (dest_align
>= TYPE_ALIGN (srctype
))
9001 destvar
= fold_build2 (MEM_REF
, srctype
, dest
, off0
);
9004 if (STRICT_ALIGNMENT
)
9006 desttype
= build_aligned_type (TYPE_MAIN_VARIANT (srctype
),
9008 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
9012 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (destvar
), destvar
, srcvar
);
9018 if (endp
== 0 || endp
== 3)
9019 return omit_one_operand_loc (loc
, type
, dest
, expr
);
9025 len
= fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (len
), len
,
9028 dest
= fold_build_pointer_plus_loc (loc
, dest
, len
);
9029 dest
= fold_convert_loc (loc
, type
, dest
);
9031 dest
= omit_one_operand_loc (loc
, type
, dest
, expr
);
9035 /* Fold function call to builtin strcpy with arguments DEST and SRC.
9036 If LEN is not NULL, it represents the length of the string to be
9037 copied. Return NULL_TREE if no simplification can be made. */
9040 fold_builtin_strcpy (location_t loc
, tree fndecl
, tree dest
, tree src
, tree len
)
9044 if (!validate_arg (dest
, POINTER_TYPE
)
9045 || !validate_arg (src
, POINTER_TYPE
))
9048 /* If SRC and DEST are the same (and not volatile), return DEST. */
9049 if (operand_equal_p (src
, dest
, 0))
9050 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
9052 if (optimize_function_for_size_p (cfun
))
9055 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
9061 len
= c_strlen (src
, 1);
9062 if (! len
|| TREE_SIDE_EFFECTS (len
))
9066 len
= fold_convert_loc (loc
, size_type_node
, len
);
9067 len
= size_binop_loc (loc
, PLUS_EXPR
, len
, build_int_cst (size_type_node
, 1));
9068 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
9069 build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
));
9072 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
9073 Return NULL_TREE if no simplification can be made. */
9076 fold_builtin_stpcpy (location_t loc
, tree fndecl
, tree dest
, tree src
)
9078 tree fn
, len
, lenp1
, call
, type
;
9080 if (!validate_arg (dest
, POINTER_TYPE
)
9081 || !validate_arg (src
, POINTER_TYPE
))
9084 len
= c_strlen (src
, 1);
9086 || TREE_CODE (len
) != INTEGER_CST
)
9089 if (optimize_function_for_size_p (cfun
)
9090 /* If length is zero it's small enough. */
9091 && !integer_zerop (len
))
9094 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
9098 lenp1
= size_binop_loc (loc
, PLUS_EXPR
,
9099 fold_convert_loc (loc
, size_type_node
, len
),
9100 build_int_cst (size_type_node
, 1));
9101 /* We use dest twice in building our expression. Save it from
9102 multiple expansions. */
9103 dest
= builtin_save_expr (dest
);
9104 call
= build_call_expr_loc (loc
, fn
, 3, dest
, src
, lenp1
);
9106 type
= TREE_TYPE (TREE_TYPE (fndecl
));
9107 dest
= fold_build_pointer_plus_loc (loc
, dest
, len
);
9108 dest
= fold_convert_loc (loc
, type
, dest
);
9109 dest
= omit_one_operand_loc (loc
, type
, dest
, call
);
9113 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
9114 If SLEN is not NULL, it represents the length of the source string.
9115 Return NULL_TREE if no simplification can be made. */
9118 fold_builtin_strncpy (location_t loc
, tree fndecl
, tree dest
,
9119 tree src
, tree len
, tree slen
)
9123 if (!validate_arg (dest
, POINTER_TYPE
)
9124 || !validate_arg (src
, POINTER_TYPE
)
9125 || !validate_arg (len
, INTEGER_TYPE
))
9128 /* If the LEN parameter is zero, return DEST. */
9129 if (integer_zerop (len
))
9130 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
9132 /* We can't compare slen with len as constants below if len is not a
9134 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
9138 slen
= c_strlen (src
, 1);
9140 /* Now, we must be passed a constant src ptr parameter. */
9141 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
9144 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
9146 /* We do not support simplification of this case, though we do
9147 support it when expanding trees into RTL. */
9148 /* FIXME: generate a call to __builtin_memset. */
9149 if (tree_int_cst_lt (slen
, len
))
9152 /* OK transform into builtin memcpy. */
9153 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
9157 len
= fold_convert_loc (loc
, size_type_node
, len
);
9158 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
9159 build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
));
9162 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
9163 arguments to the call, and TYPE is its return type.
9164 Return NULL_TREE if no simplification can be made. */
9167 fold_builtin_memchr (location_t loc
, tree arg1
, tree arg2
, tree len
, tree type
)
9169 if (!validate_arg (arg1
, POINTER_TYPE
)
9170 || !validate_arg (arg2
, INTEGER_TYPE
)
9171 || !validate_arg (len
, INTEGER_TYPE
))
9177 if (TREE_CODE (arg2
) != INTEGER_CST
9178 || !tree_fits_uhwi_p (len
))
9181 p1
= c_getstr (arg1
);
9182 if (p1
&& compare_tree_int (len
, strlen (p1
) + 1) <= 0)
9188 if (target_char_cast (arg2
, &c
))
9191 r
= (const char *) memchr (p1
, c
, tree_to_uhwi (len
));
9194 return build_int_cst (TREE_TYPE (arg1
), 0);
9196 tem
= fold_build_pointer_plus_hwi_loc (loc
, arg1
, r
- p1
);
9197 return fold_convert_loc (loc
, type
, tem
);
9203 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
9204 Return NULL_TREE if no simplification can be made. */
9207 fold_builtin_memcmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
9209 const char *p1
, *p2
;
9211 if (!validate_arg (arg1
, POINTER_TYPE
)
9212 || !validate_arg (arg2
, POINTER_TYPE
)
9213 || !validate_arg (len
, INTEGER_TYPE
))
9216 /* If the LEN parameter is zero, return zero. */
9217 if (integer_zerop (len
))
9218 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
9221 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9222 if (operand_equal_p (arg1
, arg2
, 0))
9223 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
9225 p1
= c_getstr (arg1
);
9226 p2
= c_getstr (arg2
);
9228 /* If all arguments are constant, and the value of len is not greater
9229 than the lengths of arg1 and arg2, evaluate at compile-time. */
9230 if (tree_fits_uhwi_p (len
) && p1
&& p2
9231 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
9232 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
9234 const int r
= memcmp (p1
, p2
, tree_to_uhwi (len
));
9237 return integer_one_node
;
9239 return integer_minus_one_node
;
9241 return integer_zero_node
;
9244 /* If len parameter is one, return an expression corresponding to
9245 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9246 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
9248 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9249 tree cst_uchar_ptr_node
9250 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9253 = fold_convert_loc (loc
, integer_type_node
,
9254 build1 (INDIRECT_REF
, cst_uchar_node
,
9255 fold_convert_loc (loc
,
9259 = fold_convert_loc (loc
, integer_type_node
,
9260 build1 (INDIRECT_REF
, cst_uchar_node
,
9261 fold_convert_loc (loc
,
9264 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
9270 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
9271 Return NULL_TREE if no simplification can be made. */
9274 fold_builtin_strcmp (location_t loc
, tree arg1
, tree arg2
)
9276 const char *p1
, *p2
;
9278 if (!validate_arg (arg1
, POINTER_TYPE
)
9279 || !validate_arg (arg2
, POINTER_TYPE
))
9282 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9283 if (operand_equal_p (arg1
, arg2
, 0))
9284 return integer_zero_node
;
9286 p1
= c_getstr (arg1
);
9287 p2
= c_getstr (arg2
);
9291 const int i
= strcmp (p1
, p2
);
9293 return integer_minus_one_node
;
9295 return integer_one_node
;
9297 return integer_zero_node
;
9300 /* If the second arg is "", return *(const unsigned char*)arg1. */
9301 if (p2
&& *p2
== '\0')
9303 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9304 tree cst_uchar_ptr_node
9305 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9307 return fold_convert_loc (loc
, integer_type_node
,
9308 build1 (INDIRECT_REF
, cst_uchar_node
,
9309 fold_convert_loc (loc
,
9314 /* If the first arg is "", return -*(const unsigned char*)arg2. */
9315 if (p1
&& *p1
== '\0')
9317 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9318 tree cst_uchar_ptr_node
9319 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9322 = fold_convert_loc (loc
, integer_type_node
,
9323 build1 (INDIRECT_REF
, cst_uchar_node
,
9324 fold_convert_loc (loc
,
9327 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
9333 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9334 Return NULL_TREE if no simplification can be made. */
9337 fold_builtin_strncmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
9339 const char *p1
, *p2
;
9341 if (!validate_arg (arg1
, POINTER_TYPE
)
9342 || !validate_arg (arg2
, POINTER_TYPE
)
9343 || !validate_arg (len
, INTEGER_TYPE
))
9346 /* If the LEN parameter is zero, return zero. */
9347 if (integer_zerop (len
))
9348 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
9351 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9352 if (operand_equal_p (arg1
, arg2
, 0))
9353 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
9355 p1
= c_getstr (arg1
);
9356 p2
= c_getstr (arg2
);
9358 if (tree_fits_uhwi_p (len
) && p1
&& p2
)
9360 const int i
= strncmp (p1
, p2
, tree_to_uhwi (len
));
9362 return integer_one_node
;
9364 return integer_minus_one_node
;
9366 return integer_zero_node
;
9369 /* If the second arg is "", and the length is greater than zero,
9370 return *(const unsigned char*)arg1. */
9371 if (p2
&& *p2
== '\0'
9372 && TREE_CODE (len
) == INTEGER_CST
9373 && tree_int_cst_sgn (len
) == 1)
9375 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9376 tree cst_uchar_ptr_node
9377 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9379 return fold_convert_loc (loc
, integer_type_node
,
9380 build1 (INDIRECT_REF
, cst_uchar_node
,
9381 fold_convert_loc (loc
,
9386 /* If the first arg is "", and the length is greater than zero,
9387 return -*(const unsigned char*)arg2. */
9388 if (p1
&& *p1
== '\0'
9389 && TREE_CODE (len
) == INTEGER_CST
9390 && tree_int_cst_sgn (len
) == 1)
9392 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9393 tree cst_uchar_ptr_node
9394 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9396 tree temp
= fold_convert_loc (loc
, integer_type_node
,
9397 build1 (INDIRECT_REF
, cst_uchar_node
,
9398 fold_convert_loc (loc
,
9401 return fold_build1_loc (loc
, NEGATE_EXPR
, integer_type_node
, temp
);
9404 /* If len parameter is one, return an expression corresponding to
9405 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9406 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
9408 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9409 tree cst_uchar_ptr_node
9410 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9412 tree ind1
= fold_convert_loc (loc
, integer_type_node
,
9413 build1 (INDIRECT_REF
, cst_uchar_node
,
9414 fold_convert_loc (loc
,
9417 tree ind2
= fold_convert_loc (loc
, integer_type_node
,
9418 build1 (INDIRECT_REF
, cst_uchar_node
,
9419 fold_convert_loc (loc
,
9422 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
9428 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9429 ARG. Return NULL_TREE if no simplification can be made. */
9432 fold_builtin_signbit (location_t loc
, tree arg
, tree type
)
9434 if (!validate_arg (arg
, REAL_TYPE
))
9437 /* If ARG is a compile-time constant, determine the result. */
9438 if (TREE_CODE (arg
) == REAL_CST
9439 && !TREE_OVERFLOW (arg
))
9443 c
= TREE_REAL_CST (arg
);
9444 return (REAL_VALUE_NEGATIVE (c
)
9445 ? build_one_cst (type
)
9446 : build_zero_cst (type
));
9449 /* If ARG is non-negative, the result is always zero. */
9450 if (tree_expr_nonnegative_p (arg
))
9451 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9453 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
9454 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
9455 return fold_convert (type
,
9456 fold_build2_loc (loc
, LT_EXPR
, boolean_type_node
, arg
,
9457 build_real (TREE_TYPE (arg
), dconst0
)));
9462 /* Fold function call to builtin copysign, copysignf or copysignl with
9463 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
9467 fold_builtin_copysign (location_t loc
, tree fndecl
,
9468 tree arg1
, tree arg2
, tree type
)
9472 if (!validate_arg (arg1
, REAL_TYPE
)
9473 || !validate_arg (arg2
, REAL_TYPE
))
9476 /* copysign(X,X) is X. */
9477 if (operand_equal_p (arg1
, arg2
, 0))
9478 return fold_convert_loc (loc
, type
, arg1
);
9480 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
9481 if (TREE_CODE (arg1
) == REAL_CST
9482 && TREE_CODE (arg2
) == REAL_CST
9483 && !TREE_OVERFLOW (arg1
)
9484 && !TREE_OVERFLOW (arg2
))
9486 REAL_VALUE_TYPE c1
, c2
;
9488 c1
= TREE_REAL_CST (arg1
);
9489 c2
= TREE_REAL_CST (arg2
);
9490 /* c1.sign := c2.sign. */
9491 real_copysign (&c1
, &c2
);
9492 return build_real (type
, c1
);
9495 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9496 Remember to evaluate Y for side-effects. */
9497 if (tree_expr_nonnegative_p (arg2
))
9498 return omit_one_operand_loc (loc
, type
,
9499 fold_build1_loc (loc
, ABS_EXPR
, type
, arg1
),
9502 /* Strip sign changing operations for the first argument. */
9503 tem
= fold_strip_sign_ops (arg1
);
9505 return build_call_expr_loc (loc
, fndecl
, 2, tem
, arg2
);
9510 /* Fold a call to builtin isascii with argument ARG. */
9513 fold_builtin_isascii (location_t loc
, tree arg
)
9515 if (!validate_arg (arg
, INTEGER_TYPE
))
9519 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9520 arg
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
9521 build_int_cst (integer_type_node
,
9522 ~ (unsigned HOST_WIDE_INT
) 0x7f));
9523 return fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
,
9524 arg
, integer_zero_node
);
9528 /* Fold a call to builtin toascii with argument ARG. */
9531 fold_builtin_toascii (location_t loc
, tree arg
)
9533 if (!validate_arg (arg
, INTEGER_TYPE
))
9536 /* Transform toascii(c) -> (c & 0x7f). */
9537 return fold_build2_loc (loc
, BIT_AND_EXPR
, integer_type_node
, arg
,
9538 build_int_cst (integer_type_node
, 0x7f));
9541 /* Fold a call to builtin isdigit with argument ARG. */
9544 fold_builtin_isdigit (location_t loc
, tree arg
)
9546 if (!validate_arg (arg
, INTEGER_TYPE
))
9550 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9551 /* According to the C standard, isdigit is unaffected by locale.
9552 However, it definitely is affected by the target character set. */
9553 unsigned HOST_WIDE_INT target_digit0
9554 = lang_hooks
.to_target_charset ('0');
9556 if (target_digit0
== 0)
9559 arg
= fold_convert_loc (loc
, unsigned_type_node
, arg
);
9560 arg
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
9561 build_int_cst (unsigned_type_node
, target_digit0
));
9562 return fold_build2_loc (loc
, LE_EXPR
, integer_type_node
, arg
,
9563 build_int_cst (unsigned_type_node
, 9));
9567 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9570 fold_builtin_fabs (location_t loc
, tree arg
, tree type
)
9572 if (!validate_arg (arg
, REAL_TYPE
))
9575 arg
= fold_convert_loc (loc
, type
, arg
);
9576 if (TREE_CODE (arg
) == REAL_CST
)
9577 return fold_abs_const (arg
, type
);
9578 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9581 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9584 fold_builtin_abs (location_t loc
, tree arg
, tree type
)
9586 if (!validate_arg (arg
, INTEGER_TYPE
))
9589 arg
= fold_convert_loc (loc
, type
, arg
);
9590 if (TREE_CODE (arg
) == INTEGER_CST
)
9591 return fold_abs_const (arg
, type
);
9592 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9595 /* Fold a fma operation with arguments ARG[012]. */
9598 fold_fma (location_t loc ATTRIBUTE_UNUSED
,
9599 tree type
, tree arg0
, tree arg1
, tree arg2
)
9601 if (TREE_CODE (arg0
) == REAL_CST
9602 && TREE_CODE (arg1
) == REAL_CST
9603 && TREE_CODE (arg2
) == REAL_CST
)
9604 return do_mpfr_arg3 (arg0
, arg1
, arg2
, type
, mpfr_fma
);
9609 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
9612 fold_builtin_fma (location_t loc
, tree arg0
, tree arg1
, tree arg2
, tree type
)
9614 if (validate_arg (arg0
, REAL_TYPE
)
9615 && validate_arg (arg1
, REAL_TYPE
)
9616 && validate_arg (arg2
, REAL_TYPE
))
9618 tree tem
= fold_fma (loc
, type
, arg0
, arg1
, arg2
);
9622 /* ??? Only expand to FMA_EXPR if it's directly supported. */
9623 if (optab_handler (fma_optab
, TYPE_MODE (type
)) != CODE_FOR_nothing
)
9624 return fold_build3_loc (loc
, FMA_EXPR
, type
, arg0
, arg1
, arg2
);
9629 /* Fold a call to builtin fmin or fmax. */
9632 fold_builtin_fmin_fmax (location_t loc
, tree arg0
, tree arg1
,
9633 tree type
, bool max
)
9635 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, REAL_TYPE
))
9637 /* Calculate the result when the argument is a constant. */
9638 tree res
= do_mpfr_arg2 (arg0
, arg1
, type
, (max
? mpfr_max
: mpfr_min
));
9643 /* If either argument is NaN, return the other one. Avoid the
9644 transformation if we get (and honor) a signalling NaN. Using
9645 omit_one_operand() ensures we create a non-lvalue. */
9646 if (TREE_CODE (arg0
) == REAL_CST
9647 && real_isnan (&TREE_REAL_CST (arg0
))
9648 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
9649 || ! TREE_REAL_CST (arg0
).signalling
))
9650 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
9651 if (TREE_CODE (arg1
) == REAL_CST
9652 && real_isnan (&TREE_REAL_CST (arg1
))
9653 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
9654 || ! TREE_REAL_CST (arg1
).signalling
))
9655 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9657 /* Transform fmin/fmax(x,x) -> x. */
9658 if (operand_equal_p (arg0
, arg1
, OEP_PURE_SAME
))
9659 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9661 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9662 functions to return the numeric arg if the other one is NaN.
9663 These tree codes don't honor that, so only transform if
9664 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9665 handled, so we don't have to worry about it either. */
9666 if (flag_finite_math_only
)
9667 return fold_build2_loc (loc
, (max
? MAX_EXPR
: MIN_EXPR
), type
,
9668 fold_convert_loc (loc
, type
, arg0
),
9669 fold_convert_loc (loc
, type
, arg1
));
9674 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9677 fold_builtin_carg (location_t loc
, tree arg
, tree type
)
9679 if (validate_arg (arg
, COMPLEX_TYPE
)
9680 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
)
9682 tree atan2_fn
= mathfn_built_in (type
, BUILT_IN_ATAN2
);
9686 tree new_arg
= builtin_save_expr (arg
);
9687 tree r_arg
= fold_build1_loc (loc
, REALPART_EXPR
, type
, new_arg
);
9688 tree i_arg
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, new_arg
);
9689 return build_call_expr_loc (loc
, atan2_fn
, 2, i_arg
, r_arg
);
9696 /* Fold a call to builtin logb/ilogb. */
9699 fold_builtin_logb (location_t loc
, tree arg
, tree rettype
)
9701 if (! validate_arg (arg
, REAL_TYPE
))
9706 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9708 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9714 /* If arg is Inf or NaN and we're logb, return it. */
9715 if (TREE_CODE (rettype
) == REAL_TYPE
)
9717 /* For logb(-Inf) we have to return +Inf. */
9718 if (real_isinf (value
) && real_isneg (value
))
9720 REAL_VALUE_TYPE tem
;
9722 return build_real (rettype
, tem
);
9724 return fold_convert_loc (loc
, rettype
, arg
);
9726 /* Fall through... */
9728 /* Zero may set errno and/or raise an exception for logb, also
9729 for ilogb we don't know FP_ILOGB0. */
9732 /* For normal numbers, proceed iff radix == 2. In GCC,
9733 normalized significands are in the range [0.5, 1.0). We
9734 want the exponent as if they were [1.0, 2.0) so get the
9735 exponent and subtract 1. */
9736 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9737 return fold_convert_loc (loc
, rettype
,
9738 build_int_cst (integer_type_node
,
9739 REAL_EXP (value
)-1));
9747 /* Fold a call to builtin significand, if radix == 2. */
9750 fold_builtin_significand (location_t loc
, tree arg
, tree rettype
)
9752 if (! validate_arg (arg
, REAL_TYPE
))
9757 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_OVERFLOW (arg
))
9759 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg
);
9766 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9767 return fold_convert_loc (loc
, rettype
, arg
);
9769 /* For normal numbers, proceed iff radix == 2. */
9770 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg
)))->b
== 2)
9772 REAL_VALUE_TYPE result
= *value
;
9773 /* In GCC, normalized significands are in the range [0.5,
9774 1.0). We want them to be [1.0, 2.0) so set the
9776 SET_REAL_EXP (&result
, 1);
9777 return build_real (rettype
, result
);
9786 /* Fold a call to builtin frexp, we can assume the base is 2. */
9789 fold_builtin_frexp (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9791 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9796 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9799 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9801 /* Proceed if a valid pointer type was passed in. */
9802 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == integer_type_node
)
9804 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9810 /* For +-0, return (*exp = 0, +-0). */
9811 exp
= integer_zero_node
;
9816 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9817 return omit_one_operand_loc (loc
, rettype
, arg0
, arg1
);
9820 /* Since the frexp function always expects base 2, and in
9821 GCC normalized significands are already in the range
9822 [0.5, 1.0), we have exactly what frexp wants. */
9823 REAL_VALUE_TYPE frac_rvt
= *value
;
9824 SET_REAL_EXP (&frac_rvt
, 0);
9825 frac
= build_real (rettype
, frac_rvt
);
9826 exp
= build_int_cst (integer_type_node
, REAL_EXP (value
));
9833 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9834 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
, exp
);
9835 TREE_SIDE_EFFECTS (arg1
) = 1;
9836 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
, frac
);
9842 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9843 then we can assume the base is two. If it's false, then we have to
9844 check the mode of the TYPE parameter in certain cases. */
9847 fold_builtin_load_exponent (location_t loc
, tree arg0
, tree arg1
,
9848 tree type
, bool ldexp
)
9850 if (validate_arg (arg0
, REAL_TYPE
) && validate_arg (arg1
, INTEGER_TYPE
))
9855 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9856 if (real_zerop (arg0
) || integer_zerop (arg1
)
9857 || (TREE_CODE (arg0
) == REAL_CST
9858 && !real_isfinite (&TREE_REAL_CST (arg0
))))
9859 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
9861 /* If both arguments are constant, then try to evaluate it. */
9862 if ((ldexp
|| REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2)
9863 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
9864 && tree_fits_shwi_p (arg1
))
9866 /* Bound the maximum adjustment to twice the range of the
9867 mode's valid exponents. Use abs to ensure the range is
9868 positive as a sanity check. */
9869 const long max_exp_adj
= 2 *
9870 labs (REAL_MODE_FORMAT (TYPE_MODE (type
))->emax
9871 - REAL_MODE_FORMAT (TYPE_MODE (type
))->emin
);
9873 /* Get the user-requested adjustment. */
9874 const HOST_WIDE_INT req_exp_adj
= tree_to_shwi (arg1
);
9876 /* The requested adjustment must be inside this range. This
9877 is a preliminary cap to avoid things like overflow, we
9878 may still fail to compute the result for other reasons. */
9879 if (-max_exp_adj
< req_exp_adj
&& req_exp_adj
< max_exp_adj
)
9881 REAL_VALUE_TYPE initial_result
;
9883 real_ldexp (&initial_result
, &TREE_REAL_CST (arg0
), req_exp_adj
);
9885 /* Ensure we didn't overflow. */
9886 if (! real_isinf (&initial_result
))
9888 const REAL_VALUE_TYPE trunc_result
9889 = real_value_truncate (TYPE_MODE (type
), initial_result
);
9891 /* Only proceed if the target mode can hold the
9893 if (REAL_VALUES_EQUAL (initial_result
, trunc_result
))
9894 return build_real (type
, trunc_result
);
9903 /* Fold a call to builtin modf. */
9906 fold_builtin_modf (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9908 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9913 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9916 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9918 /* Proceed if a valid pointer type was passed in. */
9919 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == TYPE_MAIN_VARIANT (rettype
))
9921 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9922 REAL_VALUE_TYPE trunc
, frac
;
9928 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9929 trunc
= frac
= *value
;
9932 /* For +-Inf, return (*arg1 = arg0, +-0). */
9934 frac
.sign
= value
->sign
;
9938 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9939 real_trunc (&trunc
, VOIDmode
, value
);
9940 real_arithmetic (&frac
, MINUS_EXPR
, value
, &trunc
);
9941 /* If the original number was negative and already
9942 integral, then the fractional part is -0.0. */
9943 if (value
->sign
&& frac
.cl
== rvc_zero
)
9944 frac
.sign
= value
->sign
;
9948 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9949 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
,
9950 build_real (rettype
, trunc
));
9951 TREE_SIDE_EFFECTS (arg1
) = 1;
9952 return fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
,
9953 build_real (rettype
, frac
));
9959 /* Given a location LOC, an interclass builtin function decl FNDECL
9960 and its single argument ARG, return an folded expression computing
9961 the same, or NULL_TREE if we either couldn't or didn't want to fold
9962 (the latter happen if there's an RTL instruction available). */
9965 fold_builtin_interclass_mathfn (location_t loc
, tree fndecl
, tree arg
)
9967 enum machine_mode mode
;
9969 if (!validate_arg (arg
, REAL_TYPE
))
9972 if (interclass_mathfn_icode (arg
, fndecl
) != CODE_FOR_nothing
)
9975 mode
= TYPE_MODE (TREE_TYPE (arg
));
9977 /* If there is no optab, try generic code. */
9978 switch (DECL_FUNCTION_CODE (fndecl
))
9982 CASE_FLT_FN (BUILT_IN_ISINF
):
9984 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9985 tree
const isgr_fn
= builtin_decl_explicit (BUILT_IN_ISGREATER
);
9986 tree
const type
= TREE_TYPE (arg
);
9990 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
9991 real_from_string (&r
, buf
);
9992 result
= build_call_expr (isgr_fn
, 2,
9993 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9994 build_real (type
, r
));
9997 CASE_FLT_FN (BUILT_IN_FINITE
):
9998 case BUILT_IN_ISFINITE
:
10000 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
10001 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
10002 tree
const type
= TREE_TYPE (arg
);
10006 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
10007 real_from_string (&r
, buf
);
10008 result
= build_call_expr (isle_fn
, 2,
10009 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
10010 build_real (type
, r
));
10011 /*result = fold_build2_loc (loc, UNGT_EXPR,
10012 TREE_TYPE (TREE_TYPE (fndecl)),
10013 fold_build1_loc (loc, ABS_EXPR, type, arg),
10014 build_real (type, r));
10015 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
10016 TREE_TYPE (TREE_TYPE (fndecl)),
10020 case BUILT_IN_ISNORMAL
:
10022 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
10023 islessequal(fabs(x),DBL_MAX). */
10024 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
10025 tree
const isge_fn
= builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL
);
10026 tree
const type
= TREE_TYPE (arg
);
10027 REAL_VALUE_TYPE rmax
, rmin
;
10030 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
));
10031 real_from_string (&rmax
, buf
);
10032 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
10033 real_from_string (&rmin
, buf
);
10034 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
10035 result
= build_call_expr (isle_fn
, 2, arg
,
10036 build_real (type
, rmax
));
10037 result
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, result
,
10038 build_call_expr (isge_fn
, 2, arg
,
10039 build_real (type
, rmin
)));
10049 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
10050 ARG is the argument for the call. */
10053 fold_builtin_classify (location_t loc
, tree fndecl
, tree arg
, int builtin_index
)
10055 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10058 if (!validate_arg (arg
, REAL_TYPE
))
10061 switch (builtin_index
)
10063 case BUILT_IN_ISINF
:
10064 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
10065 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
10067 if (TREE_CODE (arg
) == REAL_CST
)
10069 r
= TREE_REAL_CST (arg
);
10070 if (real_isinf (&r
))
10071 return real_compare (GT_EXPR
, &r
, &dconst0
)
10072 ? integer_one_node
: integer_minus_one_node
;
10074 return integer_zero_node
;
10079 case BUILT_IN_ISINF_SIGN
:
10081 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
10082 /* In a boolean context, GCC will fold the inner COND_EXPR to
10083 1. So e.g. "if (isinf_sign(x))" would be folded to just
10084 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
10085 tree signbit_fn
= mathfn_built_in_1 (TREE_TYPE (arg
), BUILT_IN_SIGNBIT
, 0);
10086 tree isinf_fn
= builtin_decl_explicit (BUILT_IN_ISINF
);
10087 tree tmp
= NULL_TREE
;
10089 arg
= builtin_save_expr (arg
);
10091 if (signbit_fn
&& isinf_fn
)
10093 tree signbit_call
= build_call_expr_loc (loc
, signbit_fn
, 1, arg
);
10094 tree isinf_call
= build_call_expr_loc (loc
, isinf_fn
, 1, arg
);
10096 signbit_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
10097 signbit_call
, integer_zero_node
);
10098 isinf_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
10099 isinf_call
, integer_zero_node
);
10101 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, signbit_call
,
10102 integer_minus_one_node
, integer_one_node
);
10103 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
10105 integer_zero_node
);
10111 case BUILT_IN_ISFINITE
:
10112 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg
)))
10113 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
10114 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
10116 if (TREE_CODE (arg
) == REAL_CST
)
10118 r
= TREE_REAL_CST (arg
);
10119 return real_isfinite (&r
) ? integer_one_node
: integer_zero_node
;
10124 case BUILT_IN_ISNAN
:
10125 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg
))))
10126 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
10128 if (TREE_CODE (arg
) == REAL_CST
)
10130 r
= TREE_REAL_CST (arg
);
10131 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
10134 arg
= builtin_save_expr (arg
);
10135 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg
, arg
);
10138 gcc_unreachable ();
10142 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
10143 This builtin will generate code to return the appropriate floating
10144 point classification depending on the value of the floating point
10145 number passed in. The possible return values must be supplied as
10146 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
10147 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
10148 one floating point argument which is "type generic". */
10151 fold_builtin_fpclassify (location_t loc
, tree exp
)
10153 tree fp_nan
, fp_infinite
, fp_normal
, fp_subnormal
, fp_zero
,
10154 arg
, type
, res
, tmp
;
10155 enum machine_mode mode
;
10159 /* Verify the required arguments in the original call. */
10160 if (!validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
,
10161 INTEGER_TYPE
, INTEGER_TYPE
,
10162 INTEGER_TYPE
, REAL_TYPE
, VOID_TYPE
))
10165 fp_nan
= CALL_EXPR_ARG (exp
, 0);
10166 fp_infinite
= CALL_EXPR_ARG (exp
, 1);
10167 fp_normal
= CALL_EXPR_ARG (exp
, 2);
10168 fp_subnormal
= CALL_EXPR_ARG (exp
, 3);
10169 fp_zero
= CALL_EXPR_ARG (exp
, 4);
10170 arg
= CALL_EXPR_ARG (exp
, 5);
10171 type
= TREE_TYPE (arg
);
10172 mode
= TYPE_MODE (type
);
10173 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
10175 /* fpclassify(x) ->
10176 isnan(x) ? FP_NAN :
10177 (fabs(x) == Inf ? FP_INFINITE :
10178 (fabs(x) >= DBL_MIN ? FP_NORMAL :
10179 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
10181 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
10182 build_real (type
, dconst0
));
10183 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
10184 tmp
, fp_zero
, fp_subnormal
);
10186 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
10187 real_from_string (&r
, buf
);
10188 tmp
= fold_build2_loc (loc
, GE_EXPR
, integer_type_node
,
10189 arg
, build_real (type
, r
));
10190 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, fp_normal
, res
);
10192 if (HONOR_INFINITIES (mode
))
10195 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
10196 build_real (type
, r
));
10197 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
,
10201 if (HONOR_NANS (mode
))
10203 tmp
= fold_build2_loc (loc
, ORDERED_EXPR
, integer_type_node
, arg
, arg
);
10204 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, res
, fp_nan
);
10210 /* Fold a call to an unordered comparison function such as
10211 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
10212 being called and ARG0 and ARG1 are the arguments for the call.
10213 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
10214 the opposite of the desired result. UNORDERED_CODE is used
10215 for modes that can hold NaNs and ORDERED_CODE is used for
10219 fold_builtin_unordered_cmp (location_t loc
, tree fndecl
, tree arg0
, tree arg1
,
10220 enum tree_code unordered_code
,
10221 enum tree_code ordered_code
)
10223 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10224 enum tree_code code
;
10226 enum tree_code code0
, code1
;
10227 tree cmp_type
= NULL_TREE
;
10229 type0
= TREE_TYPE (arg0
);
10230 type1
= TREE_TYPE (arg1
);
10232 code0
= TREE_CODE (type0
);
10233 code1
= TREE_CODE (type1
);
10235 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
10236 /* Choose the wider of two real types. */
10237 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
10239 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
10241 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
10244 arg0
= fold_convert_loc (loc
, cmp_type
, arg0
);
10245 arg1
= fold_convert_loc (loc
, cmp_type
, arg1
);
10247 if (unordered_code
== UNORDERED_EXPR
)
10249 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
10250 return omit_two_operands_loc (loc
, type
, integer_zero_node
, arg0
, arg1
);
10251 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg0
, arg1
);
10254 code
= HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
10256 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
,
10257 fold_build2_loc (loc
, code
, type
, arg0
, arg1
));
10260 /* Fold a call to built-in function FNDECL with 0 arguments.
10261 IGNORE is true if the result of the function call is ignored. This
10262 function returns NULL_TREE if no simplification was possible. */
10265 fold_builtin_0 (location_t loc
, tree fndecl
, bool ignore ATTRIBUTE_UNUSED
)
10267 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10268 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10271 CASE_FLT_FN (BUILT_IN_INF
):
10272 case BUILT_IN_INFD32
:
10273 case BUILT_IN_INFD64
:
10274 case BUILT_IN_INFD128
:
10275 return fold_builtin_inf (loc
, type
, true);
10277 CASE_FLT_FN (BUILT_IN_HUGE_VAL
):
10278 return fold_builtin_inf (loc
, type
, false);
10280 case BUILT_IN_CLASSIFY_TYPE
:
10281 return fold_builtin_classify_type (NULL_TREE
);
10283 case BUILT_IN_UNREACHABLE
:
10284 if (flag_sanitize
& SANITIZE_UNREACHABLE
10285 && (current_function_decl
== NULL
10286 || !lookup_attribute ("no_sanitize_undefined",
10287 DECL_ATTRIBUTES (current_function_decl
))))
10288 return ubsan_instrument_unreachable (loc
);
10297 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
10298 IGNORE is true if the result of the function call is ignored. This
10299 function returns NULL_TREE if no simplification was possible. */
10302 fold_builtin_1 (location_t loc
, tree fndecl
, tree arg0
, bool ignore
)
10304 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10305 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10308 case BUILT_IN_CONSTANT_P
:
10310 tree val
= fold_builtin_constant_p (arg0
);
10312 /* Gimplification will pull the CALL_EXPR for the builtin out of
10313 an if condition. When not optimizing, we'll not CSE it back.
10314 To avoid link error types of regressions, return false now. */
10315 if (!val
&& !optimize
)
10316 val
= integer_zero_node
;
10321 case BUILT_IN_CLASSIFY_TYPE
:
10322 return fold_builtin_classify_type (arg0
);
10324 case BUILT_IN_STRLEN
:
10325 return fold_builtin_strlen (loc
, type
, arg0
);
10327 CASE_FLT_FN (BUILT_IN_FABS
):
10328 case BUILT_IN_FABSD32
:
10329 case BUILT_IN_FABSD64
:
10330 case BUILT_IN_FABSD128
:
10331 return fold_builtin_fabs (loc
, arg0
, type
);
10334 case BUILT_IN_LABS
:
10335 case BUILT_IN_LLABS
:
10336 case BUILT_IN_IMAXABS
:
10337 return fold_builtin_abs (loc
, arg0
, type
);
10339 CASE_FLT_FN (BUILT_IN_CONJ
):
10340 if (validate_arg (arg0
, COMPLEX_TYPE
)
10341 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10342 return fold_build1_loc (loc
, CONJ_EXPR
, type
, arg0
);
10345 CASE_FLT_FN (BUILT_IN_CREAL
):
10346 if (validate_arg (arg0
, COMPLEX_TYPE
)
10347 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10348 return non_lvalue_loc (loc
, fold_build1_loc (loc
, REALPART_EXPR
, type
, arg0
));;
10351 CASE_FLT_FN (BUILT_IN_CIMAG
):
10352 if (validate_arg (arg0
, COMPLEX_TYPE
)
10353 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10354 return non_lvalue_loc (loc
, fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg0
));
10357 CASE_FLT_FN (BUILT_IN_CCOS
):
10358 return fold_builtin_ccos (loc
, arg0
, type
, fndecl
, /*hyper=*/ false);
10360 CASE_FLT_FN (BUILT_IN_CCOSH
):
10361 return fold_builtin_ccos (loc
, arg0
, type
, fndecl
, /*hyper=*/ true);
10363 CASE_FLT_FN (BUILT_IN_CPROJ
):
10364 return fold_builtin_cproj (loc
, arg0
, type
);
10366 CASE_FLT_FN (BUILT_IN_CSIN
):
10367 if (validate_arg (arg0
, COMPLEX_TYPE
)
10368 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10369 return do_mpc_arg1 (arg0
, type
, mpc_sin
);
10372 CASE_FLT_FN (BUILT_IN_CSINH
):
10373 if (validate_arg (arg0
, COMPLEX_TYPE
)
10374 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10375 return do_mpc_arg1 (arg0
, type
, mpc_sinh
);
10378 CASE_FLT_FN (BUILT_IN_CTAN
):
10379 if (validate_arg (arg0
, COMPLEX_TYPE
)
10380 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10381 return do_mpc_arg1 (arg0
, type
, mpc_tan
);
10384 CASE_FLT_FN (BUILT_IN_CTANH
):
10385 if (validate_arg (arg0
, COMPLEX_TYPE
)
10386 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10387 return do_mpc_arg1 (arg0
, type
, mpc_tanh
);
10390 CASE_FLT_FN (BUILT_IN_CLOG
):
10391 if (validate_arg (arg0
, COMPLEX_TYPE
)
10392 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10393 return do_mpc_arg1 (arg0
, type
, mpc_log
);
10396 CASE_FLT_FN (BUILT_IN_CSQRT
):
10397 if (validate_arg (arg0
, COMPLEX_TYPE
)
10398 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10399 return do_mpc_arg1 (arg0
, type
, mpc_sqrt
);
10402 CASE_FLT_FN (BUILT_IN_CASIN
):
10403 if (validate_arg (arg0
, COMPLEX_TYPE
)
10404 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10405 return do_mpc_arg1 (arg0
, type
, mpc_asin
);
10408 CASE_FLT_FN (BUILT_IN_CACOS
):
10409 if (validate_arg (arg0
, COMPLEX_TYPE
)
10410 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10411 return do_mpc_arg1 (arg0
, type
, mpc_acos
);
10414 CASE_FLT_FN (BUILT_IN_CATAN
):
10415 if (validate_arg (arg0
, COMPLEX_TYPE
)
10416 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10417 return do_mpc_arg1 (arg0
, type
, mpc_atan
);
10420 CASE_FLT_FN (BUILT_IN_CASINH
):
10421 if (validate_arg (arg0
, COMPLEX_TYPE
)
10422 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10423 return do_mpc_arg1 (arg0
, type
, mpc_asinh
);
10426 CASE_FLT_FN (BUILT_IN_CACOSH
):
10427 if (validate_arg (arg0
, COMPLEX_TYPE
)
10428 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10429 return do_mpc_arg1 (arg0
, type
, mpc_acosh
);
10432 CASE_FLT_FN (BUILT_IN_CATANH
):
10433 if (validate_arg (arg0
, COMPLEX_TYPE
)
10434 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10435 return do_mpc_arg1 (arg0
, type
, mpc_atanh
);
10438 CASE_FLT_FN (BUILT_IN_CABS
):
10439 return fold_builtin_cabs (loc
, arg0
, type
, fndecl
);
10441 CASE_FLT_FN (BUILT_IN_CARG
):
10442 return fold_builtin_carg (loc
, arg0
, type
);
10444 CASE_FLT_FN (BUILT_IN_SQRT
):
10445 return fold_builtin_sqrt (loc
, arg0
, type
);
10447 CASE_FLT_FN (BUILT_IN_CBRT
):
10448 return fold_builtin_cbrt (loc
, arg0
, type
);
10450 CASE_FLT_FN (BUILT_IN_ASIN
):
10451 if (validate_arg (arg0
, REAL_TYPE
))
10452 return do_mpfr_arg1 (arg0
, type
, mpfr_asin
,
10453 &dconstm1
, &dconst1
, true);
10456 CASE_FLT_FN (BUILT_IN_ACOS
):
10457 if (validate_arg (arg0
, REAL_TYPE
))
10458 return do_mpfr_arg1 (arg0
, type
, mpfr_acos
,
10459 &dconstm1
, &dconst1
, true);
10462 CASE_FLT_FN (BUILT_IN_ATAN
):
10463 if (validate_arg (arg0
, REAL_TYPE
))
10464 return do_mpfr_arg1 (arg0
, type
, mpfr_atan
, NULL
, NULL
, 0);
10467 CASE_FLT_FN (BUILT_IN_ASINH
):
10468 if (validate_arg (arg0
, REAL_TYPE
))
10469 return do_mpfr_arg1 (arg0
, type
, mpfr_asinh
, NULL
, NULL
, 0);
10472 CASE_FLT_FN (BUILT_IN_ACOSH
):
10473 if (validate_arg (arg0
, REAL_TYPE
))
10474 return do_mpfr_arg1 (arg0
, type
, mpfr_acosh
,
10475 &dconst1
, NULL
, true);
10478 CASE_FLT_FN (BUILT_IN_ATANH
):
10479 if (validate_arg (arg0
, REAL_TYPE
))
10480 return do_mpfr_arg1 (arg0
, type
, mpfr_atanh
,
10481 &dconstm1
, &dconst1
, false);
10484 CASE_FLT_FN (BUILT_IN_SIN
):
10485 if (validate_arg (arg0
, REAL_TYPE
))
10486 return do_mpfr_arg1 (arg0
, type
, mpfr_sin
, NULL
, NULL
, 0);
10489 CASE_FLT_FN (BUILT_IN_COS
):
10490 return fold_builtin_cos (loc
, arg0
, type
, fndecl
);
10492 CASE_FLT_FN (BUILT_IN_TAN
):
10493 return fold_builtin_tan (arg0
, type
);
10495 CASE_FLT_FN (BUILT_IN_CEXP
):
10496 return fold_builtin_cexp (loc
, arg0
, type
);
10498 CASE_FLT_FN (BUILT_IN_CEXPI
):
10499 if (validate_arg (arg0
, REAL_TYPE
))
10500 return do_mpfr_sincos (arg0
, NULL_TREE
, NULL_TREE
);
10503 CASE_FLT_FN (BUILT_IN_SINH
):
10504 if (validate_arg (arg0
, REAL_TYPE
))
10505 return do_mpfr_arg1 (arg0
, type
, mpfr_sinh
, NULL
, NULL
, 0);
10508 CASE_FLT_FN (BUILT_IN_COSH
):
10509 return fold_builtin_cosh (loc
, arg0
, type
, fndecl
);
10511 CASE_FLT_FN (BUILT_IN_TANH
):
10512 if (validate_arg (arg0
, REAL_TYPE
))
10513 return do_mpfr_arg1 (arg0
, type
, mpfr_tanh
, NULL
, NULL
, 0);
10516 CASE_FLT_FN (BUILT_IN_ERF
):
10517 if (validate_arg (arg0
, REAL_TYPE
))
10518 return do_mpfr_arg1 (arg0
, type
, mpfr_erf
, NULL
, NULL
, 0);
10521 CASE_FLT_FN (BUILT_IN_ERFC
):
10522 if (validate_arg (arg0
, REAL_TYPE
))
10523 return do_mpfr_arg1 (arg0
, type
, mpfr_erfc
, NULL
, NULL
, 0);
10526 CASE_FLT_FN (BUILT_IN_TGAMMA
):
10527 if (validate_arg (arg0
, REAL_TYPE
))
10528 return do_mpfr_arg1 (arg0
, type
, mpfr_gamma
, NULL
, NULL
, 0);
10531 CASE_FLT_FN (BUILT_IN_EXP
):
10532 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp
);
10534 CASE_FLT_FN (BUILT_IN_EXP2
):
10535 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp2
);
10537 CASE_FLT_FN (BUILT_IN_EXP10
):
10538 CASE_FLT_FN (BUILT_IN_POW10
):
10539 return fold_builtin_exponent (loc
, fndecl
, arg0
, mpfr_exp10
);
10541 CASE_FLT_FN (BUILT_IN_EXPM1
):
10542 if (validate_arg (arg0
, REAL_TYPE
))
10543 return do_mpfr_arg1 (arg0
, type
, mpfr_expm1
, NULL
, NULL
, 0);
10546 CASE_FLT_FN (BUILT_IN_LOG
):
10547 return fold_builtin_logarithm (loc
, fndecl
, arg0
, mpfr_log
);
10549 CASE_FLT_FN (BUILT_IN_LOG2
):
10550 return fold_builtin_logarithm (loc
, fndecl
, arg0
, mpfr_log2
);
10552 CASE_FLT_FN (BUILT_IN_LOG10
):
10553 return fold_builtin_logarithm (loc
, fndecl
, arg0
, mpfr_log10
);
10555 CASE_FLT_FN (BUILT_IN_LOG1P
):
10556 if (validate_arg (arg0
, REAL_TYPE
))
10557 return do_mpfr_arg1 (arg0
, type
, mpfr_log1p
,
10558 &dconstm1
, NULL
, false);
10561 CASE_FLT_FN (BUILT_IN_J0
):
10562 if (validate_arg (arg0
, REAL_TYPE
))
10563 return do_mpfr_arg1 (arg0
, type
, mpfr_j0
,
10567 CASE_FLT_FN (BUILT_IN_J1
):
10568 if (validate_arg (arg0
, REAL_TYPE
))
10569 return do_mpfr_arg1 (arg0
, type
, mpfr_j1
,
10573 CASE_FLT_FN (BUILT_IN_Y0
):
10574 if (validate_arg (arg0
, REAL_TYPE
))
10575 return do_mpfr_arg1 (arg0
, type
, mpfr_y0
,
10576 &dconst0
, NULL
, false);
10579 CASE_FLT_FN (BUILT_IN_Y1
):
10580 if (validate_arg (arg0
, REAL_TYPE
))
10581 return do_mpfr_arg1 (arg0
, type
, mpfr_y1
,
10582 &dconst0
, NULL
, false);
10585 CASE_FLT_FN (BUILT_IN_NAN
):
10586 case BUILT_IN_NAND32
:
10587 case BUILT_IN_NAND64
:
10588 case BUILT_IN_NAND128
:
10589 return fold_builtin_nan (arg0
, type
, true);
10591 CASE_FLT_FN (BUILT_IN_NANS
):
10592 return fold_builtin_nan (arg0
, type
, false);
10594 CASE_FLT_FN (BUILT_IN_FLOOR
):
10595 return fold_builtin_floor (loc
, fndecl
, arg0
);
10597 CASE_FLT_FN (BUILT_IN_CEIL
):
10598 return fold_builtin_ceil (loc
, fndecl
, arg0
);
10600 CASE_FLT_FN (BUILT_IN_TRUNC
):
10601 return fold_builtin_trunc (loc
, fndecl
, arg0
);
10603 CASE_FLT_FN (BUILT_IN_ROUND
):
10604 return fold_builtin_round (loc
, fndecl
, arg0
);
10606 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
10607 CASE_FLT_FN (BUILT_IN_RINT
):
10608 return fold_trunc_transparent_mathfn (loc
, fndecl
, arg0
);
10610 CASE_FLT_FN (BUILT_IN_ICEIL
):
10611 CASE_FLT_FN (BUILT_IN_LCEIL
):
10612 CASE_FLT_FN (BUILT_IN_LLCEIL
):
10613 CASE_FLT_FN (BUILT_IN_LFLOOR
):
10614 CASE_FLT_FN (BUILT_IN_IFLOOR
):
10615 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
10616 CASE_FLT_FN (BUILT_IN_IROUND
):
10617 CASE_FLT_FN (BUILT_IN_LROUND
):
10618 CASE_FLT_FN (BUILT_IN_LLROUND
):
10619 return fold_builtin_int_roundingfn (loc
, fndecl
, arg0
);
10621 CASE_FLT_FN (BUILT_IN_IRINT
):
10622 CASE_FLT_FN (BUILT_IN_LRINT
):
10623 CASE_FLT_FN (BUILT_IN_LLRINT
):
10624 return fold_fixed_mathfn (loc
, fndecl
, arg0
);
10626 case BUILT_IN_BSWAP16
:
10627 case BUILT_IN_BSWAP32
:
10628 case BUILT_IN_BSWAP64
:
10629 return fold_builtin_bswap (fndecl
, arg0
);
10631 CASE_INT_FN (BUILT_IN_FFS
):
10632 CASE_INT_FN (BUILT_IN_CLZ
):
10633 CASE_INT_FN (BUILT_IN_CTZ
):
10634 CASE_INT_FN (BUILT_IN_CLRSB
):
10635 CASE_INT_FN (BUILT_IN_POPCOUNT
):
10636 CASE_INT_FN (BUILT_IN_PARITY
):
10637 return fold_builtin_bitop (fndecl
, arg0
);
10639 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
10640 return fold_builtin_signbit (loc
, arg0
, type
);
10642 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
10643 return fold_builtin_significand (loc
, arg0
, type
);
10645 CASE_FLT_FN (BUILT_IN_ILOGB
):
10646 CASE_FLT_FN (BUILT_IN_LOGB
):
10647 return fold_builtin_logb (loc
, arg0
, type
);
10649 case BUILT_IN_ISASCII
:
10650 return fold_builtin_isascii (loc
, arg0
);
10652 case BUILT_IN_TOASCII
:
10653 return fold_builtin_toascii (loc
, arg0
);
10655 case BUILT_IN_ISDIGIT
:
10656 return fold_builtin_isdigit (loc
, arg0
);
10658 CASE_FLT_FN (BUILT_IN_FINITE
):
10659 case BUILT_IN_FINITED32
:
10660 case BUILT_IN_FINITED64
:
10661 case BUILT_IN_FINITED128
:
10662 case BUILT_IN_ISFINITE
:
10664 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISFINITE
);
10667 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10670 CASE_FLT_FN (BUILT_IN_ISINF
):
10671 case BUILT_IN_ISINFD32
:
10672 case BUILT_IN_ISINFD64
:
10673 case BUILT_IN_ISINFD128
:
10675 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF
);
10678 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10681 case BUILT_IN_ISNORMAL
:
10682 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10684 case BUILT_IN_ISINF_SIGN
:
10685 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF_SIGN
);
10687 CASE_FLT_FN (BUILT_IN_ISNAN
):
10688 case BUILT_IN_ISNAND32
:
10689 case BUILT_IN_ISNAND64
:
10690 case BUILT_IN_ISNAND128
:
10691 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISNAN
);
10693 case BUILT_IN_PRINTF
:
10694 case BUILT_IN_PRINTF_UNLOCKED
:
10695 case BUILT_IN_VPRINTF
:
10696 return fold_builtin_printf (loc
, fndecl
, arg0
, NULL_TREE
, ignore
, fcode
);
10698 case BUILT_IN_FREE
:
10699 if (integer_zerop (arg0
))
10700 return build_empty_stmt (loc
);
10711 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10712 IGNORE is true if the result of the function call is ignored. This
10713 function returns NULL_TREE if no simplification was possible. */
10716 fold_builtin_2 (location_t loc
, tree fndecl
, tree arg0
, tree arg1
, bool ignore
)
10718 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10719 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10723 CASE_FLT_FN (BUILT_IN_JN
):
10724 if (validate_arg (arg0
, INTEGER_TYPE
)
10725 && validate_arg (arg1
, REAL_TYPE
))
10726 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_jn
, NULL
, 0);
10729 CASE_FLT_FN (BUILT_IN_YN
):
10730 if (validate_arg (arg0
, INTEGER_TYPE
)
10731 && validate_arg (arg1
, REAL_TYPE
))
10732 return do_mpfr_bessel_n (arg0
, arg1
, type
, mpfr_yn
,
10736 CASE_FLT_FN (BUILT_IN_DREM
):
10737 CASE_FLT_FN (BUILT_IN_REMAINDER
):
10738 if (validate_arg (arg0
, REAL_TYPE
)
10739 && validate_arg (arg1
, REAL_TYPE
))
10740 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_remainder
);
10743 CASE_FLT_FN_REENT (BUILT_IN_GAMMA
): /* GAMMA_R */
10744 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA
): /* LGAMMA_R */
10745 if (validate_arg (arg0
, REAL_TYPE
)
10746 && validate_arg (arg1
, POINTER_TYPE
))
10747 return do_mpfr_lgamma_r (arg0
, arg1
, type
);
10750 CASE_FLT_FN (BUILT_IN_ATAN2
):
10751 if (validate_arg (arg0
, REAL_TYPE
)
10752 && validate_arg (arg1
, REAL_TYPE
))
10753 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_atan2
);
10756 CASE_FLT_FN (BUILT_IN_FDIM
):
10757 if (validate_arg (arg0
, REAL_TYPE
)
10758 && validate_arg (arg1
, REAL_TYPE
))
10759 return do_mpfr_arg2 (arg0
, arg1
, type
, mpfr_dim
);
10762 CASE_FLT_FN (BUILT_IN_HYPOT
):
10763 return fold_builtin_hypot (loc
, fndecl
, arg0
, arg1
, type
);
10765 CASE_FLT_FN (BUILT_IN_CPOW
):
10766 if (validate_arg (arg0
, COMPLEX_TYPE
)
10767 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
10768 && validate_arg (arg1
, COMPLEX_TYPE
)
10769 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
)
10770 return do_mpc_arg2 (arg0
, arg1
, type
, /*do_nonfinite=*/ 0, mpc_pow
);
10773 CASE_FLT_FN (BUILT_IN_LDEXP
):
10774 return fold_builtin_load_exponent (loc
, arg0
, arg1
, type
, /*ldexp=*/true);
10775 CASE_FLT_FN (BUILT_IN_SCALBN
):
10776 CASE_FLT_FN (BUILT_IN_SCALBLN
):
10777 return fold_builtin_load_exponent (loc
, arg0
, arg1
,
10778 type
, /*ldexp=*/false);
10780 CASE_FLT_FN (BUILT_IN_FREXP
):
10781 return fold_builtin_frexp (loc
, arg0
, arg1
, type
);
10783 CASE_FLT_FN (BUILT_IN_MODF
):
10784 return fold_builtin_modf (loc
, arg0
, arg1
, type
);
10786 case BUILT_IN_BZERO
:
10787 return fold_builtin_bzero (loc
, arg0
, arg1
, ignore
);
10789 case BUILT_IN_FPUTS
:
10790 return fold_builtin_fputs (loc
, arg0
, arg1
, ignore
, false, NULL_TREE
);
10792 case BUILT_IN_FPUTS_UNLOCKED
:
10793 return fold_builtin_fputs (loc
, arg0
, arg1
, ignore
, true, NULL_TREE
);
10795 case BUILT_IN_STRSTR
:
10796 return fold_builtin_strstr (loc
, arg0
, arg1
, type
);
10798 case BUILT_IN_STRCAT
:
10799 return fold_builtin_strcat (loc
, arg0
, arg1
, NULL_TREE
);
10801 case BUILT_IN_STRSPN
:
10802 return fold_builtin_strspn (loc
, arg0
, arg1
);
10804 case BUILT_IN_STRCSPN
:
10805 return fold_builtin_strcspn (loc
, arg0
, arg1
);
10807 case BUILT_IN_STRCHR
:
10808 case BUILT_IN_INDEX
:
10809 return fold_builtin_strchr (loc
, arg0
, arg1
, type
);
10811 case BUILT_IN_STRRCHR
:
10812 case BUILT_IN_RINDEX
:
10813 return fold_builtin_strrchr (loc
, arg0
, arg1
, type
);
10815 case BUILT_IN_STRCPY
:
10816 return fold_builtin_strcpy (loc
, fndecl
, arg0
, arg1
, NULL_TREE
);
10818 case BUILT_IN_STPCPY
:
10821 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
10825 return build_call_expr_loc (loc
, fn
, 2, arg0
, arg1
);
10828 return fold_builtin_stpcpy (loc
, fndecl
, arg0
, arg1
);
10831 case BUILT_IN_STRCMP
:
10832 return fold_builtin_strcmp (loc
, arg0
, arg1
);
10834 case BUILT_IN_STRPBRK
:
10835 return fold_builtin_strpbrk (loc
, arg0
, arg1
, type
);
10837 case BUILT_IN_EXPECT
:
10838 return fold_builtin_expect (loc
, arg0
, arg1
, NULL_TREE
);
10840 CASE_FLT_FN (BUILT_IN_POW
):
10841 return fold_builtin_pow (loc
, fndecl
, arg0
, arg1
, type
);
10843 CASE_FLT_FN (BUILT_IN_POWI
):
10844 return fold_builtin_powi (loc
, fndecl
, arg0
, arg1
, type
);
10846 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
10847 return fold_builtin_copysign (loc
, fndecl
, arg0
, arg1
, type
);
10849 CASE_FLT_FN (BUILT_IN_FMIN
):
10850 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/false);
10852 CASE_FLT_FN (BUILT_IN_FMAX
):
10853 return fold_builtin_fmin_fmax (loc
, arg0
, arg1
, type
, /*max=*/true);
10855 case BUILT_IN_ISGREATER
:
10856 return fold_builtin_unordered_cmp (loc
, fndecl
,
10857 arg0
, arg1
, UNLE_EXPR
, LE_EXPR
);
10858 case BUILT_IN_ISGREATEREQUAL
:
10859 return fold_builtin_unordered_cmp (loc
, fndecl
,
10860 arg0
, arg1
, UNLT_EXPR
, LT_EXPR
);
10861 case BUILT_IN_ISLESS
:
10862 return fold_builtin_unordered_cmp (loc
, fndecl
,
10863 arg0
, arg1
, UNGE_EXPR
, GE_EXPR
);
10864 case BUILT_IN_ISLESSEQUAL
:
10865 return fold_builtin_unordered_cmp (loc
, fndecl
,
10866 arg0
, arg1
, UNGT_EXPR
, GT_EXPR
);
10867 case BUILT_IN_ISLESSGREATER
:
10868 return fold_builtin_unordered_cmp (loc
, fndecl
,
10869 arg0
, arg1
, UNEQ_EXPR
, EQ_EXPR
);
10870 case BUILT_IN_ISUNORDERED
:
10871 return fold_builtin_unordered_cmp (loc
, fndecl
,
10872 arg0
, arg1
, UNORDERED_EXPR
,
10875 /* We do the folding for va_start in the expander. */
10876 case BUILT_IN_VA_START
:
10879 case BUILT_IN_SPRINTF
:
10880 return fold_builtin_sprintf (loc
, arg0
, arg1
, NULL_TREE
, ignore
);
10882 case BUILT_IN_OBJECT_SIZE
:
10883 return fold_builtin_object_size (arg0
, arg1
);
10885 case BUILT_IN_PRINTF
:
10886 case BUILT_IN_PRINTF_UNLOCKED
:
10887 case BUILT_IN_VPRINTF
:
10888 return fold_builtin_printf (loc
, fndecl
, arg0
, arg1
, ignore
, fcode
);
10890 case BUILT_IN_PRINTF_CHK
:
10891 case BUILT_IN_VPRINTF_CHK
:
10892 if (!validate_arg (arg0
, INTEGER_TYPE
)
10893 || TREE_SIDE_EFFECTS (arg0
))
10896 return fold_builtin_printf (loc
, fndecl
,
10897 arg1
, NULL_TREE
, ignore
, fcode
);
10900 case BUILT_IN_FPRINTF
:
10901 case BUILT_IN_FPRINTF_UNLOCKED
:
10902 case BUILT_IN_VFPRINTF
:
10903 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg1
, NULL_TREE
,
10906 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
10907 return fold_builtin_atomic_always_lock_free (arg0
, arg1
);
10909 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
10910 return fold_builtin_atomic_is_lock_free (arg0
, arg1
);
10918 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10919 and ARG2. IGNORE is true if the result of the function call is ignored.
10920 This function returns NULL_TREE if no simplification was possible. */
10923 fold_builtin_3 (location_t loc
, tree fndecl
,
10924 tree arg0
, tree arg1
, tree arg2
, bool ignore
)
10926 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10927 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10931 CASE_FLT_FN (BUILT_IN_SINCOS
):
10932 return fold_builtin_sincos (loc
, arg0
, arg1
, arg2
);
10934 CASE_FLT_FN (BUILT_IN_FMA
):
10935 return fold_builtin_fma (loc
, arg0
, arg1
, arg2
, type
);
10938 CASE_FLT_FN (BUILT_IN_REMQUO
):
10939 if (validate_arg (arg0
, REAL_TYPE
)
10940 && validate_arg (arg1
, REAL_TYPE
)
10941 && validate_arg (arg2
, POINTER_TYPE
))
10942 return do_mpfr_remquo (arg0
, arg1
, arg2
);
10945 case BUILT_IN_MEMSET
:
10946 return fold_builtin_memset (loc
, arg0
, arg1
, arg2
, type
, ignore
);
10948 case BUILT_IN_BCOPY
:
10949 return fold_builtin_memory_op (loc
, arg1
, arg0
, arg2
,
10950 void_type_node
, true, /*endp=*/3);
10952 case BUILT_IN_MEMCPY
:
10953 return fold_builtin_memory_op (loc
, arg0
, arg1
, arg2
,
10954 type
, ignore
, /*endp=*/0);
10956 case BUILT_IN_MEMPCPY
:
10957 return fold_builtin_memory_op (loc
, arg0
, arg1
, arg2
,
10958 type
, ignore
, /*endp=*/1);
10960 case BUILT_IN_MEMMOVE
:
10961 return fold_builtin_memory_op (loc
, arg0
, arg1
, arg2
,
10962 type
, ignore
, /*endp=*/3);
10964 case BUILT_IN_STRNCAT
:
10965 return fold_builtin_strncat (loc
, arg0
, arg1
, arg2
);
10967 case BUILT_IN_STRNCPY
:
10968 return fold_builtin_strncpy (loc
, fndecl
, arg0
, arg1
, arg2
, NULL_TREE
);
10970 case BUILT_IN_STRNCMP
:
10971 return fold_builtin_strncmp (loc
, arg0
, arg1
, arg2
);
10973 case BUILT_IN_MEMCHR
:
10974 return fold_builtin_memchr (loc
, arg0
, arg1
, arg2
, type
);
10976 case BUILT_IN_BCMP
:
10977 case BUILT_IN_MEMCMP
:
10978 return fold_builtin_memcmp (loc
, arg0
, arg1
, arg2
);;
10980 case BUILT_IN_SPRINTF
:
10981 return fold_builtin_sprintf (loc
, arg0
, arg1
, arg2
, ignore
);
10983 case BUILT_IN_SNPRINTF
:
10984 return fold_builtin_snprintf (loc
, arg0
, arg1
, arg2
, NULL_TREE
, ignore
);
10986 case BUILT_IN_STRCPY_CHK
:
10987 case BUILT_IN_STPCPY_CHK
:
10988 return fold_builtin_stxcpy_chk (loc
, fndecl
, arg0
, arg1
, arg2
, NULL_TREE
,
10991 case BUILT_IN_STRCAT_CHK
:
10992 return fold_builtin_strcat_chk (loc
, fndecl
, arg0
, arg1
, arg2
);
10994 case BUILT_IN_PRINTF_CHK
:
10995 case BUILT_IN_VPRINTF_CHK
:
10996 if (!validate_arg (arg0
, INTEGER_TYPE
)
10997 || TREE_SIDE_EFFECTS (arg0
))
11000 return fold_builtin_printf (loc
, fndecl
, arg1
, arg2
, ignore
, fcode
);
11003 case BUILT_IN_FPRINTF
:
11004 case BUILT_IN_FPRINTF_UNLOCKED
:
11005 case BUILT_IN_VFPRINTF
:
11006 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg1
, arg2
,
11009 case BUILT_IN_FPRINTF_CHK
:
11010 case BUILT_IN_VFPRINTF_CHK
:
11011 if (!validate_arg (arg1
, INTEGER_TYPE
)
11012 || TREE_SIDE_EFFECTS (arg1
))
11015 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg2
, NULL_TREE
,
11018 case BUILT_IN_EXPECT
:
11019 return fold_builtin_expect (loc
, arg0
, arg1
, arg2
);
11027 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
11028 ARG2, and ARG3. IGNORE is true if the result of the function call is
11029 ignored. This function returns NULL_TREE if no simplification was
11033 fold_builtin_4 (location_t loc
, tree fndecl
,
11034 tree arg0
, tree arg1
, tree arg2
, tree arg3
, bool ignore
)
11036 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
11040 case BUILT_IN_MEMCPY_CHK
:
11041 case BUILT_IN_MEMPCPY_CHK
:
11042 case BUILT_IN_MEMMOVE_CHK
:
11043 case BUILT_IN_MEMSET_CHK
:
11044 return fold_builtin_memory_chk (loc
, fndecl
, arg0
, arg1
, arg2
, arg3
,
11046 DECL_FUNCTION_CODE (fndecl
));
11048 case BUILT_IN_STRNCPY_CHK
:
11049 case BUILT_IN_STPNCPY_CHK
:
11050 return fold_builtin_stxncpy_chk (loc
, arg0
, arg1
, arg2
, arg3
, NULL_TREE
,
11053 case BUILT_IN_STRNCAT_CHK
:
11054 return fold_builtin_strncat_chk (loc
, fndecl
, arg0
, arg1
, arg2
, arg3
);
11056 case BUILT_IN_SNPRINTF
:
11057 return fold_builtin_snprintf (loc
, arg0
, arg1
, arg2
, arg3
, ignore
);
11059 case BUILT_IN_FPRINTF_CHK
:
11060 case BUILT_IN_VFPRINTF_CHK
:
11061 if (!validate_arg (arg1
, INTEGER_TYPE
)
11062 || TREE_SIDE_EFFECTS (arg1
))
11065 return fold_builtin_fprintf (loc
, fndecl
, arg0
, arg2
, arg3
,
11075 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
11076 arguments, where NARGS <= 4. IGNORE is true if the result of the
11077 function call is ignored. This function returns NULL_TREE if no
11078 simplification was possible. Note that this only folds builtins with
11079 fixed argument patterns. Foldings that do varargs-to-varargs
11080 transformations, or that match calls with more than 4 arguments,
11081 need to be handled with fold_builtin_varargs instead. */
11083 #define MAX_ARGS_TO_FOLD_BUILTIN 4
11086 fold_builtin_n (location_t loc
, tree fndecl
, tree
*args
, int nargs
, bool ignore
)
11088 tree ret
= NULL_TREE
;
11093 ret
= fold_builtin_0 (loc
, fndecl
, ignore
);
11096 ret
= fold_builtin_1 (loc
, fndecl
, args
[0], ignore
);
11099 ret
= fold_builtin_2 (loc
, fndecl
, args
[0], args
[1], ignore
);
11102 ret
= fold_builtin_3 (loc
, fndecl
, args
[0], args
[1], args
[2], ignore
);
11105 ret
= fold_builtin_4 (loc
, fndecl
, args
[0], args
[1], args
[2], args
[3],
11113 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
11114 SET_EXPR_LOCATION (ret
, loc
);
11115 TREE_NO_WARNING (ret
) = 1;
11121 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11122 list ARGS along with N new arguments in NEWARGS. SKIP is the number
11123 of arguments in ARGS to be omitted. OLDNARGS is the number of
11124 elements in ARGS. */
11127 rewrite_call_expr_valist (location_t loc
, int oldnargs
, tree
*args
,
11128 int skip
, tree fndecl
, int n
, va_list newargs
)
11130 int nargs
= oldnargs
- skip
+ n
;
11137 buffer
= XALLOCAVEC (tree
, nargs
);
11138 for (i
= 0; i
< n
; i
++)
11139 buffer
[i
] = va_arg (newargs
, tree
);
11140 for (j
= skip
; j
< oldnargs
; j
++, i
++)
11141 buffer
[i
] = args
[j
];
11144 buffer
= args
+ skip
;
11146 return build_call_expr_loc_array (loc
, fndecl
, nargs
, buffer
);
11149 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11150 list ARGS along with N new arguments specified as the "..."
11151 parameters. SKIP is the number of arguments in ARGS to be omitted.
11152 OLDNARGS is the number of elements in ARGS. */
11155 rewrite_call_expr_array (location_t loc
, int oldnargs
, tree
*args
,
11156 int skip
, tree fndecl
, int n
, ...)
11162 t
= rewrite_call_expr_valist (loc
, oldnargs
, args
, skip
, fndecl
, n
, ap
);
11168 /* Return true if FNDECL shouldn't be folded right now.
11169 If a built-in function has an inline attribute always_inline
11170 wrapper, defer folding it after always_inline functions have
11171 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
11172 might not be performed. */
11175 avoid_folding_inline_builtin (tree fndecl
)
11177 return (DECL_DECLARED_INLINE_P (fndecl
)
11178 && DECL_DISREGARD_INLINE_LIMITS (fndecl
)
11180 && !cfun
->always_inline_functions_inlined
11181 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl
)));
11184 /* A wrapper function for builtin folding that prevents warnings for
11185 "statement without effect" and the like, caused by removing the
11186 call node earlier than the warning is generated. */
11189 fold_call_expr (location_t loc
, tree exp
, bool ignore
)
11191 tree ret
= NULL_TREE
;
11192 tree fndecl
= get_callee_fndecl (exp
);
11194 && TREE_CODE (fndecl
) == FUNCTION_DECL
11195 && DECL_BUILT_IN (fndecl
)
11196 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
11197 yet. Defer folding until we see all the arguments
11198 (after inlining). */
11199 && !CALL_EXPR_VA_ARG_PACK (exp
))
11201 int nargs
= call_expr_nargs (exp
);
11203 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
11204 instead last argument is __builtin_va_arg_pack (). Defer folding
11205 even in that case, until arguments are finalized. */
11206 if (nargs
&& TREE_CODE (CALL_EXPR_ARG (exp
, nargs
- 1)) == CALL_EXPR
)
11208 tree fndecl2
= get_callee_fndecl (CALL_EXPR_ARG (exp
, nargs
- 1));
11210 && TREE_CODE (fndecl2
) == FUNCTION_DECL
11211 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
11212 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
11216 if (avoid_folding_inline_builtin (fndecl
))
11219 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
11220 return targetm
.fold_builtin (fndecl
, call_expr_nargs (exp
),
11221 CALL_EXPR_ARGP (exp
), ignore
);
11224 if (nargs
<= MAX_ARGS_TO_FOLD_BUILTIN
)
11226 tree
*args
= CALL_EXPR_ARGP (exp
);
11227 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
11230 ret
= fold_builtin_varargs (loc
, fndecl
, exp
, ignore
);
11238 /* Conveniently construct a function call expression. FNDECL names the
11239 function to be called and N arguments are passed in the array
11243 build_call_expr_loc_array (location_t loc
, tree fndecl
, int n
, tree
*argarray
)
11245 tree fntype
= TREE_TYPE (fndecl
);
11246 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
11248 return fold_builtin_call_array (loc
, TREE_TYPE (fntype
), fn
, n
, argarray
);
11251 /* Conveniently construct a function call expression. FNDECL names the
11252 function to be called and the arguments are passed in the vector
11256 build_call_expr_loc_vec (location_t loc
, tree fndecl
, vec
<tree
, va_gc
> *vec
)
11258 return build_call_expr_loc_array (loc
, fndecl
, vec_safe_length (vec
),
11259 vec_safe_address (vec
));
11263 /* Conveniently construct a function call expression. FNDECL names the
11264 function to be called, N is the number of arguments, and the "..."
11265 parameters are the argument expressions. */
11268 build_call_expr_loc (location_t loc
, tree fndecl
, int n
, ...)
11271 tree
*argarray
= XALLOCAVEC (tree
, n
);
11275 for (i
= 0; i
< n
; i
++)
11276 argarray
[i
] = va_arg (ap
, tree
);
11278 return build_call_expr_loc_array (loc
, fndecl
, n
, argarray
);
11281 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because
11282 varargs macros aren't supported by all bootstrap compilers. */
11285 build_call_expr (tree fndecl
, int n
, ...)
11288 tree
*argarray
= XALLOCAVEC (tree
, n
);
11292 for (i
= 0; i
< n
; i
++)
11293 argarray
[i
] = va_arg (ap
, tree
);
11295 return build_call_expr_loc_array (UNKNOWN_LOCATION
, fndecl
, n
, argarray
);
11298 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
11299 N arguments are passed in the array ARGARRAY. */
11302 fold_builtin_call_array (location_t loc
, tree type
,
11307 tree ret
= NULL_TREE
;
11310 if (TREE_CODE (fn
) == ADDR_EXPR
)
11312 tree fndecl
= TREE_OPERAND (fn
, 0);
11313 if (TREE_CODE (fndecl
) == FUNCTION_DECL
11314 && DECL_BUILT_IN (fndecl
))
11316 /* If last argument is __builtin_va_arg_pack (), arguments to this
11317 function are not finalized yet. Defer folding until they are. */
11318 if (n
&& TREE_CODE (argarray
[n
- 1]) == CALL_EXPR
)
11320 tree fndecl2
= get_callee_fndecl (argarray
[n
- 1]);
11322 && TREE_CODE (fndecl2
) == FUNCTION_DECL
11323 && DECL_BUILT_IN_CLASS (fndecl2
) == BUILT_IN_NORMAL
11324 && DECL_FUNCTION_CODE (fndecl2
) == BUILT_IN_VA_ARG_PACK
)
11325 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
11327 if (avoid_folding_inline_builtin (fndecl
))
11328 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
11329 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
11331 ret
= targetm
.fold_builtin (fndecl
, n
, argarray
, false);
11335 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
11337 else if (n
<= MAX_ARGS_TO_FOLD_BUILTIN
)
11339 /* First try the transformations that don't require consing up
11341 ret
= fold_builtin_n (loc
, fndecl
, argarray
, n
, false);
11346 /* If we got this far, we need to build an exp. */
11347 exp
= build_call_array_loc (loc
, type
, fn
, n
, argarray
);
11348 ret
= fold_builtin_varargs (loc
, fndecl
, exp
, false);
11349 return ret
? ret
: exp
;
11353 return build_call_array_loc (loc
, type
, fn
, n
, argarray
);
11356 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
11357 along with N new arguments specified as the "..." parameters. SKIP
11358 is the number of arguments in EXP to be omitted. This function is used
11359 to do varargs-to-varargs transformations. */
11362 rewrite_call_expr (location_t loc
, tree exp
, int skip
, tree fndecl
, int n
, ...)
11368 t
= rewrite_call_expr_valist (loc
, call_expr_nargs (exp
),
11369 CALL_EXPR_ARGP (exp
), skip
, fndecl
, n
, ap
);
11375 /* Validate a single argument ARG against a tree code CODE representing
11379 validate_arg (const_tree arg
, enum tree_code code
)
11383 else if (code
== POINTER_TYPE
)
11384 return POINTER_TYPE_P (TREE_TYPE (arg
));
11385 else if (code
== INTEGER_TYPE
)
11386 return INTEGRAL_TYPE_P (TREE_TYPE (arg
));
11387 return code
== TREE_CODE (TREE_TYPE (arg
));
11390 /* This function validates the types of a function call argument list
11391 against a specified list of tree_codes. If the last specifier is a 0,
11392 that represents an ellipses, otherwise the last specifier must be a
11395 This is the GIMPLE version of validate_arglist. Eventually we want to
11396 completely convert builtins.c to work from GIMPLEs and the tree based
11397 validate_arglist will then be removed. */
11400 validate_gimple_arglist (const_gimple call
, ...)
11402 enum tree_code code
;
11408 va_start (ap
, call
);
11413 code
= (enum tree_code
) va_arg (ap
, int);
11417 /* This signifies an ellipses, any further arguments are all ok. */
11421 /* This signifies an endlink, if no arguments remain, return
11422 true, otherwise return false. */
11423 res
= (i
== gimple_call_num_args (call
));
11426 /* If no parameters remain or the parameter's code does not
11427 match the specified code, return false. Otherwise continue
11428 checking any remaining arguments. */
11429 arg
= gimple_call_arg (call
, i
++);
11430 if (!validate_arg (arg
, code
))
11437 /* We need gotos here since we can only have one VA_CLOSE in a
11445 /* Default target-specific builtin expander that does nothing. */
11448 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
11449 rtx target ATTRIBUTE_UNUSED
,
11450 rtx subtarget ATTRIBUTE_UNUSED
,
11451 enum machine_mode mode ATTRIBUTE_UNUSED
,
11452 int ignore ATTRIBUTE_UNUSED
)
11457 /* Returns true is EXP represents data that would potentially reside
11458 in a readonly section. */
11461 readonly_data_expr (tree exp
)
11465 if (TREE_CODE (exp
) != ADDR_EXPR
)
11468 exp
= get_base_address (TREE_OPERAND (exp
, 0));
11472 /* Make sure we call decl_readonly_section only for trees it
11473 can handle (since it returns true for everything it doesn't
11475 if (TREE_CODE (exp
) == STRING_CST
11476 || TREE_CODE (exp
) == CONSTRUCTOR
11477 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
11478 return decl_readonly_section (exp
, 0);
11483 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
11484 to the call, and TYPE is its return type.
11486 Return NULL_TREE if no simplification was possible, otherwise return the
11487 simplified form of the call as a tree.
11489 The simplified form may be a constant or other expression which
11490 computes the same value, but in a more efficient manner (including
11491 calls to other builtin functions).
11493 The call may contain arguments which need to be evaluated, but
11494 which are not useful to determine the result of the call. In
11495 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11496 COMPOUND_EXPR will be an argument which must be evaluated.
11497 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11498 COMPOUND_EXPR in the chain will contain the tree for the simplified
11499 form of the builtin function call. */
11502 fold_builtin_strstr (location_t loc
, tree s1
, tree s2
, tree type
)
11504 if (!validate_arg (s1
, POINTER_TYPE
)
11505 || !validate_arg (s2
, POINTER_TYPE
))
11510 const char *p1
, *p2
;
11512 p2
= c_getstr (s2
);
11516 p1
= c_getstr (s1
);
11519 const char *r
= strstr (p1
, p2
);
11523 return build_int_cst (TREE_TYPE (s1
), 0);
11525 /* Return an offset into the constant string argument. */
11526 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11527 return fold_convert_loc (loc
, type
, tem
);
11530 /* The argument is const char *, and the result is char *, so we need
11531 a type conversion here to avoid a warning. */
11533 return fold_convert_loc (loc
, type
, s1
);
11538 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11542 /* New argument list transforming strstr(s1, s2) to
11543 strchr(s1, s2[0]). */
11544 return build_call_expr_loc (loc
, fn
, 2, s1
,
11545 build_int_cst (integer_type_node
, p2
[0]));
11549 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
11550 the call, and TYPE is its return type.
11552 Return NULL_TREE if no simplification was possible, otherwise return the
11553 simplified form of the call as a tree.
11555 The simplified form may be a constant or other expression which
11556 computes the same value, but in a more efficient manner (including
11557 calls to other builtin functions).
11559 The call may contain arguments which need to be evaluated, but
11560 which are not useful to determine the result of the call. In
11561 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11562 COMPOUND_EXPR will be an argument which must be evaluated.
11563 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11564 COMPOUND_EXPR in the chain will contain the tree for the simplified
11565 form of the builtin function call. */
11568 fold_builtin_strchr (location_t loc
, tree s1
, tree s2
, tree type
)
11570 if (!validate_arg (s1
, POINTER_TYPE
)
11571 || !validate_arg (s2
, INTEGER_TYPE
))
11577 if (TREE_CODE (s2
) != INTEGER_CST
)
11580 p1
= c_getstr (s1
);
11587 if (target_char_cast (s2
, &c
))
11590 r
= strchr (p1
, c
);
11593 return build_int_cst (TREE_TYPE (s1
), 0);
11595 /* Return an offset into the constant string argument. */
11596 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11597 return fold_convert_loc (loc
, type
, tem
);
11603 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
11604 the call, and TYPE is its return type.
11606 Return NULL_TREE if no simplification was possible, otherwise return the
11607 simplified form of the call as a tree.
11609 The simplified form may be a constant or other expression which
11610 computes the same value, but in a more efficient manner (including
11611 calls to other builtin functions).
11613 The call may contain arguments which need to be evaluated, but
11614 which are not useful to determine the result of the call. In
11615 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11616 COMPOUND_EXPR will be an argument which must be evaluated.
11617 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11618 COMPOUND_EXPR in the chain will contain the tree for the simplified
11619 form of the builtin function call. */
11622 fold_builtin_strrchr (location_t loc
, tree s1
, tree s2
, tree type
)
11624 if (!validate_arg (s1
, POINTER_TYPE
)
11625 || !validate_arg (s2
, INTEGER_TYPE
))
11632 if (TREE_CODE (s2
) != INTEGER_CST
)
11635 p1
= c_getstr (s1
);
11642 if (target_char_cast (s2
, &c
))
11645 r
= strrchr (p1
, c
);
11648 return build_int_cst (TREE_TYPE (s1
), 0);
11650 /* Return an offset into the constant string argument. */
11651 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11652 return fold_convert_loc (loc
, type
, tem
);
11655 if (! integer_zerop (s2
))
11658 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11662 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
11663 return build_call_expr_loc (loc
, fn
, 2, s1
, s2
);
11667 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11668 to the call, and TYPE is its return type.
11670 Return NULL_TREE if no simplification was possible, otherwise return the
11671 simplified form of the call as a tree.
11673 The simplified form may be a constant or other expression which
11674 computes the same value, but in a more efficient manner (including
11675 calls to other builtin functions).
11677 The call may contain arguments which need to be evaluated, but
11678 which are not useful to determine the result of the call. In
11679 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11680 COMPOUND_EXPR will be an argument which must be evaluated.
11681 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11682 COMPOUND_EXPR in the chain will contain the tree for the simplified
11683 form of the builtin function call. */
11686 fold_builtin_strpbrk (location_t loc
, tree s1
, tree s2
, tree type
)
11688 if (!validate_arg (s1
, POINTER_TYPE
)
11689 || !validate_arg (s2
, POINTER_TYPE
))
11694 const char *p1
, *p2
;
11696 p2
= c_getstr (s2
);
11700 p1
= c_getstr (s1
);
11703 const char *r
= strpbrk (p1
, p2
);
11707 return build_int_cst (TREE_TYPE (s1
), 0);
11709 /* Return an offset into the constant string argument. */
11710 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11711 return fold_convert_loc (loc
, type
, tem
);
11715 /* strpbrk(x, "") == NULL.
11716 Evaluate and ignore s1 in case it had side-effects. */
11717 return omit_one_operand_loc (loc
, TREE_TYPE (s1
), integer_zero_node
, s1
);
11720 return NULL_TREE
; /* Really call strpbrk. */
11722 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11726 /* New argument list transforming strpbrk(s1, s2) to
11727 strchr(s1, s2[0]). */
11728 return build_call_expr_loc (loc
, fn
, 2, s1
,
11729 build_int_cst (integer_type_node
, p2
[0]));
11733 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
11736 Return NULL_TREE if no simplification was possible, otherwise return the
11737 simplified form of the call as a tree.
11739 The simplified form may be a constant or other expression which
11740 computes the same value, but in a more efficient manner (including
11741 calls to other builtin functions).
11743 The call may contain arguments which need to be evaluated, but
11744 which are not useful to determine the result of the call. In
11745 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11746 COMPOUND_EXPR will be an argument which must be evaluated.
11747 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11748 COMPOUND_EXPR in the chain will contain the tree for the simplified
11749 form of the builtin function call. */
11752 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED
, tree dst
, tree src
,
11755 if (!validate_arg (dst
, POINTER_TYPE
)
11756 || !validate_arg (src
, POINTER_TYPE
))
11760 const char *p
= c_getstr (src
);
11762 /* If the string length is zero, return the dst parameter. */
11763 if (p
&& *p
== '\0')
11766 if (optimize_insn_for_speed_p ())
11768 /* See if we can store by pieces into (dst + strlen(dst)). */
11770 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
11771 tree memcpy_fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
11773 if (!strlen_fn
|| !memcpy_fn
)
11776 /* If the length of the source string isn't computable don't
11777 split strcat into strlen and memcpy. */
11779 len
= c_strlen (src
, 1);
11780 if (! len
|| TREE_SIDE_EFFECTS (len
))
11783 /* Stabilize the argument list. */
11784 dst
= builtin_save_expr (dst
);
11786 /* Create strlen (dst). */
11787 newdst
= build_call_expr_loc (loc
, strlen_fn
, 1, dst
);
11788 /* Create (dst p+ strlen (dst)). */
11790 newdst
= fold_build_pointer_plus_loc (loc
, dst
, newdst
);
11791 newdst
= builtin_save_expr (newdst
);
11793 len
= fold_convert_loc (loc
, size_type_node
, len
);
11794 len
= size_binop_loc (loc
, PLUS_EXPR
, len
,
11795 build_int_cst (size_type_node
, 1));
11797 call
= build_call_expr_loc (loc
, memcpy_fn
, 3, newdst
, src
, len
);
11798 return build2 (COMPOUND_EXPR
, TREE_TYPE (dst
), call
, dst
);
11804 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
11805 arguments to the call.
11807 Return NULL_TREE if no simplification was possible, otherwise return the
11808 simplified form of the call as a tree.
11810 The simplified form may be a constant or other expression which
11811 computes the same value, but in a more efficient manner (including
11812 calls to other builtin functions).
11814 The call may contain arguments which need to be evaluated, but
11815 which are not useful to determine the result of the call. In
11816 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11817 COMPOUND_EXPR will be an argument which must be evaluated.
11818 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11819 COMPOUND_EXPR in the chain will contain the tree for the simplified
11820 form of the builtin function call. */
11823 fold_builtin_strncat (location_t loc
, tree dst
, tree src
, tree len
)
11825 if (!validate_arg (dst
, POINTER_TYPE
)
11826 || !validate_arg (src
, POINTER_TYPE
)
11827 || !validate_arg (len
, INTEGER_TYPE
))
11831 const char *p
= c_getstr (src
);
11833 /* If the requested length is zero, or the src parameter string
11834 length is zero, return the dst parameter. */
11835 if (integer_zerop (len
) || (p
&& *p
== '\0'))
11836 return omit_two_operands_loc (loc
, TREE_TYPE (dst
), dst
, src
, len
);
11838 /* If the requested len is greater than or equal to the string
11839 length, call strcat. */
11840 if (TREE_CODE (len
) == INTEGER_CST
&& p
11841 && compare_tree_int (len
, strlen (p
)) >= 0)
11843 tree fn
= builtin_decl_implicit (BUILT_IN_STRCAT
);
11845 /* If the replacement _DECL isn't initialized, don't do the
11850 return build_call_expr_loc (loc
, fn
, 2, dst
, src
);
11856 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11859 Return NULL_TREE if no simplification was possible, otherwise return the
11860 simplified form of the call as a tree.
11862 The simplified form may be a constant or other expression which
11863 computes the same value, but in a more efficient manner (including
11864 calls to other builtin functions).
11866 The call may contain arguments which need to be evaluated, but
11867 which are not useful to determine the result of the call. In
11868 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11869 COMPOUND_EXPR will be an argument which must be evaluated.
11870 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11871 COMPOUND_EXPR in the chain will contain the tree for the simplified
11872 form of the builtin function call. */
11875 fold_builtin_strspn (location_t loc
, tree s1
, tree s2
)
11877 if (!validate_arg (s1
, POINTER_TYPE
)
11878 || !validate_arg (s2
, POINTER_TYPE
))
11882 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11884 /* If both arguments are constants, evaluate at compile-time. */
11887 const size_t r
= strspn (p1
, p2
);
11888 return build_int_cst (size_type_node
, r
);
11891 /* If either argument is "", return NULL_TREE. */
11892 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
11893 /* Evaluate and ignore both arguments in case either one has
11895 return omit_two_operands_loc (loc
, size_type_node
, size_zero_node
,
11901 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11904 Return NULL_TREE if no simplification was possible, otherwise return the
11905 simplified form of the call as a tree.
11907 The simplified form may be a constant or other expression which
11908 computes the same value, but in a more efficient manner (including
11909 calls to other builtin functions).
11911 The call may contain arguments which need to be evaluated, but
11912 which are not useful to determine the result of the call. In
11913 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11914 COMPOUND_EXPR will be an argument which must be evaluated.
11915 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11916 COMPOUND_EXPR in the chain will contain the tree for the simplified
11917 form of the builtin function call. */
11920 fold_builtin_strcspn (location_t loc
, tree s1
, tree s2
)
11922 if (!validate_arg (s1
, POINTER_TYPE
)
11923 || !validate_arg (s2
, POINTER_TYPE
))
11927 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11929 /* If both arguments are constants, evaluate at compile-time. */
11932 const size_t r
= strcspn (p1
, p2
);
11933 return build_int_cst (size_type_node
, r
);
11936 /* If the first argument is "", return NULL_TREE. */
11937 if (p1
&& *p1
== '\0')
11939 /* Evaluate and ignore argument s2 in case it has
11941 return omit_one_operand_loc (loc
, size_type_node
,
11942 size_zero_node
, s2
);
11945 /* If the second argument is "", return __builtin_strlen(s1). */
11946 if (p2
&& *p2
== '\0')
11948 tree fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
11950 /* If the replacement _DECL isn't initialized, don't do the
11955 return build_call_expr_loc (loc
, fn
, 1, s1
);
11961 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
11962 to the call. IGNORE is true if the value returned
11963 by the builtin will be ignored. UNLOCKED is true is true if this
11964 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
11965 the known length of the string. Return NULL_TREE if no simplification
11969 fold_builtin_fputs (location_t loc
, tree arg0
, tree arg1
,
11970 bool ignore
, bool unlocked
, tree len
)
11972 /* If we're using an unlocked function, assume the other unlocked
11973 functions exist explicitly. */
11974 tree
const fn_fputc
= (unlocked
11975 ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
)
11976 : builtin_decl_implicit (BUILT_IN_FPUTC
));
11977 tree
const fn_fwrite
= (unlocked
11978 ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED
)
11979 : builtin_decl_implicit (BUILT_IN_FWRITE
));
11981 /* If the return value is used, don't do the transformation. */
11985 /* Verify the arguments in the original call. */
11986 if (!validate_arg (arg0
, POINTER_TYPE
)
11987 || !validate_arg (arg1
, POINTER_TYPE
))
11991 len
= c_strlen (arg0
, 0);
11993 /* Get the length of the string passed to fputs. If the length
11994 can't be determined, punt. */
11996 || TREE_CODE (len
) != INTEGER_CST
)
11999 switch (compare_tree_int (len
, 1))
12001 case -1: /* length is 0, delete the call entirely . */
12002 return omit_one_operand_loc (loc
, integer_type_node
,
12003 integer_zero_node
, arg1
);;
12005 case 0: /* length is 1, call fputc. */
12007 const char *p
= c_getstr (arg0
);
12012 return build_call_expr_loc (loc
, fn_fputc
, 2,
12014 (integer_type_node
, p
[0]), arg1
);
12020 case 1: /* length is greater than 1, call fwrite. */
12022 /* If optimizing for size keep fputs. */
12023 if (optimize_function_for_size_p (cfun
))
12025 /* New argument list transforming fputs(string, stream) to
12026 fwrite(string, 1, len, stream). */
12028 return build_call_expr_loc (loc
, fn_fwrite
, 4, arg0
,
12029 size_one_node
, len
, arg1
);
12034 gcc_unreachable ();
12039 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
12040 produced. False otherwise. This is done so that we don't output the error
12041 or warning twice or three times. */
12044 fold_builtin_next_arg (tree exp
, bool va_start_p
)
12046 tree fntype
= TREE_TYPE (current_function_decl
);
12047 int nargs
= call_expr_nargs (exp
);
12049 /* There is good chance the current input_location points inside the
12050 definition of the va_start macro (perhaps on the token for
12051 builtin) in a system header, so warnings will not be emitted.
12052 Use the location in real source code. */
12053 source_location current_location
=
12054 linemap_unwind_to_first_non_reserved_loc (line_table
, input_location
,
12057 if (!stdarg_p (fntype
))
12059 error ("%<va_start%> used in function with fixed args");
12065 if (va_start_p
&& (nargs
!= 2))
12067 error ("wrong number of arguments to function %<va_start%>");
12070 arg
= CALL_EXPR_ARG (exp
, 1);
12072 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
12073 when we checked the arguments and if needed issued a warning. */
12078 /* Evidently an out of date version of <stdarg.h>; can't validate
12079 va_start's second argument, but can still work as intended. */
12080 warning_at (current_location
,
12082 "%<__builtin_next_arg%> called without an argument");
12085 else if (nargs
> 1)
12087 error ("wrong number of arguments to function %<__builtin_next_arg%>");
12090 arg
= CALL_EXPR_ARG (exp
, 0);
12093 if (TREE_CODE (arg
) == SSA_NAME
)
12094 arg
= SSA_NAME_VAR (arg
);
12096 /* We destructively modify the call to be __builtin_va_start (ap, 0)
12097 or __builtin_next_arg (0) the first time we see it, after checking
12098 the arguments and if needed issuing a warning. */
12099 if (!integer_zerop (arg
))
12101 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
12103 /* Strip off all nops for the sake of the comparison. This
12104 is not quite the same as STRIP_NOPS. It does more.
12105 We must also strip off INDIRECT_EXPR for C++ reference
12107 while (CONVERT_EXPR_P (arg
)
12108 || TREE_CODE (arg
) == INDIRECT_REF
)
12109 arg
= TREE_OPERAND (arg
, 0);
12110 if (arg
!= last_parm
)
12112 /* FIXME: Sometimes with the tree optimizers we can get the
12113 not the last argument even though the user used the last
12114 argument. We just warn and set the arg to be the last
12115 argument so that we will get wrong-code because of
12117 warning_at (current_location
,
12119 "second parameter of %<va_start%> not last named argument");
12122 /* Undefined by C99 7.15.1.4p4 (va_start):
12123 "If the parameter parmN is declared with the register storage
12124 class, with a function or array type, or with a type that is
12125 not compatible with the type that results after application of
12126 the default argument promotions, the behavior is undefined."
12128 else if (DECL_REGISTER (arg
))
12130 warning_at (current_location
,
12132 "undefined behaviour when second parameter of "
12133 "%<va_start%> is declared with %<register%> storage");
12136 /* We want to verify the second parameter just once before the tree
12137 optimizers are run and then avoid keeping it in the tree,
12138 as otherwise we could warn even for correct code like:
12139 void foo (int i, ...)
12140 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
12142 CALL_EXPR_ARG (exp
, 1) = integer_zero_node
;
12144 CALL_EXPR_ARG (exp
, 0) = integer_zero_node
;
12150 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
12151 ORIG may be null if this is a 2-argument call. We don't attempt to
12152 simplify calls with more than 3 arguments.
12154 Return NULL_TREE if no simplification was possible, otherwise return the
12155 simplified form of the call as a tree. If IGNORED is true, it means that
12156 the caller does not use the returned value of the function. */
12159 fold_builtin_sprintf (location_t loc
, tree dest
, tree fmt
,
12160 tree orig
, int ignored
)
12163 const char *fmt_str
= NULL
;
12165 /* Verify the required arguments in the original call. We deal with two
12166 types of sprintf() calls: 'sprintf (str, fmt)' and
12167 'sprintf (dest, "%s", orig)'. */
12168 if (!validate_arg (dest
, POINTER_TYPE
)
12169 || !validate_arg (fmt
, POINTER_TYPE
))
12171 if (orig
&& !validate_arg (orig
, POINTER_TYPE
))
12174 /* Check whether the format is a literal string constant. */
12175 fmt_str
= c_getstr (fmt
);
12176 if (fmt_str
== NULL
)
12180 retval
= NULL_TREE
;
12182 if (!init_target_chars ())
12185 /* If the format doesn't contain % args or %%, use strcpy. */
12186 if (strchr (fmt_str
, target_percent
) == NULL
)
12188 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
12193 /* Don't optimize sprintf (buf, "abc", ptr++). */
12197 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
12198 'format' is known to contain no % formats. */
12199 call
= build_call_expr_loc (loc
, fn
, 2, dest
, fmt
);
12201 retval
= build_int_cst (integer_type_node
, strlen (fmt_str
));
12204 /* If the format is "%s", use strcpy if the result isn't used. */
12205 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
12208 fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
12213 /* Don't crash on sprintf (str1, "%s"). */
12217 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
12220 retval
= c_strlen (orig
, 1);
12221 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
12224 call
= build_call_expr_loc (loc
, fn
, 2, dest
, orig
);
12227 if (call
&& retval
)
12229 retval
= fold_convert_loc
12230 (loc
, TREE_TYPE (TREE_TYPE (builtin_decl_implicit (BUILT_IN_SPRINTF
))),
12232 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);
12238 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
12239 FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
12240 attempt to simplify calls with more than 4 arguments.
12242 Return NULL_TREE if no simplification was possible, otherwise return the
12243 simplified form of the call as a tree. If IGNORED is true, it means that
12244 the caller does not use the returned value of the function. */
12247 fold_builtin_snprintf (location_t loc
, tree dest
, tree destsize
, tree fmt
,
12248 tree orig
, int ignored
)
12251 const char *fmt_str
= NULL
;
12252 unsigned HOST_WIDE_INT destlen
;
12254 /* Verify the required arguments in the original call. We deal with two
12255 types of snprintf() calls: 'snprintf (str, cst, fmt)' and
12256 'snprintf (dest, cst, "%s", orig)'. */
12257 if (!validate_arg (dest
, POINTER_TYPE
)
12258 || !validate_arg (destsize
, INTEGER_TYPE
)
12259 || !validate_arg (fmt
, POINTER_TYPE
))
12261 if (orig
&& !validate_arg (orig
, POINTER_TYPE
))
12264 if (!tree_fits_uhwi_p (destsize
))
12267 /* Check whether the format is a literal string constant. */
12268 fmt_str
= c_getstr (fmt
);
12269 if (fmt_str
== NULL
)
12273 retval
= NULL_TREE
;
12275 if (!init_target_chars ())
12278 destlen
= tree_to_uhwi (destsize
);
12280 /* If the format doesn't contain % args or %%, use strcpy. */
12281 if (strchr (fmt_str
, target_percent
) == NULL
)
12283 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
12284 size_t len
= strlen (fmt_str
);
12286 /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
12290 /* We could expand this as
12291 memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
12293 memcpy (str, fmt_with_nul_at_cstm1, cst);
12294 but in the former case that might increase code size
12295 and in the latter case grow .rodata section too much.
12296 So punt for now. */
12297 if (len
>= destlen
)
12303 /* Convert snprintf (str, cst, fmt) into strcpy (str, fmt) when
12304 'format' is known to contain no % formats and
12305 strlen (fmt) < cst. */
12306 call
= build_call_expr_loc (loc
, fn
, 2, dest
, fmt
);
12309 retval
= build_int_cst (integer_type_node
, strlen (fmt_str
));
12312 /* If the format is "%s", use strcpy if the result isn't used. */
12313 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
12315 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
12316 unsigned HOST_WIDE_INT origlen
;
12318 /* Don't crash on snprintf (str1, cst, "%s"). */
12322 retval
= c_strlen (orig
, 1);
12323 if (!retval
|| !tree_fits_uhwi_p (retval
))
12326 origlen
= tree_to_uhwi (retval
);
12327 /* We could expand this as
12328 memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
12330 memcpy (str1, str2_with_nul_at_cstm1, cst);
12331 but in the former case that might increase code size
12332 and in the latter case grow .rodata section too much.
12333 So punt for now. */
12334 if (origlen
>= destlen
)
12337 /* Convert snprintf (str1, cst, "%s", str2) into
12338 strcpy (str1, str2) if strlen (str2) < cst. */
12342 call
= build_call_expr_loc (loc
, fn
, 2, dest
, orig
);
12345 retval
= NULL_TREE
;
12348 if (call
&& retval
)
12350 tree fn
= builtin_decl_explicit (BUILT_IN_SNPRINTF
);
12351 retval
= fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fn
)), retval
);
12352 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);
12358 /* Expand a call EXP to __builtin_object_size. */
12361 expand_builtin_object_size (tree exp
)
12364 int object_size_type
;
12365 tree fndecl
= get_callee_fndecl (exp
);
12367 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
12369 error ("%Kfirst argument of %D must be a pointer, second integer constant",
12371 expand_builtin_trap ();
12375 ost
= CALL_EXPR_ARG (exp
, 1);
12378 if (TREE_CODE (ost
) != INTEGER_CST
12379 || tree_int_cst_sgn (ost
) < 0
12380 || compare_tree_int (ost
, 3) > 0)
12382 error ("%Klast argument of %D is not integer constant between 0 and 3",
12384 expand_builtin_trap ();
12388 object_size_type
= tree_to_shwi (ost
);
12390 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
12393 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12394 FCODE is the BUILT_IN_* to use.
12395 Return NULL_RTX if we failed; the caller should emit a normal call,
12396 otherwise try to get the result in TARGET, if convenient (and in
12397 mode MODE if that's convenient). */
12400 expand_builtin_memory_chk (tree exp
, rtx target
, enum machine_mode mode
,
12401 enum built_in_function fcode
)
12403 tree dest
, src
, len
, size
;
12405 if (!validate_arglist (exp
,
12407 fcode
== BUILT_IN_MEMSET_CHK
12408 ? INTEGER_TYPE
: POINTER_TYPE
,
12409 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
12412 dest
= CALL_EXPR_ARG (exp
, 0);
12413 src
= CALL_EXPR_ARG (exp
, 1);
12414 len
= CALL_EXPR_ARG (exp
, 2);
12415 size
= CALL_EXPR_ARG (exp
, 3);
12417 if (! tree_fits_uhwi_p (size
))
12420 if (tree_fits_uhwi_p (len
) || integer_all_onesp (size
))
12424 if (! integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
12426 warning_at (tree_nonartificial_location (exp
),
12427 0, "%Kcall to %D will always overflow destination buffer",
12428 exp
, get_callee_fndecl (exp
));
12433 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12434 mem{cpy,pcpy,move,set} is available. */
12437 case BUILT_IN_MEMCPY_CHK
:
12438 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
12440 case BUILT_IN_MEMPCPY_CHK
:
12441 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
12443 case BUILT_IN_MEMMOVE_CHK
:
12444 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
12446 case BUILT_IN_MEMSET_CHK
:
12447 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
12456 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 3, dest
, src
, len
);
12457 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
12458 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
12459 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
12461 else if (fcode
== BUILT_IN_MEMSET_CHK
)
12465 unsigned int dest_align
= get_pointer_alignment (dest
);
12467 /* If DEST is not a pointer type, call the normal function. */
12468 if (dest_align
== 0)
12471 /* If SRC and DEST are the same (and not volatile), do nothing. */
12472 if (operand_equal_p (src
, dest
, 0))
12476 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
12478 /* Evaluate and ignore LEN in case it has side-effects. */
12479 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
12480 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
12483 expr
= fold_build_pointer_plus (dest
, len
);
12484 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
12487 /* __memmove_chk special case. */
12488 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
12490 unsigned int src_align
= get_pointer_alignment (src
);
12492 if (src_align
== 0)
12495 /* If src is categorized for a readonly section we can use
12496 normal __memcpy_chk. */
12497 if (readonly_data_expr (src
))
12499 tree fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
12502 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 4,
12503 dest
, src
, len
, size
);
12504 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
12505 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
12506 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
12513 /* Emit warning if a buffer overflow is detected at compile time. */
12516 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
12520 location_t loc
= tree_nonartificial_location (exp
);
12524 case BUILT_IN_STRCPY_CHK
:
12525 case BUILT_IN_STPCPY_CHK
:
12526 /* For __strcat_chk the warning will be emitted only if overflowing
12527 by at least strlen (dest) + 1 bytes. */
12528 case BUILT_IN_STRCAT_CHK
:
12529 len
= CALL_EXPR_ARG (exp
, 1);
12530 size
= CALL_EXPR_ARG (exp
, 2);
12533 case BUILT_IN_STRNCAT_CHK
:
12534 case BUILT_IN_STRNCPY_CHK
:
12535 case BUILT_IN_STPNCPY_CHK
:
12536 len
= CALL_EXPR_ARG (exp
, 2);
12537 size
= CALL_EXPR_ARG (exp
, 3);
12539 case BUILT_IN_SNPRINTF_CHK
:
12540 case BUILT_IN_VSNPRINTF_CHK
:
12541 len
= CALL_EXPR_ARG (exp
, 1);
12542 size
= CALL_EXPR_ARG (exp
, 3);
12545 gcc_unreachable ();
12551 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
12556 len
= c_strlen (len
, 1);
12557 if (! len
|| ! tree_fits_uhwi_p (len
) || tree_int_cst_lt (len
, size
))
12560 else if (fcode
== BUILT_IN_STRNCAT_CHK
)
12562 tree src
= CALL_EXPR_ARG (exp
, 1);
12563 if (! src
|| ! tree_fits_uhwi_p (len
) || tree_int_cst_lt (len
, size
))
12565 src
= c_strlen (src
, 1);
12566 if (! src
|| ! tree_fits_uhwi_p (src
))
12568 warning_at (loc
, 0, "%Kcall to %D might overflow destination buffer",
12569 exp
, get_callee_fndecl (exp
));
12572 else if (tree_int_cst_lt (src
, size
))
12575 else if (! tree_fits_uhwi_p (len
) || ! tree_int_cst_lt (size
, len
))
12578 warning_at (loc
, 0, "%Kcall to %D will always overflow destination buffer",
12579 exp
, get_callee_fndecl (exp
));
12582 /* Emit warning if a buffer overflow is detected at compile time
12583 in __sprintf_chk/__vsprintf_chk calls. */
12586 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
12588 tree size
, len
, fmt
;
12589 const char *fmt_str
;
12590 int nargs
= call_expr_nargs (exp
);
12592 /* Verify the required arguments in the original call. */
12596 size
= CALL_EXPR_ARG (exp
, 2);
12597 fmt
= CALL_EXPR_ARG (exp
, 3);
12599 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
12602 /* Check whether the format is a literal string constant. */
12603 fmt_str
= c_getstr (fmt
);
12604 if (fmt_str
== NULL
)
12607 if (!init_target_chars ())
12610 /* If the format doesn't contain % args or %%, we know its size. */
12611 if (strchr (fmt_str
, target_percent
) == 0)
12612 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
12613 /* If the format is "%s" and first ... argument is a string literal,
12615 else if (fcode
== BUILT_IN_SPRINTF_CHK
12616 && strcmp (fmt_str
, target_percent_s
) == 0)
12622 arg
= CALL_EXPR_ARG (exp
, 4);
12623 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
12626 len
= c_strlen (arg
, 1);
12627 if (!len
|| ! tree_fits_uhwi_p (len
))
12633 if (! tree_int_cst_lt (len
, size
))
12634 warning_at (tree_nonartificial_location (exp
),
12635 0, "%Kcall to %D will always overflow destination buffer",
12636 exp
, get_callee_fndecl (exp
));
12639 /* Emit warning if a free is called with address of a variable. */
12642 maybe_emit_free_warning (tree exp
)
12644 tree arg
= CALL_EXPR_ARG (exp
, 0);
12647 if (TREE_CODE (arg
) != ADDR_EXPR
)
12650 arg
= get_base_address (TREE_OPERAND (arg
, 0));
12651 if (arg
== NULL
|| INDIRECT_REF_P (arg
) || TREE_CODE (arg
) == MEM_REF
)
12654 if (SSA_VAR_P (arg
))
12655 warning_at (tree_nonartificial_location (exp
), OPT_Wfree_nonheap_object
,
12656 "%Kattempt to free a non-heap object %qD", exp
, arg
);
12658 warning_at (tree_nonartificial_location (exp
), OPT_Wfree_nonheap_object
,
12659 "%Kattempt to free a non-heap object", exp
);
12662 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12666 fold_builtin_object_size (tree ptr
, tree ost
)
12668 unsigned HOST_WIDE_INT bytes
;
12669 int object_size_type
;
12671 if (!validate_arg (ptr
, POINTER_TYPE
)
12672 || !validate_arg (ost
, INTEGER_TYPE
))
12677 if (TREE_CODE (ost
) != INTEGER_CST
12678 || tree_int_cst_sgn (ost
) < 0
12679 || compare_tree_int (ost
, 3) > 0)
12682 object_size_type
= tree_to_shwi (ost
);
12684 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12685 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12686 and (size_t) 0 for types 2 and 3. */
12687 if (TREE_SIDE_EFFECTS (ptr
))
12688 return build_int_cst_type (size_type_node
, object_size_type
< 2 ? -1 : 0);
12690 if (TREE_CODE (ptr
) == ADDR_EXPR
)
12692 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
12693 if (double_int_fits_to_tree_p (size_type_node
,
12694 double_int::from_uhwi (bytes
)))
12695 return build_int_cstu (size_type_node
, bytes
);
12697 else if (TREE_CODE (ptr
) == SSA_NAME
)
12699 /* If object size is not known yet, delay folding until
12700 later. Maybe subsequent passes will help determining
12702 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
12703 if (bytes
!= (unsigned HOST_WIDE_INT
) (object_size_type
< 2 ? -1 : 0)
12704 && double_int_fits_to_tree_p (size_type_node
,
12705 double_int::from_uhwi (bytes
)))
12706 return build_int_cstu (size_type_node
, bytes
);
12712 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12713 DEST, SRC, LEN, and SIZE are the arguments to the call.
12714 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
12715 code of the builtin. If MAXLEN is not NULL, it is maximum length
12716 passed as third argument. */
12719 fold_builtin_memory_chk (location_t loc
, tree fndecl
,
12720 tree dest
, tree src
, tree len
, tree size
,
12721 tree maxlen
, bool ignore
,
12722 enum built_in_function fcode
)
12726 if (!validate_arg (dest
, POINTER_TYPE
)
12727 || !validate_arg (src
,
12728 (fcode
== BUILT_IN_MEMSET_CHK
12729 ? INTEGER_TYPE
: POINTER_TYPE
))
12730 || !validate_arg (len
, INTEGER_TYPE
)
12731 || !validate_arg (size
, INTEGER_TYPE
))
12734 /* If SRC and DEST are the same (and not volatile), return DEST
12735 (resp. DEST+LEN for __mempcpy_chk). */
12736 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
12738 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
12739 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
12743 tree temp
= fold_build_pointer_plus_loc (loc
, dest
, len
);
12744 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), temp
);
12748 if (! tree_fits_uhwi_p (size
))
12751 if (! integer_all_onesp (size
))
12753 if (! tree_fits_uhwi_p (len
))
12755 /* If LEN is not constant, try MAXLEN too.
12756 For MAXLEN only allow optimizing into non-_ocs function
12757 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12758 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
12760 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
12762 /* (void) __mempcpy_chk () can be optimized into
12763 (void) __memcpy_chk (). */
12764 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
12768 return build_call_expr_loc (loc
, fn
, 4, dest
, src
, len
, size
);
12776 if (tree_int_cst_lt (size
, maxlen
))
12781 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12782 mem{cpy,pcpy,move,set} is available. */
12785 case BUILT_IN_MEMCPY_CHK
:
12786 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
12788 case BUILT_IN_MEMPCPY_CHK
:
12789 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
12791 case BUILT_IN_MEMMOVE_CHK
:
12792 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
12794 case BUILT_IN_MEMSET_CHK
:
12795 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
12804 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
12807 /* Fold a call to the __st[rp]cpy_chk builtin.
12808 DEST, SRC, and SIZE are the arguments to the call.
12809 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
12810 code of the builtin. If MAXLEN is not NULL, it is maximum length of
12811 strings passed as second argument. */
12814 fold_builtin_stxcpy_chk (location_t loc
, tree fndecl
, tree dest
,
12815 tree src
, tree size
,
12816 tree maxlen
, bool ignore
,
12817 enum built_in_function fcode
)
12821 if (!validate_arg (dest
, POINTER_TYPE
)
12822 || !validate_arg (src
, POINTER_TYPE
)
12823 || !validate_arg (size
, INTEGER_TYPE
))
12826 /* If SRC and DEST are the same (and not volatile), return DEST. */
12827 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
12828 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
12830 if (! tree_fits_uhwi_p (size
))
12833 if (! integer_all_onesp (size
))
12835 len
= c_strlen (src
, 1);
12836 if (! len
|| ! tree_fits_uhwi_p (len
))
12838 /* If LEN is not constant, try MAXLEN too.
12839 For MAXLEN only allow optimizing into non-_ocs function
12840 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12841 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
12843 if (fcode
== BUILT_IN_STPCPY_CHK
)
12848 /* If return value of __stpcpy_chk is ignored,
12849 optimize into __strcpy_chk. */
12850 fn
= builtin_decl_explicit (BUILT_IN_STRCPY_CHK
);
12854 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, size
);
12857 if (! len
|| TREE_SIDE_EFFECTS (len
))
12860 /* If c_strlen returned something, but not a constant,
12861 transform __strcpy_chk into __memcpy_chk. */
12862 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
12866 len
= fold_convert_loc (loc
, size_type_node
, len
);
12867 len
= size_binop_loc (loc
, PLUS_EXPR
, len
,
12868 build_int_cst (size_type_node
, 1));
12869 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)),
12870 build_call_expr_loc (loc
, fn
, 4,
12871 dest
, src
, len
, size
));
12877 if (! tree_int_cst_lt (maxlen
, size
))
12881 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
12882 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPCPY_CHK
12883 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
);
12887 return build_call_expr_loc (loc
, fn
, 2, dest
, src
);
12890 /* Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE
12891 are the arguments to the call. If MAXLEN is not NULL, it is maximum
12892 length passed as third argument. IGNORE is true if return value can be
12893 ignored. FCODE is the BUILT_IN_* code of the builtin. */
12896 fold_builtin_stxncpy_chk (location_t loc
, tree dest
, tree src
,
12897 tree len
, tree size
, tree maxlen
, bool ignore
,
12898 enum built_in_function fcode
)
12902 if (!validate_arg (dest
, POINTER_TYPE
)
12903 || !validate_arg (src
, POINTER_TYPE
)
12904 || !validate_arg (len
, INTEGER_TYPE
)
12905 || !validate_arg (size
, INTEGER_TYPE
))
12908 if (fcode
== BUILT_IN_STPNCPY_CHK
&& ignore
)
12910 /* If return value of __stpncpy_chk is ignored,
12911 optimize into __strncpy_chk. */
12912 fn
= builtin_decl_explicit (BUILT_IN_STRNCPY_CHK
);
12914 return build_call_expr_loc (loc
, fn
, 4, dest
, src
, len
, size
);
12917 if (! tree_fits_uhwi_p (size
))
12920 if (! integer_all_onesp (size
))
12922 if (! tree_fits_uhwi_p (len
))
12924 /* If LEN is not constant, try MAXLEN too.
12925 For MAXLEN only allow optimizing into non-_ocs function
12926 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
12927 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
12933 if (tree_int_cst_lt (size
, maxlen
))
12937 /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available. */
12938 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPNCPY_CHK
12939 ? BUILT_IN_STPNCPY
: BUILT_IN_STRNCPY
);
12943 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
12946 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
12947 are the arguments to the call. */
12950 fold_builtin_strcat_chk (location_t loc
, tree fndecl
, tree dest
,
12951 tree src
, tree size
)
12956 if (!validate_arg (dest
, POINTER_TYPE
)
12957 || !validate_arg (src
, POINTER_TYPE
)
12958 || !validate_arg (size
, INTEGER_TYPE
))
12961 p
= c_getstr (src
);
12962 /* If the SRC parameter is "", return DEST. */
12963 if (p
&& *p
== '\0')
12964 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
12966 if (! tree_fits_uhwi_p (size
) || ! integer_all_onesp (size
))
12969 /* If __builtin_strcat_chk is used, assume strcat is available. */
12970 fn
= builtin_decl_explicit (BUILT_IN_STRCAT
);
12974 return build_call_expr_loc (loc
, fn
, 2, dest
, src
);
12977 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12981 fold_builtin_strncat_chk (location_t loc
, tree fndecl
,
12982 tree dest
, tree src
, tree len
, tree size
)
12987 if (!validate_arg (dest
, POINTER_TYPE
)
12988 || !validate_arg (src
, POINTER_TYPE
)
12989 || !validate_arg (size
, INTEGER_TYPE
)
12990 || !validate_arg (size
, INTEGER_TYPE
))
12993 p
= c_getstr (src
);
12994 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
12995 if (p
&& *p
== '\0')
12996 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
12997 else if (integer_zerop (len
))
12998 return omit_one_operand_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
13000 if (! tree_fits_uhwi_p (size
))
13003 if (! integer_all_onesp (size
))
13005 tree src_len
= c_strlen (src
, 1);
13007 && tree_fits_uhwi_p (src_len
)
13008 && tree_fits_uhwi_p (len
)
13009 && ! tree_int_cst_lt (len
, src_len
))
13011 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
13012 fn
= builtin_decl_explicit (BUILT_IN_STRCAT_CHK
);
13016 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, size
);
13021 /* If __builtin_strncat_chk is used, assume strncat is available. */
13022 fn
= builtin_decl_explicit (BUILT_IN_STRNCAT
);
13026 return build_call_expr_loc (loc
, fn
, 3, dest
, src
, len
);
13029 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
13030 Return NULL_TREE if a normal call should be emitted rather than
13031 expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
13032 or BUILT_IN_VSPRINTF_CHK. */
13035 fold_builtin_sprintf_chk_1 (location_t loc
, int nargs
, tree
*args
,
13036 enum built_in_function fcode
)
13038 tree dest
, size
, len
, fn
, fmt
, flag
;
13039 const char *fmt_str
;
13041 /* Verify the required arguments in the original call. */
13045 if (!validate_arg (dest
, POINTER_TYPE
))
13048 if (!validate_arg (flag
, INTEGER_TYPE
))
13051 if (!validate_arg (size
, INTEGER_TYPE
))
13054 if (!validate_arg (fmt
, POINTER_TYPE
))
13057 if (! tree_fits_uhwi_p (size
))
13062 if (!init_target_chars ())
13065 /* Check whether the format is a literal string constant. */
13066 fmt_str
= c_getstr (fmt
);
13067 if (fmt_str
!= NULL
)
13069 /* If the format doesn't contain % args or %%, we know the size. */
13070 if (strchr (fmt_str
, target_percent
) == 0)
13072 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| nargs
== 4)
13073 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
13075 /* If the format is "%s" and first ... argument is a string literal,
13076 we know the size too. */
13077 else if (fcode
== BUILT_IN_SPRINTF_CHK
13078 && strcmp (fmt_str
, target_percent_s
) == 0)
13085 if (validate_arg (arg
, POINTER_TYPE
))
13087 len
= c_strlen (arg
, 1);
13088 if (! len
|| ! tree_fits_uhwi_p (len
))
13095 if (! integer_all_onesp (size
))
13097 if (! len
|| ! tree_int_cst_lt (len
, size
))
13101 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13102 or if format doesn't contain % chars or is "%s". */
13103 if (! integer_zerop (flag
))
13105 if (fmt_str
== NULL
)
13107 if (strchr (fmt_str
, target_percent
) != NULL
13108 && strcmp (fmt_str
, target_percent_s
))
13112 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
13113 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSPRINTF_CHK
13114 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
);
13118 return rewrite_call_expr_array (loc
, nargs
, args
, 4, fn
, 2, dest
, fmt
);
13121 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
13122 a normal call should be emitted rather than expanding the function
13123 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
13126 fold_builtin_sprintf_chk (location_t loc
, tree exp
,
13127 enum built_in_function fcode
)
13129 return fold_builtin_sprintf_chk_1 (loc
, call_expr_nargs (exp
),
13130 CALL_EXPR_ARGP (exp
), fcode
);
13133 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
13134 NULL_TREE if a normal call should be emitted rather than expanding
13135 the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13136 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13137 passed as second argument. */
13140 fold_builtin_snprintf_chk_1 (location_t loc
, int nargs
, tree
*args
,
13141 tree maxlen
, enum built_in_function fcode
)
13143 tree dest
, size
, len
, fn
, fmt
, flag
;
13144 const char *fmt_str
;
13146 /* Verify the required arguments in the original call. */
13150 if (!validate_arg (dest
, POINTER_TYPE
))
13153 if (!validate_arg (len
, INTEGER_TYPE
))
13156 if (!validate_arg (flag
, INTEGER_TYPE
))
13159 if (!validate_arg (size
, INTEGER_TYPE
))
13162 if (!validate_arg (fmt
, POINTER_TYPE
))
13165 if (! tree_fits_uhwi_p (size
))
13168 if (! integer_all_onesp (size
))
13170 if (! tree_fits_uhwi_p (len
))
13172 /* If LEN is not constant, try MAXLEN too.
13173 For MAXLEN only allow optimizing into non-_ocs function
13174 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
13175 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
13181 if (tree_int_cst_lt (size
, maxlen
))
13185 if (!init_target_chars ())
13188 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13189 or if format doesn't contain % chars or is "%s". */
13190 if (! integer_zerop (flag
))
13192 fmt_str
= c_getstr (fmt
);
13193 if (fmt_str
== NULL
)
13195 if (strchr (fmt_str
, target_percent
) != NULL
13196 && strcmp (fmt_str
, target_percent_s
))
13200 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13202 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSNPRINTF_CHK
13203 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
);
13207 return rewrite_call_expr_array (loc
, nargs
, args
, 5, fn
, 3, dest
, len
, fmt
);
13210 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
13211 a normal call should be emitted rather than expanding the function
13212 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
13213 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
13214 passed as second argument. */
13217 fold_builtin_snprintf_chk (location_t loc
, tree exp
, tree maxlen
,
13218 enum built_in_function fcode
)
13220 return fold_builtin_snprintf_chk_1 (loc
, call_expr_nargs (exp
),
13221 CALL_EXPR_ARGP (exp
), maxlen
, fcode
);
13224 /* Builtins with folding operations that operate on "..." arguments
13225 need special handling; we need to store the arguments in a convenient
13226 data structure before attempting any folding. Fortunately there are
13227 only a few builtins that fall into this category. FNDECL is the
13228 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13229 result of the function call is ignored. */
13232 fold_builtin_varargs (location_t loc
, tree fndecl
, tree exp
,
13233 bool ignore ATTRIBUTE_UNUSED
)
13235 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
13236 tree ret
= NULL_TREE
;
13240 case BUILT_IN_SPRINTF_CHK
:
13241 case BUILT_IN_VSPRINTF_CHK
:
13242 ret
= fold_builtin_sprintf_chk (loc
, exp
, fcode
);
13245 case BUILT_IN_SNPRINTF_CHK
:
13246 case BUILT_IN_VSNPRINTF_CHK
:
13247 ret
= fold_builtin_snprintf_chk (loc
, exp
, NULL_TREE
, fcode
);
13250 case BUILT_IN_FPCLASSIFY
:
13251 ret
= fold_builtin_fpclassify (loc
, exp
);
13259 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
13260 SET_EXPR_LOCATION (ret
, loc
);
13261 TREE_NO_WARNING (ret
) = 1;
13267 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
13268 FMT and ARG are the arguments to the call; we don't fold cases with
13269 more than 2 arguments, and ARG may be null if this is a 1-argument case.
13271 Return NULL_TREE if no simplification was possible, otherwise return the
13272 simplified form of the call as a tree. FCODE is the BUILT_IN_*
13273 code of the function to be simplified. */
13276 fold_builtin_printf (location_t loc
, tree fndecl
, tree fmt
,
13277 tree arg
, bool ignore
,
13278 enum built_in_function fcode
)
13280 tree fn_putchar
, fn_puts
, newarg
, call
= NULL_TREE
;
13281 const char *fmt_str
= NULL
;
13283 /* If the return value is used, don't do the transformation. */
13287 /* Verify the required arguments in the original call. */
13288 if (!validate_arg (fmt
, POINTER_TYPE
))
13291 /* Check whether the format is a literal string constant. */
13292 fmt_str
= c_getstr (fmt
);
13293 if (fmt_str
== NULL
)
13296 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
13298 /* If we're using an unlocked function, assume the other
13299 unlocked functions exist explicitly. */
13300 fn_putchar
= builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED
);
13301 fn_puts
= builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED
);
13305 fn_putchar
= builtin_decl_implicit (BUILT_IN_PUTCHAR
);
13306 fn_puts
= builtin_decl_implicit (BUILT_IN_PUTS
);
13309 if (!init_target_chars ())
13312 if (strcmp (fmt_str
, target_percent_s
) == 0
13313 || strchr (fmt_str
, target_percent
) == NULL
)
13317 if (strcmp (fmt_str
, target_percent_s
) == 0)
13319 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
13322 if (!arg
|| !validate_arg (arg
, POINTER_TYPE
))
13325 str
= c_getstr (arg
);
13331 /* The format specifier doesn't contain any '%' characters. */
13332 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
13338 /* If the string was "", printf does nothing. */
13339 if (str
[0] == '\0')
13340 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
13342 /* If the string has length of 1, call putchar. */
13343 if (str
[1] == '\0')
13345 /* Given printf("c"), (where c is any one character,)
13346 convert "c"[0] to an int and pass that to the replacement
13348 newarg
= build_int_cst (integer_type_node
, str
[0]);
13350 call
= build_call_expr_loc (loc
, fn_putchar
, 1, newarg
);
13354 /* If the string was "string\n", call puts("string"). */
13355 size_t len
= strlen (str
);
13356 if ((unsigned char)str
[len
- 1] == target_newline
13357 && (size_t) (int) len
== len
13361 tree offset_node
, string_cst
;
13363 /* Create a NUL-terminated string that's one char shorter
13364 than the original, stripping off the trailing '\n'. */
13365 newarg
= build_string_literal (len
, str
);
13366 string_cst
= string_constant (newarg
, &offset_node
);
13367 gcc_checking_assert (string_cst
13368 && (TREE_STRING_LENGTH (string_cst
)
13370 && integer_zerop (offset_node
)
13372 TREE_STRING_POINTER (string_cst
)[len
- 1]
13373 == target_newline
);
13374 /* build_string_literal creates a new STRING_CST,
13375 modify it in place to avoid double copying. */
13376 newstr
= CONST_CAST (char *, TREE_STRING_POINTER (string_cst
));
13377 newstr
[len
- 1] = '\0';
13379 call
= build_call_expr_loc (loc
, fn_puts
, 1, newarg
);
13382 /* We'd like to arrange to call fputs(string,stdout) here,
13383 but we need stdout and don't have a way to get it yet. */
13388 /* The other optimizations can be done only on the non-va_list variants. */
13389 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
13392 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
13393 else if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
13395 if (!arg
|| !validate_arg (arg
, POINTER_TYPE
))
13398 call
= build_call_expr_loc (loc
, fn_puts
, 1, arg
);
13401 /* If the format specifier was "%c", call __builtin_putchar(arg). */
13402 else if (strcmp (fmt_str
, target_percent_c
) == 0)
13404 if (!arg
|| !validate_arg (arg
, INTEGER_TYPE
))
13407 call
= build_call_expr_loc (loc
, fn_putchar
, 1, arg
);
13413 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), call
);
13416 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13417 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
13418 more than 3 arguments, and ARG may be null in the 2-argument case.
13420 Return NULL_TREE if no simplification was possible, otherwise return the
13421 simplified form of the call as a tree. FCODE is the BUILT_IN_*
13422 code of the function to be simplified. */
13425 fold_builtin_fprintf (location_t loc
, tree fndecl
, tree fp
,
13426 tree fmt
, tree arg
, bool ignore
,
13427 enum built_in_function fcode
)
13429 tree fn_fputc
, fn_fputs
, call
= NULL_TREE
;
13430 const char *fmt_str
= NULL
;
13432 /* If the return value is used, don't do the transformation. */
13436 /* Verify the required arguments in the original call. */
13437 if (!validate_arg (fp
, POINTER_TYPE
))
13439 if (!validate_arg (fmt
, POINTER_TYPE
))
13442 /* Check whether the format is a literal string constant. */
13443 fmt_str
= c_getstr (fmt
);
13444 if (fmt_str
== NULL
)
13447 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
13449 /* If we're using an unlocked function, assume the other
13450 unlocked functions exist explicitly. */
13451 fn_fputc
= builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
);
13452 fn_fputs
= builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED
);
13456 fn_fputc
= builtin_decl_implicit (BUILT_IN_FPUTC
);
13457 fn_fputs
= builtin_decl_implicit (BUILT_IN_FPUTS
);
13460 if (!init_target_chars ())
13463 /* If the format doesn't contain % args or %%, use strcpy. */
13464 if (strchr (fmt_str
, target_percent
) == NULL
)
13466 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
13470 /* If the format specifier was "", fprintf does nothing. */
13471 if (fmt_str
[0] == '\0')
13473 /* If FP has side-effects, just wait until gimplification is
13475 if (TREE_SIDE_EFFECTS (fp
))
13478 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
13481 /* When "string" doesn't contain %, replace all cases of
13482 fprintf (fp, string) with fputs (string, fp). The fputs
13483 builtin will take care of special cases like length == 1. */
13485 call
= build_call_expr_loc (loc
, fn_fputs
, 2, fmt
, fp
);
13488 /* The other optimizations can be done only on the non-va_list variants. */
13489 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
13492 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
13493 else if (strcmp (fmt_str
, target_percent_s
) == 0)
13495 if (!arg
|| !validate_arg (arg
, POINTER_TYPE
))
13498 call
= build_call_expr_loc (loc
, fn_fputs
, 2, arg
, fp
);
13501 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
13502 else if (strcmp (fmt_str
, target_percent_c
) == 0)
13504 if (!arg
|| !validate_arg (arg
, INTEGER_TYPE
))
13507 call
= build_call_expr_loc (loc
, fn_fputc
, 2, arg
, fp
);
13512 return fold_convert_loc (loc
, TREE_TYPE (TREE_TYPE (fndecl
)), call
);
13515 /* Initialize format string characters in the target charset. */
13518 init_target_chars (void)
13523 target_newline
= lang_hooks
.to_target_charset ('\n');
13524 target_percent
= lang_hooks
.to_target_charset ('%');
13525 target_c
= lang_hooks
.to_target_charset ('c');
13526 target_s
= lang_hooks
.to_target_charset ('s');
13527 if (target_newline
== 0 || target_percent
== 0 || target_c
== 0
13531 target_percent_c
[0] = target_percent
;
13532 target_percent_c
[1] = target_c
;
13533 target_percent_c
[2] = '\0';
13535 target_percent_s
[0] = target_percent
;
13536 target_percent_s
[1] = target_s
;
13537 target_percent_s
[2] = '\0';
13539 target_percent_s_newline
[0] = target_percent
;
13540 target_percent_s_newline
[1] = target_s
;
13541 target_percent_s_newline
[2] = target_newline
;
13542 target_percent_s_newline
[3] = '\0';
13549 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
13550 and no overflow/underflow occurred. INEXACT is true if M was not
13551 exactly calculated. TYPE is the tree type for the result. This
13552 function assumes that you cleared the MPFR flags and then
13553 calculated M to see if anything subsequently set a flag prior to
13554 entering this function. Return NULL_TREE if any checks fail. */
13557 do_mpfr_ckconv (mpfr_srcptr m
, tree type
, int inexact
)
13559 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13560 overflow/underflow occurred. If -frounding-math, proceed iff the
13561 result of calling FUNC was exact. */
13562 if (mpfr_number_p (m
) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13563 && (!flag_rounding_math
|| !inexact
))
13565 REAL_VALUE_TYPE rr
;
13567 real_from_mpfr (&rr
, m
, type
, GMP_RNDN
);
13568 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13569 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13570 but the mpft_t is not, then we underflowed in the
13572 if (real_isfinite (&rr
)
13573 && (rr
.cl
== rvc_zero
) == (mpfr_zero_p (m
) != 0))
13575 REAL_VALUE_TYPE rmode
;
13577 real_convert (&rmode
, TYPE_MODE (type
), &rr
);
13578 /* Proceed iff the specified mode can hold the value. */
13579 if (real_identical (&rmode
, &rr
))
13580 return build_real (type
, rmode
);
13586 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
13587 number and no overflow/underflow occurred. INEXACT is true if M
13588 was not exactly calculated. TYPE is the tree type for the result.
13589 This function assumes that you cleared the MPFR flags and then
13590 calculated M to see if anything subsequently set a flag prior to
13591 entering this function. Return NULL_TREE if any checks fail, if
13592 FORCE_CONVERT is true, then bypass the checks. */
13595 do_mpc_ckconv (mpc_srcptr m
, tree type
, int inexact
, int force_convert
)
13597 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13598 overflow/underflow occurred. If -frounding-math, proceed iff the
13599 result of calling FUNC was exact. */
13601 || (mpfr_number_p (mpc_realref (m
)) && mpfr_number_p (mpc_imagref (m
))
13602 && !mpfr_overflow_p () && !mpfr_underflow_p ()
13603 && (!flag_rounding_math
|| !inexact
)))
13605 REAL_VALUE_TYPE re
, im
;
13607 real_from_mpfr (&re
, mpc_realref (m
), TREE_TYPE (type
), GMP_RNDN
);
13608 real_from_mpfr (&im
, mpc_imagref (m
), TREE_TYPE (type
), GMP_RNDN
);
13609 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13610 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
13611 but the mpft_t is not, then we underflowed in the
13614 || (real_isfinite (&re
) && real_isfinite (&im
)
13615 && (re
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_realref (m
)) != 0)
13616 && (im
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_imagref (m
)) != 0)))
13618 REAL_VALUE_TYPE re_mode
, im_mode
;
13620 real_convert (&re_mode
, TYPE_MODE (TREE_TYPE (type
)), &re
);
13621 real_convert (&im_mode
, TYPE_MODE (TREE_TYPE (type
)), &im
);
13622 /* Proceed iff the specified mode can hold the value. */
13624 || (real_identical (&re_mode
, &re
)
13625 && real_identical (&im_mode
, &im
)))
13626 return build_complex (type
, build_real (TREE_TYPE (type
), re_mode
),
13627 build_real (TREE_TYPE (type
), im_mode
));
13633 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13634 FUNC on it and return the resulting value as a tree with type TYPE.
13635 If MIN and/or MAX are not NULL, then the supplied ARG must be
13636 within those bounds. If INCLUSIVE is true, then MIN/MAX are
13637 acceptable values, otherwise they are not. The mpfr precision is
13638 set to the precision of TYPE. We assume that function FUNC returns
13639 zero if the result could be calculated exactly within the requested
13643 do_mpfr_arg1 (tree arg
, tree type
, int (*func
)(mpfr_ptr
, mpfr_srcptr
, mp_rnd_t
),
13644 const REAL_VALUE_TYPE
*min
, const REAL_VALUE_TYPE
*max
,
13647 tree result
= NULL_TREE
;
13651 /* To proceed, MPFR must exactly represent the target floating point
13652 format, which only happens when the target base equals two. */
13653 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13654 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
))
13656 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
13658 if (real_isfinite (ra
)
13659 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
))
13660 && (!max
|| real_compare (inclusive
? LE_EXPR
: LT_EXPR
, ra
, max
)))
13662 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13663 const int prec
= fmt
->p
;
13664 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13668 mpfr_init2 (m
, prec
);
13669 mpfr_from_real (m
, ra
, GMP_RNDN
);
13670 mpfr_clear_flags ();
13671 inexact
= func (m
, m
, rnd
);
13672 result
= do_mpfr_ckconv (m
, type
, inexact
);
13680 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13681 FUNC on it and return the resulting value as a tree with type TYPE.
13682 The mpfr precision is set to the precision of TYPE. We assume that
13683 function FUNC returns zero if the result could be calculated
13684 exactly within the requested precision. */
13687 do_mpfr_arg2 (tree arg1
, tree arg2
, tree type
,
13688 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
13690 tree result
= NULL_TREE
;
13695 /* To proceed, MPFR must exactly represent the target floating point
13696 format, which only happens when the target base equals two. */
13697 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13698 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
13699 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
13701 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
13702 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
13704 if (real_isfinite (ra1
) && real_isfinite (ra2
))
13706 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13707 const int prec
= fmt
->p
;
13708 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13712 mpfr_inits2 (prec
, m1
, m2
, NULL
);
13713 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
13714 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
13715 mpfr_clear_flags ();
13716 inexact
= func (m1
, m1
, m2
, rnd
);
13717 result
= do_mpfr_ckconv (m1
, type
, inexact
);
13718 mpfr_clears (m1
, m2
, NULL
);
13725 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13726 FUNC on it and return the resulting value as a tree with type TYPE.
13727 The mpfr precision is set to the precision of TYPE. We assume that
13728 function FUNC returns zero if the result could be calculated
13729 exactly within the requested precision. */
13732 do_mpfr_arg3 (tree arg1
, tree arg2
, tree arg3
, tree type
,
13733 int (*func
)(mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_srcptr
, mp_rnd_t
))
13735 tree result
= NULL_TREE
;
13741 /* To proceed, MPFR must exactly represent the target floating point
13742 format, which only happens when the target base equals two. */
13743 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13744 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
)
13745 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
)
13746 && TREE_CODE (arg3
) == REAL_CST
&& !TREE_OVERFLOW (arg3
))
13748 const REAL_VALUE_TYPE
*const ra1
= &TREE_REAL_CST (arg1
);
13749 const REAL_VALUE_TYPE
*const ra2
= &TREE_REAL_CST (arg2
);
13750 const REAL_VALUE_TYPE
*const ra3
= &TREE_REAL_CST (arg3
);
13752 if (real_isfinite (ra1
) && real_isfinite (ra2
) && real_isfinite (ra3
))
13754 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13755 const int prec
= fmt
->p
;
13756 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13760 mpfr_inits2 (prec
, m1
, m2
, m3
, NULL
);
13761 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
13762 mpfr_from_real (m2
, ra2
, GMP_RNDN
);
13763 mpfr_from_real (m3
, ra3
, GMP_RNDN
);
13764 mpfr_clear_flags ();
13765 inexact
= func (m1
, m1
, m2
, m3
, rnd
);
13766 result
= do_mpfr_ckconv (m1
, type
, inexact
);
13767 mpfr_clears (m1
, m2
, m3
, NULL
);
13774 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13775 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13776 If ARG_SINP and ARG_COSP are NULL then the result is returned
13777 as a complex value.
13778 The type is taken from the type of ARG and is used for setting the
13779 precision of the calculation and results. */
13782 do_mpfr_sincos (tree arg
, tree arg_sinp
, tree arg_cosp
)
13784 tree
const type
= TREE_TYPE (arg
);
13785 tree result
= NULL_TREE
;
13789 /* To proceed, MPFR must exactly represent the target floating point
13790 format, which only happens when the target base equals two. */
13791 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13792 && TREE_CODE (arg
) == REAL_CST
13793 && !TREE_OVERFLOW (arg
))
13795 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg
);
13797 if (real_isfinite (ra
))
13799 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13800 const int prec
= fmt
->p
;
13801 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13802 tree result_s
, result_c
;
13806 mpfr_inits2 (prec
, m
, ms
, mc
, NULL
);
13807 mpfr_from_real (m
, ra
, GMP_RNDN
);
13808 mpfr_clear_flags ();
13809 inexact
= mpfr_sin_cos (ms
, mc
, m
, rnd
);
13810 result_s
= do_mpfr_ckconv (ms
, type
, inexact
);
13811 result_c
= do_mpfr_ckconv (mc
, type
, inexact
);
13812 mpfr_clears (m
, ms
, mc
, NULL
);
13813 if (result_s
&& result_c
)
13815 /* If we are to return in a complex value do so. */
13816 if (!arg_sinp
&& !arg_cosp
)
13817 return build_complex (build_complex_type (type
),
13818 result_c
, result_s
);
13820 /* Dereference the sin/cos pointer arguments. */
13821 arg_sinp
= build_fold_indirect_ref (arg_sinp
);
13822 arg_cosp
= build_fold_indirect_ref (arg_cosp
);
13823 /* Proceed if valid pointer type were passed in. */
13824 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp
)) == TYPE_MAIN_VARIANT (type
)
13825 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp
)) == TYPE_MAIN_VARIANT (type
))
13827 /* Set the values. */
13828 result_s
= fold_build2 (MODIFY_EXPR
, type
, arg_sinp
,
13830 TREE_SIDE_EFFECTS (result_s
) = 1;
13831 result_c
= fold_build2 (MODIFY_EXPR
, type
, arg_cosp
,
13833 TREE_SIDE_EFFECTS (result_c
) = 1;
13834 /* Combine the assignments into a compound expr. */
13835 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
13836 result_s
, result_c
));
13844 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13845 two-argument mpfr order N Bessel function FUNC on them and return
13846 the resulting value as a tree with type TYPE. The mpfr precision
13847 is set to the precision of TYPE. We assume that function FUNC
13848 returns zero if the result could be calculated exactly within the
13849 requested precision. */
13851 do_mpfr_bessel_n (tree arg1
, tree arg2
, tree type
,
13852 int (*func
)(mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
13853 const REAL_VALUE_TYPE
*min
, bool inclusive
)
13855 tree result
= NULL_TREE
;
13860 /* To proceed, MPFR must exactly represent the target floating point
13861 format, which only happens when the target base equals two. */
13862 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13863 && tree_fits_shwi_p (arg1
)
13864 && TREE_CODE (arg2
) == REAL_CST
&& !TREE_OVERFLOW (arg2
))
13866 const HOST_WIDE_INT n
= tree_to_shwi (arg1
);
13867 const REAL_VALUE_TYPE
*const ra
= &TREE_REAL_CST (arg2
);
13870 && real_isfinite (ra
)
13871 && (!min
|| real_compare (inclusive
? GE_EXPR
: GT_EXPR
, ra
, min
)))
13873 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13874 const int prec
= fmt
->p
;
13875 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13879 mpfr_init2 (m
, prec
);
13880 mpfr_from_real (m
, ra
, GMP_RNDN
);
13881 mpfr_clear_flags ();
13882 inexact
= func (m
, n
, m
, rnd
);
13883 result
= do_mpfr_ckconv (m
, type
, inexact
);
13891 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13892 the pointer *(ARG_QUO) and return the result. The type is taken
13893 from the type of ARG0 and is used for setting the precision of the
13894 calculation and results. */
13897 do_mpfr_remquo (tree arg0
, tree arg1
, tree arg_quo
)
13899 tree
const type
= TREE_TYPE (arg0
);
13900 tree result
= NULL_TREE
;
13905 /* To proceed, MPFR must exactly represent the target floating point
13906 format, which only happens when the target base equals two. */
13907 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13908 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
13909 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
))
13911 const REAL_VALUE_TYPE
*const ra0
= TREE_REAL_CST_PTR (arg0
);
13912 const REAL_VALUE_TYPE
*const ra1
= TREE_REAL_CST_PTR (arg1
);
13914 if (real_isfinite (ra0
) && real_isfinite (ra1
))
13916 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13917 const int prec
= fmt
->p
;
13918 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
13923 mpfr_inits2 (prec
, m0
, m1
, NULL
);
13924 mpfr_from_real (m0
, ra0
, GMP_RNDN
);
13925 mpfr_from_real (m1
, ra1
, GMP_RNDN
);
13926 mpfr_clear_flags ();
13927 mpfr_remquo (m0
, &integer_quo
, m0
, m1
, rnd
);
13928 /* Remquo is independent of the rounding mode, so pass
13929 inexact=0 to do_mpfr_ckconv(). */
13930 result_rem
= do_mpfr_ckconv (m0
, type
, /*inexact=*/ 0);
13931 mpfr_clears (m0
, m1
, NULL
);
13934 /* MPFR calculates quo in the host's long so it may
13935 return more bits in quo than the target int can hold
13936 if sizeof(host long) > sizeof(target int). This can
13937 happen even for native compilers in LP64 mode. In
13938 these cases, modulo the quo value with the largest
13939 number that the target int can hold while leaving one
13940 bit for the sign. */
13941 if (sizeof (integer_quo
) * CHAR_BIT
> INT_TYPE_SIZE
)
13942 integer_quo
%= (long)(1UL << (INT_TYPE_SIZE
- 1));
13944 /* Dereference the quo pointer argument. */
13945 arg_quo
= build_fold_indirect_ref (arg_quo
);
13946 /* Proceed iff a valid pointer type was passed in. */
13947 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo
)) == integer_type_node
)
13949 /* Set the value. */
13951 = fold_build2 (MODIFY_EXPR
, TREE_TYPE (arg_quo
), arg_quo
,
13952 build_int_cst (TREE_TYPE (arg_quo
),
13954 TREE_SIDE_EFFECTS (result_quo
) = 1;
13955 /* Combine the quo assignment with the rem. */
13956 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
13957 result_quo
, result_rem
));
13965 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13966 resulting value as a tree with type TYPE. The mpfr precision is
13967 set to the precision of TYPE. We assume that this mpfr function
13968 returns zero if the result could be calculated exactly within the
13969 requested precision. In addition, the integer pointer represented
13970 by ARG_SG will be dereferenced and set to the appropriate signgam
13974 do_mpfr_lgamma_r (tree arg
, tree arg_sg
, tree type
)
13976 tree result
= NULL_TREE
;
13980 /* To proceed, MPFR must exactly represent the target floating point
13981 format, which only happens when the target base equals two. Also
13982 verify ARG is a constant and that ARG_SG is an int pointer. */
13983 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
13984 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
)
13985 && TREE_CODE (TREE_TYPE (arg_sg
)) == POINTER_TYPE
13986 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg
))) == integer_type_node
)
13988 const REAL_VALUE_TYPE
*const ra
= TREE_REAL_CST_PTR (arg
);
13990 /* In addition to NaN and Inf, the argument cannot be zero or a
13991 negative integer. */
13992 if (real_isfinite (ra
)
13993 && ra
->cl
!= rvc_zero
13994 && !(real_isneg (ra
) && real_isinteger (ra
, TYPE_MODE (type
))))
13996 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
13997 const int prec
= fmt
->p
;
13998 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
14003 mpfr_init2 (m
, prec
);
14004 mpfr_from_real (m
, ra
, GMP_RNDN
);
14005 mpfr_clear_flags ();
14006 inexact
= mpfr_lgamma (m
, &sg
, m
, rnd
);
14007 result_lg
= do_mpfr_ckconv (m
, type
, inexact
);
14013 /* Dereference the arg_sg pointer argument. */
14014 arg_sg
= build_fold_indirect_ref (arg_sg
);
14015 /* Assign the signgam value into *arg_sg. */
14016 result_sg
= fold_build2 (MODIFY_EXPR
,
14017 TREE_TYPE (arg_sg
), arg_sg
,
14018 build_int_cst (TREE_TYPE (arg_sg
), sg
));
14019 TREE_SIDE_EFFECTS (result_sg
) = 1;
14020 /* Combine the signgam assignment with the lgamma result. */
14021 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
14022 result_sg
, result_lg
));
14030 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
14031 function FUNC on it and return the resulting value as a tree with
14032 type TYPE. The mpfr precision is set to the precision of TYPE. We
14033 assume that function FUNC returns zero if the result could be
14034 calculated exactly within the requested precision. */
14037 do_mpc_arg1 (tree arg
, tree type
, int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_rnd_t
))
14039 tree result
= NULL_TREE
;
14043 /* To proceed, MPFR must exactly represent the target floating point
14044 format, which only happens when the target base equals two. */
14045 if (TREE_CODE (arg
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg
)
14046 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == REAL_TYPE
14047 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg
))))->b
== 2)
14049 const REAL_VALUE_TYPE
*const re
= TREE_REAL_CST_PTR (TREE_REALPART (arg
));
14050 const REAL_VALUE_TYPE
*const im
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg
));
14052 if (real_isfinite (re
) && real_isfinite (im
))
14054 const struct real_format
*const fmt
=
14055 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
14056 const int prec
= fmt
->p
;
14057 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
14058 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
14062 mpc_init2 (m
, prec
);
14063 mpfr_from_real (mpc_realref (m
), re
, rnd
);
14064 mpfr_from_real (mpc_imagref (m
), im
, rnd
);
14065 mpfr_clear_flags ();
14066 inexact
= func (m
, m
, crnd
);
14067 result
= do_mpc_ckconv (m
, type
, inexact
, /*force_convert=*/ 0);
14075 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
14076 mpc function FUNC on it and return the resulting value as a tree
14077 with type TYPE. The mpfr precision is set to the precision of
14078 TYPE. We assume that function FUNC returns zero if the result
14079 could be calculated exactly within the requested precision. If
14080 DO_NONFINITE is true, then fold expressions containing Inf or NaN
14081 in the arguments and/or results. */
14084 do_mpc_arg2 (tree arg0
, tree arg1
, tree type
, int do_nonfinite
,
14085 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
))
14087 tree result
= NULL_TREE
;
14092 /* To proceed, MPFR must exactly represent the target floating point
14093 format, which only happens when the target base equals two. */
14094 if (TREE_CODE (arg0
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg0
)
14095 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
14096 && TREE_CODE (arg1
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg1
)
14097 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1
))) == REAL_TYPE
14098 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0
))))->b
== 2)
14100 const REAL_VALUE_TYPE
*const re0
= TREE_REAL_CST_PTR (TREE_REALPART (arg0
));
14101 const REAL_VALUE_TYPE
*const im0
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg0
));
14102 const REAL_VALUE_TYPE
*const re1
= TREE_REAL_CST_PTR (TREE_REALPART (arg1
));
14103 const REAL_VALUE_TYPE
*const im1
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg1
));
14106 || (real_isfinite (re0
) && real_isfinite (im0
)
14107 && real_isfinite (re1
) && real_isfinite (im1
)))
14109 const struct real_format
*const fmt
=
14110 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
14111 const int prec
= fmt
->p
;
14112 const mp_rnd_t rnd
= fmt
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
14113 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
14117 mpc_init2 (m0
, prec
);
14118 mpc_init2 (m1
, prec
);
14119 mpfr_from_real (mpc_realref (m0
), re0
, rnd
);
14120 mpfr_from_real (mpc_imagref (m0
), im0
, rnd
);
14121 mpfr_from_real (mpc_realref (m1
), re1
, rnd
);
14122 mpfr_from_real (mpc_imagref (m1
), im1
, rnd
);
14123 mpfr_clear_flags ();
14124 inexact
= func (m0
, m0
, m1
, crnd
);
14125 result
= do_mpc_ckconv (m0
, type
, inexact
, do_nonfinite
);
14134 /* Fold a call STMT to __{,v}sprintf_chk. Return NULL_TREE if
14135 a normal call should be emitted rather than expanding the function
14136 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
14139 gimple_fold_builtin_sprintf_chk (gimple stmt
, enum built_in_function fcode
)
14141 int nargs
= gimple_call_num_args (stmt
);
14143 return fold_builtin_sprintf_chk_1 (gimple_location (stmt
), nargs
,
14145 ? gimple_call_arg_ptr (stmt
, 0)
14146 : &error_mark_node
), fcode
);
14149 /* Fold a call STMT to {,v}snprintf. Return NULL_TREE if
14150 a normal call should be emitted rather than expanding the function
14151 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
14152 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
14153 passed as second argument. */
14156 gimple_fold_builtin_snprintf_chk (gimple stmt
, tree maxlen
,
14157 enum built_in_function fcode
)
14159 int nargs
= gimple_call_num_args (stmt
);
14161 return fold_builtin_snprintf_chk_1 (gimple_location (stmt
), nargs
,
14163 ? gimple_call_arg_ptr (stmt
, 0)
14164 : &error_mark_node
), maxlen
, fcode
);
14167 /* Builtins with folding operations that operate on "..." arguments
14168 need special handling; we need to store the arguments in a convenient
14169 data structure before attempting any folding. Fortunately there are
14170 only a few builtins that fall into this category. FNDECL is the
14171 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
14172 result of the function call is ignored. */
14175 gimple_fold_builtin_varargs (tree fndecl
, gimple stmt
,
14176 bool ignore ATTRIBUTE_UNUSED
)
14178 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
14179 tree ret
= NULL_TREE
;
14183 case BUILT_IN_SPRINTF_CHK
:
14184 case BUILT_IN_VSPRINTF_CHK
:
14185 ret
= gimple_fold_builtin_sprintf_chk (stmt
, fcode
);
14188 case BUILT_IN_SNPRINTF_CHK
:
14189 case BUILT_IN_VSNPRINTF_CHK
:
14190 ret
= gimple_fold_builtin_snprintf_chk (stmt
, NULL_TREE
, fcode
);
14197 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
14198 TREE_NO_WARNING (ret
) = 1;
14204 /* A wrapper function for builtin folding that prevents warnings for
14205 "statement without effect" and the like, caused by removing the
14206 call node earlier than the warning is generated. */
14209 fold_call_stmt (gimple stmt
, bool ignore
)
14211 tree ret
= NULL_TREE
;
14212 tree fndecl
= gimple_call_fndecl (stmt
);
14213 location_t loc
= gimple_location (stmt
);
14215 && TREE_CODE (fndecl
) == FUNCTION_DECL
14216 && DECL_BUILT_IN (fndecl
)
14217 && !gimple_call_va_arg_pack_p (stmt
))
14219 int nargs
= gimple_call_num_args (stmt
);
14220 tree
*args
= (nargs
> 0
14221 ? gimple_call_arg_ptr (stmt
, 0)
14222 : &error_mark_node
);
14224 if (avoid_folding_inline_builtin (fndecl
))
14226 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
14228 return targetm
.fold_builtin (fndecl
, nargs
, args
, ignore
);
14232 if (nargs
<= MAX_ARGS_TO_FOLD_BUILTIN
)
14233 ret
= fold_builtin_n (loc
, fndecl
, args
, nargs
, ignore
);
14235 ret
= gimple_fold_builtin_varargs (fndecl
, stmt
, ignore
);
14238 /* Propagate location information from original call to
14239 expansion of builtin. Otherwise things like
14240 maybe_emit_chk_warning, that operate on the expansion
14241 of a builtin, will use the wrong location information. */
14242 if (gimple_has_location (stmt
))
14244 tree realret
= ret
;
14245 if (TREE_CODE (ret
) == NOP_EXPR
)
14246 realret
= TREE_OPERAND (ret
, 0);
14247 if (CAN_HAVE_LOCATION_P (realret
)
14248 && !EXPR_HAS_LOCATION (realret
))
14249 SET_EXPR_LOCATION (realret
, loc
);
14259 /* Look up the function in builtin_decl that corresponds to DECL
14260 and set ASMSPEC as its user assembler name. DECL must be a
14261 function decl that declares a builtin. */
14264 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
14267 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
14268 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
14271 builtin
= builtin_decl_explicit (DECL_FUNCTION_CODE (decl
));
14272 set_user_assembler_name (builtin
, asmspec
);
14273 switch (DECL_FUNCTION_CODE (decl
))
14275 case BUILT_IN_MEMCPY
:
14276 init_block_move_fn (asmspec
);
14277 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
14279 case BUILT_IN_MEMSET
:
14280 init_block_clear_fn (asmspec
);
14281 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
14283 case BUILT_IN_MEMMOVE
:
14284 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
14286 case BUILT_IN_MEMCMP
:
14287 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
14289 case BUILT_IN_ABORT
:
14290 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
14293 if (INT_TYPE_SIZE
< BITS_PER_WORD
)
14295 set_user_assembler_libfunc ("ffs", asmspec
);
14296 set_optab_libfunc (ffs_optab
, mode_for_size (INT_TYPE_SIZE
,
14297 MODE_INT
, 0), "ffs");
14305 /* Return true if DECL is a builtin that expands to a constant or similarly
14308 is_simple_builtin (tree decl
)
14310 if (decl
&& DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
14311 switch (DECL_FUNCTION_CODE (decl
))
14313 /* Builtins that expand to constants. */
14314 case BUILT_IN_CONSTANT_P
:
14315 case BUILT_IN_EXPECT
:
14316 case BUILT_IN_OBJECT_SIZE
:
14317 case BUILT_IN_UNREACHABLE
:
14318 /* Simple register moves or loads from stack. */
14319 case BUILT_IN_ASSUME_ALIGNED
:
14320 case BUILT_IN_RETURN_ADDRESS
:
14321 case BUILT_IN_EXTRACT_RETURN_ADDR
:
14322 case BUILT_IN_FROB_RETURN_ADDR
:
14323 case BUILT_IN_RETURN
:
14324 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
14325 case BUILT_IN_FRAME_ADDRESS
:
14326 case BUILT_IN_VA_END
:
14327 case BUILT_IN_STACK_SAVE
:
14328 case BUILT_IN_STACK_RESTORE
:
14329 /* Exception state returns or moves registers around. */
14330 case BUILT_IN_EH_FILTER
:
14331 case BUILT_IN_EH_POINTER
:
14332 case BUILT_IN_EH_COPY_VALUES
:
14342 /* Return true if DECL is a builtin that is not expensive, i.e., they are
14343 most probably expanded inline into reasonably simple code. This is a
14344 superset of is_simple_builtin. */
14346 is_inexpensive_builtin (tree decl
)
14350 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_MD
)
14352 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
14353 switch (DECL_FUNCTION_CODE (decl
))
14356 case BUILT_IN_ALLOCA
:
14357 case BUILT_IN_ALLOCA_WITH_ALIGN
:
14358 case BUILT_IN_BSWAP16
:
14359 case BUILT_IN_BSWAP32
:
14360 case BUILT_IN_BSWAP64
:
14362 case BUILT_IN_CLZIMAX
:
14363 case BUILT_IN_CLZL
:
14364 case BUILT_IN_CLZLL
:
14366 case BUILT_IN_CTZIMAX
:
14367 case BUILT_IN_CTZL
:
14368 case BUILT_IN_CTZLL
:
14370 case BUILT_IN_FFSIMAX
:
14371 case BUILT_IN_FFSL
:
14372 case BUILT_IN_FFSLL
:
14373 case BUILT_IN_IMAXABS
:
14374 case BUILT_IN_FINITE
:
14375 case BUILT_IN_FINITEF
:
14376 case BUILT_IN_FINITEL
:
14377 case BUILT_IN_FINITED32
:
14378 case BUILT_IN_FINITED64
:
14379 case BUILT_IN_FINITED128
:
14380 case BUILT_IN_FPCLASSIFY
:
14381 case BUILT_IN_ISFINITE
:
14382 case BUILT_IN_ISINF_SIGN
:
14383 case BUILT_IN_ISINF
:
14384 case BUILT_IN_ISINFF
:
14385 case BUILT_IN_ISINFL
:
14386 case BUILT_IN_ISINFD32
:
14387 case BUILT_IN_ISINFD64
:
14388 case BUILT_IN_ISINFD128
:
14389 case BUILT_IN_ISNAN
:
14390 case BUILT_IN_ISNANF
:
14391 case BUILT_IN_ISNANL
:
14392 case BUILT_IN_ISNAND32
:
14393 case BUILT_IN_ISNAND64
:
14394 case BUILT_IN_ISNAND128
:
14395 case BUILT_IN_ISNORMAL
:
14396 case BUILT_IN_ISGREATER
:
14397 case BUILT_IN_ISGREATEREQUAL
:
14398 case BUILT_IN_ISLESS
:
14399 case BUILT_IN_ISLESSEQUAL
:
14400 case BUILT_IN_ISLESSGREATER
:
14401 case BUILT_IN_ISUNORDERED
:
14402 case BUILT_IN_VA_ARG_PACK
:
14403 case BUILT_IN_VA_ARG_PACK_LEN
:
14404 case BUILT_IN_VA_COPY
:
14405 case BUILT_IN_TRAP
:
14406 case BUILT_IN_SAVEREGS
:
14407 case BUILT_IN_POPCOUNTL
:
14408 case BUILT_IN_POPCOUNTLL
:
14409 case BUILT_IN_POPCOUNTIMAX
:
14410 case BUILT_IN_POPCOUNT
:
14411 case BUILT_IN_PARITYL
:
14412 case BUILT_IN_PARITYLL
:
14413 case BUILT_IN_PARITYIMAX
:
14414 case BUILT_IN_PARITY
:
14415 case BUILT_IN_LABS
:
14416 case BUILT_IN_LLABS
:
14417 case BUILT_IN_PREFETCH
:
14421 return is_simple_builtin (decl
);