1 /* Expand builtin functions.
2 Copyright (C) 1988-2024 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/>. */
20 /* Legacy warning! Please add no further builtin simplifications here
21 (apart from pure constant folding) - builtin simplifications should go
22 to match.pd or gimple-fold.cc instead. */
26 #include "coretypes.h"
35 #include "stringpool.h"
37 #include "tree-ssanames.h"
42 #include "diagnostic-core.h"
44 #include "fold-const.h"
45 #include "fold-const-call.h"
46 #include "gimple-ssa-warn-access.h"
47 #include "stor-layout.h"
50 #include "tree-object-size.h"
51 #include "tree-ssa-strlen.h"
61 #include "typeclass.h"
62 #include "langhooks.h"
63 #include "value-prof.h"
65 #include "stringpool.h"
68 #include "internal-fn.h"
69 #include "case-cfn-macros.h"
70 #include "gimple-iterator.h"
71 #include "gimple-fold.h"
73 #include "file-prefix-map.h" /* remap_macro_filename() */
74 #include "ipa-strub.h" /* strub_watermark_parm() */
75 #include "gomp-constants.h"
76 #include "omp-general.h"
78 #include "gimple-ssa.h"
79 #include "tree-ssa-live.h"
80 #include "tree-outof-ssa.h"
81 #include "attr-fnspec.h"
83 #include "gimple-range.h"
84 #include "pointer-query.h"
86 struct target_builtins default_target_builtins
;
88 struct target_builtins
*this_target_builtins
= &default_target_builtins
;
91 /* Define the names of the builtin function types and codes. */
92 const char *const built_in_class_names
[BUILT_IN_LAST
]
93 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
95 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
96 const char * built_in_names
[(int) END_BUILTINS
] =
98 #include "builtins.def"
101 /* Setup an array of builtin_info_type, make sure each element decl is
102 initialized to NULL_TREE. */
103 builtin_info_type builtin_info
[(int)END_BUILTINS
];
105 /* Non-zero if __builtin_constant_p should be folded right away. */
106 bool force_folding_builtin_constant_p
;
108 static int target_char_cast (tree
, char *);
109 static int apply_args_size (void);
110 static int apply_result_size (void);
111 static rtx
result_vector (int, rtx
);
112 static void expand_builtin_prefetch (tree
);
113 static rtx
expand_builtin_apply_args (void);
114 static rtx
expand_builtin_apply_args_1 (void);
115 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
116 static void expand_builtin_return (rtx
);
117 static rtx
expand_builtin_classify_type (tree
);
118 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
119 static rtx
expand_builtin_mathfn_ternary (tree
, rtx
, rtx
);
120 static rtx
expand_builtin_interclass_mathfn (tree
, rtx
);
121 static rtx
expand_builtin_sincos (tree
);
122 static rtx
expand_builtin_fegetround (tree
, rtx
, machine_mode
);
123 static rtx
expand_builtin_feclear_feraise_except (tree
, rtx
, machine_mode
,
125 static rtx
expand_builtin_cexpi (tree
, rtx
);
126 static rtx
expand_builtin_issignaling (tree
, rtx
);
127 static rtx
expand_builtin_int_roundingfn (tree
, rtx
);
128 static rtx
expand_builtin_int_roundingfn_2 (tree
, rtx
);
129 static rtx
expand_builtin_next_arg (void);
130 static rtx
expand_builtin_va_start (tree
);
131 static rtx
expand_builtin_va_end (tree
);
132 static rtx
expand_builtin_va_copy (tree
);
133 static rtx
inline_expand_builtin_bytecmp (tree
, rtx
);
134 static rtx
expand_builtin_strcmp (tree
, rtx
);
135 static rtx
expand_builtin_strncmp (tree
, rtx
, machine_mode
);
136 static rtx
expand_builtin_memcpy (tree
, rtx
);
137 static rtx
expand_builtin_memory_copy_args (tree dest
, tree src
, tree len
,
138 rtx target
, tree exp
,
141 static rtx
expand_builtin_memmove (tree
, rtx
);
142 static rtx
expand_builtin_mempcpy (tree
, rtx
);
143 static rtx
expand_builtin_mempcpy_args (tree
, tree
, tree
, rtx
, tree
, memop_ret
);
144 static rtx
expand_builtin_strcpy (tree
, rtx
);
145 static rtx
expand_builtin_strcpy_args (tree
, tree
, tree
, rtx
);
146 static rtx
expand_builtin_stpcpy (tree
, rtx
, machine_mode
);
147 static rtx
expand_builtin_strncpy (tree
, rtx
);
148 static rtx
expand_builtin_memset_args (tree
, tree
, tree
, rtx
, machine_mode
, tree
);
149 static rtx
expand_builtin_bzero (tree
);
150 static rtx
expand_builtin_strlen (tree
, rtx
, machine_mode
);
151 static rtx
expand_builtin_strnlen (tree
, rtx
, machine_mode
);
152 static rtx
expand_builtin_alloca (tree
);
153 static rtx
expand_builtin_unop (machine_mode
, tree
, rtx
, rtx
, optab
);
154 static rtx
expand_builtin_frame_address (tree
, tree
);
155 static rtx
expand_builtin_stack_address ();
156 static tree
stabilize_va_list_loc (location_t
, tree
, int);
157 static rtx
expand_builtin_expect (tree
, rtx
);
158 static rtx
expand_builtin_expect_with_probability (tree
, rtx
);
159 static tree
fold_builtin_constant_p (tree
);
160 static tree
fold_builtin_classify_type (tree
);
161 static tree
fold_builtin_strlen (location_t
, tree
, tree
, tree
);
162 static tree
fold_builtin_inf (location_t
, tree
, int);
163 static tree
rewrite_call_expr (location_t
, tree
, int, tree
, int, ...);
164 static bool validate_arg (const_tree
, enum tree_code code
);
165 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
166 static rtx
expand_builtin_signbit (tree
, rtx
);
167 static tree
fold_builtin_memcmp (location_t
, tree
, tree
, tree
);
168 static tree
fold_builtin_isascii (location_t
, tree
);
169 static tree
fold_builtin_toascii (location_t
, tree
);
170 static tree
fold_builtin_isdigit (location_t
, tree
);
171 static tree
fold_builtin_fabs (location_t
, tree
, tree
);
172 static tree
fold_builtin_abs (location_t
, tree
, tree
);
173 static tree
fold_builtin_unordered_cmp (location_t
, tree
, tree
, tree
, enum tree_code
,
175 static tree
fold_builtin_iseqsig (location_t
, tree
, tree
);
176 static tree
fold_builtin_varargs (location_t
, tree
, tree
*, int);
178 static tree
fold_builtin_strpbrk (location_t
, tree
, tree
, tree
, tree
);
179 static tree
fold_builtin_strspn (location_t
, tree
, tree
, tree
);
180 static tree
fold_builtin_strcspn (location_t
, tree
, tree
, tree
);
182 static rtx
expand_builtin_object_size (tree
);
183 static rtx
expand_builtin_memory_chk (tree
, rtx
, machine_mode
,
184 enum built_in_function
);
185 static void maybe_emit_chk_warning (tree
, enum built_in_function
);
186 static void maybe_emit_sprintf_chk_warning (tree
, enum built_in_function
);
187 static tree
fold_builtin_object_size (tree
, tree
, enum built_in_function
);
189 unsigned HOST_WIDE_INT target_newline
;
190 unsigned HOST_WIDE_INT target_percent
;
191 static unsigned HOST_WIDE_INT target_c
;
192 static unsigned HOST_WIDE_INT target_s
;
193 char target_percent_c
[3];
194 char target_percent_s
[3];
195 char target_percent_s_newline
[4];
196 static tree
do_mpfr_remquo (tree
, tree
, tree
);
197 static tree
do_mpfr_lgamma_r (tree
, tree
, tree
);
198 static void expand_builtin_sync_synchronize (void);
200 /* Return true if NAME starts with __builtin_ or __sync_. */
203 is_builtin_name (const char *name
)
205 return (startswith (name
, "__builtin_")
206 || startswith (name
, "__sync_")
207 || startswith (name
, "__atomic_"));
210 /* Return true if NODE should be considered for inline expansion regardless
211 of the optimization level. This means whenever a function is invoked with
212 its "internal" name, which normally contains the prefix "__builtin". */
215 called_as_built_in (tree node
)
217 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
218 we want the name used to call the function, not the name it
220 const char *name
= IDENTIFIER_POINTER (DECL_NAME (node
));
221 return is_builtin_name (name
);
224 /* Compute values M and N such that M divides (address of EXP - N) and such
225 that N < M. If these numbers can be determined, store M in alignp and N in
226 *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to
227 *alignp and any bit-offset to *bitposp.
229 Note that the address (and thus the alignment) computed here is based
230 on the address to which a symbol resolves, whereas DECL_ALIGN is based
231 on the address at which an object is actually located. These two
232 addresses are not always the same. For example, on ARM targets,
233 the address &foo of a Thumb function foo() has the lowest bit set,
234 whereas foo() itself starts on an even address.
236 If ADDR_P is true we are taking the address of the memory reference EXP
237 and thus cannot rely on the access taking place. */
240 get_object_alignment_2 (tree exp
, unsigned int *alignp
,
241 unsigned HOST_WIDE_INT
*bitposp
, bool addr_p
)
243 poly_int64 bitsize
, bitpos
;
246 int unsignedp
, reversep
, volatilep
;
247 unsigned int align
= BITS_PER_UNIT
;
248 bool known_alignment
= false;
250 /* Get the innermost object and the constant (bitpos) and possibly
251 variable (offset) offset of the access. */
252 exp
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode
,
253 &unsignedp
, &reversep
, &volatilep
);
255 /* Extract alignment information from the innermost object and
256 possibly adjust bitpos and offset. */
257 if (TREE_CODE (exp
) == FUNCTION_DECL
)
259 /* Function addresses can encode extra information besides their
260 alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
261 allows the low bit to be used as a virtual bit, we know
262 that the address itself must be at least 2-byte aligned. */
263 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
)
264 align
= 2 * BITS_PER_UNIT
;
266 else if (TREE_CODE (exp
) == LABEL_DECL
)
268 else if (TREE_CODE (exp
) == CONST_DECL
)
270 /* The alignment of a CONST_DECL is determined by its initializer. */
271 exp
= DECL_INITIAL (exp
);
272 align
= TYPE_ALIGN (TREE_TYPE (exp
));
273 if (CONSTANT_CLASS_P (exp
))
274 align
= targetm
.constant_alignment (exp
, align
);
276 known_alignment
= true;
278 else if (DECL_P (exp
))
280 align
= DECL_ALIGN (exp
);
281 known_alignment
= true;
283 else if (TREE_CODE (exp
) == INDIRECT_REF
284 || TREE_CODE (exp
) == MEM_REF
285 || TREE_CODE (exp
) == TARGET_MEM_REF
)
287 tree addr
= TREE_OPERAND (exp
, 0);
289 unsigned HOST_WIDE_INT ptr_bitpos
;
290 unsigned HOST_WIDE_INT ptr_bitmask
= ~0;
292 /* If the address is explicitely aligned, handle that. */
293 if (TREE_CODE (addr
) == BIT_AND_EXPR
294 && TREE_CODE (TREE_OPERAND (addr
, 1)) == INTEGER_CST
)
296 ptr_bitmask
= TREE_INT_CST_LOW (TREE_OPERAND (addr
, 1));
297 ptr_bitmask
*= BITS_PER_UNIT
;
298 align
= least_bit_hwi (ptr_bitmask
);
299 addr
= TREE_OPERAND (addr
, 0);
303 = get_pointer_alignment_1 (addr
, &ptr_align
, &ptr_bitpos
);
304 align
= MAX (ptr_align
, align
);
306 /* Re-apply explicit alignment to the bitpos. */
307 ptr_bitpos
&= ptr_bitmask
;
309 /* The alignment of the pointer operand in a TARGET_MEM_REF
310 has to take the variable offset parts into account. */
311 if (TREE_CODE (exp
) == TARGET_MEM_REF
)
315 unsigned HOST_WIDE_INT step
= 1;
317 step
= TREE_INT_CST_LOW (TMR_STEP (exp
));
318 align
= MIN (align
, least_bit_hwi (step
) * BITS_PER_UNIT
);
320 if (TMR_INDEX2 (exp
))
321 align
= BITS_PER_UNIT
;
322 known_alignment
= false;
325 /* When EXP is an actual memory reference then we can use
326 TYPE_ALIGN of a pointer indirection to derive alignment.
327 Do so only if get_pointer_alignment_1 did not reveal absolute
328 alignment knowledge and if using that alignment would
329 improve the situation. */
331 if (!addr_p
&& !known_alignment
332 && (talign
= min_align_of_type (TREE_TYPE (exp
)) * BITS_PER_UNIT
)
337 /* Else adjust bitpos accordingly. */
338 bitpos
+= ptr_bitpos
;
339 if (TREE_CODE (exp
) == MEM_REF
340 || TREE_CODE (exp
) == TARGET_MEM_REF
)
341 bitpos
+= mem_ref_offset (exp
).force_shwi () * BITS_PER_UNIT
;
344 else if (TREE_CODE (exp
) == STRING_CST
)
346 /* STRING_CST are the only constant objects we allow to be not
347 wrapped inside a CONST_DECL. */
348 align
= TYPE_ALIGN (TREE_TYPE (exp
));
349 if (CONSTANT_CLASS_P (exp
))
350 align
= targetm
.constant_alignment (exp
, align
);
352 known_alignment
= true;
355 /* If there is a non-constant offset part extract the maximum
356 alignment that can prevail. */
359 unsigned int trailing_zeros
= tree_ctz (offset
);
360 if (trailing_zeros
< HOST_BITS_PER_INT
)
362 unsigned int inner
= (1U << trailing_zeros
) * BITS_PER_UNIT
;
364 align
= MIN (align
, inner
);
368 /* Account for the alignment of runtime coefficients, so that the constant
369 bitpos is guaranteed to be accurate. */
370 unsigned int alt_align
= ::known_alignment (bitpos
- bitpos
.coeffs
[0]);
371 if (alt_align
!= 0 && alt_align
< align
)
374 known_alignment
= false;
378 *bitposp
= bitpos
.coeffs
[0] & (align
- 1);
379 return known_alignment
;
382 /* For a memory reference expression EXP compute values M and N such that M
383 divides (&EXP - N) and such that N < M. If these numbers can be determined,
384 store M in alignp and N in *BITPOSP and return true. Otherwise return false
385 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
388 get_object_alignment_1 (tree exp
, unsigned int *alignp
,
389 unsigned HOST_WIDE_INT
*bitposp
)
391 /* Strip a WITH_SIZE_EXPR, get_inner_reference doesn't know how to deal
393 if (TREE_CODE (exp
) == WITH_SIZE_EXPR
)
394 exp
= TREE_OPERAND (exp
, 0);
395 return get_object_alignment_2 (exp
, alignp
, bitposp
, false);
398 /* Return the alignment in bits of EXP, an object. */
401 get_object_alignment (tree exp
)
403 unsigned HOST_WIDE_INT bitpos
= 0;
406 get_object_alignment_1 (exp
, &align
, &bitpos
);
408 /* align and bitpos now specify known low bits of the pointer.
409 ptr & (align - 1) == bitpos. */
412 align
= least_bit_hwi (bitpos
);
416 /* For a pointer valued expression EXP compute values M and N such that M
417 divides (EXP - N) and such that N < M. If these numbers can be determined,
418 store M in alignp and N in *BITPOSP and return true. Return false if
419 the results are just a conservative approximation.
421 If EXP is not a pointer, false is returned too. */
424 get_pointer_alignment_1 (tree exp
, unsigned int *alignp
,
425 unsigned HOST_WIDE_INT
*bitposp
)
429 if (TREE_CODE (exp
) == ADDR_EXPR
)
430 return get_object_alignment_2 (TREE_OPERAND (exp
, 0),
431 alignp
, bitposp
, true);
432 else if (TREE_CODE (exp
) == POINTER_PLUS_EXPR
)
435 unsigned HOST_WIDE_INT bitpos
;
436 bool res
= get_pointer_alignment_1 (TREE_OPERAND (exp
, 0),
438 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
439 bitpos
+= TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)) * BITS_PER_UNIT
;
442 unsigned int trailing_zeros
= tree_ctz (TREE_OPERAND (exp
, 1));
443 if (trailing_zeros
< HOST_BITS_PER_INT
)
445 unsigned int inner
= (1U << trailing_zeros
) * BITS_PER_UNIT
;
447 align
= MIN (align
, inner
);
451 *bitposp
= bitpos
& (align
- 1);
454 else if (TREE_CODE (exp
) == SSA_NAME
455 && POINTER_TYPE_P (TREE_TYPE (exp
)))
457 unsigned int ptr_align
, ptr_misalign
;
458 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (exp
);
460 if (pi
&& get_ptr_info_alignment (pi
, &ptr_align
, &ptr_misalign
))
462 *bitposp
= ptr_misalign
* BITS_PER_UNIT
;
463 *alignp
= ptr_align
* BITS_PER_UNIT
;
464 /* Make sure to return a sensible alignment when the multiplication
465 by BITS_PER_UNIT overflowed. */
467 *alignp
= 1u << (HOST_BITS_PER_INT
- 1);
468 /* We cannot really tell whether this result is an approximation. */
474 *alignp
= BITS_PER_UNIT
;
478 else if (TREE_CODE (exp
) == INTEGER_CST
)
480 *alignp
= BIGGEST_ALIGNMENT
;
481 *bitposp
= ((TREE_INT_CST_LOW (exp
) * BITS_PER_UNIT
)
482 & (BIGGEST_ALIGNMENT
- 1));
487 *alignp
= BITS_PER_UNIT
;
491 /* Return the alignment in bits of EXP, a pointer valued expression.
492 The alignment returned is, by default, the alignment of the thing that
493 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
495 Otherwise, look at the expression to see if we can do better, i.e., if the
496 expression is actually pointing at an object whose alignment is tighter. */
499 get_pointer_alignment (tree exp
)
501 unsigned HOST_WIDE_INT bitpos
= 0;
504 get_pointer_alignment_1 (exp
, &align
, &bitpos
);
506 /* align and bitpos now specify known low bits of the pointer.
507 ptr & (align - 1) == bitpos. */
510 align
= least_bit_hwi (bitpos
);
515 /* Return the number of leading non-zero elements in the sequence
516 [ PTR, PTR + MAXELTS ) where each element's size is ELTSIZE bytes.
517 ELTSIZE must be a power of 2 less than 8. Used by c_strlen. */
520 string_length (const void *ptr
, unsigned eltsize
, unsigned maxelts
)
522 gcc_checking_assert (eltsize
== 1 || eltsize
== 2 || eltsize
== 4);
528 /* Optimize the common case of plain char. */
529 for (n
= 0; n
< maxelts
; n
++)
531 const char *elt
= (const char*) ptr
+ n
;
538 for (n
= 0; n
< maxelts
; n
++)
540 const char *elt
= (const char*) ptr
+ n
* eltsize
;
541 if (!memcmp (elt
, "\0\0\0\0", eltsize
))
548 /* Compute the length of a null-terminated character string or wide
549 character string handling character sizes of 1, 2, and 4 bytes.
550 TREE_STRING_LENGTH is not the right way because it evaluates to
551 the size of the character array in bytes (as opposed to characters)
552 and because it can contain a zero byte in the middle.
554 ONLY_VALUE should be nonzero if the result is not going to be emitted
555 into the instruction stream and zero if it is going to be expanded.
556 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
557 is returned, otherwise NULL, since
558 len = c_strlen (ARG, 1); if (len) expand_expr (len, ...); would not
559 evaluate the side-effects.
561 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
562 accesses. Note that this implies the result is not going to be emitted
563 into the instruction stream.
565 Additional information about the string accessed may be recorded
566 in DATA. For example, if ARG references an unterminated string,
567 then the declaration will be stored in the DECL field. If the
568 length of the unterminated string can be determined, it'll be
569 stored in the LEN field. Note this length could well be different
570 than what a C strlen call would return.
572 ELTSIZE is 1 for normal single byte character strings, and 2 or
573 4 for wide characer strings. ELTSIZE is by default 1.
575 The value returned is of type `ssizetype'. */
578 c_strlen (tree arg
, int only_value
, c_strlen_data
*data
, unsigned eltsize
)
580 /* If we were not passed a DATA pointer, then get one to a local
581 structure. That avoids having to check DATA for NULL before
582 each time we want to use it. */
583 c_strlen_data local_strlen_data
= { };
585 data
= &local_strlen_data
;
587 gcc_checking_assert (eltsize
== 1 || eltsize
== 2 || eltsize
== 4);
589 tree src
= STRIP_NOPS (arg
);
590 if (TREE_CODE (src
) == COND_EXPR
591 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
595 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
, data
, eltsize
);
596 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
, data
, eltsize
);
597 if (tree_int_cst_equal (len1
, len2
))
601 if (TREE_CODE (src
) == COMPOUND_EXPR
602 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
603 return c_strlen (TREE_OPERAND (src
, 1), only_value
, data
, eltsize
);
605 location_t loc
= EXPR_LOC_OR_LOC (src
, input_location
);
607 /* Offset from the beginning of the string in bytes. */
611 src
= string_constant (src
, &byteoff
, &memsize
, &decl
);
615 /* Determine the size of the string element. */
616 if (eltsize
!= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (src
)))))
619 /* Set MAXELTS to ARRAY_SIZE (SRC) - 1, the maximum possible
620 length of SRC. Prefer TYPE_SIZE() to TREE_STRING_LENGTH() if possible
621 in case the latter is less than the size of the array, such as when
622 SRC refers to a short string literal used to initialize a large array.
623 In that case, the elements of the array after the terminating NUL are
625 HOST_WIDE_INT strelts
= TREE_STRING_LENGTH (src
);
626 strelts
= strelts
/ eltsize
;
628 if (!tree_fits_uhwi_p (memsize
))
631 HOST_WIDE_INT maxelts
= tree_to_uhwi (memsize
) / eltsize
;
633 /* PTR can point to the byte representation of any string type, including
634 char* and wchar_t*. */
635 const char *ptr
= TREE_STRING_POINTER (src
);
637 if (byteoff
&& TREE_CODE (byteoff
) != INTEGER_CST
)
639 /* The code below works only for single byte character types. */
643 /* If the string has an internal NUL character followed by any
644 non-NUL characters (e.g., "foo\0bar"), we can't compute
645 the offset to the following NUL if we don't know where to
646 start searching for it. */
647 unsigned len
= string_length (ptr
, eltsize
, strelts
);
649 /* Return when an embedded null character is found or none at all.
650 In the latter case, set the DECL/LEN field in the DATA structure
651 so that callers may examine them. */
652 if (len
+ 1 < strelts
)
654 else if (len
>= maxelts
)
658 data
->minlen
= ssize_int (len
);
662 /* For empty strings the result should be zero. */
664 return ssize_int (0);
666 /* We don't know the starting offset, but we do know that the string
667 has no internal zero bytes. If the offset falls within the bounds
668 of the string subtract the offset from the length of the string,
669 and return that. Otherwise the length is zero. Take care to
670 use SAVE_EXPR in case the OFFSET has side-effects. */
671 tree offsave
= TREE_SIDE_EFFECTS (byteoff
) ? save_expr (byteoff
)
673 offsave
= fold_convert_loc (loc
, sizetype
, offsave
);
674 tree condexp
= fold_build2_loc (loc
, LE_EXPR
, boolean_type_node
, offsave
,
676 tree lenexp
= fold_build2_loc (loc
, MINUS_EXPR
, sizetype
, size_int (len
),
678 lenexp
= fold_convert_loc (loc
, ssizetype
, lenexp
);
679 return fold_build3_loc (loc
, COND_EXPR
, ssizetype
, condexp
, lenexp
,
680 build_zero_cst (ssizetype
));
683 /* Offset from the beginning of the string in elements. */
684 HOST_WIDE_INT eltoff
;
686 /* We have a known offset into the string. Start searching there for
687 a null character if we can represent it as a single HOST_WIDE_INT. */
690 else if (! tree_fits_uhwi_p (byteoff
) || tree_to_uhwi (byteoff
) % eltsize
)
693 eltoff
= tree_to_uhwi (byteoff
) / eltsize
;
695 /* If the offset is known to be out of bounds, warn, and call strlen at
697 if (eltoff
< 0 || eltoff
>= maxelts
)
699 /* Suppress multiple warnings for propagated constant strings. */
701 && !warning_suppressed_p (arg
, OPT_Warray_bounds_
)
702 && warning_at (loc
, OPT_Warray_bounds_
,
703 "offset %qwi outside bounds of constant string",
707 inform (DECL_SOURCE_LOCATION (decl
), "%qE declared here", decl
);
708 suppress_warning (arg
, OPT_Warray_bounds_
);
713 /* If eltoff is larger than strelts but less than maxelts the
714 string length is zero, since the excess memory will be zero. */
715 if (eltoff
> strelts
)
716 return ssize_int (0);
718 /* Use strlen to search for the first zero byte. Since any strings
719 constructed with build_string will have nulls appended, we win even
720 if we get handed something like (char[4])"abcd".
722 Since ELTOFF is our starting index into the string, no further
723 calculation is needed. */
724 unsigned len
= string_length (ptr
+ eltoff
* eltsize
, eltsize
,
727 /* Don't know what to return if there was no zero termination.
728 Ideally this would turn into a gcc_checking_assert over time.
729 Set DECL/LEN so callers can examine them. */
730 if (len
>= maxelts
- eltoff
)
734 data
->minlen
= ssize_int (len
);
738 return ssize_int (len
);
741 /* Return a constant integer corresponding to target reading
742 GET_MODE_BITSIZE (MODE) bits from string constant STR. If
743 NULL_TERMINATED_P, reading stops after '\0' character, all further ones
744 are assumed to be zero, otherwise it reads as many characters
748 c_readstr (const char *str
, fixed_size_mode mode
,
749 bool null_terminated_p
/*=true*/)
751 auto_vec
<target_unit
, MAX_BITSIZE_MODE_ANY_INT
/ BITS_PER_UNIT
> bytes
;
753 bytes
.reserve (GET_MODE_SIZE (mode
));
756 for (unsigned int i
= 0; i
< GET_MODE_SIZE (mode
); ++i
)
758 if (ch
|| !null_terminated_p
)
759 ch
= (unsigned char) str
[i
];
760 bytes
.quick_push (ch
);
763 return native_decode_rtx (mode
, bytes
, 0);
766 /* Cast a target constant CST to target CHAR and if that value fits into
767 host char type, return zero and put that value into variable pointed to by
771 target_char_cast (tree cst
, char *p
)
773 unsigned HOST_WIDE_INT val
, hostval
;
775 if (TREE_CODE (cst
) != INTEGER_CST
776 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
779 /* Do not care if it fits or not right here. */
780 val
= TREE_INT_CST_LOW (cst
);
782 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
783 val
&= (HOST_WIDE_INT_1U
<< CHAR_TYPE_SIZE
) - 1;
786 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
787 hostval
&= (HOST_WIDE_INT_1U
<< HOST_BITS_PER_CHAR
) - 1;
796 /* Similar to save_expr, but assumes that arbitrary code is not executed
797 in between the multiple evaluations. In particular, we assume that a
798 non-addressable local variable will not be modified. */
801 builtin_save_expr (tree exp
)
803 if (TREE_CODE (exp
) == SSA_NAME
804 || (TREE_ADDRESSABLE (exp
) == 0
805 && (TREE_CODE (exp
) == PARM_DECL
806 || (VAR_P (exp
) && !TREE_STATIC (exp
)))))
809 return save_expr (exp
);
812 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
813 times to get the address of either a higher stack frame, or a return
814 address located within it (depending on FNDECL_CODE). */
817 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
820 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
823 /* For a zero count with __builtin_return_address, we don't care what
824 frame address we return, because target-specific definitions will
825 override us. Therefore frame pointer elimination is OK, and using
826 the soft frame pointer is OK.
828 For a nonzero count, or a zero count with __builtin_frame_address,
829 we require a stable offset from the current frame pointer to the
830 previous one, so we must use the hard frame pointer, and
831 we must disable frame pointer elimination. */
832 if (count
== 0 && fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
833 tem
= frame_pointer_rtx
;
836 tem
= hard_frame_pointer_rtx
;
838 /* Tell reload not to eliminate the frame pointer. */
839 crtl
->accesses_prior_frames
= 1;
844 SETUP_FRAME_ADDRESSES ();
846 /* On the SPARC, the return address is not in the frame, it is in a
847 register. There is no way to access it off of the current frame
848 pointer, but it can be accessed off the previous frame pointer by
849 reading the value from the register window save area. */
850 if (RETURN_ADDR_IN_PREVIOUS_FRAME
&& fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
853 /* Scan back COUNT frames to the specified frame. */
854 for (i
= 0; i
< count
; i
++)
856 /* Assume the dynamic chain pointer is in the word that the
857 frame address points to, unless otherwise specified. */
858 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
859 tem
= memory_address (Pmode
, tem
);
860 tem
= gen_frame_mem (Pmode
, tem
);
861 tem
= copy_to_reg (tem
);
864 /* For __builtin_frame_address, return what we've got. But, on
865 the SPARC for example, we may have to add a bias. */
866 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
867 return FRAME_ADDR_RTX (tem
);
869 /* For __builtin_return_address, get the return address from that frame. */
870 #ifdef RETURN_ADDR_RTX
871 tem
= RETURN_ADDR_RTX (count
, tem
);
873 tem
= memory_address (Pmode
,
874 plus_constant (Pmode
, tem
, GET_MODE_SIZE (Pmode
)));
875 tem
= gen_frame_mem (Pmode
, tem
);
880 /* Alias set used for setjmp buffer. */
881 static alias_set_type setjmp_alias_set
= -1;
883 /* Construct the leading half of a __builtin_setjmp call. Control will
884 return to RECEIVER_LABEL. This is also called directly by the SJLJ
885 exception handling code. */
888 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
890 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
894 if (setjmp_alias_set
== -1)
895 setjmp_alias_set
= new_alias_set ();
897 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
899 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
901 /* We store the frame pointer and the address of receiver_label in
902 the buffer and use the rest of it for the stack save area, which
903 is machine-dependent. */
905 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
906 set_mem_alias_set (mem
, setjmp_alias_set
);
907 emit_move_insn (mem
, hard_frame_pointer_rtx
);
909 mem
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
910 GET_MODE_SIZE (Pmode
))),
911 set_mem_alias_set (mem
, setjmp_alias_set
);
913 emit_move_insn (validize_mem (mem
),
914 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
916 stack_save
= gen_rtx_MEM (sa_mode
,
917 plus_constant (Pmode
, buf_addr
,
918 2 * GET_MODE_SIZE (Pmode
)));
919 set_mem_alias_set (stack_save
, setjmp_alias_set
);
920 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
922 /* If there is further processing to do, do it. */
923 if (targetm
.have_builtin_setjmp_setup ())
924 emit_insn (targetm
.gen_builtin_setjmp_setup (buf_addr
));
926 /* We have a nonlocal label. */
927 cfun
->has_nonlocal_label
= 1;
930 /* Construct the trailing part of a __builtin_setjmp call. This is
931 also called directly by the SJLJ exception handling code.
932 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
935 expand_builtin_setjmp_receiver (rtx receiver_label
)
939 /* Mark the FP as used when we get here, so we have to make sure it's
940 marked as used by this function. */
941 emit_use (hard_frame_pointer_rtx
);
943 /* Mark the static chain as clobbered here so life information
944 doesn't get messed up for it. */
945 chain
= rtx_for_static_chain (current_function_decl
, true);
946 if (chain
&& REG_P (chain
))
947 emit_clobber (chain
);
949 if (!HARD_FRAME_POINTER_IS_ARG_POINTER
&& fixed_regs
[ARG_POINTER_REGNUM
])
951 /* If the argument pointer can be eliminated in favor of the
952 frame pointer, we don't need to restore it. We assume here
953 that if such an elimination is present, it can always be used.
954 This is the case on all known machines; if we don't make this
955 assumption, we do unnecessary saving on many machines. */
957 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
959 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
960 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
961 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
964 if (i
== ARRAY_SIZE (elim_regs
))
966 /* Now restore our arg pointer from the address at which it
967 was saved in our stack frame. */
968 emit_move_insn (crtl
->args
.internal_arg_pointer
,
969 copy_to_reg (get_arg_pointer_save_area ()));
973 if (receiver_label
!= NULL
&& targetm
.have_builtin_setjmp_receiver ())
974 emit_insn (targetm
.gen_builtin_setjmp_receiver (receiver_label
));
975 else if (targetm
.have_nonlocal_goto_receiver ())
976 emit_insn (targetm
.gen_nonlocal_goto_receiver ());
980 /* We must not allow the code we just generated to be reordered by
981 scheduling. Specifically, the update of the frame pointer must
982 happen immediately, not later. */
983 emit_insn (gen_blockage ());
986 /* __builtin_longjmp is passed a pointer to an array of five words (not
987 all will be used on all machines). It operates similarly to the C
988 library function of the same name, but is more efficient. Much of
989 the code below is copied from the handling of non-local gotos. */
992 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
995 rtx_insn
*insn
, *last
;
996 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
998 /* DRAP is needed for stack realign if longjmp is expanded to current
1000 if (SUPPORTS_STACK_ALIGNMENT
)
1001 crtl
->need_drap
= true;
1003 if (setjmp_alias_set
== -1)
1004 setjmp_alias_set
= new_alias_set ();
1006 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
1008 buf_addr
= force_reg (Pmode
, buf_addr
);
1010 /* We require that the user must pass a second argument of 1, because
1011 that is what builtin_setjmp will return. */
1012 gcc_assert (value
== const1_rtx
);
1014 last
= get_last_insn ();
1015 if (targetm
.have_builtin_longjmp ())
1016 emit_insn (targetm
.gen_builtin_longjmp (buf_addr
));
1019 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
1020 lab
= gen_rtx_MEM (Pmode
, plus_constant (Pmode
, buf_addr
,
1021 GET_MODE_SIZE (Pmode
)));
1023 stack
= gen_rtx_MEM (sa_mode
, plus_constant (Pmode
, buf_addr
,
1024 2 * GET_MODE_SIZE (Pmode
)));
1025 set_mem_alias_set (fp
, setjmp_alias_set
);
1026 set_mem_alias_set (lab
, setjmp_alias_set
);
1027 set_mem_alias_set (stack
, setjmp_alias_set
);
1029 /* Pick up FP, label, and SP from the block and jump. This code is
1030 from expand_goto in stmt.cc; see there for detailed comments. */
1031 if (targetm
.have_nonlocal_goto ())
1032 /* We have to pass a value to the nonlocal_goto pattern that will
1033 get copied into the static_chain pointer, but it does not matter
1034 what that value is, because builtin_setjmp does not use it. */
1035 emit_insn (targetm
.gen_nonlocal_goto (value
, lab
, stack
, fp
));
1038 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1039 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1041 lab
= copy_to_reg (lab
);
1043 /* Restore the frame pointer and stack pointer. We must use a
1044 temporary since the setjmp buffer may be a local. */
1045 fp
= copy_to_reg (fp
);
1046 emit_stack_restore (SAVE_NONLOCAL
, stack
);
1048 /* Ensure the frame pointer move is not optimized. */
1049 emit_insn (gen_blockage ());
1050 emit_clobber (hard_frame_pointer_rtx
);
1051 emit_clobber (frame_pointer_rtx
);
1052 emit_move_insn (hard_frame_pointer_rtx
, fp
);
1054 emit_use (hard_frame_pointer_rtx
);
1055 emit_use (stack_pointer_rtx
);
1056 emit_indirect_jump (lab
);
1060 /* Search backwards and mark the jump insn as a non-local goto.
1061 Note that this precludes the use of __builtin_longjmp to a
1062 __builtin_setjmp target in the same function. However, we've
1063 already cautioned the user that these functions are for
1064 internal exception handling use only. */
1065 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1067 gcc_assert (insn
!= last
);
1071 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1074 else if (CALL_P (insn
))
1080 more_const_call_expr_args_p (const const_call_expr_arg_iterator
*iter
)
1082 return (iter
->i
< iter
->n
);
1085 /* This function validates the types of a function call argument list
1086 against a specified list of tree_codes. If the last specifier is a 0,
1087 that represents an ellipsis, otherwise the last specifier must be a
1091 validate_arglist (const_tree callexpr
, ...)
1093 enum tree_code code
;
1096 const_call_expr_arg_iterator iter
;
1099 va_start (ap
, callexpr
);
1100 init_const_call_expr_arg_iterator (callexpr
, &iter
);
1102 /* Get a bitmap of pointer argument numbers declared attribute nonnull. */
1103 tree fn
= CALL_EXPR_FN (callexpr
);
1104 bitmap argmap
= get_nonnull_args (TREE_TYPE (TREE_TYPE (fn
)));
1106 for (unsigned argno
= 1; ; ++argno
)
1108 code
= (enum tree_code
) va_arg (ap
, int);
1113 /* This signifies an ellipses, any further arguments are all ok. */
1117 /* This signifies an endlink, if no arguments remain, return
1118 true, otherwise return false. */
1119 res
= !more_const_call_expr_args_p (&iter
);
1122 /* The actual argument must be nonnull when either the whole
1123 called function has been declared nonnull, or when the formal
1124 argument corresponding to the actual argument has been. */
1126 && (bitmap_empty_p (argmap
) || bitmap_bit_p (argmap
, argno
)))
1128 arg
= next_const_call_expr_arg (&iter
);
1129 if (!validate_arg (arg
, code
) || integer_zerop (arg
))
1135 /* If no parameters remain or the parameter's code does not
1136 match the specified code, return false. Otherwise continue
1137 checking any remaining arguments. */
1138 arg
= next_const_call_expr_arg (&iter
);
1139 if (!validate_arg (arg
, code
))
1145 /* We need gotos here since we can only have one VA_CLOSE in a
1150 BITMAP_FREE (argmap
);
1155 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1156 and the address of the save area. */
1159 expand_builtin_nonlocal_goto (tree exp
)
1161 tree t_label
, t_save_area
;
1162 rtx r_label
, r_save_area
, r_fp
, r_sp
;
1165 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1168 t_label
= CALL_EXPR_ARG (exp
, 0);
1169 t_save_area
= CALL_EXPR_ARG (exp
, 1);
1171 r_label
= expand_normal (t_label
);
1172 r_label
= convert_memory_address (Pmode
, r_label
);
1173 r_save_area
= expand_normal (t_save_area
);
1174 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
1175 /* Copy the address of the save location to a register just in case it was
1176 based on the frame pointer. */
1177 r_save_area
= copy_to_reg (r_save_area
);
1178 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
1179 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
1180 plus_constant (Pmode
, r_save_area
,
1181 GET_MODE_SIZE (Pmode
)));
1183 crtl
->has_nonlocal_goto
= 1;
1185 /* ??? We no longer need to pass the static chain value, afaik. */
1186 if (targetm
.have_nonlocal_goto ())
1187 emit_insn (targetm
.gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
1190 emit_clobber (gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
)));
1191 emit_clobber (gen_rtx_MEM (BLKmode
, hard_frame_pointer_rtx
));
1193 r_label
= copy_to_reg (r_label
);
1195 /* Restore the frame pointer and stack pointer. We must use a
1196 temporary since the setjmp buffer may be a local. */
1197 r_fp
= copy_to_reg (r_fp
);
1198 emit_stack_restore (SAVE_NONLOCAL
, r_sp
);
1200 /* Ensure the frame pointer move is not optimized. */
1201 emit_insn (gen_blockage ());
1202 emit_clobber (hard_frame_pointer_rtx
);
1203 emit_clobber (frame_pointer_rtx
);
1204 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
1206 /* USE of hard_frame_pointer_rtx added for consistency;
1207 not clear if really needed. */
1208 emit_use (hard_frame_pointer_rtx
);
1209 emit_use (stack_pointer_rtx
);
1211 /* If the architecture is using a GP register, we must
1212 conservatively assume that the target function makes use of it.
1213 The prologue of functions with nonlocal gotos must therefore
1214 initialize the GP register to the appropriate value, and we
1215 must then make sure that this value is live at the point
1216 of the jump. (Note that this doesn't necessarily apply
1217 to targets with a nonlocal_goto pattern; they are free
1218 to implement it in their own way. Note also that this is
1219 a no-op if the GP register is a global invariant.) */
1220 unsigned regnum
= PIC_OFFSET_TABLE_REGNUM
;
1221 if (regnum
!= INVALID_REGNUM
&& fixed_regs
[regnum
])
1222 emit_use (pic_offset_table_rtx
);
1224 emit_indirect_jump (r_label
);
1227 /* Search backwards to the jump insn and mark it as a
1229 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
1233 add_reg_note (insn
, REG_NON_LOCAL_GOTO
, const0_rtx
);
1236 else if (CALL_P (insn
))
1243 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1244 (not all will be used on all machines) that was passed to __builtin_setjmp.
1245 It updates the stack pointer in that block to the current value. This is
1246 also called directly by the SJLJ exception handling code. */
1249 expand_builtin_update_setjmp_buf (rtx buf_addr
)
1251 machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
1252 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
1254 = gen_rtx_MEM (sa_mode
,
1257 plus_constant (Pmode
, buf_addr
,
1258 2 * GET_MODE_SIZE (Pmode
))));
1260 emit_stack_save (SAVE_NONLOCAL
, &stack_save
);
1263 /* Expand a call to __builtin_prefetch. For a target that does not support
1264 data prefetch, evaluate the memory address argument in case it has side
1268 expand_builtin_prefetch (tree exp
)
1270 tree arg0
, arg1
, arg2
;
1274 if (!validate_arglist (exp
, POINTER_TYPE
, 0))
1277 arg0
= CALL_EXPR_ARG (exp
, 0);
1279 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1280 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1282 nargs
= call_expr_nargs (exp
);
1284 arg1
= CALL_EXPR_ARG (exp
, 1);
1286 arg1
= integer_zero_node
;
1288 arg2
= CALL_EXPR_ARG (exp
, 2);
1290 arg2
= integer_three_node
;
1292 /* Argument 0 is an address. */
1293 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
1295 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1296 if (TREE_CODE (arg1
) != INTEGER_CST
)
1298 error ("second argument to %<__builtin_prefetch%> must be a constant");
1299 arg1
= integer_zero_node
;
1301 op1
= expand_normal (arg1
);
1302 /* Argument 1 must be either zero or one. */
1303 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
1305 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1310 /* Argument 2 (locality) must be a compile-time constant int. */
1311 if (TREE_CODE (arg2
) != INTEGER_CST
)
1313 error ("third argument to %<__builtin_prefetch%> must be a constant");
1314 arg2
= integer_zero_node
;
1316 op2
= expand_normal (arg2
);
1317 /* Argument 2 must be 0, 1, 2, or 3. */
1318 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
1320 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1324 if (targetm
.have_prefetch ())
1326 class expand_operand ops
[3];
1328 create_address_operand (&ops
[0], op0
);
1329 create_integer_operand (&ops
[1], INTVAL (op1
));
1330 create_integer_operand (&ops
[2], INTVAL (op2
));
1331 if (maybe_expand_insn (targetm
.code_for_prefetch
, 3, ops
))
1335 /* Don't do anything with direct references to volatile memory, but
1336 generate code to handle other side effects. */
1337 if (!MEM_P (op0
) && side_effects_p (op0
))
1341 /* Get a MEM rtx for expression EXP which is the address of an operand
1342 to be used in a string instruction (cmpstrsi, cpymemsi, ..). LEN is
1343 the maximum length of the block of memory that might be accessed or
1347 get_memory_rtx (tree exp
, tree len
)
1349 tree orig_exp
= exp
, base
;
1353 (ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))));
1355 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1356 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1357 if (TREE_CODE (exp
) == SAVE_EXPR
&& !SAVE_EXPR_RESOLVED_P (exp
))
1358 exp
= TREE_OPERAND (exp
, 0);
1360 addr
= expand_expr (orig_exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1361 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1363 /* Get an expression we can use to find the attributes to assign to MEM.
1364 First remove any nops. */
1365 while (CONVERT_EXPR_P (exp
)
1366 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1367 exp
= TREE_OPERAND (exp
, 0);
1369 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1370 (as builtin stringops may alias with anything). */
1371 exp
= fold_build2 (MEM_REF
,
1372 build_array_type (char_type_node
,
1373 build_range_type (sizetype
,
1374 size_one_node
, len
)),
1375 exp
, build_int_cst (ptr_type_node
, 0));
1377 /* If the MEM_REF has no acceptable address, try to get the base object
1378 from the original address we got, and build an all-aliasing
1379 unknown-sized access to that one. */
1380 if (is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
1381 set_mem_attributes (mem
, exp
, 0);
1382 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
1383 && (base
= get_base_address (TREE_OPERAND (TREE_OPERAND (exp
, 0),
1386 unsigned int align
= get_pointer_alignment (TREE_OPERAND (exp
, 0));
1387 exp
= build_fold_addr_expr (base
);
1388 exp
= fold_build2 (MEM_REF
,
1389 build_array_type (char_type_node
,
1390 build_range_type (sizetype
,
1393 exp
, build_int_cst (ptr_type_node
, 0));
1394 set_mem_attributes (mem
, exp
, 0);
1395 /* Since we stripped parts make sure the offset is unknown and the
1396 alignment is computed from the original address. */
1397 clear_mem_offset (mem
);
1398 set_mem_align (mem
, align
);
1400 set_mem_alias_set (mem
, 0);
1404 /* Built-in functions to perform an untyped call and return. */
1406 /* Wrapper that implicitly applies a delta when getting or setting the
1408 template <typename T
>
1411 T
&value
; T
const delta
;
1413 delta_type (T
&val
, T dlt
) : value (val
), delta (dlt
) {}
1414 operator T () const { return value
+ delta
; }
1415 T
operator = (T val
) const { value
= val
- delta
; return val
; }
1418 #define saved_apply_args_size \
1419 (delta_type<int> (this_target_builtins->x_apply_args_size_plus_one, -1))
1420 #define apply_args_mode \
1421 (this_target_builtins->x_apply_args_mode)
1422 #define saved_apply_result_size \
1423 (delta_type<int> (this_target_builtins->x_apply_result_size_plus_one, -1))
1424 #define apply_result_mode \
1425 (this_target_builtins->x_apply_result_mode)
1427 /* Return the size required for the block returned by __builtin_apply_args,
1428 and initialize apply_args_mode. */
1431 apply_args_size (void)
1433 int size
= saved_apply_args_size
;
1437 /* The values computed by this function never change. */
1440 /* The first value is the incoming arg-pointer. */
1441 size
= GET_MODE_SIZE (Pmode
);
1443 /* The second value is the structure value address unless this is
1444 passed as an "invisible" first argument. */
1445 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1446 size
+= GET_MODE_SIZE (Pmode
);
1448 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1449 if (FUNCTION_ARG_REGNO_P (regno
))
1451 fixed_size_mode mode
= targetm
.calls
.get_raw_arg_mode (regno
);
1453 if (mode
!= VOIDmode
)
1455 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1456 if (size
% align
!= 0)
1457 size
= CEIL (size
, align
) * align
;
1458 size
+= GET_MODE_SIZE (mode
);
1459 apply_args_mode
[regno
] = mode
;
1462 apply_args_mode
[regno
] = as_a
<fixed_size_mode
> (VOIDmode
);
1465 apply_args_mode
[regno
] = as_a
<fixed_size_mode
> (VOIDmode
);
1467 saved_apply_args_size
= size
;
1472 /* Return the size required for the block returned by __builtin_apply,
1473 and initialize apply_result_mode. */
1476 apply_result_size (void)
1478 int size
= saved_apply_result_size
;
1481 /* The values computed by this function never change. */
1486 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1487 if (targetm
.calls
.function_value_regno_p (regno
))
1489 fixed_size_mode mode
= targetm
.calls
.get_raw_result_mode (regno
);
1491 if (mode
!= VOIDmode
)
1493 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1494 if (size
% align
!= 0)
1495 size
= CEIL (size
, align
) * align
;
1496 size
+= GET_MODE_SIZE (mode
);
1497 apply_result_mode
[regno
] = mode
;
1500 apply_result_mode
[regno
] = as_a
<fixed_size_mode
> (VOIDmode
);
1503 apply_result_mode
[regno
] = as_a
<fixed_size_mode
> (VOIDmode
);
1505 /* Allow targets that use untyped_call and untyped_return to override
1506 the size so that machine-specific information can be stored here. */
1507 #ifdef APPLY_RESULT_SIZE
1508 size
= APPLY_RESULT_SIZE
;
1511 saved_apply_result_size
= size
;
1516 /* Create a vector describing the result block RESULT. If SAVEP is true,
1517 the result block is used to save the values; otherwise it is used to
1518 restore the values. */
1521 result_vector (int savep
, rtx result
)
1523 int regno
, size
, align
, nelts
;
1524 fixed_size_mode mode
;
1526 rtx
*savevec
= XALLOCAVEC (rtx
, FIRST_PSEUDO_REGISTER
);
1529 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1530 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1532 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1533 if (size
% align
!= 0)
1534 size
= CEIL (size
, align
) * align
;
1535 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1536 mem
= adjust_address (result
, mode
, size
);
1537 savevec
[nelts
++] = (savep
1538 ? gen_rtx_SET (mem
, reg
)
1539 : gen_rtx_SET (reg
, mem
));
1540 size
+= GET_MODE_SIZE (mode
);
1542 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1545 /* Save the state required to perform an untyped call with the same
1546 arguments as were passed to the current function. */
1549 expand_builtin_apply_args_1 (void)
1552 int size
, align
, regno
;
1553 fixed_size_mode mode
;
1554 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1556 /* Create a block where the arg-pointer, structure value address,
1557 and argument registers can be saved. */
1558 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1560 /* Walk past the arg-pointer and structure value address. */
1561 size
= GET_MODE_SIZE (Pmode
);
1562 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1563 size
+= GET_MODE_SIZE (Pmode
);
1565 /* Save each register used in calling a function to the block. */
1566 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1567 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1569 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1570 if (size
% align
!= 0)
1571 size
= CEIL (size
, align
) * align
;
1573 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1575 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1576 size
+= GET_MODE_SIZE (mode
);
1579 /* Save the arg pointer to the block. */
1580 tem
= copy_to_reg (crtl
->args
.internal_arg_pointer
);
1581 /* We need the pointer as the caller actually passed them to us, not
1582 as we might have pretended they were passed. Make sure it's a valid
1583 operand, as emit_move_insn isn't expected to handle a PLUS. */
1584 if (STACK_GROWS_DOWNWARD
)
1586 = force_operand (plus_constant (Pmode
, tem
,
1587 crtl
->args
.pretend_args_size
),
1589 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1591 size
= GET_MODE_SIZE (Pmode
);
1593 /* Save the structure value address unless this is passed as an
1594 "invisible" first argument. */
1595 if (struct_incoming_value
)
1596 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1597 copy_to_reg (struct_incoming_value
));
1599 /* Return the address of the block. */
1600 return copy_addr_to_reg (XEXP (registers
, 0));
1603 /* __builtin_apply_args returns block of memory allocated on
1604 the stack into which is stored the arg pointer, structure
1605 value address, static chain, and all the registers that might
1606 possibly be used in performing a function call. The code is
1607 moved to the start of the function so the incoming values are
1611 expand_builtin_apply_args (void)
1613 /* Don't do __builtin_apply_args more than once in a function.
1614 Save the result of the first call and reuse it. */
1615 if (apply_args_value
!= 0)
1616 return apply_args_value
;
1618 /* When this function is called, it means that registers must be
1619 saved on entry to this function. So we migrate the
1620 call to the first insn of this function. */
1624 temp
= expand_builtin_apply_args_1 ();
1625 rtx_insn
*seq
= get_insns ();
1628 apply_args_value
= temp
;
1630 /* Put the insns after the NOTE that starts the function.
1631 If this is inside a start_sequence, make the outer-level insn
1632 chain current, so the code is placed at the start of the
1633 function. If internal_arg_pointer is a non-virtual pseudo,
1634 it needs to be placed after the function that initializes
1636 push_topmost_sequence ();
1637 if (REG_P (crtl
->args
.internal_arg_pointer
)
1638 && REGNO (crtl
->args
.internal_arg_pointer
) > LAST_VIRTUAL_REGISTER
)
1639 emit_insn_before (seq
, parm_birth_insn
);
1641 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1642 pop_topmost_sequence ();
1647 /* Perform an untyped call and save the state required to perform an
1648 untyped return of whatever value was returned by the given function. */
1651 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1653 int size
, align
, regno
;
1654 fixed_size_mode mode
;
1655 rtx incoming_args
, result
, reg
, dest
, src
;
1656 rtx_call_insn
*call_insn
;
1657 rtx old_stack_level
= 0;
1658 rtx call_fusage
= 0;
1659 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1661 arguments
= convert_memory_address (Pmode
, arguments
);
1663 /* Create a block where the return registers can be saved. */
1664 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1666 /* Fetch the arg pointer from the ARGUMENTS block. */
1667 incoming_args
= gen_reg_rtx (Pmode
);
1668 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1669 if (!STACK_GROWS_DOWNWARD
)
1670 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1671 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1673 /* Push a new argument block and copy the arguments. Do not allow
1674 the (potential) memcpy call below to interfere with our stack
1676 do_pending_stack_adjust ();
1679 /* Save the stack with nonlocal if available. */
1680 if (targetm
.have_save_stack_nonlocal ())
1681 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
);
1683 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
1685 /* Allocate a block of memory onto the stack and copy the memory
1686 arguments to the outgoing arguments address. We can pass TRUE
1687 as the 4th argument because we just saved the stack pointer
1688 and will restore it right after the call. */
1689 allocate_dynamic_stack_space (argsize
, 0, BIGGEST_ALIGNMENT
, -1, true);
1691 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1692 may have already set current_function_calls_alloca to true.
1693 current_function_calls_alloca won't be set if argsize is zero,
1694 so we have to guarantee need_drap is true here. */
1695 if (SUPPORTS_STACK_ALIGNMENT
)
1696 crtl
->need_drap
= true;
1698 dest
= virtual_outgoing_args_rtx
;
1699 if (!STACK_GROWS_DOWNWARD
)
1701 if (CONST_INT_P (argsize
))
1702 dest
= plus_constant (Pmode
, dest
, -INTVAL (argsize
));
1704 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1706 dest
= gen_rtx_MEM (BLKmode
, dest
);
1707 set_mem_align (dest
, PARM_BOUNDARY
);
1708 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1709 set_mem_align (src
, PARM_BOUNDARY
);
1710 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1712 /* Refer to the argument block. */
1714 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1715 set_mem_align (arguments
, PARM_BOUNDARY
);
1717 /* Walk past the arg-pointer and structure value address. */
1718 size
= GET_MODE_SIZE (Pmode
);
1720 size
+= GET_MODE_SIZE (Pmode
);
1722 /* Restore each of the registers previously saved. Make USE insns
1723 for each of these registers for use in making the call. */
1724 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1725 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1727 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1728 if (size
% align
!= 0)
1729 size
= CEIL (size
, align
) * align
;
1730 reg
= gen_rtx_REG (mode
, regno
);
1731 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1732 use_reg (&call_fusage
, reg
);
1733 size
+= GET_MODE_SIZE (mode
);
1736 /* Restore the structure value address unless this is passed as an
1737 "invisible" first argument. */
1738 size
= GET_MODE_SIZE (Pmode
);
1741 rtx value
= gen_reg_rtx (Pmode
);
1742 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1743 emit_move_insn (struct_value
, value
);
1744 if (REG_P (struct_value
))
1745 use_reg (&call_fusage
, struct_value
);
1748 /* All arguments and registers used for the call are set up by now! */
1749 function
= prepare_call_address (NULL
, function
, NULL
, &call_fusage
, 0, 0);
1751 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1752 and we don't want to load it into a register as an optimization,
1753 because prepare_call_address already did it if it should be done. */
1754 if (GET_CODE (function
) != SYMBOL_REF
)
1755 function
= memory_address (FUNCTION_MODE
, function
);
1757 /* Generate the actual call instruction and save the return value. */
1758 if (targetm
.have_untyped_call ())
1760 rtx mem
= gen_rtx_MEM (FUNCTION_MODE
, function
);
1761 rtx_insn
*seq
= targetm
.gen_untyped_call (mem
, result
,
1762 result_vector (1, result
));
1763 for (rtx_insn
*insn
= seq
; insn
; insn
= NEXT_INSN (insn
))
1765 add_reg_note (insn
, REG_UNTYPED_CALL
, NULL_RTX
);
1768 else if (targetm
.have_call_value ())
1772 /* Locate the unique return register. It is not possible to
1773 express a call that sets more than one return register using
1774 call_value; use untyped_call for that. In fact, untyped_call
1775 only needs to save the return registers in the given block. */
1776 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1777 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1779 gcc_assert (!valreg
); /* have_untyped_call required. */
1781 valreg
= gen_rtx_REG (mode
, regno
);
1784 emit_insn (targetm
.gen_call_value (valreg
,
1785 gen_rtx_MEM (FUNCTION_MODE
, function
),
1786 const0_rtx
, NULL_RTX
, const0_rtx
));
1788 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1793 /* Find the CALL insn we just emitted, and attach the register usage
1795 call_insn
= last_call_insn ();
1796 add_function_usage_to (call_insn
, call_fusage
);
1798 /* Restore the stack. */
1799 if (targetm
.have_save_stack_nonlocal ())
1800 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
);
1802 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
1803 fixup_args_size_notes (call_insn
, get_last_insn (), 0);
1807 /* Return the address of the result block. */
1808 result
= copy_addr_to_reg (XEXP (result
, 0));
1809 return convert_memory_address (ptr_mode
, result
);
1812 /* Perform an untyped return. */
1815 expand_builtin_return (rtx result
)
1817 int size
, align
, regno
;
1818 fixed_size_mode mode
;
1820 rtx_insn
*call_fusage
= 0;
1822 result
= convert_memory_address (Pmode
, result
);
1824 apply_result_size ();
1825 result
= gen_rtx_MEM (BLKmode
, result
);
1827 if (targetm
.have_untyped_return ())
1829 rtx vector
= result_vector (0, result
);
1830 emit_jump_insn (targetm
.gen_untyped_return (result
, vector
));
1835 /* Restore the return value and note that each value is used. */
1837 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1838 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1840 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1841 if (size
% align
!= 0)
1842 size
= CEIL (size
, align
) * align
;
1843 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1844 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1846 push_to_sequence (call_fusage
);
1848 call_fusage
= get_insns ();
1850 size
+= GET_MODE_SIZE (mode
);
1853 /* Put the USE insns before the return. */
1854 emit_insn (call_fusage
);
1856 /* Return whatever values was restored by jumping directly to the end
1858 expand_naked_return ();
1861 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1864 type_to_class (tree type
)
1866 switch (TREE_CODE (type
))
1868 case VOID_TYPE
: return void_type_class
;
1869 case INTEGER_TYPE
: return integer_type_class
;
1870 case ENUMERAL_TYPE
: return enumeral_type_class
;
1871 case BOOLEAN_TYPE
: return boolean_type_class
;
1872 case POINTER_TYPE
: return pointer_type_class
;
1873 case REFERENCE_TYPE
: return reference_type_class
;
1874 case OFFSET_TYPE
: return offset_type_class
;
1875 case REAL_TYPE
: return real_type_class
;
1876 case COMPLEX_TYPE
: return complex_type_class
;
1877 case FUNCTION_TYPE
: return function_type_class
;
1878 case METHOD_TYPE
: return method_type_class
;
1879 case RECORD_TYPE
: return record_type_class
;
1881 case QUAL_UNION_TYPE
: return union_type_class
;
1882 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1883 ? string_type_class
: array_type_class
);
1884 case LANG_TYPE
: return lang_type_class
;
1885 case OPAQUE_TYPE
: return opaque_type_class
;
1886 case BITINT_TYPE
: return bitint_type_class
;
1887 case VECTOR_TYPE
: return vector_type_class
;
1888 default: return no_type_class
;
1892 /* Expand a call EXP to __builtin_classify_type. */
1895 expand_builtin_classify_type (tree exp
)
1897 if (call_expr_nargs (exp
))
1898 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))));
1899 return GEN_INT (no_type_class
);
1902 /* This helper macro, meant to be used in mathfn_built_in below, determines
1903 which among a set of builtin math functions is appropriate for a given type
1904 mode. The `F' (float) and `L' (long double) are automatically generated
1905 from the 'double' case. If a function supports the _Float<N> and _Float<N>X
1906 types, there are additional types that are considered with 'F32', 'F64',
1907 'F128', etc. suffixes. */
1908 #define CASE_MATHFN(MATHFN) \
1909 CASE_CFN_##MATHFN: \
1910 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1911 fcodel = BUILT_IN_##MATHFN##L ; break;
1912 /* Similar to the above, but also add support for the _Float<N> and _Float<N>X
1914 #define CASE_MATHFN_FLOATN(MATHFN) \
1915 CASE_CFN_##MATHFN: \
1916 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1917 fcodel = BUILT_IN_##MATHFN##L ; fcodef16 = BUILT_IN_##MATHFN##F16 ; \
1918 fcodef32 = BUILT_IN_##MATHFN##F32; fcodef64 = BUILT_IN_##MATHFN##F64 ; \
1919 fcodef128 = BUILT_IN_##MATHFN##F128 ; fcodef32x = BUILT_IN_##MATHFN##F32X ; \
1920 fcodef64x = BUILT_IN_##MATHFN##F64X ; fcodef128x = BUILT_IN_##MATHFN##F128X ;\
1922 /* Similar to above, but appends _R after any F/L suffix. */
1923 #define CASE_MATHFN_REENT(MATHFN) \
1924 case CFN_BUILT_IN_##MATHFN##_R: \
1925 case CFN_BUILT_IN_##MATHFN##F_R: \
1926 case CFN_BUILT_IN_##MATHFN##L_R: \
1927 fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \
1928 fcodel = BUILT_IN_##MATHFN##L_R ; break;
1930 /* Return a function equivalent to FN but operating on floating-point
1931 values of type TYPE, or END_BUILTINS if no such function exists.
1932 This is purely an operation on function codes; it does not guarantee
1933 that the target actually has an implementation of the function. */
1935 static built_in_function
1936 mathfn_built_in_2 (tree type
, combined_fn fn
)
1939 built_in_function fcode
, fcodef
, fcodel
;
1940 built_in_function fcodef16
= END_BUILTINS
;
1941 built_in_function fcodef32
= END_BUILTINS
;
1942 built_in_function fcodef64
= END_BUILTINS
;
1943 built_in_function fcodef128
= END_BUILTINS
;
1944 built_in_function fcodef32x
= END_BUILTINS
;
1945 built_in_function fcodef64x
= END_BUILTINS
;
1946 built_in_function fcodef128x
= END_BUILTINS
;
1948 /* If <math.h> has been included somehow, HUGE_VAL and NAN definitions
1949 break the uses below. */
1955 #define SEQ_OF_CASE_MATHFN \
1956 CASE_MATHFN_FLOATN (ACOS) \
1957 CASE_MATHFN_FLOATN (ACOSH) \
1958 CASE_MATHFN_FLOATN (ASIN) \
1959 CASE_MATHFN_FLOATN (ASINH) \
1960 CASE_MATHFN_FLOATN (ATAN) \
1961 CASE_MATHFN_FLOATN (ATAN2) \
1962 CASE_MATHFN_FLOATN (ATANH) \
1963 CASE_MATHFN_FLOATN (CBRT) \
1964 CASE_MATHFN_FLOATN (CEIL) \
1965 CASE_MATHFN (CEXPI) \
1966 CASE_MATHFN_FLOATN (COPYSIGN) \
1967 CASE_MATHFN_FLOATN (COS) \
1968 CASE_MATHFN_FLOATN (COSH) \
1969 CASE_MATHFN (DREM) \
1970 CASE_MATHFN_FLOATN (ERF) \
1971 CASE_MATHFN_FLOATN (ERFC) \
1972 CASE_MATHFN_FLOATN (EXP) \
1973 CASE_MATHFN (EXP10) \
1974 CASE_MATHFN_FLOATN (EXP2) \
1975 CASE_MATHFN_FLOATN (EXPM1) \
1976 CASE_MATHFN_FLOATN (FABS) \
1977 CASE_MATHFN_FLOATN (FDIM) \
1978 CASE_MATHFN_FLOATN (FLOOR) \
1979 CASE_MATHFN_FLOATN (FMA) \
1980 CASE_MATHFN_FLOATN (FMAX) \
1981 CASE_MATHFN_FLOATN (FMIN) \
1982 CASE_MATHFN_FLOATN (FMOD) \
1983 CASE_MATHFN_FLOATN (FREXP) \
1984 CASE_MATHFN (GAMMA) \
1985 CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */ \
1986 CASE_MATHFN_FLOATN (HUGE_VAL) \
1987 CASE_MATHFN_FLOATN (HYPOT) \
1988 CASE_MATHFN_FLOATN (ILOGB) \
1989 CASE_MATHFN (ICEIL) \
1990 CASE_MATHFN (IFLOOR) \
1991 CASE_MATHFN_FLOATN (INF) \
1992 CASE_MATHFN (IRINT) \
1993 CASE_MATHFN (IROUND) \
1994 CASE_MATHFN (ISINF) \
1998 CASE_MATHFN (LCEIL) \
1999 CASE_MATHFN_FLOATN (LDEXP) \
2000 CASE_MATHFN (LFLOOR) \
2001 CASE_MATHFN_FLOATN (LGAMMA) \
2002 CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */ \
2003 CASE_MATHFN (LLCEIL) \
2004 CASE_MATHFN (LLFLOOR) \
2005 CASE_MATHFN_FLOATN (LLRINT) \
2006 CASE_MATHFN_FLOATN (LLROUND) \
2007 CASE_MATHFN_FLOATN (LOG) \
2008 CASE_MATHFN_FLOATN (LOG10) \
2009 CASE_MATHFN_FLOATN (LOG1P) \
2010 CASE_MATHFN_FLOATN (LOG2) \
2011 CASE_MATHFN_FLOATN (LOGB) \
2012 CASE_MATHFN_FLOATN (LRINT) \
2013 CASE_MATHFN_FLOATN (LROUND) \
2014 CASE_MATHFN_FLOATN (MODF) \
2015 CASE_MATHFN_FLOATN (NAN) \
2016 CASE_MATHFN_FLOATN (NANS) \
2017 CASE_MATHFN_FLOATN (NEARBYINT) \
2018 CASE_MATHFN_FLOATN (NEXTAFTER) \
2019 CASE_MATHFN (NEXTTOWARD) \
2020 CASE_MATHFN_FLOATN (POW) \
2021 CASE_MATHFN (POWI) \
2022 CASE_MATHFN (POW10) \
2023 CASE_MATHFN_FLOATN (REMAINDER) \
2024 CASE_MATHFN_FLOATN (REMQUO) \
2025 CASE_MATHFN_FLOATN (RINT) \
2026 CASE_MATHFN_FLOATN (ROUND) \
2027 CASE_MATHFN_FLOATN (ROUNDEVEN) \
2028 CASE_MATHFN (SCALB) \
2029 CASE_MATHFN_FLOATN (SCALBLN) \
2030 CASE_MATHFN_FLOATN (SCALBN) \
2031 CASE_MATHFN (SIGNBIT) \
2032 CASE_MATHFN (SIGNIFICAND) \
2033 CASE_MATHFN_FLOATN (SIN) \
2034 CASE_MATHFN (SINCOS) \
2035 CASE_MATHFN_FLOATN (SINH) \
2036 CASE_MATHFN_FLOATN (SQRT) \
2037 CASE_MATHFN_FLOATN (TAN) \
2038 CASE_MATHFN_FLOATN (TANH) \
2039 CASE_MATHFN_FLOATN (TGAMMA) \
2040 CASE_MATHFN_FLOATN (TRUNC) \
2048 return END_BUILTINS
;
2051 mtype
= TYPE_MAIN_VARIANT (type
);
2052 if (mtype
== double_type_node
)
2054 else if (mtype
== float_type_node
)
2056 else if (mtype
== long_double_type_node
)
2058 else if (mtype
== float16_type_node
)
2060 else if (mtype
== float32_type_node
)
2062 else if (mtype
== float64_type_node
)
2064 else if (mtype
== float128_type_node
)
2066 else if (mtype
== float32x_type_node
)
2068 else if (mtype
== float64x_type_node
)
2070 else if (mtype
== float128x_type_node
)
2073 return END_BUILTINS
;
2077 #undef CASE_MATHFN_FLOATN
2078 #undef CASE_MATHFN_REENT
2080 /* Return mathematic function equivalent to FN but operating directly on TYPE,
2081 if available. If IMPLICIT_P is true use the implicit builtin declaration,
2082 otherwise use the explicit declaration. If we can't do the conversion,
2086 mathfn_built_in_1 (tree type
, combined_fn fn
, bool implicit_p
)
2088 built_in_function fcode2
= mathfn_built_in_2 (type
, fn
);
2089 if (fcode2
== END_BUILTINS
)
2092 if (implicit_p
&& !builtin_decl_implicit_p (fcode2
))
2095 return builtin_decl_explicit (fcode2
);
2098 /* Like mathfn_built_in_1, but always use the implicit array. */
2101 mathfn_built_in (tree type
, combined_fn fn
)
2103 return mathfn_built_in_1 (type
, fn
, /*implicit=*/ 1);
2106 /* Like mathfn_built_in_1, but always use the explicit array. */
2109 mathfn_built_in_explicit (tree type
, combined_fn fn
)
2111 return mathfn_built_in_1 (type
, fn
, /*implicit=*/ 0);
2114 /* Like mathfn_built_in_1, but take a built_in_function and
2115 always use the implicit array. */
2118 mathfn_built_in (tree type
, enum built_in_function fn
)
2120 return mathfn_built_in_1 (type
, as_combined_fn (fn
), /*implicit=*/ 1);
2123 /* Return the type associated with a built in function, i.e., the one
2124 to be passed to mathfn_built_in to get the type-specific
2128 mathfn_built_in_type (combined_fn fn
)
2130 #define CASE_MATHFN(MATHFN) \
2131 case CFN_BUILT_IN_##MATHFN: \
2132 return double_type_node; \
2133 case CFN_BUILT_IN_##MATHFN##F: \
2134 return float_type_node; \
2135 case CFN_BUILT_IN_##MATHFN##L: \
2136 return long_double_type_node;
2138 #define CASE_MATHFN_FLOATN(MATHFN) \
2139 CASE_MATHFN(MATHFN) \
2140 case CFN_BUILT_IN_##MATHFN##F16: \
2141 return float16_type_node; \
2142 case CFN_BUILT_IN_##MATHFN##F32: \
2143 return float32_type_node; \
2144 case CFN_BUILT_IN_##MATHFN##F64: \
2145 return float64_type_node; \
2146 case CFN_BUILT_IN_##MATHFN##F128: \
2147 return float128_type_node; \
2148 case CFN_BUILT_IN_##MATHFN##F32X: \
2149 return float32x_type_node; \
2150 case CFN_BUILT_IN_##MATHFN##F64X: \
2151 return float64x_type_node; \
2152 case CFN_BUILT_IN_##MATHFN##F128X: \
2153 return float128x_type_node;
2155 /* Similar to above, but appends _R after any F/L suffix. */
2156 #define CASE_MATHFN_REENT(MATHFN) \
2157 case CFN_BUILT_IN_##MATHFN##_R: \
2158 return double_type_node; \
2159 case CFN_BUILT_IN_##MATHFN##F_R: \
2160 return float_type_node; \
2161 case CFN_BUILT_IN_##MATHFN##L_R: \
2162 return long_double_type_node;
2173 #undef CASE_MATHFN_FLOATN
2174 #undef CASE_MATHFN_REENT
2175 #undef SEQ_OF_CASE_MATHFN
2178 /* Check whether there is an internal function associated with function FN
2179 and return type RETURN_TYPE. Return the function if so, otherwise return
2182 Note that this function only tests whether the function is defined in
2183 internals.def, not whether it is actually available on the target. */
2186 associated_internal_fn (built_in_function fn
, tree return_type
)
2190 #define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \
2191 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME;
2192 #define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE) \
2193 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME; \
2194 CASE_FLT_FN_FLOATN_NX (BUILT_IN_##NAME): return IFN_##NAME;
2195 #define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \
2196 CASE_INT_FN (BUILT_IN_##NAME): return IFN_##NAME;
2197 #include "internal-fn.def"
2199 CASE_FLT_FN (BUILT_IN_POW10
):
2202 CASE_FLT_FN (BUILT_IN_DREM
):
2203 return IFN_REMAINDER
;
2205 CASE_FLT_FN (BUILT_IN_SCALBN
):
2206 CASE_FLT_FN (BUILT_IN_SCALBLN
):
2207 if (REAL_MODE_FORMAT (TYPE_MODE (return_type
))->b
== 2)
2216 /* If BUILT_IN_NORMAL function FNDECL has an associated internal function,
2217 return its code, otherwise return IFN_LAST. Note that this function
2218 only tests whether the function is defined in internals.def, not whether
2219 it is actually available on the target. */
2222 associated_internal_fn (tree fndecl
)
2224 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
);
2225 return associated_internal_fn (DECL_FUNCTION_CODE (fndecl
),
2226 TREE_TYPE (TREE_TYPE (fndecl
)));
2229 /* Check whether there is an internal function associated with function CFN
2230 and return type RETURN_TYPE. Return the function if so, otherwise return
2233 Note that this function only tests whether the function is defined in
2234 internals.def, not whether it is actually available on the target. */
2237 associated_internal_fn (combined_fn cfn
, tree return_type
)
2239 if (internal_fn_p (cfn
))
2240 return as_internal_fn (cfn
);
2241 return associated_internal_fn (as_builtin_fn (cfn
), return_type
);
2244 /* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced
2245 on the current target by a call to an internal function, return the
2246 code of that internal function, otherwise return IFN_LAST. The caller
2247 is responsible for ensuring that any side-effects of the built-in
2248 call are dealt with correctly. E.g. if CALL sets errno, the caller
2249 must decide that the errno result isn't needed or make it available
2250 in some other way. */
2253 replacement_internal_fn (gcall
*call
)
2255 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
))
2257 internal_fn ifn
= associated_internal_fn (gimple_call_fndecl (call
));
2258 if (ifn
!= IFN_LAST
)
2260 tree_pair types
= direct_internal_fn_types (ifn
, call
);
2261 optimization_type opt_type
= bb_optimization_type (gimple_bb (call
));
2262 if (direct_internal_fn_supported_p (ifn
, types
, opt_type
))
2269 /* Expand a call to the builtin trinary math functions (fma).
2270 Return NULL_RTX if a normal call should be emitted rather than expanding the
2271 function in-line. EXP is the expression that is a call to the builtin
2272 function; if convenient, the result should be placed in TARGET.
2273 SUBTARGET may be used as the target for computing one of EXP's
2277 expand_builtin_mathfn_ternary (tree exp
, rtx target
, rtx subtarget
)
2279 optab builtin_optab
;
2280 rtx op0
, op1
, op2
, result
;
2282 tree fndecl
= get_callee_fndecl (exp
);
2283 tree arg0
, arg1
, arg2
;
2286 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2289 arg0
= CALL_EXPR_ARG (exp
, 0);
2290 arg1
= CALL_EXPR_ARG (exp
, 1);
2291 arg2
= CALL_EXPR_ARG (exp
, 2);
2293 switch (DECL_FUNCTION_CODE (fndecl
))
2295 CASE_FLT_FN (BUILT_IN_FMA
):
2296 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMA
):
2297 builtin_optab
= fma_optab
; break;
2302 /* Make a suitable register to place result in. */
2303 mode
= TYPE_MODE (TREE_TYPE (exp
));
2305 /* Before working hard, check whether the instruction is available. */
2306 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2309 result
= gen_reg_rtx (mode
);
2311 /* Always stabilize the argument list. */
2312 CALL_EXPR_ARG (exp
, 0) = arg0
= builtin_save_expr (arg0
);
2313 CALL_EXPR_ARG (exp
, 1) = arg1
= builtin_save_expr (arg1
);
2314 CALL_EXPR_ARG (exp
, 2) = arg2
= builtin_save_expr (arg2
);
2316 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2317 op1
= expand_normal (arg1
);
2318 op2
= expand_normal (arg2
);
2322 /* Compute into RESULT.
2323 Set RESULT to wherever the result comes back. */
2324 result
= expand_ternary_op (mode
, builtin_optab
, op0
, op1
, op2
,
2327 /* If we were unable to expand via the builtin, stop the sequence
2328 (without outputting the insns) and call to the library function
2329 with the stabilized argument list. */
2333 return expand_call (exp
, target
, target
== const0_rtx
);
2336 /* Output the entire sequence. */
2337 insns
= get_insns ();
2344 /* Expand a call to the builtin sin and cos math functions.
2345 Return NULL_RTX if a normal call should be emitted rather than expanding the
2346 function in-line. EXP is the expression that is a call to the builtin
2347 function; if convenient, the result should be placed in TARGET.
2348 SUBTARGET may be used as the target for computing one of EXP's
2352 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2354 optab builtin_optab
;
2357 tree fndecl
= get_callee_fndecl (exp
);
2361 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2364 arg
= CALL_EXPR_ARG (exp
, 0);
2366 switch (DECL_FUNCTION_CODE (fndecl
))
2368 CASE_FLT_FN (BUILT_IN_SIN
):
2369 CASE_FLT_FN (BUILT_IN_COS
):
2370 builtin_optab
= sincos_optab
; break;
2375 /* Make a suitable register to place result in. */
2376 mode
= TYPE_MODE (TREE_TYPE (exp
));
2378 /* Check if sincos insn is available, otherwise fallback
2379 to sin or cos insn. */
2380 if (optab_handler (builtin_optab
, mode
) == CODE_FOR_nothing
)
2381 switch (DECL_FUNCTION_CODE (fndecl
))
2383 CASE_FLT_FN (BUILT_IN_SIN
):
2384 builtin_optab
= sin_optab
; break;
2385 CASE_FLT_FN (BUILT_IN_COS
):
2386 builtin_optab
= cos_optab
; break;
2391 /* Before working hard, check whether the instruction is available. */
2392 if (optab_handler (builtin_optab
, mode
) != CODE_FOR_nothing
)
2394 rtx result
= gen_reg_rtx (mode
);
2396 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2397 need to expand the argument again. This way, we will not perform
2398 side-effects more the once. */
2399 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2401 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
2405 /* Compute into RESULT.
2406 Set RESULT to wherever the result comes back. */
2407 if (builtin_optab
== sincos_optab
)
2411 switch (DECL_FUNCTION_CODE (fndecl
))
2413 CASE_FLT_FN (BUILT_IN_SIN
):
2414 ok
= expand_twoval_unop (builtin_optab
, op0
, 0, result
, 0);
2416 CASE_FLT_FN (BUILT_IN_COS
):
2417 ok
= expand_twoval_unop (builtin_optab
, op0
, result
, 0, 0);
2425 result
= expand_unop (mode
, builtin_optab
, op0
, result
, 0);
2429 /* Output the entire sequence. */
2430 insns
= get_insns ();
2436 /* If we were unable to expand via the builtin, stop the sequence
2437 (without outputting the insns) and call to the library function
2438 with the stabilized argument list. */
2442 return expand_call (exp
, target
, target
== const0_rtx
);
2445 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2446 return an RTL instruction code that implements the functionality.
2447 If that isn't possible or available return CODE_FOR_nothing. */
2449 static enum insn_code
2450 interclass_mathfn_icode (tree arg
, tree fndecl
)
2452 bool errno_set
= false;
2453 optab builtin_optab
= unknown_optab
;
2456 switch (DECL_FUNCTION_CODE (fndecl
))
2458 CASE_FLT_FN (BUILT_IN_ILOGB
):
2459 errno_set
= true; builtin_optab
= ilogb_optab
; break;
2460 CASE_FLT_FN (BUILT_IN_ISINF
):
2461 builtin_optab
= isinf_optab
; break;
2462 case BUILT_IN_ISNORMAL
:
2463 case BUILT_IN_ISFINITE
:
2464 CASE_FLT_FN (BUILT_IN_FINITE
):
2465 case BUILT_IN_FINITED32
:
2466 case BUILT_IN_FINITED64
:
2467 case BUILT_IN_FINITED128
:
2468 case BUILT_IN_ISINFD32
:
2469 case BUILT_IN_ISINFD64
:
2470 case BUILT_IN_ISINFD128
:
2471 /* These builtins have no optabs (yet). */
2477 /* There's no easy way to detect the case we need to set EDOM. */
2478 if (flag_errno_math
&& errno_set
)
2479 return CODE_FOR_nothing
;
2481 /* Optab mode depends on the mode of the input argument. */
2482 mode
= TYPE_MODE (TREE_TYPE (arg
));
2485 return optab_handler (builtin_optab
, mode
);
2486 return CODE_FOR_nothing
;
2489 /* Expand a call to one of the builtin math functions that operate on
2490 floating point argument and output an integer result (ilogb, isinf,
2492 Return 0 if a normal call should be emitted rather than expanding the
2493 function in-line. EXP is the expression that is a call to the builtin
2494 function; if convenient, the result should be placed in TARGET. */
2497 expand_builtin_interclass_mathfn (tree exp
, rtx target
)
2499 enum insn_code icode
= CODE_FOR_nothing
;
2501 tree fndecl
= get_callee_fndecl (exp
);
2505 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2508 arg
= CALL_EXPR_ARG (exp
, 0);
2509 icode
= interclass_mathfn_icode (arg
, fndecl
);
2510 mode
= TYPE_MODE (TREE_TYPE (arg
));
2512 if (icode
!= CODE_FOR_nothing
)
2514 class expand_operand ops
[1];
2515 rtx_insn
*last
= get_last_insn ();
2516 tree orig_arg
= arg
;
2518 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2519 need to expand the argument again. This way, we will not perform
2520 side-effects more the once. */
2521 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
2523 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2525 if (mode
!= GET_MODE (op0
))
2526 op0
= convert_to_mode (mode
, op0
, 0);
2528 create_output_operand (&ops
[0], target
, TYPE_MODE (TREE_TYPE (exp
)));
2529 if (maybe_legitimize_operands (icode
, 0, 1, ops
)
2530 && maybe_emit_unop_insn (icode
, ops
[0].value
, op0
, UNKNOWN
))
2531 return ops
[0].value
;
2533 delete_insns_since (last
);
2534 CALL_EXPR_ARG (exp
, 0) = orig_arg
;
2540 /* Expand a call to the builtin sincos math function.
2541 Return NULL_RTX if a normal call should be emitted rather than expanding the
2542 function in-line. EXP is the expression that is a call to the builtin
2546 expand_builtin_sincos (tree exp
)
2548 rtx op0
, op1
, op2
, target1
, target2
;
2550 tree arg
, sinp
, cosp
;
2552 location_t loc
= EXPR_LOCATION (exp
);
2553 tree alias_type
, alias_off
;
2555 if (!validate_arglist (exp
, REAL_TYPE
,
2556 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2559 arg
= CALL_EXPR_ARG (exp
, 0);
2560 sinp
= CALL_EXPR_ARG (exp
, 1);
2561 cosp
= CALL_EXPR_ARG (exp
, 2);
2563 /* Make a suitable register to place result in. */
2564 mode
= TYPE_MODE (TREE_TYPE (arg
));
2566 /* Check if sincos insn is available, otherwise emit the call. */
2567 if (optab_handler (sincos_optab
, mode
) == CODE_FOR_nothing
)
2570 target1
= gen_reg_rtx (mode
);
2571 target2
= gen_reg_rtx (mode
);
2573 op0
= expand_normal (arg
);
2574 alias_type
= build_pointer_type_for_mode (TREE_TYPE (arg
), ptr_mode
, true);
2575 alias_off
= build_int_cst (alias_type
, 0);
2576 op1
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2578 op2
= expand_normal (fold_build2_loc (loc
, MEM_REF
, TREE_TYPE (arg
),
2581 /* Compute into target1 and target2.
2582 Set TARGET to wherever the result comes back. */
2583 result
= expand_twoval_unop (sincos_optab
, op0
, target2
, target1
, 0);
2584 gcc_assert (result
);
2586 /* Move target1 and target2 to the memory locations indicated
2588 emit_move_insn (op1
, target1
);
2589 emit_move_insn (op2
, target2
);
2594 /* Expand call EXP to the fegetround builtin (from C99 fenv.h), returning the
2595 result and setting it in TARGET. Otherwise return NULL_RTX on failure. */
2597 expand_builtin_fegetround (tree exp
, rtx target
, machine_mode target_mode
)
2599 if (!validate_arglist (exp
, VOID_TYPE
))
2602 insn_code icode
= direct_optab_handler (fegetround_optab
, SImode
);
2603 if (icode
== CODE_FOR_nothing
)
2607 || GET_MODE (target
) != target_mode
2608 || !(*insn_data
[icode
].operand
[0].predicate
) (target
, target_mode
))
2609 target
= gen_reg_rtx (target_mode
);
2611 rtx pat
= GEN_FCN (icode
) (target
);
2619 /* Expand call EXP to either feclearexcept or feraiseexcept builtins (from C99
2620 fenv.h), returning the result and setting it in TARGET. Otherwise return
2621 NULL_RTX on failure. */
2623 expand_builtin_feclear_feraise_except (tree exp
, rtx target
,
2624 machine_mode target_mode
, optab op_optab
)
2626 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
2628 rtx op0
= expand_normal (CALL_EXPR_ARG (exp
, 0));
2630 insn_code icode
= direct_optab_handler (op_optab
, SImode
);
2631 if (icode
== CODE_FOR_nothing
)
2634 if (!(*insn_data
[icode
].operand
[1].predicate
) (op0
, GET_MODE (op0
)))
2638 || GET_MODE (target
) != target_mode
2639 || !(*insn_data
[icode
].operand
[0].predicate
) (target
, target_mode
))
2640 target
= gen_reg_rtx (target_mode
);
2642 rtx pat
= GEN_FCN (icode
) (target
, op0
);
2650 /* Expand a call to the internal cexpi builtin to the sincos math function.
2651 EXP is the expression that is a call to the builtin function; if convenient,
2652 the result should be placed in TARGET. */
2655 expand_builtin_cexpi (tree exp
, rtx target
)
2657 tree fndecl
= get_callee_fndecl (exp
);
2661 location_t loc
= EXPR_LOCATION (exp
);
2663 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2666 arg
= CALL_EXPR_ARG (exp
, 0);
2667 type
= TREE_TYPE (arg
);
2668 mode
= TYPE_MODE (TREE_TYPE (arg
));
2670 /* Try expanding via a sincos optab, fall back to emitting a libcall
2671 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2672 is only generated from sincos, cexp or if we have either of them. */
2673 if (optab_handler (sincos_optab
, mode
) != CODE_FOR_nothing
)
2675 op1
= gen_reg_rtx (mode
);
2676 op2
= gen_reg_rtx (mode
);
2678 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2680 /* Compute into op1 and op2. */
2681 expand_twoval_unop (sincos_optab
, op0
, op2
, op1
, 0);
2683 else if (targetm
.libc_has_function (function_sincos
, type
))
2685 tree call
, fn
= NULL_TREE
;
2689 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2690 fn
= builtin_decl_explicit (BUILT_IN_SINCOSF
);
2691 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2692 fn
= builtin_decl_explicit (BUILT_IN_SINCOS
);
2693 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2694 fn
= builtin_decl_explicit (BUILT_IN_SINCOSL
);
2698 op1
= assign_temp (TREE_TYPE (arg
), 1, 1);
2699 op2
= assign_temp (TREE_TYPE (arg
), 1, 1);
2700 op1a
= copy_addr_to_reg (XEXP (op1
, 0));
2701 op2a
= copy_addr_to_reg (XEXP (op2
, 0));
2702 top1
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op1a
);
2703 top2
= make_tree (build_pointer_type (TREE_TYPE (arg
)), op2a
);
2705 /* Make sure not to fold the sincos call again. */
2706 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2707 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn
)),
2708 call
, 3, arg
, top1
, top2
));
2712 tree call
, fn
= NULL_TREE
, narg
;
2713 tree ctype
= build_complex_type (type
);
2715 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2716 fn
= builtin_decl_explicit (BUILT_IN_CEXPF
);
2717 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2718 fn
= builtin_decl_explicit (BUILT_IN_CEXP
);
2719 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2720 fn
= builtin_decl_explicit (BUILT_IN_CEXPL
);
2724 /* If we don't have a decl for cexp create one. This is the
2725 friendliest fallback if the user calls __builtin_cexpi
2726 without full target C99 function support. */
2727 if (fn
== NULL_TREE
)
2730 const char *name
= NULL
;
2732 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIF
)
2734 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPI
)
2736 else if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CEXPIL
)
2739 fntype
= build_function_type_list (ctype
, ctype
, NULL_TREE
);
2740 fn
= build_fn_decl (name
, fntype
);
2743 narg
= fold_build2_loc (loc
, COMPLEX_EXPR
, ctype
,
2744 build_real (type
, dconst0
), arg
);
2746 /* Make sure not to fold the cexp call again. */
2747 call
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
2748 return expand_expr (build_call_nary (ctype
, call
, 1, narg
),
2749 target
, VOIDmode
, EXPAND_NORMAL
);
2752 /* Now build the proper return type. */
2753 return expand_expr (build2 (COMPLEX_EXPR
, build_complex_type (type
),
2754 make_tree (TREE_TYPE (arg
), op2
),
2755 make_tree (TREE_TYPE (arg
), op1
)),
2756 target
, VOIDmode
, EXPAND_NORMAL
);
2759 /* Conveniently construct a function call expression. FNDECL names the
2760 function to be called, N is the number of arguments, and the "..."
2761 parameters are the argument expressions. Unlike build_call_exr
2762 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2765 build_call_nofold_loc (location_t loc
, tree fndecl
, int n
, ...)
2768 tree fntype
= TREE_TYPE (fndecl
);
2769 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (fntype
), fndecl
);
2772 fn
= build_call_valist (TREE_TYPE (fntype
), fn
, n
, ap
);
2774 SET_EXPR_LOCATION (fn
, loc
);
2778 /* Expand the __builtin_issignaling builtin. This needs to handle
2779 all floating point formats that do support NaNs (for those that
2780 don't it just sets target to 0). */
2783 expand_builtin_issignaling (tree exp
, rtx target
)
2785 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
2788 tree arg
= CALL_EXPR_ARG (exp
, 0);
2789 scalar_float_mode fmode
= SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (arg
));
2790 const struct real_format
*fmt
= REAL_MODE_FORMAT (fmode
);
2792 /* Expand the argument yielding a RTX expression. */
2793 rtx temp
= expand_normal (arg
);
2795 /* If mode doesn't support NaN, always return 0.
2796 Don't use !HONOR_SNANS (fmode) here, so there is some possibility of
2797 __builtin_issignaling working without -fsignaling-nans. Especially
2798 when -fno-signaling-nans is the default.
2799 On the other side, MODE_HAS_NANS (fmode) is unnecessary, with
2800 -ffinite-math-only even __builtin_isnan or __builtin_fpclassify
2801 fold to 0 or non-NaN/Inf classification. */
2802 if (!HONOR_NANS (fmode
))
2804 emit_move_insn (target
, const0_rtx
);
2808 /* Check if the back end provides an insn that handles issignaling for the
2810 enum insn_code icode
= optab_handler (issignaling_optab
, fmode
);
2811 if (icode
!= CODE_FOR_nothing
)
2813 rtx_insn
*last
= get_last_insn ();
2814 rtx this_target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
2815 if (maybe_emit_unop_insn (icode
, this_target
, temp
, UNKNOWN
))
2817 delete_insns_since (last
);
2820 if (DECIMAL_FLOAT_MODE_P (fmode
))
2822 scalar_int_mode imode
;
2824 switch (fmt
->ieee_bits
)
2828 imode
= int_mode_for_mode (fmode
).require ();
2829 temp
= gen_lowpart (imode
, temp
);
2832 imode
= int_mode_for_size (64, 1).require ();
2834 /* For decimal128, TImode support isn't always there and even when
2835 it is, working on the DImode high part is usually better. */
2838 if (rtx t
= simplify_gen_subreg (imode
, temp
, fmode
,
2839 subreg_highpart_offset (imode
,
2844 scalar_int_mode imode2
;
2845 if (int_mode_for_mode (fmode
).exists (&imode2
))
2847 rtx temp2
= gen_lowpart (imode2
, temp
);
2848 poly_uint64 off
= subreg_highpart_offset (imode
, imode2
);
2849 if (rtx t
= simplify_gen_subreg (imode
, temp2
,
2856 rtx mem
= assign_stack_temp (fmode
, GET_MODE_SIZE (fmode
));
2857 emit_move_insn (mem
, temp
);
2864 = subreg_highpart_offset (imode
, GET_MODE (temp
));
2865 hi
= adjust_address (temp
, imode
, offset
);
2872 /* In all of decimal{32,64,128}, there is MSB sign bit and sNaN
2873 have 6 bits below it all set. */
2875 = GEN_INT (HOST_WIDE_INT_C (0x3f) << (GET_MODE_BITSIZE (imode
) - 7));
2876 temp
= expand_binop (imode
, and_optab
, temp
, val
,
2877 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2878 temp
= emit_store_flag_force (target
, EQ
, temp
, val
, imode
, 1, 1);
2882 /* Only PDP11 has these defined differently but doesn't support NaNs. */
2883 gcc_assert (FLOAT_WORDS_BIG_ENDIAN
== WORDS_BIG_ENDIAN
);
2884 gcc_assert (fmt
->signbit_ro
> 0 && fmt
->b
== 2);
2885 gcc_assert (MODE_COMPOSITE_P (fmode
)
2886 || (fmt
->pnan
== fmt
->p
2887 && fmt
->signbit_ro
== fmt
->signbit_rw
));
2891 case 106: /* IBM double double */
2892 /* For IBM double double, recurse on the most significant double. */
2893 gcc_assert (MODE_COMPOSITE_P (fmode
));
2894 temp
= convert_modes (DFmode
, fmode
, temp
, 0);
2896 fmt
= REAL_MODE_FORMAT (DFmode
);
2898 case 8: /* bfloat */
2899 case 11: /* IEEE half */
2900 case 24: /* IEEE single */
2901 case 53: /* IEEE double or Intel extended with rounding to double */
2902 if (fmt
->p
== 53 && fmt
->signbit_ro
== 79)
2905 scalar_int_mode imode
= int_mode_for_mode (fmode
).require ();
2906 temp
= gen_lowpart (imode
, temp
);
2907 rtx val
= GEN_INT ((HOST_WIDE_INT_M1U
<< (fmt
->p
- 2))
2908 & ~(HOST_WIDE_INT_M1U
<< fmt
->signbit_ro
));
2909 if (fmt
->qnan_msb_set
)
2911 rtx mask
= GEN_INT (~(HOST_WIDE_INT_M1U
<< fmt
->signbit_ro
));
2912 rtx bit
= GEN_INT (HOST_WIDE_INT_1U
<< (fmt
->p
- 2));
2913 /* For non-MIPS/PA IEEE single/double/half or bfloat, expand to:
2914 ((temp ^ bit) & mask) > val. */
2915 temp
= expand_binop (imode
, xor_optab
, temp
, bit
,
2916 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2917 temp
= expand_binop (imode
, and_optab
, temp
, mask
,
2918 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2919 temp
= emit_store_flag_force (target
, GTU
, temp
, val
, imode
,
2924 /* For MIPS/PA IEEE single/double, expand to:
2925 (temp & val) == val. */
2926 temp
= expand_binop (imode
, and_optab
, temp
, val
,
2927 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2928 temp
= emit_store_flag_force (target
, EQ
, temp
, val
, imode
,
2933 case 113: /* IEEE quad */
2935 rtx hi
= NULL_RTX
, lo
= NULL_RTX
;
2936 scalar_int_mode imode
= int_mode_for_size (64, 1).require ();
2937 /* For IEEE quad, TImode support isn't always there and even when
2938 it is, working on DImode parts is usually better. */
2941 hi
= simplify_gen_subreg (imode
, temp
, fmode
,
2942 subreg_highpart_offset (imode
, fmode
));
2943 lo
= simplify_gen_subreg (imode
, temp
, fmode
,
2944 subreg_lowpart_offset (imode
, fmode
));
2947 scalar_int_mode imode2
;
2948 if (int_mode_for_mode (fmode
).exists (&imode2
))
2950 rtx temp2
= gen_lowpart (imode2
, temp
);
2951 hi
= simplify_gen_subreg (imode
, temp2
, imode2
,
2952 subreg_highpart_offset (imode
,
2954 lo
= simplify_gen_subreg (imode
, temp2
, imode2
,
2955 subreg_lowpart_offset (imode
,
2961 rtx mem
= assign_stack_temp (fmode
, GET_MODE_SIZE (fmode
));
2962 emit_move_insn (mem
, temp
);
2969 = subreg_highpart_offset (imode
, GET_MODE (temp
));
2970 hi
= adjust_address (temp
, imode
, offset
);
2971 offset
= subreg_lowpart_offset (imode
, GET_MODE (temp
));
2972 lo
= adjust_address (temp
, imode
, offset
);
2974 rtx val
= GEN_INT ((HOST_WIDE_INT_M1U
<< (fmt
->p
- 2 - 64))
2975 & ~(HOST_WIDE_INT_M1U
<< (fmt
->signbit_ro
- 64)));
2976 if (fmt
->qnan_msb_set
)
2978 rtx mask
= GEN_INT (~(HOST_WIDE_INT_M1U
<< (fmt
->signbit_ro
2980 rtx bit
= GEN_INT (HOST_WIDE_INT_1U
<< (fmt
->p
- 2 - 64));
2981 /* For non-MIPS/PA IEEE quad, expand to:
2982 (((hi ^ bit) | ((lo | -lo) >> 63)) & mask) > val. */
2983 rtx nlo
= expand_unop (imode
, neg_optab
, lo
, NULL_RTX
, 0);
2984 lo
= expand_binop (imode
, ior_optab
, lo
, nlo
,
2985 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2986 lo
= expand_shift (RSHIFT_EXPR
, imode
, lo
, 63, NULL_RTX
, 1);
2987 temp
= expand_binop (imode
, xor_optab
, hi
, bit
,
2988 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2989 temp
= expand_binop (imode
, ior_optab
, temp
, lo
,
2990 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2991 temp
= expand_binop (imode
, and_optab
, temp
, mask
,
2992 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
2993 temp
= emit_store_flag_force (target
, GTU
, temp
, val
, imode
,
2998 /* For MIPS/PA IEEE quad, expand to:
2999 (hi & val) == val. */
3000 temp
= expand_binop (imode
, and_optab
, hi
, val
,
3001 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3002 temp
= emit_store_flag_force (target
, EQ
, temp
, val
, imode
,
3007 case 64: /* Intel or Motorola extended */
3011 scalar_int_mode imode
= int_mode_for_size (32, 1).require ();
3012 scalar_int_mode iemode
= int_mode_for_size (16, 1).require ();
3015 rtx mem
= assign_stack_temp (fmode
, GET_MODE_SIZE (fmode
));
3016 emit_move_insn (mem
, temp
);
3019 if (fmt
->signbit_ro
== 95)
3021 /* Motorola, always big endian, with 16-bit gap in between
3022 16-bit sign+exponent and 64-bit mantissa. */
3023 ex
= adjust_address (temp
, iemode
, 0);
3024 hi
= adjust_address (temp
, imode
, 4);
3025 lo
= adjust_address (temp
, imode
, 8);
3027 else if (!WORDS_BIG_ENDIAN
)
3029 /* Intel little endian, 64-bit mantissa followed by 16-bit
3030 sign+exponent and then either 16 or 48 bits of gap. */
3031 ex
= adjust_address (temp
, iemode
, 8);
3032 hi
= adjust_address (temp
, imode
, 4);
3033 lo
= adjust_address (temp
, imode
, 0);
3037 /* Big endian Itanium. */
3038 ex
= adjust_address (temp
, iemode
, 0);
3039 hi
= adjust_address (temp
, imode
, 2);
3040 lo
= adjust_address (temp
, imode
, 6);
3042 rtx val
= GEN_INT (HOST_WIDE_INT_M1U
<< 30);
3043 gcc_assert (fmt
->qnan_msb_set
);
3044 rtx mask
= GEN_INT (0x7fff);
3045 rtx bit
= GEN_INT (HOST_WIDE_INT_1U
<< 30);
3046 /* For Intel/Motorola extended format, expand to:
3047 (ex & mask) == mask && ((hi ^ bit) | ((lo | -lo) >> 31)) > val. */
3048 rtx nlo
= expand_unop (imode
, neg_optab
, lo
, NULL_RTX
, 0);
3049 lo
= expand_binop (imode
, ior_optab
, lo
, nlo
,
3050 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3051 lo
= expand_shift (RSHIFT_EXPR
, imode
, lo
, 31, NULL_RTX
, 1);
3052 temp
= expand_binop (imode
, xor_optab
, hi
, bit
,
3053 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3054 temp
= expand_binop (imode
, ior_optab
, temp
, lo
,
3055 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3056 temp
= emit_store_flag_force (target
, GTU
, temp
, val
, imode
, 1, 1);
3057 ex
= expand_binop (iemode
, and_optab
, ex
, mask
,
3058 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3059 ex
= emit_store_flag_force (gen_reg_rtx (GET_MODE (temp
)), EQ
,
3060 ex
, mask
, iemode
, 1, 1);
3061 temp
= expand_binop (GET_MODE (temp
), and_optab
, temp
, ex
,
3062 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3072 /* Expand a call to one of the builtin rounding functions gcc defines
3073 as an extension (lfloor and lceil). As these are gcc extensions we
3074 do not need to worry about setting errno to EDOM.
3075 If expanding via optab fails, lower expression to (int)(floor(x)).
3076 EXP is the expression that is a call to the builtin function;
3077 if convenient, the result should be placed in TARGET. */
3080 expand_builtin_int_roundingfn (tree exp
, rtx target
)
3082 convert_optab builtin_optab
;
3085 tree fndecl
= get_callee_fndecl (exp
);
3086 enum built_in_function fallback_fn
;
3087 tree fallback_fndecl
;
3091 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
3094 arg
= CALL_EXPR_ARG (exp
, 0);
3096 switch (DECL_FUNCTION_CODE (fndecl
))
3098 CASE_FLT_FN (BUILT_IN_ICEIL
):
3099 CASE_FLT_FN (BUILT_IN_LCEIL
):
3100 CASE_FLT_FN (BUILT_IN_LLCEIL
):
3101 builtin_optab
= lceil_optab
;
3102 fallback_fn
= BUILT_IN_CEIL
;
3105 CASE_FLT_FN (BUILT_IN_IFLOOR
):
3106 CASE_FLT_FN (BUILT_IN_LFLOOR
):
3107 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
3108 builtin_optab
= lfloor_optab
;
3109 fallback_fn
= BUILT_IN_FLOOR
;
3116 /* Make a suitable register to place result in. */
3117 mode
= TYPE_MODE (TREE_TYPE (exp
));
3119 target
= gen_reg_rtx (mode
);
3121 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
3122 need to expand the argument again. This way, we will not perform
3123 side-effects more the once. */
3124 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
3126 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
3130 /* Compute into TARGET. */
3131 if (expand_sfix_optab (target
, op0
, builtin_optab
))
3133 /* Output the entire sequence. */
3134 insns
= get_insns ();
3140 /* If we were unable to expand via the builtin, stop the sequence
3141 (without outputting the insns). */
3144 /* Fall back to floating point rounding optab. */
3145 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
3147 /* For non-C99 targets we may end up without a fallback fndecl here
3148 if the user called __builtin_lfloor directly. In this case emit
3149 a call to the floor/ceil variants nevertheless. This should result
3150 in the best user experience for not full C99 targets. */
3151 if (fallback_fndecl
== NULL_TREE
)
3154 const char *name
= NULL
;
3156 switch (DECL_FUNCTION_CODE (fndecl
))
3158 case BUILT_IN_ICEIL
:
3159 case BUILT_IN_LCEIL
:
3160 case BUILT_IN_LLCEIL
:
3163 case BUILT_IN_ICEILF
:
3164 case BUILT_IN_LCEILF
:
3165 case BUILT_IN_LLCEILF
:
3168 case BUILT_IN_ICEILL
:
3169 case BUILT_IN_LCEILL
:
3170 case BUILT_IN_LLCEILL
:
3173 case BUILT_IN_IFLOOR
:
3174 case BUILT_IN_LFLOOR
:
3175 case BUILT_IN_LLFLOOR
:
3178 case BUILT_IN_IFLOORF
:
3179 case BUILT_IN_LFLOORF
:
3180 case BUILT_IN_LLFLOORF
:
3183 case BUILT_IN_IFLOORL
:
3184 case BUILT_IN_LFLOORL
:
3185 case BUILT_IN_LLFLOORL
:
3192 fntype
= build_function_type_list (TREE_TYPE (arg
),
3193 TREE_TYPE (arg
), NULL_TREE
);
3194 fallback_fndecl
= build_fn_decl (name
, fntype
);
3197 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
), fallback_fndecl
, 1, arg
);
3199 tmp
= expand_normal (exp
);
3200 tmp
= maybe_emit_group_store (tmp
, TREE_TYPE (exp
));
3202 /* Truncate the result of floating point optab to integer
3203 via expand_fix (). */
3204 target
= gen_reg_rtx (mode
);
3205 expand_fix (target
, tmp
, 0);
3210 /* Expand a call to one of the builtin math functions doing integer
3212 Return 0 if a normal call should be emitted rather than expanding the
3213 function in-line. EXP is the expression that is a call to the builtin
3214 function; if convenient, the result should be placed in TARGET. */
3217 expand_builtin_int_roundingfn_2 (tree exp
, rtx target
)
3219 convert_optab builtin_optab
;
3222 tree fndecl
= get_callee_fndecl (exp
);
3225 enum built_in_function fallback_fn
= BUILT_IN_NONE
;
3227 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
3230 arg
= CALL_EXPR_ARG (exp
, 0);
3232 switch (DECL_FUNCTION_CODE (fndecl
))
3234 CASE_FLT_FN (BUILT_IN_IRINT
):
3235 fallback_fn
= BUILT_IN_LRINT
;
3237 CASE_FLT_FN (BUILT_IN_LRINT
):
3238 CASE_FLT_FN (BUILT_IN_LLRINT
):
3239 builtin_optab
= lrint_optab
;
3242 CASE_FLT_FN (BUILT_IN_IROUND
):
3243 fallback_fn
= BUILT_IN_LROUND
;
3245 CASE_FLT_FN (BUILT_IN_LROUND
):
3246 CASE_FLT_FN (BUILT_IN_LLROUND
):
3247 builtin_optab
= lround_optab
;
3254 /* There's no easy way to detect the case we need to set EDOM. */
3255 if (flag_errno_math
&& fallback_fn
== BUILT_IN_NONE
)
3258 /* Make a suitable register to place result in. */
3259 mode
= TYPE_MODE (TREE_TYPE (exp
));
3261 /* There's no easy way to detect the case we need to set EDOM. */
3262 if (!flag_errno_math
)
3264 rtx result
= gen_reg_rtx (mode
);
3266 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
3267 need to expand the argument again. This way, we will not perform
3268 side-effects more the once. */
3269 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
3271 op0
= expand_expr (arg
, NULL
, VOIDmode
, EXPAND_NORMAL
);
3275 if (expand_sfix_optab (result
, op0
, builtin_optab
))
3277 /* Output the entire sequence. */
3278 insns
= get_insns ();
3284 /* If we were unable to expand via the builtin, stop the sequence
3285 (without outputting the insns) and call to the library function
3286 with the stabilized argument list. */
3290 if (fallback_fn
!= BUILT_IN_NONE
)
3292 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
3293 targets, (int) round (x) should never be transformed into
3294 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
3295 a call to lround in the hope that the target provides at least some
3296 C99 functions. This should result in the best user experience for
3297 not full C99 targets.
3298 As scalar float conversions with same mode are useless in GIMPLE,
3299 we can end up e.g. with _Float32 argument passed to float builtin,
3300 try to get the type from the builtin prototype first. */
3301 tree fallback_fndecl
= NULL_TREE
;
3302 if (tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
3304 = mathfn_built_in_1 (TREE_VALUE (argtypes
),
3305 as_combined_fn (fallback_fn
), 0);
3306 if (fallback_fndecl
== NULL_TREE
)
3308 = mathfn_built_in_1 (TREE_TYPE (arg
),
3309 as_combined_fn (fallback_fn
), 0);
3310 if (fallback_fndecl
)
3312 exp
= build_call_nofold_loc (EXPR_LOCATION (exp
),
3313 fallback_fndecl
, 1, arg
);
3315 target
= expand_call (exp
, NULL_RTX
, target
== const0_rtx
);
3316 target
= maybe_emit_group_store (target
, TREE_TYPE (exp
));
3317 return convert_to_mode (mode
, target
, 0);
3321 return expand_call (exp
, target
, target
== const0_rtx
);
3324 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
3325 a normal call should be emitted rather than expanding the function
3326 in-line. EXP is the expression that is a call to the builtin
3327 function; if convenient, the result should be placed in TARGET. */
3330 expand_builtin_powi (tree exp
, rtx target
)
3337 if (! validate_arglist (exp
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3340 arg0
= CALL_EXPR_ARG (exp
, 0);
3341 arg1
= CALL_EXPR_ARG (exp
, 1);
3342 mode
= TYPE_MODE (TREE_TYPE (exp
));
3344 /* Emit a libcall to libgcc. */
3346 /* Mode of the 2nd argument must match that of an int. */
3347 mode2
= int_mode_for_size (INT_TYPE_SIZE
, 0).require ();
3349 if (target
== NULL_RTX
)
3350 target
= gen_reg_rtx (mode
);
3352 op0
= expand_expr (arg0
, NULL_RTX
, mode
, EXPAND_NORMAL
);
3353 if (GET_MODE (op0
) != mode
)
3354 op0
= convert_to_mode (mode
, op0
, 0);
3355 op1
= expand_expr (arg1
, NULL_RTX
, mode2
, EXPAND_NORMAL
);
3356 if (GET_MODE (op1
) != mode2
)
3357 op1
= convert_to_mode (mode2
, op1
, 0);
3359 target
= emit_library_call_value (optab_libfunc (powi_optab
, mode
),
3360 target
, LCT_CONST
, mode
,
3361 op0
, mode
, op1
, mode2
);
3366 /* Expand expression EXP which is a call to the strlen builtin. Return
3367 NULL_RTX if we failed and the caller should emit a normal call, otherwise
3368 try to get the result in TARGET, if convenient. */
3371 expand_builtin_strlen (tree exp
, rtx target
,
3372 machine_mode target_mode
)
3374 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
3377 tree src
= CALL_EXPR_ARG (exp
, 0);
3379 /* If the length can be computed at compile-time, return it. */
3380 if (tree len
= c_strlen (src
, 0))
3381 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3383 /* If the length can be computed at compile-time and is constant
3384 integer, but there are side-effects in src, evaluate
3385 src for side-effects, then return len.
3386 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3387 can be optimized into: i++; x = 3; */
3388 tree len
= c_strlen (src
, 1);
3389 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
3391 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3392 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3395 unsigned int align
= get_pointer_alignment (src
) / BITS_PER_UNIT
;
3397 /* If SRC is not a pointer type, don't do this operation inline. */
3401 /* Bail out if we can't compute strlen in the right mode. */
3402 machine_mode insn_mode
;
3403 enum insn_code icode
= CODE_FOR_nothing
;
3404 FOR_EACH_MODE_FROM (insn_mode
, target_mode
)
3406 icode
= optab_handler (strlen_optab
, insn_mode
);
3407 if (icode
!= CODE_FOR_nothing
)
3410 if (insn_mode
== VOIDmode
)
3413 /* Make a place to hold the source address. We will not expand
3414 the actual source until we are sure that the expansion will
3415 not fail -- there are trees that cannot be expanded twice. */
3416 rtx src_reg
= gen_reg_rtx (Pmode
);
3418 /* Mark the beginning of the strlen sequence so we can emit the
3419 source operand later. */
3420 rtx_insn
*before_strlen
= get_last_insn ();
3422 class expand_operand ops
[4];
3423 create_output_operand (&ops
[0], target
, insn_mode
);
3424 create_fixed_operand (&ops
[1], gen_rtx_MEM (BLKmode
, src_reg
));
3425 create_integer_operand (&ops
[2], 0);
3426 create_integer_operand (&ops
[3], align
);
3427 if (!maybe_expand_insn (icode
, 4, ops
))
3430 /* Check to see if the argument was declared attribute nonstring
3431 and if so, issue a warning since at this point it's not known
3432 to be nul-terminated. */
3433 maybe_warn_nonstring_arg (get_callee_fndecl (exp
), exp
);
3435 /* Now that we are assured of success, expand the source. */
3437 rtx pat
= expand_expr (src
, src_reg
, Pmode
, EXPAND_NORMAL
);
3440 #ifdef POINTERS_EXTEND_UNSIGNED
3441 if (GET_MODE (pat
) != Pmode
)
3442 pat
= convert_to_mode (Pmode
, pat
,
3443 POINTERS_EXTEND_UNSIGNED
);
3445 emit_move_insn (src_reg
, pat
);
3451 emit_insn_after (pat
, before_strlen
);
3453 emit_insn_before (pat
, get_insns ());
3455 /* Return the value in the proper mode for this function. */
3456 if (GET_MODE (ops
[0].value
) == target_mode
)
3457 target
= ops
[0].value
;
3458 else if (target
!= 0)
3459 convert_move (target
, ops
[0].value
, 0);
3461 target
= convert_to_mode (target_mode
, ops
[0].value
, 0);
3466 /* Expand call EXP to the strnlen built-in, returning the result
3467 and setting it in TARGET. Otherwise return NULL_RTX on failure. */
3470 expand_builtin_strnlen (tree exp
, rtx target
, machine_mode target_mode
)
3472 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3475 tree src
= CALL_EXPR_ARG (exp
, 0);
3476 tree bound
= CALL_EXPR_ARG (exp
, 1);
3481 location_t loc
= UNKNOWN_LOCATION
;
3482 if (EXPR_HAS_LOCATION (exp
))
3483 loc
= EXPR_LOCATION (exp
);
3485 /* FIXME: Change c_strlen() to return sizetype instead of ssizetype
3486 so these conversions aren't necessary. */
3487 c_strlen_data lendata
= { };
3488 tree len
= c_strlen (src
, 0, &lendata
, 1);
3490 len
= fold_convert_loc (loc
, TREE_TYPE (bound
), len
);
3492 if (TREE_CODE (bound
) == INTEGER_CST
)
3497 len
= fold_build2_loc (loc
, MIN_EXPR
, size_type_node
, len
, bound
);
3498 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3501 if (TREE_CODE (bound
) != SSA_NAME
)
3506 get_global_range_query ()->range_of_expr (r
, bound
);
3507 if (r
.varying_p () || r
.undefined_p ())
3509 min
= r
.lower_bound ();
3510 max
= r
.upper_bound ();
3512 if (!len
|| TREE_CODE (len
) != INTEGER_CST
)
3515 lendata
.decl
= unterminated_array (src
, &len
, &exact
);
3523 if (wi::gtu_p (min
, wi::to_wide (len
)))
3524 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3526 len
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (len
), len
, bound
);
3527 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
3530 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3531 bytes from bytes at DATA + OFFSET and return it reinterpreted as
3532 a target constant. */
3535 builtin_memcpy_read_str (void *data
, void *, HOST_WIDE_INT offset
,
3536 fixed_size_mode mode
)
3538 /* The REPresentation pointed to by DATA need not be a nul-terminated
3539 string but the caller guarantees it's large enough for MODE. */
3540 const char *rep
= (const char *) data
;
3542 return c_readstr (rep
+ offset
, mode
, /*nul_terminated=*/false);
3545 /* LEN specify length of the block of memcpy/memset operation.
3546 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
3547 In some cases we can make very likely guess on max size, then we
3548 set it into PROBABLE_MAX_SIZE. */
3551 determine_block_size (tree len
, rtx len_rtx
,
3552 unsigned HOST_WIDE_INT
*min_size
,
3553 unsigned HOST_WIDE_INT
*max_size
,
3554 unsigned HOST_WIDE_INT
*probable_max_size
)
3556 if (CONST_INT_P (len_rtx
))
3558 *min_size
= *max_size
= *probable_max_size
= UINTVAL (len_rtx
);
3564 enum value_range_kind range_type
= VR_UNDEFINED
;
3566 /* Determine bounds from the type. */
3567 if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len
))))
3568 *min_size
= tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len
)));
3571 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len
))))
3572 *probable_max_size
= *max_size
3573 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len
)));
3575 *probable_max_size
= *max_size
= GET_MODE_MASK (GET_MODE (len_rtx
));
3577 if (TREE_CODE (len
) == SSA_NAME
)
3581 get_global_range_query ()->range_of_expr (r
, len
);
3582 range_type
= get_legacy_range (r
, tmin
, tmax
);
3583 if (range_type
!= VR_UNDEFINED
)
3585 min
= wi::to_wide (tmin
);
3586 max
= wi::to_wide (tmax
);
3589 if (range_type
== VR_RANGE
)
3591 if (wi::fits_uhwi_p (min
) && *min_size
< min
.to_uhwi ())
3592 *min_size
= min
.to_uhwi ();
3593 if (wi::fits_uhwi_p (max
) && *max_size
> max
.to_uhwi ())
3594 *probable_max_size
= *max_size
= max
.to_uhwi ();
3596 else if (range_type
== VR_ANTI_RANGE
)
3604 Produce anti range allowing negative values of N. We still
3605 can use the information and make a guess that N is not negative.
3607 if (!wi::leu_p (max
, 1 << 30) && wi::fits_uhwi_p (min
))
3608 *probable_max_size
= min
.to_uhwi () - 1;
3611 gcc_checking_assert (*max_size
<=
3612 (unsigned HOST_WIDE_INT
)
3613 GET_MODE_MASK (GET_MODE (len_rtx
)));
3616 /* Expand a call EXP to the memcpy builtin.
3617 Return NULL_RTX if we failed, the caller should emit a normal call,
3618 otherwise try to get the result in TARGET, if convenient (and in
3619 mode MODE if that's convenient). */
3622 expand_builtin_memcpy (tree exp
, rtx target
)
3624 if (!validate_arglist (exp
,
3625 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3628 tree dest
= CALL_EXPR_ARG (exp
, 0);
3629 tree src
= CALL_EXPR_ARG (exp
, 1);
3630 tree len
= CALL_EXPR_ARG (exp
, 2);
3632 return expand_builtin_memory_copy_args (dest
, src
, len
, target
, exp
,
3633 /*retmode=*/ RETURN_BEGIN
, false);
3636 /* Check a call EXP to the memmove built-in for validity.
3637 Return NULL_RTX on both success and failure. */
3640 expand_builtin_memmove (tree exp
, rtx target
)
3642 if (!validate_arglist (exp
,
3643 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3646 tree dest
= CALL_EXPR_ARG (exp
, 0);
3647 tree src
= CALL_EXPR_ARG (exp
, 1);
3648 tree len
= CALL_EXPR_ARG (exp
, 2);
3650 return expand_builtin_memory_copy_args (dest
, src
, len
, target
, exp
,
3651 /*retmode=*/ RETURN_BEGIN
, true);
3654 /* Expand a call EXP to the mempcpy builtin.
3655 Return NULL_RTX if we failed; the caller should emit a normal call,
3656 otherwise try to get the result in TARGET, if convenient (and in
3657 mode MODE if that's convenient). */
3660 expand_builtin_mempcpy (tree exp
, rtx target
)
3662 if (!validate_arglist (exp
,
3663 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3666 tree dest
= CALL_EXPR_ARG (exp
, 0);
3667 tree src
= CALL_EXPR_ARG (exp
, 1);
3668 tree len
= CALL_EXPR_ARG (exp
, 2);
3670 /* Policy does not generally allow using compute_objsize (which
3671 is used internally by check_memop_size) to change code generation
3672 or drive optimization decisions.
3674 In this instance it is safe because the code we generate has
3675 the same semantics regardless of the return value of
3676 check_memop_sizes. Exactly the same amount of data is copied
3677 and the return value is exactly the same in both cases.
3679 Furthermore, check_memop_size always uses mode 0 for the call to
3680 compute_objsize, so the imprecise nature of compute_objsize is
3683 /* Avoid expanding mempcpy into memcpy when the call is determined
3684 to overflow the buffer. This also prevents the same overflow
3685 from being diagnosed again when expanding memcpy. */
3687 return expand_builtin_mempcpy_args (dest
, src
, len
,
3688 target
, exp
, /*retmode=*/ RETURN_END
);
3691 /* Helper function to do the actual work for expand of memory copy family
3692 functions (memcpy, mempcpy, stpcpy). Expansing should assign LEN bytes
3693 of memory from SRC to DEST and assign to TARGET if convenient. Return
3694 value is based on RETMODE argument. */
3697 expand_builtin_memory_copy_args (tree dest
, tree src
, tree len
,
3698 rtx target
, tree exp
, memop_ret retmode
,
3701 unsigned int src_align
= get_pointer_alignment (src
);
3702 unsigned int dest_align
= get_pointer_alignment (dest
);
3703 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
3704 HOST_WIDE_INT expected_size
= -1;
3705 unsigned int expected_align
= 0;
3706 unsigned HOST_WIDE_INT min_size
;
3707 unsigned HOST_WIDE_INT max_size
;
3708 unsigned HOST_WIDE_INT probable_max_size
;
3712 /* If DEST is not a pointer type, call the normal function. */
3713 if (dest_align
== 0)
3716 /* If either SRC is not a pointer type, don't do this
3717 operation in-line. */
3721 if (currently_expanding_gimple_stmt
)
3722 stringop_block_profile (currently_expanding_gimple_stmt
,
3723 &expected_align
, &expected_size
);
3725 if (expected_align
< dest_align
)
3726 expected_align
= dest_align
;
3727 dest_mem
= get_memory_rtx (dest
, len
);
3728 set_mem_align (dest_mem
, dest_align
);
3729 len_rtx
= expand_normal (len
);
3730 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
3731 &probable_max_size
);
3733 /* Try to get the byte representation of the constant SRC points to,
3734 with its byte size in NBYTES. */
3735 unsigned HOST_WIDE_INT nbytes
;
3736 const char *rep
= getbyterep (src
, &nbytes
);
3738 /* If the function's constant bound LEN_RTX is less than or equal
3739 to the byte size of the representation of the constant argument,
3740 and if block move would be done by pieces, we can avoid loading
3741 the bytes from memory and only store the computed constant.
3742 This works in the overlap (memmove) case as well because
3743 store_by_pieces just generates a series of stores of constants
3744 from the representation returned by getbyterep(). */
3746 && CONST_INT_P (len_rtx
)
3747 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= nbytes
3748 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
3749 CONST_CAST (char *, rep
),
3752 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
3753 builtin_memcpy_read_str
,
3754 CONST_CAST (char *, rep
),
3755 dest_align
, false, retmode
);
3756 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
3757 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3761 src_mem
= get_memory_rtx (src
, len
);
3762 set_mem_align (src_mem
, src_align
);
3764 /* Copy word part most expediently. */
3765 enum block_op_methods method
= BLOCK_OP_NORMAL
;
3766 if (CALL_EXPR_TAILCALL (exp
)
3767 && (retmode
== RETURN_BEGIN
|| target
== const0_rtx
))
3768 method
= BLOCK_OP_TAILCALL
;
3769 bool use_mempcpy_call
= (targetm
.libc_has_fast_function (BUILT_IN_MEMPCPY
)
3770 && retmode
== RETURN_END
3772 && target
!= const0_rtx
);
3773 if (use_mempcpy_call
)
3774 method
= BLOCK_OP_NO_LIBCALL_RET
;
3775 dest_addr
= emit_block_move_hints (dest_mem
, src_mem
, len_rtx
, method
,
3776 expected_align
, expected_size
,
3777 min_size
, max_size
, probable_max_size
,
3778 use_mempcpy_call
, &is_move_done
,
3779 might_overlap
, tree_ctz (len
));
3781 /* Bail out when a mempcpy call would be expanded as libcall and when
3782 we have a target that provides a fast implementation
3783 of mempcpy routine. */
3787 if (dest_addr
== pc_rtx
)
3792 dest_addr
= force_operand (XEXP (dest_mem
, 0), target
);
3793 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3796 if (retmode
!= RETURN_BEGIN
&& target
!= const0_rtx
)
3798 dest_addr
= gen_rtx_PLUS (ptr_mode
, dest_addr
, len_rtx
);
3799 /* stpcpy pointer to last byte. */
3800 if (retmode
== RETURN_END_MINUS_ONE
)
3801 dest_addr
= gen_rtx_MINUS (ptr_mode
, dest_addr
, const1_rtx
);
3808 expand_builtin_mempcpy_args (tree dest
, tree src
, tree len
,
3809 rtx target
, tree orig_exp
, memop_ret retmode
)
3811 return expand_builtin_memory_copy_args (dest
, src
, len
, target
, orig_exp
,
3815 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3816 we failed, the caller should emit a normal call, otherwise try to
3817 get the result in TARGET, if convenient.
3818 Return value is based on RETMODE argument. */
3821 expand_movstr (tree dest
, tree src
, rtx target
, memop_ret retmode
)
3823 class expand_operand ops
[3];
3827 if (!targetm
.have_movstr ())
3830 dest_mem
= get_memory_rtx (dest
, NULL
);
3831 src_mem
= get_memory_rtx (src
, NULL
);
3832 if (retmode
== RETURN_BEGIN
)
3834 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3835 dest_mem
= replace_equiv_address (dest_mem
, target
);
3838 create_output_operand (&ops
[0],
3839 retmode
!= RETURN_BEGIN
? target
: NULL_RTX
, Pmode
);
3840 create_fixed_operand (&ops
[1], dest_mem
);
3841 create_fixed_operand (&ops
[2], src_mem
);
3842 if (!maybe_expand_insn (targetm
.code_for_movstr
, 3, ops
))
3845 if (retmode
!= RETURN_BEGIN
&& target
!= const0_rtx
)
3847 target
= ops
[0].value
;
3848 /* movstr is supposed to set end to the address of the NUL
3849 terminator. If the caller requested a mempcpy-like return value,
3851 if (retmode
== RETURN_END
)
3853 rtx tem
= plus_constant (GET_MODE (target
),
3854 gen_lowpart (GET_MODE (target
), target
), 1);
3855 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3861 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3862 NULL_RTX if we failed the caller should emit a normal call, otherwise
3863 try to get the result in TARGET, if convenient (and in mode MODE if that's
3867 expand_builtin_strcpy (tree exp
, rtx target
)
3869 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3872 tree dest
= CALL_EXPR_ARG (exp
, 0);
3873 tree src
= CALL_EXPR_ARG (exp
, 1);
3875 return expand_builtin_strcpy_args (exp
, dest
, src
, target
);
3878 /* Helper function to do the actual work for expand_builtin_strcpy. The
3879 arguments to the builtin_strcpy call DEST and SRC are broken out
3880 so that this can also be called without constructing an actual CALL_EXPR.
3881 The other arguments and return value are the same as for
3882 expand_builtin_strcpy. */
3885 expand_builtin_strcpy_args (tree
, tree dest
, tree src
, rtx target
)
3887 return expand_movstr (dest
, src
, target
, /*retmode=*/ RETURN_BEGIN
);
3890 /* Expand a call EXP to the stpcpy builtin.
3891 Return NULL_RTX if we failed the caller should emit a normal call,
3892 otherwise try to get the result in TARGET, if convenient (and in
3893 mode MODE if that's convenient). */
3896 expand_builtin_stpcpy_1 (tree exp
, rtx target
, machine_mode mode
)
3899 location_t loc
= EXPR_LOCATION (exp
);
3901 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3904 dst
= CALL_EXPR_ARG (exp
, 0);
3905 src
= CALL_EXPR_ARG (exp
, 1);
3907 /* If return value is ignored, transform stpcpy into strcpy. */
3908 if (target
== const0_rtx
&& builtin_decl_implicit (BUILT_IN_STRCPY
))
3910 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3911 tree result
= build_call_nofold_loc (loc
, fn
, 2, dst
, src
);
3912 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3919 /* Ensure we get an actual string whose length can be evaluated at
3920 compile-time, not an expression containing a string. This is
3921 because the latter will potentially produce pessimized code
3922 when used to produce the return value. */
3923 c_strlen_data lendata
= { };
3925 || !(len
= c_strlen (src
, 0, &lendata
, 1)))
3926 return expand_movstr (dst
, src
, target
,
3927 /*retmode=*/ RETURN_END_MINUS_ONE
);
3929 lenp1
= size_binop_loc (loc
, PLUS_EXPR
, len
, ssize_int (1));
3930 ret
= expand_builtin_mempcpy_args (dst
, src
, lenp1
,
3932 /*retmode=*/ RETURN_END_MINUS_ONE
);
3937 if (TREE_CODE (len
) == INTEGER_CST
)
3939 rtx len_rtx
= expand_normal (len
);
3941 if (CONST_INT_P (len_rtx
))
3943 ret
= expand_builtin_strcpy_args (exp
, dst
, src
, target
);
3949 if (mode
!= VOIDmode
)
3950 target
= gen_reg_rtx (mode
);
3952 target
= gen_reg_rtx (GET_MODE (ret
));
3954 if (GET_MODE (target
) != GET_MODE (ret
))
3955 ret
= gen_lowpart (GET_MODE (target
), ret
);
3957 ret
= plus_constant (GET_MODE (ret
), ret
, INTVAL (len_rtx
));
3958 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3966 return expand_movstr (dst
, src
, target
,
3967 /*retmode=*/ RETURN_END_MINUS_ONE
);
3971 /* Expand a call EXP to the stpcpy builtin and diagnose uses of nonstring
3972 arguments while being careful to avoid duplicate warnings (which could
3973 be issued if the expander were to expand the call, resulting in it
3974 being emitted in expand_call(). */
3977 expand_builtin_stpcpy (tree exp
, rtx target
, machine_mode mode
)
3979 if (rtx ret
= expand_builtin_stpcpy_1 (exp
, target
, mode
))
3981 /* The call has been successfully expanded. Check for nonstring
3982 arguments and issue warnings as appropriate. */
3983 maybe_warn_nonstring_arg (get_callee_fndecl (exp
), exp
);
3990 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3991 bytes from constant string DATA + OFFSET and return it as target
3995 builtin_strncpy_read_str (void *data
, void *, HOST_WIDE_INT offset
,
3996 fixed_size_mode mode
)
3998 const char *str
= (const char *) data
;
4000 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
4003 return c_readstr (str
+ offset
, mode
);
4006 /* Helper to check the sizes of sequences and the destination of calls
4007 to __builtin_strncat and __builtin___strncat_chk. Returns true on
4008 success (no overflow or invalid sizes), false otherwise. */
4011 check_strncat_sizes (tree exp
, tree objsize
)
4013 tree dest
= CALL_EXPR_ARG (exp
, 0);
4014 tree src
= CALL_EXPR_ARG (exp
, 1);
4015 tree maxread
= CALL_EXPR_ARG (exp
, 2);
4017 /* Try to determine the range of lengths that the source expression
4019 c_strlen_data lendata
= { };
4020 get_range_strlen (src
, &lendata
, /* eltsize = */ 1);
4022 /* Try to verify that the destination is big enough for the shortest
4025 access_data
data (nullptr, exp
, access_read_write
, maxread
, true);
4026 if (!objsize
&& warn_stringop_overflow
)
4028 /* If it hasn't been provided by __strncat_chk, try to determine
4029 the size of the destination object into which the source is
4031 objsize
= compute_objsize (dest
, warn_stringop_overflow
- 1, &data
.dst
);
4034 /* Add one for the terminating nul. */
4035 tree srclen
= (lendata
.minlen
4036 ? fold_build2 (PLUS_EXPR
, size_type_node
, lendata
.minlen
,
4040 /* The strncat function copies at most MAXREAD bytes and always appends
4041 the terminating nul so the specified upper bound should never be equal
4042 to (or greater than) the size of the destination. */
4043 if (tree_fits_uhwi_p (maxread
) && tree_fits_uhwi_p (objsize
)
4044 && tree_int_cst_equal (objsize
, maxread
))
4046 location_t loc
= EXPR_LOCATION (exp
);
4047 warning_at (loc
, OPT_Wstringop_overflow_
,
4048 "%qD specified bound %E equals destination size",
4049 get_callee_fndecl (exp
), maxread
);
4055 || (maxread
&& tree_fits_uhwi_p (maxread
)
4056 && tree_fits_uhwi_p (srclen
)
4057 && tree_int_cst_lt (maxread
, srclen
)))
4060 /* The number of bytes to write is LEN but check_access will alsoa
4061 check SRCLEN if LEN's value isn't known. */
4062 return check_access (exp
, /*dstwrite=*/NULL_TREE
, maxread
, srclen
,
4063 objsize
, data
.mode
, &data
);
4066 /* Expand expression EXP, which is a call to the strncpy builtin. Return
4067 NULL_RTX if we failed the caller should emit a normal call. */
4070 expand_builtin_strncpy (tree exp
, rtx target
)
4072 location_t loc
= EXPR_LOCATION (exp
);
4074 if (!validate_arglist (exp
,
4075 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4077 tree dest
= CALL_EXPR_ARG (exp
, 0);
4078 tree src
= CALL_EXPR_ARG (exp
, 1);
4079 /* The number of bytes to write (not the maximum). */
4080 tree len
= CALL_EXPR_ARG (exp
, 2);
4082 /* The length of the source sequence. */
4083 tree slen
= c_strlen (src
, 1);
4085 /* We must be passed a constant len and src parameter. */
4086 if (!tree_fits_uhwi_p (len
) || !slen
|| !tree_fits_uhwi_p (slen
))
4089 slen
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
4091 /* We're required to pad with trailing zeros if the requested
4092 len is greater than strlen(s2)+1. In that case try to
4093 use store_by_pieces, if it fails, punt. */
4094 if (tree_int_cst_lt (slen
, len
))
4096 unsigned int dest_align
= get_pointer_alignment (dest
);
4097 const char *p
= c_getstr (src
);
4100 if (!p
|| dest_align
== 0 || !tree_fits_uhwi_p (len
)
4101 || !can_store_by_pieces (tree_to_uhwi (len
),
4102 builtin_strncpy_read_str
,
4103 CONST_CAST (char *, p
),
4107 dest_mem
= get_memory_rtx (dest
, len
);
4108 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
4109 builtin_strncpy_read_str
,
4110 CONST_CAST (char *, p
), dest_align
, false,
4112 dest_mem
= force_operand (XEXP (dest_mem
, 0), target
);
4113 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
4120 /* Return the RTL of a register in MODE generated from PREV in the
4121 previous iteration. */
4124 gen_memset_value_from_prev (by_pieces_prev
*prev
, fixed_size_mode mode
)
4126 rtx target
= nullptr;
4127 if (prev
!= nullptr && prev
->data
!= nullptr)
4129 /* Use the previous data in the same mode. */
4130 if (prev
->mode
== mode
)
4133 fixed_size_mode prev_mode
= prev
->mode
;
4135 /* Don't use the previous data to write QImode if it is in a
4137 if (VECTOR_MODE_P (prev_mode
) && mode
== QImode
)
4140 rtx prev_rtx
= prev
->data
;
4142 if (REG_P (prev_rtx
)
4143 && HARD_REGISTER_P (prev_rtx
)
4144 && lowpart_subreg_regno (REGNO (prev_rtx
), prev_mode
, mode
) < 0)
4146 /* This case occurs when PREV_MODE is a vector and when
4147 MODE is too small to store using vector operations.
4148 After register allocation, the code will need to move the
4149 lowpart of the vector register into a non-vector register.
4151 Also, the target has chosen to use a hard register
4152 instead of going with the default choice of using a
4153 pseudo register. We should respect that choice and try to
4154 avoid creating a pseudo register with the same mode as the
4155 current hard register.
4157 In principle, we could just use a lowpart MODE subreg of
4158 the vector register. However, the vector register mode might
4159 be too wide for non-vector registers, and we already know
4160 that the non-vector mode is too small for vector registers.
4161 It's therefore likely that we'd need to spill to memory in
4162 the vector mode and reload the non-vector value from there.
4164 Try to avoid that by reducing the vector register to the
4165 smallest size that it can hold. This should increase the
4166 chances that non-vector registers can hold both the inner
4167 and outer modes of the subreg that we generate later. */
4169 fixed_size_mode candidate
;
4170 FOR_EACH_MODE_IN_CLASS (m
, GET_MODE_CLASS (mode
))
4171 if (is_a
<fixed_size_mode
> (m
, &candidate
))
4173 if (GET_MODE_SIZE (candidate
)
4174 >= GET_MODE_SIZE (prev_mode
))
4176 if (GET_MODE_SIZE (candidate
) >= GET_MODE_SIZE (mode
)
4177 && lowpart_subreg_regno (REGNO (prev_rtx
),
4178 prev_mode
, candidate
) >= 0)
4180 target
= lowpart_subreg (candidate
, prev_rtx
,
4183 prev_mode
= candidate
;
4187 if (target
== nullptr)
4188 prev_rtx
= copy_to_reg (prev_rtx
);
4191 target
= lowpart_subreg (mode
, prev_rtx
, prev_mode
);
4196 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
4197 bytes from constant string DATA + OFFSET and return it as target
4198 constant. If PREV isn't nullptr, it has the RTL info from the
4199 previous iteration. */
4202 builtin_memset_read_str (void *data
, void *prev
,
4203 HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
4204 fixed_size_mode mode
)
4206 const char *c
= (const char *) data
;
4207 unsigned int size
= GET_MODE_SIZE (mode
);
4209 rtx target
= gen_memset_value_from_prev ((by_pieces_prev
*) prev
,
4211 if (target
!= nullptr)
4213 rtx src
= gen_int_mode (*c
, QImode
);
4215 if (VECTOR_MODE_P (mode
))
4217 gcc_assert (GET_MODE_INNER (mode
) == QImode
);
4219 rtx const_vec
= gen_const_vec_duplicate (mode
, src
);
4221 /* Return CONST_VECTOR when called by a query function. */
4224 /* Use the move expander with CONST_VECTOR. */
4225 target
= gen_reg_rtx (mode
);
4226 emit_move_insn (target
, const_vec
);
4230 char *p
= XALLOCAVEC (char, size
);
4232 memset (p
, *c
, size
);
4234 return c_readstr (p
, mode
);
4237 /* Callback routine for store_by_pieces. Return the RTL of a register
4238 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
4239 char value given in the RTL register data. For example, if mode is
4240 4 bytes wide, return the RTL for 0x01010101*data. If PREV isn't
4241 nullptr, it has the RTL info from the previous iteration. */
4244 builtin_memset_gen_str (void *data
, void *prev
,
4245 HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
4246 fixed_size_mode mode
)
4252 size
= GET_MODE_SIZE (mode
);
4256 target
= gen_memset_value_from_prev ((by_pieces_prev
*) prev
, mode
);
4257 if (target
!= nullptr)
4260 if (VECTOR_MODE_P (mode
))
4262 gcc_assert (GET_MODE_INNER (mode
) == QImode
);
4264 /* vec_duplicate_optab is a precondition to pick a vector mode for
4265 the memset expander. */
4266 insn_code icode
= optab_handler (vec_duplicate_optab
, mode
);
4268 target
= gen_reg_rtx (mode
);
4269 class expand_operand ops
[2];
4270 create_output_operand (&ops
[0], target
, mode
);
4271 create_input_operand (&ops
[1], (rtx
) data
, QImode
);
4272 expand_insn (icode
, 2, ops
);
4273 if (!rtx_equal_p (target
, ops
[0].value
))
4274 emit_move_insn (target
, ops
[0].value
);
4279 p
= XALLOCAVEC (char, size
);
4280 memset (p
, 1, size
);
4281 coeff
= c_readstr (p
, mode
);
4283 target
= convert_to_mode (mode
, (rtx
) data
, 1);
4284 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
4285 return force_reg (mode
, target
);
4288 /* Expand expression EXP, which is a call to the memset builtin. Return
4289 NULL_RTX if we failed the caller should emit a normal call, otherwise
4290 try to get the result in TARGET, if convenient (and in mode MODE if that's
4294 expand_builtin_memset (tree exp
, rtx target
, machine_mode mode
)
4296 if (!validate_arglist (exp
,
4297 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4300 tree dest
= CALL_EXPR_ARG (exp
, 0);
4301 tree val
= CALL_EXPR_ARG (exp
, 1);
4302 tree len
= CALL_EXPR_ARG (exp
, 2);
4304 return expand_builtin_memset_args (dest
, val
, len
, target
, mode
, exp
);
4307 /* Check that store_by_pieces allows BITS + LEN (so that we don't
4308 expand something too unreasonably long), and every power of 2 in
4309 BITS. It is assumed that LEN has already been tested by
4312 can_store_by_multiple_pieces (unsigned HOST_WIDE_INT bits
,
4313 by_pieces_constfn constfun
,
4314 void *constfundata
, unsigned int align
,
4316 unsigned HOST_WIDE_INT len
)
4319 && !can_store_by_pieces (bits
+ len
, constfun
, constfundata
,
4323 /* BITS set are expected to be generally in the low range and
4324 contiguous. We do NOT want to repeat the test above in case BITS
4325 has a single bit set, so we terminate the loop when BITS == BIT.
4326 In the unlikely case that BITS has the MSB set, also terminate in
4327 case BIT gets shifted out. */
4328 for (unsigned HOST_WIDE_INT bit
= 1; bit
< bits
&& bit
; bit
<<= 1)
4330 if ((bits
& bit
) == 0)
4333 if (!can_store_by_pieces (bit
, constfun
, constfundata
,
4341 /* Try to store VAL (or, if NULL_RTX, VALC) in LEN bytes starting at TO.
4342 Return TRUE if successful, FALSE otherwise. TO is assumed to be
4343 aligned at an ALIGN-bits boundary. LEN must be a multiple of
4344 1<<CTZ_LEN between MIN_LEN and MAX_LEN.
4346 The strategy is to issue one store_by_pieces for each power of two,
4347 from most to least significant, guarded by a test on whether there
4348 are at least that many bytes left to copy in LEN.
4350 ??? Should we skip some powers of two in favor of loops? Maybe start
4351 at the max of TO/LEN/word alignment, at least when optimizing for
4352 size, instead of ensuring O(log len) dynamic compares? */
4355 try_store_by_multiple_pieces (rtx to
, rtx len
, unsigned int ctz_len
,
4356 unsigned HOST_WIDE_INT min_len
,
4357 unsigned HOST_WIDE_INT max_len
,
4358 rtx val
, char valc
, unsigned int align
)
4360 int max_bits
= floor_log2 (max_len
);
4361 int min_bits
= floor_log2 (min_len
);
4362 int sctz_len
= ctz_len
;
4364 gcc_checking_assert (sctz_len
>= 0);
4369 /* Bits more significant than TST_BITS are part of the shared prefix
4370 in the binary representation of both min_len and max_len. Since
4371 they're identical, we don't need to test them in the loop. */
4372 int tst_bits
= (max_bits
!= min_bits
? max_bits
4373 : floor_log2 (max_len
^ min_len
));
4375 /* Save the pre-blksize values. */
4376 int orig_max_bits
= max_bits
;
4377 int orig_tst_bits
= tst_bits
;
4379 /* Check whether it's profitable to start by storing a fixed BLKSIZE
4380 bytes, to lower max_bits. In the unlikely case of a constant LEN
4381 (implied by identical MAX_LEN and MIN_LEN), we want to issue a
4382 single store_by_pieces, but otherwise, select the minimum multiple
4383 of the ALIGN (in bytes) and of the MCD of the possible LENs, that
4384 brings MAX_LEN below TST_BITS, if that's lower than min_len. */
4385 unsigned HOST_WIDE_INT blksize
;
4386 if (max_len
> min_len
)
4388 unsigned HOST_WIDE_INT alrng
= MAX (HOST_WIDE_INT_1U
<< ctz_len
,
4389 align
/ BITS_PER_UNIT
);
4390 blksize
= max_len
- (HOST_WIDE_INT_1U
<< tst_bits
) + alrng
;
4391 blksize
&= ~(alrng
- 1);
4393 else if (max_len
== min_len
)
4396 /* Huh, max_len < min_len? Punt. See pr100843.c. */
4398 if (min_len
>= blksize
4399 /* ??? Maybe try smaller fixed-prefix blksizes before
4401 && can_store_by_pieces (blksize
, builtin_memset_read_str
,
4402 &valc
, align
, true))
4405 min_bits
= floor_log2 (min_len
);
4407 max_bits
= floor_log2 (max_len
);
4409 tst_bits
= (max_bits
!= min_bits
? max_bits
4410 : floor_log2 (max_len
^ min_len
));
4415 /* Check that we can use store by pieces for the maximum store count
4416 we may issue (initial fixed-size block, plus conditional
4417 power-of-two-sized from max_bits to ctz_len. */
4418 unsigned HOST_WIDE_INT xlenest
= blksize
;
4420 xlenest
+= ((HOST_WIDE_INT_1U
<< max_bits
) * 2
4421 - (HOST_WIDE_INT_1U
<< ctz_len
));
4422 bool max_loop
= false;
4423 bool use_store_by_pieces
= true;
4424 /* Skip the test in case of overflow in xlenest. It shouldn't
4425 happen because of the way max_bits and blksize are related, but
4426 it doesn't hurt to test. */
4427 if (blksize
> xlenest
4428 || !can_store_by_multiple_pieces (xlenest
- blksize
,
4429 builtin_memset_read_str
,
4430 &valc
, align
, true, blksize
))
4432 if (!(flag_inline_stringops
& ILSOP_MEMSET
))
4435 for (max_bits
= orig_max_bits
;
4436 max_bits
>= sctz_len
;
4439 xlenest
= ((HOST_WIDE_INT_1U
<< max_bits
) * 2
4440 - (HOST_WIDE_INT_1U
<< ctz_len
));
4441 /* Check that blksize plus the bits to be stored as blocks
4442 sized at powers of two can be stored by pieces. This is
4443 like the test above, but with smaller max_bits. Skip
4444 orig_max_bits (it would be redundant). Also skip in case
4446 if (max_bits
< orig_max_bits
4447 && xlenest
+ blksize
>= xlenest
4448 && can_store_by_multiple_pieces (xlenest
,
4449 builtin_memset_read_str
,
4450 &valc
, align
, true, blksize
))
4456 && can_store_by_multiple_pieces (xlenest
,
4457 builtin_memset_read_str
,
4458 &valc
, align
, true, 0))
4462 tst_bits
= orig_tst_bits
;
4467 if (max_bits
== sctz_len
)
4469 /* We'll get here if can_store_by_pieces refuses to
4470 store even a single QImode. We'll fall back to
4471 QImode stores then. */
4476 use_store_by_pieces
= false;
4485 /* If the boundaries are such that min and max may run a
4486 different number of trips in the initial loop, the remainder
4487 needs not be between the moduli, so set tst_bits to cover all
4488 bits. Otherwise, if the trip counts are the same, max_len
4489 has the common prefix, and the previously-computed tst_bits
4491 if (max_len
>> max_bits
> min_len
>> max_bits
)
4492 tst_bits
= max_bits
;
4495 by_pieces_constfn constfun
;
4499 constfun
= builtin_memset_gen_str
;
4500 constfundata
= val
= force_reg (TYPE_MODE (unsigned_char_type_node
),
4505 constfun
= builtin_memset_read_str
;
4506 constfundata
= &valc
;
4509 rtx ptr
= copy_addr_to_reg (XEXP (to
, 0));
4510 rtx rem
= copy_to_mode_reg (ptr_mode
, convert_to_mode (ptr_mode
, len
, 0));
4511 to
= replace_equiv_address (to
, ptr
);
4512 set_mem_align (to
, align
);
4516 to
= store_by_pieces (to
, blksize
,
4517 constfun
, constfundata
,
4519 max_len
!= 0 ? RETURN_END
: RETURN_BEGIN
);
4523 /* Adjust PTR, TO and REM. Since TO's address is likely
4524 PTR+offset, we have to replace it. */
4525 emit_move_insn (ptr
, force_operand (XEXP (to
, 0), NULL_RTX
));
4526 to
= replace_equiv_address (to
, ptr
);
4527 rtx rem_minus_blksize
= plus_constant (ptr_mode
, rem
, -blksize
);
4528 emit_move_insn (rem
, force_operand (rem_minus_blksize
, NULL_RTX
));
4531 /* Iterate over power-of-two block sizes from the maximum length to
4532 the least significant bit possibly set in the length. */
4533 for (int i
= max_bits
; i
>= sctz_len
; i
--)
4535 rtx_code_label
*loop_label
= NULL
;
4536 rtx_code_label
*label
= NULL
;
4538 blksize
= HOST_WIDE_INT_1U
<< i
;
4540 /* If we're past the bits shared between min_ and max_len, expand
4541 a test on the dynamic length, comparing it with the
4545 label
= gen_label_rtx ();
4546 emit_cmp_and_jump_insns (rem
, GEN_INT (blksize
), LT
, NULL
,
4548 profile_probability::even ());
4550 /* If we are at a bit that is in the prefix shared by min_ and
4551 max_len, skip the current BLKSIZE if the bit is clear, but do
4552 not skip the loop, even if it doesn't require
4554 else if ((max_len
& blksize
) == 0
4555 && !(max_loop
&& i
== max_bits
))
4558 if (max_loop
&& i
== max_bits
)
4560 loop_label
= gen_label_rtx ();
4561 emit_label (loop_label
);
4562 /* Since we may run this multiple times, don't assume we
4563 know anything about the offset. */
4564 clear_mem_offset (to
);
4567 bool update_needed
= i
!= sctz_len
|| loop_label
;
4568 rtx next_ptr
= NULL_RTX
;
4569 if (!use_store_by_pieces
)
4571 gcc_checking_assert (blksize
== 1);
4573 val
= gen_int_mode (valc
, QImode
);
4574 to
= change_address (to
, QImode
, 0);
4575 emit_move_insn (to
, val
);
4577 next_ptr
= plus_constant (GET_MODE (ptr
), ptr
, blksize
);
4581 /* Issue a store of BLKSIZE bytes. */
4582 to
= store_by_pieces (to
, blksize
,
4583 constfun
, constfundata
,
4585 update_needed
? RETURN_END
: RETURN_BEGIN
);
4586 next_ptr
= XEXP (to
, 0);
4588 /* Adjust REM and PTR, unless this is the last iteration. */
4591 emit_move_insn (ptr
, force_operand (next_ptr
, NULL_RTX
));
4592 to
= replace_equiv_address (to
, ptr
);
4593 rtx rem_minus_blksize
= plus_constant (ptr_mode
, rem
, -blksize
);
4594 emit_move_insn (rem
, force_operand (rem_minus_blksize
, NULL_RTX
));
4598 emit_cmp_and_jump_insns (rem
, GEN_INT (blksize
), GE
, NULL
,
4599 ptr_mode
, 1, loop_label
,
4600 profile_probability::likely ());
4606 /* Given conditional stores, the offset can no longer be
4607 known, so clear it. */
4608 clear_mem_offset (to
);
4615 /* Helper function to do the actual work for expand_builtin_memset. The
4616 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
4617 so that this can also be called without constructing an actual CALL_EXPR.
4618 The other arguments and return value are the same as for
4619 expand_builtin_memset. */
4622 expand_builtin_memset_args (tree dest
, tree val
, tree len
,
4623 rtx target
, machine_mode mode
, tree orig_exp
)
4626 enum built_in_function fcode
;
4627 machine_mode val_mode
;
4629 unsigned int dest_align
;
4630 rtx dest_mem
, dest_addr
, len_rtx
;
4631 HOST_WIDE_INT expected_size
= -1;
4632 unsigned int expected_align
= 0;
4633 unsigned HOST_WIDE_INT min_size
;
4634 unsigned HOST_WIDE_INT max_size
;
4635 unsigned HOST_WIDE_INT probable_max_size
;
4637 dest_align
= get_pointer_alignment (dest
);
4639 /* If DEST is not a pointer type, don't do this operation in-line. */
4640 if (dest_align
== 0)
4643 if (currently_expanding_gimple_stmt
)
4644 stringop_block_profile (currently_expanding_gimple_stmt
,
4645 &expected_align
, &expected_size
);
4647 if (expected_align
< dest_align
)
4648 expected_align
= dest_align
;
4650 /* If the LEN parameter is zero, return DEST. */
4651 if (integer_zerop (len
))
4653 /* Evaluate and ignore VAL in case it has side-effects. */
4654 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4655 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
4658 /* Stabilize the arguments in case we fail. */
4659 dest
= builtin_save_expr (dest
);
4660 val
= builtin_save_expr (val
);
4661 len
= builtin_save_expr (len
);
4663 len_rtx
= expand_normal (len
);
4664 determine_block_size (len
, len_rtx
, &min_size
, &max_size
,
4665 &probable_max_size
);
4666 dest_mem
= get_memory_rtx (dest
, len
);
4667 val_mode
= TYPE_MODE (unsigned_char_type_node
);
4669 if (TREE_CODE (val
) != INTEGER_CST
4670 || target_char_cast (val
, &c
))
4674 val_rtx
= expand_normal (val
);
4675 val_rtx
= convert_to_mode (val_mode
, val_rtx
, 0);
4677 /* Assume that we can memset by pieces if we can store
4678 * the coefficients by pieces (in the required modes).
4679 * We can't pass builtin_memset_gen_str as that emits RTL. */
4681 if (tree_fits_uhwi_p (len
)
4682 && can_store_by_pieces (tree_to_uhwi (len
),
4683 builtin_memset_read_str
, &c
, dest_align
,
4686 val_rtx
= force_reg (val_mode
, val_rtx
);
4687 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
4688 builtin_memset_gen_str
, val_rtx
, dest_align
,
4689 true, RETURN_BEGIN
);
4691 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, val_rtx
,
4692 dest_align
, expected_align
,
4693 expected_size
, min_size
, max_size
,
4695 && !try_store_by_multiple_pieces (dest_mem
, len_rtx
,
4702 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
4703 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
4709 if (tree_fits_uhwi_p (len
)
4710 && can_store_by_pieces (tree_to_uhwi (len
),
4711 builtin_memset_read_str
, &c
, dest_align
,
4713 store_by_pieces (dest_mem
, tree_to_uhwi (len
),
4714 builtin_memset_read_str
, &c
, dest_align
, true,
4716 else if (!set_storage_via_setmem (dest_mem
, len_rtx
,
4717 gen_int_mode (c
, val_mode
),
4718 dest_align
, expected_align
,
4719 expected_size
, min_size
, max_size
,
4721 && !try_store_by_multiple_pieces (dest_mem
, len_rtx
,
4728 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
4729 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
4733 set_mem_align (dest_mem
, dest_align
);
4734 dest_addr
= clear_storage_hints (dest_mem
, len_rtx
,
4735 CALL_EXPR_TAILCALL (orig_exp
)
4736 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
,
4737 expected_align
, expected_size
,
4739 probable_max_size
, tree_ctz (len
));
4743 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
4744 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
4750 fndecl
= get_callee_fndecl (orig_exp
);
4751 fcode
= DECL_FUNCTION_CODE (fndecl
);
4752 if (fcode
== BUILT_IN_MEMSET
)
4753 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 3,
4755 else if (fcode
== BUILT_IN_BZERO
)
4756 fn
= build_call_nofold_loc (EXPR_LOCATION (orig_exp
), fndecl
, 2,
4760 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
4761 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
4762 return expand_call (fn
, target
, target
== const0_rtx
);
4765 /* Expand expression EXP, which is a call to the bzero builtin. Return
4766 NULL_RTX if we failed the caller should emit a normal call. */
4769 expand_builtin_bzero (tree exp
)
4771 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4774 tree dest
= CALL_EXPR_ARG (exp
, 0);
4775 tree size
= CALL_EXPR_ARG (exp
, 1);
4777 /* New argument list transforming bzero(ptr x, int y) to
4778 memset(ptr x, int 0, size_t y). This is done this way
4779 so that if it isn't expanded inline, we fallback to
4780 calling bzero instead of memset. */
4782 location_t loc
= EXPR_LOCATION (exp
);
4784 return expand_builtin_memset_args (dest
, integer_zero_node
,
4785 fold_convert_loc (loc
,
4786 size_type_node
, size
),
4787 const0_rtx
, VOIDmode
, exp
);
4790 /* Try to expand cmpstr operation ICODE with the given operands.
4791 Return the result rtx on success, otherwise return null. */
4794 expand_cmpstr (insn_code icode
, rtx target
, rtx arg1_rtx
, rtx arg2_rtx
,
4795 HOST_WIDE_INT align
)
4797 machine_mode insn_mode
= insn_data
[icode
].operand
[0].mode
;
4799 if (target
&& (!REG_P (target
) || HARD_REGISTER_P (target
)))
4802 class expand_operand ops
[4];
4803 create_output_operand (&ops
[0], target
, insn_mode
);
4804 create_fixed_operand (&ops
[1], arg1_rtx
);
4805 create_fixed_operand (&ops
[2], arg2_rtx
);
4806 create_integer_operand (&ops
[3], align
);
4807 if (maybe_expand_insn (icode
, 4, ops
))
4808 return ops
[0].value
;
4812 /* Expand expression EXP, which is a call to the memcmp built-in function.
4813 Return NULL_RTX if we failed and the caller should emit a normal call,
4814 otherwise try to get the result in TARGET, if convenient.
4815 RESULT_EQ is true if we can relax the returned value to be either zero
4816 or nonzero, without caring about the sign. */
4819 expand_builtin_memcmp (tree exp
, rtx target
, bool result_eq
)
4821 if (!validate_arglist (exp
,
4822 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
4825 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4826 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4827 tree len
= CALL_EXPR_ARG (exp
, 2);
4829 /* Due to the performance benefit, always inline the calls first
4830 when result_eq is false. */
4831 rtx result
= NULL_RTX
;
4832 enum built_in_function fcode
= DECL_FUNCTION_CODE (get_callee_fndecl (exp
));
4833 if (!result_eq
&& fcode
!= BUILT_IN_BCMP
)
4835 result
= inline_expand_builtin_bytecmp (exp
, target
);
4840 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4841 location_t loc
= EXPR_LOCATION (exp
);
4843 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4844 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4846 /* If we don't have POINTER_TYPE, call the function. */
4847 if (arg1_align
== 0 || arg2_align
== 0)
4850 rtx arg1_rtx
= get_memory_rtx (arg1
, len
);
4851 rtx arg2_rtx
= get_memory_rtx (arg2
, len
);
4852 rtx len_rtx
= expand_normal (fold_convert_loc (loc
, sizetype
, len
));
4854 /* Set MEM_SIZE as appropriate. */
4855 if (CONST_INT_P (len_rtx
))
4857 set_mem_size (arg1_rtx
, INTVAL (len_rtx
));
4858 set_mem_size (arg2_rtx
, INTVAL (len_rtx
));
4861 by_pieces_constfn constfn
= NULL
;
4863 /* Try to get the byte representation of the constant ARG2 (or, only
4864 when the function's result is used for equality to zero, ARG1)
4865 points to, with its byte size in NBYTES. */
4866 unsigned HOST_WIDE_INT nbytes
;
4867 const char *rep
= getbyterep (arg2
, &nbytes
);
4868 if (result_eq
&& rep
== NULL
)
4870 /* For equality to zero the arguments are interchangeable. */
4871 rep
= getbyterep (arg1
, &nbytes
);
4873 std::swap (arg1_rtx
, arg2_rtx
);
4876 /* If the function's constant bound LEN_RTX is less than or equal
4877 to the byte size of the representation of the constant argument,
4878 and if block move would be done by pieces, we can avoid loading
4879 the bytes from memory and only store the computed constant result. */
4881 && CONST_INT_P (len_rtx
)
4882 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= nbytes
)
4883 constfn
= builtin_memcpy_read_str
;
4885 result
= emit_block_cmp_hints (arg1_rtx
, arg2_rtx
, len_rtx
,
4886 TREE_TYPE (len
), target
,
4888 CONST_CAST (char *, rep
),
4893 /* Return the value in the proper mode for this function. */
4894 if (GET_MODE (result
) == mode
)
4899 convert_move (target
, result
, 0);
4903 return convert_to_mode (mode
, result
, 0);
4909 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4910 if we failed the caller should emit a normal call, otherwise try to get
4911 the result in TARGET, if convenient. */
4914 expand_builtin_strcmp (tree exp
, ATTRIBUTE_UNUSED rtx target
)
4916 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4919 tree arg1
= CALL_EXPR_ARG (exp
, 0);
4920 tree arg2
= CALL_EXPR_ARG (exp
, 1);
4922 /* Due to the performance benefit, always inline the calls first. */
4923 rtx result
= NULL_RTX
;
4924 result
= inline_expand_builtin_bytecmp (exp
, target
);
4928 insn_code cmpstr_icode
= direct_optab_handler (cmpstr_optab
, SImode
);
4929 insn_code cmpstrn_icode
= direct_optab_handler (cmpstrn_optab
, SImode
);
4930 if (cmpstr_icode
== CODE_FOR_nothing
&& cmpstrn_icode
== CODE_FOR_nothing
)
4933 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
4934 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
4936 /* If we don't have POINTER_TYPE, call the function. */
4937 if (arg1_align
== 0 || arg2_align
== 0)
4940 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4941 arg1
= builtin_save_expr (arg1
);
4942 arg2
= builtin_save_expr (arg2
);
4944 rtx arg1_rtx
= get_memory_rtx (arg1
, NULL
);
4945 rtx arg2_rtx
= get_memory_rtx (arg2
, NULL
);
4947 /* Try to call cmpstrsi. */
4948 if (cmpstr_icode
!= CODE_FOR_nothing
)
4949 result
= expand_cmpstr (cmpstr_icode
, target
, arg1_rtx
, arg2_rtx
,
4950 MIN (arg1_align
, arg2_align
));
4952 /* Try to determine at least one length and call cmpstrnsi. */
4953 if (!result
&& cmpstrn_icode
!= CODE_FOR_nothing
)
4958 tree len1
= c_strlen (arg1
, 1);
4959 tree len2
= c_strlen (arg2
, 1);
4962 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
4964 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
4966 /* If we don't have a constant length for the first, use the length
4967 of the second, if we know it. We don't require a constant for
4968 this case; some cost analysis could be done if both are available
4969 but neither is constant. For now, assume they're equally cheap,
4970 unless one has side effects. If both strings have constant lengths,
4977 else if (TREE_SIDE_EFFECTS (len1
))
4979 else if (TREE_SIDE_EFFECTS (len2
))
4981 else if (TREE_CODE (len1
) != INTEGER_CST
)
4983 else if (TREE_CODE (len2
) != INTEGER_CST
)
4985 else if (tree_int_cst_lt (len1
, len2
))
4990 /* If both arguments have side effects, we cannot optimize. */
4991 if (len
&& !TREE_SIDE_EFFECTS (len
))
4993 arg3_rtx
= expand_normal (len
);
4994 result
= expand_cmpstrn_or_cmpmem
4995 (cmpstrn_icode
, target
, arg1_rtx
, arg2_rtx
, TREE_TYPE (len
),
4996 arg3_rtx
, MIN (arg1_align
, arg2_align
));
5000 tree fndecl
= get_callee_fndecl (exp
);
5003 /* Return the value in the proper mode for this function. */
5004 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
5005 if (GET_MODE (result
) == mode
)
5008 return convert_to_mode (mode
, result
, 0);
5009 convert_move (target
, result
, 0);
5013 /* Expand the library call ourselves using a stabilized argument
5014 list to avoid re-evaluating the function's arguments twice. */
5015 tree fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fndecl
, 2, arg1
, arg2
);
5016 copy_warning (fn
, exp
);
5017 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
5018 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
5019 return expand_call (fn
, target
, target
== const0_rtx
);
5022 /* Expand expression EXP, which is a call to the strncmp builtin. Return
5023 NULL_RTX if we failed the caller should emit a normal call, otherwise
5024 try to get the result in TARGET, if convenient. */
5027 expand_builtin_strncmp (tree exp
, ATTRIBUTE_UNUSED rtx target
,
5028 ATTRIBUTE_UNUSED machine_mode mode
)
5030 if (!validate_arglist (exp
,
5031 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5034 tree arg1
= CALL_EXPR_ARG (exp
, 0);
5035 tree arg2
= CALL_EXPR_ARG (exp
, 1);
5036 tree arg3
= CALL_EXPR_ARG (exp
, 2);
5038 location_t loc
= EXPR_LOCATION (exp
);
5039 tree len1
= c_strlen (arg1
, 1);
5040 tree len2
= c_strlen (arg2
, 1);
5042 /* Due to the performance benefit, always inline the calls first. */
5043 rtx result
= NULL_RTX
;
5044 result
= inline_expand_builtin_bytecmp (exp
, target
);
5048 /* If c_strlen can determine an expression for one of the string
5049 lengths, and it doesn't have side effects, then emit cmpstrnsi
5050 using length MIN(strlen(string)+1, arg3). */
5051 insn_code cmpstrn_icode
= direct_optab_handler (cmpstrn_optab
, SImode
);
5052 if (cmpstrn_icode
== CODE_FOR_nothing
)
5057 unsigned int arg1_align
= get_pointer_alignment (arg1
) / BITS_PER_UNIT
;
5058 unsigned int arg2_align
= get_pointer_alignment (arg2
) / BITS_PER_UNIT
;
5061 len1
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len1
);
5063 len2
= size_binop_loc (loc
, PLUS_EXPR
, ssize_int (1), len2
);
5065 tree len3
= fold_convert_loc (loc
, sizetype
, arg3
);
5067 /* If we don't have a constant length for the first, use the length
5068 of the second, if we know it. If neither string is constant length,
5069 use the given length argument. We don't require a constant for
5070 this case; some cost analysis could be done if both are available
5071 but neither is constant. For now, assume they're equally cheap,
5072 unless one has side effects. If both strings have constant lengths,
5081 else if (TREE_SIDE_EFFECTS (len1
))
5083 else if (TREE_SIDE_EFFECTS (len2
))
5085 else if (TREE_CODE (len1
) != INTEGER_CST
)
5087 else if (TREE_CODE (len2
) != INTEGER_CST
)
5089 else if (tree_int_cst_lt (len1
, len2
))
5094 /* If we are not using the given length, we must incorporate it here.
5095 The actual new length parameter will be MIN(len,arg3) in this case. */
5098 len
= fold_convert_loc (loc
, sizetype
, len
);
5099 len
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (len
), len
, len3
);
5101 rtx arg1_rtx
= get_memory_rtx (arg1
, len
);
5102 rtx arg2_rtx
= get_memory_rtx (arg2
, len
);
5103 rtx arg3_rtx
= expand_normal (len
);
5104 result
= expand_cmpstrn_or_cmpmem (cmpstrn_icode
, target
, arg1_rtx
,
5105 arg2_rtx
, TREE_TYPE (len
), arg3_rtx
,
5106 MIN (arg1_align
, arg2_align
));
5108 tree fndecl
= get_callee_fndecl (exp
);
5111 /* Return the value in the proper mode for this function. */
5112 mode
= TYPE_MODE (TREE_TYPE (exp
));
5113 if (GET_MODE (result
) == mode
)
5116 return convert_to_mode (mode
, result
, 0);
5117 convert_move (target
, result
, 0);
5121 /* Expand the library call ourselves using a stabilized argument
5122 list to avoid re-evaluating the function's arguments twice. */
5123 tree call
= build_call_nofold_loc (loc
, fndecl
, 3, arg1
, arg2
, len
);
5124 copy_warning (call
, exp
);
5125 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5126 CALL_EXPR_TAILCALL (call
) = CALL_EXPR_TAILCALL (exp
);
5127 return expand_call (call
, target
, target
== const0_rtx
);
5130 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
5131 if that's convenient. */
5134 expand_builtin_saveregs (void)
5139 /* Don't do __builtin_saveregs more than once in a function.
5140 Save the result of the first call and reuse it. */
5141 if (saveregs_value
!= 0)
5142 return saveregs_value
;
5144 /* When this function is called, it means that registers must be
5145 saved on entry to this function. So we migrate the call to the
5146 first insn of this function. */
5150 /* Do whatever the machine needs done in this case. */
5151 val
= targetm
.calls
.expand_builtin_saveregs ();
5156 saveregs_value
= val
;
5158 /* Put the insns after the NOTE that starts the function. If this
5159 is inside a start_sequence, make the outer-level insn chain current, so
5160 the code is placed at the start of the function. */
5161 push_topmost_sequence ();
5162 emit_insn_after (seq
, entry_of_function ());
5163 pop_topmost_sequence ();
5168 /* Expand a call to __builtin_next_arg. */
5171 expand_builtin_next_arg (void)
5173 /* Checking arguments is already done in fold_builtin_next_arg
5174 that must be called before this function. */
5175 return expand_binop (ptr_mode
, add_optab
,
5176 crtl
->args
.internal_arg_pointer
,
5177 crtl
->args
.arg_offset_rtx
,
5178 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
5181 /* Make it easier for the backends by protecting the valist argument
5182 from multiple evaluations. */
5185 stabilize_va_list_loc (location_t loc
, tree valist
, int needs_lvalue
)
5187 tree vatype
= targetm
.canonical_va_list_type (TREE_TYPE (valist
));
5189 /* The current way of determining the type of valist is completely
5190 bogus. We should have the information on the va builtin instead. */
5192 vatype
= targetm
.fn_abi_va_list (cfun
->decl
);
5194 if (TREE_CODE (vatype
) == ARRAY_TYPE
)
5196 if (TREE_SIDE_EFFECTS (valist
))
5197 valist
= save_expr (valist
);
5199 /* For this case, the backends will be expecting a pointer to
5200 vatype, but it's possible we've actually been given an array
5201 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
5203 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
5205 tree p1
= build_pointer_type (TREE_TYPE (vatype
));
5206 valist
= build_fold_addr_expr_with_type_loc (loc
, valist
, p1
);
5211 tree pt
= build_pointer_type (vatype
);
5215 if (! TREE_SIDE_EFFECTS (valist
))
5218 valist
= fold_build1_loc (loc
, ADDR_EXPR
, pt
, valist
);
5219 TREE_SIDE_EFFECTS (valist
) = 1;
5222 if (TREE_SIDE_EFFECTS (valist
))
5223 valist
= save_expr (valist
);
5224 valist
= fold_build2_loc (loc
, MEM_REF
,
5225 vatype
, valist
, build_int_cst (pt
, 0));
5231 /* The "standard" definition of va_list is void*. */
5234 std_build_builtin_va_list (void)
5236 return ptr_type_node
;
5239 /* The "standard" abi va_list is va_list_type_node. */
5242 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED
)
5244 return va_list_type_node
;
5247 /* The "standard" type of va_list is va_list_type_node. */
5250 std_canonical_va_list_type (tree type
)
5254 wtype
= va_list_type_node
;
5257 if (TREE_CODE (wtype
) == ARRAY_TYPE
)
5259 /* If va_list is an array type, the argument may have decayed
5260 to a pointer type, e.g. by being passed to another function.
5261 In that case, unwrap both types so that we can compare the
5262 underlying records. */
5263 if (TREE_CODE (htype
) == ARRAY_TYPE
5264 || POINTER_TYPE_P (htype
))
5266 wtype
= TREE_TYPE (wtype
);
5267 htype
= TREE_TYPE (htype
);
5270 if (TYPE_MAIN_VARIANT (wtype
) == TYPE_MAIN_VARIANT (htype
))
5271 return va_list_type_node
;
5276 /* The "standard" implementation of va_start: just assign `nextarg' to
5280 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
5282 rtx va_r
= expand_expr (valist
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
5283 convert_move (va_r
, nextarg
, 0);
5286 /* Expand EXP, a call to __builtin_va_start. */
5289 expand_builtin_va_start (tree exp
)
5293 location_t loc
= EXPR_LOCATION (exp
);
5295 if (call_expr_nargs (exp
) < 2)
5297 error_at (loc
, "too few arguments to function %<va_start%>");
5301 if (fold_builtin_next_arg (exp
, true))
5304 nextarg
= expand_builtin_next_arg ();
5305 valist
= stabilize_va_list_loc (loc
, CALL_EXPR_ARG (exp
, 0), 1);
5307 if (targetm
.expand_builtin_va_start
)
5308 targetm
.expand_builtin_va_start (valist
, nextarg
);
5310 std_expand_builtin_va_start (valist
, nextarg
);
5315 /* Expand EXP, a call to __builtin_va_end. */
5318 expand_builtin_va_end (tree exp
)
5320 tree valist
= CALL_EXPR_ARG (exp
, 0);
5322 /* Evaluate for side effects, if needed. I hate macros that don't
5324 if (TREE_SIDE_EFFECTS (valist
))
5325 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5330 /* Expand EXP, a call to __builtin_va_copy. We do this as a
5331 builtin rather than just as an assignment in stdarg.h because of the
5332 nastiness of array-type va_list types. */
5335 expand_builtin_va_copy (tree exp
)
5338 location_t loc
= EXPR_LOCATION (exp
);
5340 dst
= CALL_EXPR_ARG (exp
, 0);
5341 src
= CALL_EXPR_ARG (exp
, 1);
5343 dst
= stabilize_va_list_loc (loc
, dst
, 1);
5344 src
= stabilize_va_list_loc (loc
, src
, 0);
5346 gcc_assert (cfun
!= NULL
&& cfun
->decl
!= NULL_TREE
);
5348 if (TREE_CODE (targetm
.fn_abi_va_list (cfun
->decl
)) != ARRAY_TYPE
)
5350 t
= build2 (MODIFY_EXPR
, targetm
.fn_abi_va_list (cfun
->decl
), dst
, src
);
5351 TREE_SIDE_EFFECTS (t
) = 1;
5352 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5356 rtx dstb
, srcb
, size
;
5358 /* Evaluate to pointers. */
5359 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
5360 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
5361 size
= expand_expr (TYPE_SIZE_UNIT (targetm
.fn_abi_va_list (cfun
->decl
)),
5362 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
5364 dstb
= convert_memory_address (Pmode
, dstb
);
5365 srcb
= convert_memory_address (Pmode
, srcb
);
5367 /* "Dereference" to BLKmode memories. */
5368 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
5369 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
5370 set_mem_align (dstb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
5371 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
5372 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
5373 set_mem_align (srcb
, TYPE_ALIGN (targetm
.fn_abi_va_list (cfun
->decl
)));
5376 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
5382 /* Expand a call to one of the builtin functions __builtin_frame_address or
5383 __builtin_return_address. */
5386 expand_builtin_frame_address (tree fndecl
, tree exp
)
5388 /* The argument must be a nonnegative integer constant.
5389 It counts the number of frames to scan up the stack.
5390 The value is either the frame pointer value or the return
5391 address saved in that frame. */
5392 if (call_expr_nargs (exp
) == 0)
5393 /* Warning about missing arg was already issued. */
5395 else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp
, 0)))
5397 error ("invalid argument to %qD", fndecl
);
5402 /* Number of frames to scan up the stack. */
5403 unsigned HOST_WIDE_INT count
= tree_to_uhwi (CALL_EXPR_ARG (exp
, 0));
5405 rtx tem
= expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
), count
);
5407 /* Some ports cannot access arbitrary stack frames. */
5410 warning (0, "unsupported argument to %qD", fndecl
);
5416 /* Warn since no effort is made to ensure that any frame
5417 beyond the current one exists or can be safely reached. */
5418 warning (OPT_Wframe_address
, "calling %qD with "
5419 "a nonzero argument is unsafe", fndecl
);
5422 /* For __builtin_frame_address, return what we've got. */
5423 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
5427 && ! CONSTANT_P (tem
))
5428 tem
= copy_addr_to_reg (tem
);
5433 #if ! STACK_GROWS_DOWNWARD
5434 # define STACK_TOPS GT
5436 # define STACK_TOPS LT
5439 #ifdef POINTERS_EXTEND_UNSIGNED
5440 # define STACK_UNSIGNED POINTERS_EXTEND_UNSIGNED
5442 # define STACK_UNSIGNED true
5445 /* Expand a call to builtin function __builtin_stack_address. */
5448 expand_builtin_stack_address ()
5450 rtx ret
= convert_to_mode (ptr_mode
, copy_to_reg (stack_pointer_rtx
),
5453 /* Unbias the stack pointer, bringing it to the boundary between the
5454 stack area claimed by the active function calling this builtin,
5455 and stack ranges that could get clobbered if it called another
5456 function. It should NOT encompass any stack red zone, that is
5457 used in leaf functions.
5459 On SPARC, the register save area is *not* considered active or
5460 used by the active function, but rather as akin to the area in
5461 which call-preserved registers are saved by callees. This
5462 enables __strub_leave to clear what would otherwise overlap with
5463 its own register save area.
5465 If the address is computed too high or too low, parts of a stack
5466 range that should be scrubbed may be left unscrubbed, scrubbing
5467 may corrupt active portions of the stack frame, and stack ranges
5468 may be doubly-scrubbed by caller and callee.
5470 In order for it to be just right, the area delimited by
5471 @code{__builtin_stack_address} and @code{__builtin_frame_address
5472 (0)} should encompass caller's registers saved by the function,
5473 local on-stack variables and @code{alloca} stack areas.
5474 Accumulated outgoing on-stack arguments, preallocated as part of
5475 a function's own prologue, are to be regarded as part of the
5476 (caller) function's active area as well, whereas those pushed or
5477 allocated temporarily for a call are regarded as part of the
5478 callee's stack range, rather than the caller's. */
5479 ret
= plus_constant (ptr_mode
, ret
, STACK_POINTER_OFFSET
);
5481 return force_reg (ptr_mode
, ret
);
5484 /* Expand a call to builtin function __builtin_strub_enter. */
5487 expand_builtin_strub_enter (tree exp
)
5489 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5492 if (optimize
< 1 || flag_no_inline
)
5495 rtx stktop
= expand_builtin_stack_address ();
5497 tree wmptr
= CALL_EXPR_ARG (exp
, 0);
5498 tree wmtype
= TREE_TYPE (TREE_TYPE (wmptr
));
5499 tree wmtree
= fold_build2 (MEM_REF
, wmtype
, wmptr
,
5500 build_int_cst (TREE_TYPE (wmptr
), 0));
5501 rtx wmark
= expand_expr (wmtree
, NULL_RTX
, ptr_mode
, EXPAND_MEMORY
);
5503 emit_move_insn (wmark
, stktop
);
5508 /* Expand a call to builtin function __builtin_strub_update. */
5511 expand_builtin_strub_update (tree exp
)
5513 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5516 if (optimize
< 2 || flag_no_inline
)
5519 rtx stktop
= expand_builtin_stack_address ();
5521 #ifdef RED_ZONE_SIZE
5522 /* Here's how the strub enter, update and leave functions deal with red zones.
5524 If it weren't for red zones, update, called from within a strub context,
5525 would bump the watermark to the top of the stack. Enter and leave, running
5526 in the caller, would use the caller's top of stack address both to
5527 initialize the watermark passed to the callee, and to start strubbing the
5530 Ideally, we'd update the watermark so as to cover the used amount of red
5531 zone, and strub starting at the caller's other end of the (presumably
5532 unused) red zone. Normally, only leaf functions use the red zone, but at
5533 this point we can't tell whether a function is a leaf, nor can we tell how
5534 much of the red zone it uses. Furthermore, some strub contexts may have
5535 been inlined so that update and leave are called from the same stack frame,
5536 and the strub builtins may all have been inlined, turning a strub function
5539 So cleaning the range from the caller's stack pointer (one end of the red
5540 zone) to the (potentially inlined) callee's (other end of the) red zone
5541 could scribble over the caller's own red zone.
5543 We avoid this possibility by arranging for callers that are strub contexts
5544 to use their own watermark as the strub starting point. So, if A calls B,
5545 and B calls C, B will tell A to strub up to the end of B's red zone, and
5546 will strub itself only the part of C's stack frame and red zone that
5547 doesn't overlap with B's. With that, we don't need to know who's leaf and
5548 who isn't: inlined calls will shrink their strub window to zero, each
5549 remaining call will strub some portion of the stack, and eventually the
5550 strub context will return to a caller that isn't a strub context itself,
5551 that will therefore use its own stack pointer as the strub starting point.
5552 It's not a leaf, because strub contexts can't be inlined into non-strub
5553 contexts, so it doesn't use the red zone, and it will therefore correctly
5554 strub up the callee's stack frame up to the end of the callee's red zone.
5556 if (true /* (flags_from_decl_or_type (current_function_decl) & ECF_LEAF) */)
5558 poly_int64 red_zone_size
= RED_ZONE_SIZE
;
5559 #if STACK_GROWS_DOWNWARD
5560 red_zone_size
= -red_zone_size
;
5562 stktop
= plus_constant (ptr_mode
, stktop
, red_zone_size
);
5563 stktop
= force_reg (ptr_mode
, stktop
);
5567 tree wmptr
= CALL_EXPR_ARG (exp
, 0);
5568 tree wmtype
= TREE_TYPE (TREE_TYPE (wmptr
));
5569 tree wmtree
= fold_build2 (MEM_REF
, wmtype
, wmptr
,
5570 build_int_cst (TREE_TYPE (wmptr
), 0));
5571 rtx wmark
= expand_expr (wmtree
, NULL_RTX
, ptr_mode
, EXPAND_MEMORY
);
5573 rtx wmarkr
= force_reg (ptr_mode
, wmark
);
5575 rtx_code_label
*lab
= gen_label_rtx ();
5576 do_compare_rtx_and_jump (stktop
, wmarkr
, STACK_TOPS
, STACK_UNSIGNED
,
5577 ptr_mode
, NULL_RTX
, lab
, NULL
,
5578 profile_probability::very_likely ());
5579 emit_move_insn (wmark
, stktop
);
5581 /* If this is an inlined strub function, also bump the watermark for the
5582 enclosing function. This avoids a problem with the following scenario: A
5583 calls B and B calls C, and both B and C get inlined into A. B allocates
5584 temporary stack space before calling C. If we don't update A's watermark,
5585 we may use an outdated baseline for the post-C strub_leave, erasing B's
5586 temporary stack allocation. We only need this if we're fully expanding
5587 strub_leave inline. */
5588 tree xwmptr
= (optimize
> 2
5589 ? strub_watermark_parm (current_function_decl
)
5591 if (wmptr
!= xwmptr
)
5594 wmtype
= TREE_TYPE (TREE_TYPE (wmptr
));
5595 wmtree
= fold_build2 (MEM_REF
, wmtype
, wmptr
,
5596 build_int_cst (TREE_TYPE (wmptr
), 0));
5597 wmark
= expand_expr (wmtree
, NULL_RTX
, ptr_mode
, EXPAND_MEMORY
);
5598 wmarkr
= force_reg (ptr_mode
, wmark
);
5600 do_compare_rtx_and_jump (stktop
, wmarkr
, STACK_TOPS
, STACK_UNSIGNED
,
5601 ptr_mode
, NULL_RTX
, lab
, NULL
,
5602 profile_probability::very_likely ());
5603 emit_move_insn (wmark
, stktop
);
5612 /* Expand a call to builtin function __builtin_strub_leave. */
5615 expand_builtin_strub_leave (tree exp
)
5617 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
5620 if (optimize
< 2 || optimize_size
|| flag_no_inline
)
5623 rtx stktop
= NULL_RTX
;
5625 if (tree wmptr
= (optimize
5626 ? strub_watermark_parm (current_function_decl
)
5629 tree wmtype
= TREE_TYPE (TREE_TYPE (wmptr
));
5630 tree wmtree
= fold_build2 (MEM_REF
, wmtype
, wmptr
,
5631 build_int_cst (TREE_TYPE (wmptr
), 0));
5632 rtx wmark
= expand_expr (wmtree
, NULL_RTX
, ptr_mode
, EXPAND_MEMORY
);
5633 stktop
= force_reg (ptr_mode
, wmark
);
5637 stktop
= expand_builtin_stack_address ();
5639 tree wmptr
= CALL_EXPR_ARG (exp
, 0);
5640 tree wmtype
= TREE_TYPE (TREE_TYPE (wmptr
));
5641 tree wmtree
= fold_build2 (MEM_REF
, wmtype
, wmptr
,
5642 build_int_cst (TREE_TYPE (wmptr
), 0));
5643 rtx wmark
= expand_expr (wmtree
, NULL_RTX
, ptr_mode
, EXPAND_MEMORY
);
5645 rtx wmarkr
= force_reg (ptr_mode
, wmark
);
5647 #if ! STACK_GROWS_DOWNWARD
5655 /* We're going to modify it, so make sure it's not e.g. the stack pointer. */
5656 base
= copy_to_reg (base
);
5658 rtx_code_label
*done
= gen_label_rtx ();
5659 do_compare_rtx_and_jump (base
, end
, LT
, STACK_UNSIGNED
,
5660 ptr_mode
, NULL_RTX
, done
, NULL
,
5661 profile_probability::very_likely ());
5664 expand_call (exp
, NULL_RTX
, true);
5667 /* Ok, now we've determined we want to copy the block, so convert the
5668 addresses to Pmode, as needed to dereference them to access ptr_mode
5669 memory locations, so that we don't have to convert anything within the
5671 base
= memory_address (ptr_mode
, base
);
5672 end
= memory_address (ptr_mode
, end
);
5674 rtx zero
= force_operand (const0_rtx
, NULL_RTX
);
5675 int ulen
= GET_MODE_SIZE (ptr_mode
);
5677 /* ??? It would be nice to use setmem or similar patterns here,
5678 but they do not necessarily obey the stack growth direction,
5679 which has security implications. We also have to avoid calls
5680 (memset, bzero or any machine-specific ones), which are
5681 likely unsafe here (see TARGET_STRUB_MAY_USE_MEMSET). */
5682 #if ! STACK_GROWS_DOWNWARD
5683 rtx incr
= plus_constant (Pmode
, base
, ulen
);
5684 rtx dstm
= gen_rtx_MEM (ptr_mode
, base
);
5686 rtx_code_label
*loop
= gen_label_rtx ();
5688 emit_move_insn (dstm
, zero
);
5689 emit_move_insn (base
, force_operand (incr
, NULL_RTX
));
5691 rtx decr
= plus_constant (Pmode
, end
, -ulen
);
5692 rtx dstm
= gen_rtx_MEM (ptr_mode
, end
);
5694 rtx_code_label
*loop
= gen_label_rtx ();
5696 emit_move_insn (end
, force_operand (decr
, NULL_RTX
));
5697 emit_move_insn (dstm
, zero
);
5699 do_compare_rtx_and_jump (base
, end
, LT
, STACK_UNSIGNED
,
5700 Pmode
, NULL_RTX
, NULL
, loop
,
5701 profile_probability::very_likely ());
5709 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
5710 failed and the caller should emit a normal call. */
5713 expand_builtin_alloca (tree exp
)
5718 tree fndecl
= get_callee_fndecl (exp
);
5719 HOST_WIDE_INT max_size
;
5720 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5721 bool alloca_for_var
= CALL_ALLOCA_FOR_VAR_P (exp
);
5723 = (fcode
== BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
5724 ? validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
,
5726 : fcode
== BUILT_IN_ALLOCA_WITH_ALIGN
5727 ? validate_arglist (exp
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5728 : validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
));
5733 /* Compute the argument. */
5734 op0
= expand_normal (CALL_EXPR_ARG (exp
, 0));
5736 /* Compute the alignment. */
5737 align
= (fcode
== BUILT_IN_ALLOCA
5739 : TREE_INT_CST_LOW (CALL_EXPR_ARG (exp
, 1)));
5741 /* Compute the maximum size. */
5742 max_size
= (fcode
== BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
5743 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp
, 2))
5746 /* Allocate the desired space. If the allocation stems from the declaration
5747 of a variable-sized object, it cannot accumulate. */
5749 = allocate_dynamic_stack_space (op0
, 0, align
, max_size
, alloca_for_var
);
5750 result
= convert_memory_address (ptr_mode
, result
);
5752 /* Dynamic allocations for variables are recorded during gimplification. */
5753 if (!alloca_for_var
&& (flag_callgraph_info
& CALLGRAPH_INFO_DYNAMIC_ALLOC
))
5754 record_dynamic_alloc (exp
);
5759 /* Emit a call to __asan_allocas_unpoison call in EXP. Add to second argument
5760 of the call virtual_stack_dynamic_rtx - stack_pointer_rtx, which is the
5761 STACK_DYNAMIC_OFFSET value. See motivation for this in comment to
5762 handle_builtin_stack_restore function. */
5765 expand_asan_emit_allocas_unpoison (tree exp
)
5767 tree arg0
= CALL_EXPR_ARG (exp
, 0);
5768 tree arg1
= CALL_EXPR_ARG (exp
, 1);
5769 rtx top
= expand_expr (arg0
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
5770 rtx bot
= expand_expr (arg1
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
5771 rtx off
= expand_simple_binop (Pmode
, MINUS
, virtual_stack_dynamic_rtx
,
5772 stack_pointer_rtx
, NULL_RTX
, 0,
5774 off
= convert_modes (ptr_mode
, Pmode
, off
, 0);
5775 bot
= expand_simple_binop (ptr_mode
, PLUS
, bot
, off
, NULL_RTX
, 0,
5777 rtx ret
= init_one_libfunc ("__asan_allocas_unpoison");
5778 ret
= emit_library_call_value (ret
, NULL_RTX
, LCT_NORMAL
, ptr_mode
,
5779 top
, ptr_mode
, bot
, ptr_mode
);
5783 /* Expand a call to bswap builtin in EXP.
5784 Return NULL_RTX if a normal call should be emitted rather than expanding the
5785 function in-line. If convenient, the result should be placed in TARGET.
5786 SUBTARGET may be used as the target for computing one of EXP's operands. */
5789 expand_builtin_bswap (machine_mode target_mode
, tree exp
, rtx target
,
5795 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
5798 arg
= CALL_EXPR_ARG (exp
, 0);
5799 op0
= expand_expr (arg
,
5800 subtarget
&& GET_MODE (subtarget
) == target_mode
5801 ? subtarget
: NULL_RTX
,
5802 target_mode
, EXPAND_NORMAL
);
5803 if (GET_MODE (op0
) != target_mode
)
5804 op0
= convert_to_mode (target_mode
, op0
, 1);
5806 target
= expand_unop (target_mode
, bswap_optab
, op0
, target
, 1);
5808 gcc_assert (target
);
5810 return convert_to_mode (target_mode
, target
, 1);
5813 /* Expand a call to a unary builtin in EXP.
5814 Return NULL_RTX if a normal call should be emitted rather than expanding the
5815 function in-line. If convenient, the result should be placed in TARGET.
5816 SUBTARGET may be used as the target for computing one of EXP's operands. */
5819 expand_builtin_unop (machine_mode target_mode
, tree exp
, rtx target
,
5820 rtx subtarget
, optab op_optab
)
5824 if (!validate_arglist (exp
, INTEGER_TYPE
, VOID_TYPE
))
5827 /* Compute the argument. */
5828 op0
= expand_expr (CALL_EXPR_ARG (exp
, 0),
5830 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0)))
5831 == GET_MODE (subtarget
))) ? subtarget
: NULL_RTX
,
5832 VOIDmode
, EXPAND_NORMAL
);
5833 /* Compute op, into TARGET if possible.
5834 Set TARGET to wherever the result comes back. */
5835 target
= expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp
, 0))),
5836 op_optab
, op0
, target
, op_optab
!= clrsb_optab
);
5837 gcc_assert (target
);
5839 return convert_to_mode (target_mode
, target
, 0);
5842 /* Expand a call to __builtin_expect. We just return our argument
5843 as the builtin_expect semantic should've been already executed by
5844 tree branch prediction pass. */
5847 expand_builtin_expect (tree exp
, rtx target
)
5851 if (call_expr_nargs (exp
) < 2)
5853 arg
= CALL_EXPR_ARG (exp
, 0);
5855 target
= expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5856 /* When guessing was done, the hints should be already stripped away. */
5857 gcc_assert (!flag_guess_branch_prob
5858 || optimize
== 0 || seen_error ());
5862 /* Expand a call to __builtin_expect_with_probability. We just return our
5863 argument as the builtin_expect semantic should've been already executed by
5864 tree branch prediction pass. */
5867 expand_builtin_expect_with_probability (tree exp
, rtx target
)
5871 if (call_expr_nargs (exp
) < 3)
5873 arg
= CALL_EXPR_ARG (exp
, 0);
5875 target
= expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5876 /* When guessing was done, the hints should be already stripped away. */
5877 gcc_assert (!flag_guess_branch_prob
5878 || optimize
== 0 || seen_error ());
5883 /* Expand a call to __builtin_assume_aligned. We just return our first
5884 argument as the builtin_assume_aligned semantic should've been already
5888 expand_builtin_assume_aligned (tree exp
, rtx target
)
5890 if (call_expr_nargs (exp
) < 2)
5892 target
= expand_expr (CALL_EXPR_ARG (exp
, 0), target
, VOIDmode
,
5894 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 1))
5895 && (call_expr_nargs (exp
) < 3
5896 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp
, 2))));
5901 expand_builtin_trap (void)
5903 if (targetm
.have_trap ())
5905 rtx_insn
*insn
= emit_insn (targetm
.gen_trap ());
5906 /* For trap insns when not accumulating outgoing args force
5907 REG_ARGS_SIZE note to prevent crossjumping of calls with
5908 different args sizes. */
5909 if (!ACCUMULATE_OUTGOING_ARGS
)
5910 add_args_size_note (insn
, stack_pointer_delta
);
5914 tree fn
= builtin_decl_implicit (BUILT_IN_ABORT
);
5915 tree call_expr
= build_call_expr (fn
, 0);
5916 expand_call (call_expr
, NULL_RTX
, false);
5922 /* Expand a call to __builtin_unreachable. We do nothing except emit
5923 a barrier saying that control flow will not pass here.
5925 It is the responsibility of the program being compiled to ensure
5926 that control flow does never reach __builtin_unreachable. */
5928 expand_builtin_unreachable (void)
5930 /* Use gimple_build_builtin_unreachable or builtin_decl_unreachable
5932 gcc_checking_assert (!sanitize_flags_p (SANITIZE_UNREACHABLE
));
5936 /* Expand EXP, a call to fabs, fabsf or fabsl.
5937 Return NULL_RTX if a normal call should be emitted rather than expanding
5938 the function inline. If convenient, the result should be placed
5939 in TARGET. SUBTARGET may be used as the target for computing
5943 expand_builtin_fabs (tree exp
, rtx target
, rtx subtarget
)
5949 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
5952 arg
= CALL_EXPR_ARG (exp
, 0);
5953 CALL_EXPR_ARG (exp
, 0) = arg
= builtin_save_expr (arg
);
5954 mode
= TYPE_MODE (TREE_TYPE (arg
));
5955 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
5956 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
5959 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5960 Return NULL is a normal call should be emitted rather than expanding the
5961 function inline. If convenient, the result should be placed in TARGET.
5962 SUBTARGET may be used as the target for computing the operand. */
5965 expand_builtin_copysign (tree exp
, rtx target
, rtx subtarget
)
5970 if (!validate_arglist (exp
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
5973 arg
= CALL_EXPR_ARG (exp
, 0);
5974 op0
= expand_expr (arg
, subtarget
, VOIDmode
, EXPAND_NORMAL
);
5976 arg
= CALL_EXPR_ARG (exp
, 1);
5977 op1
= expand_normal (arg
);
5979 return expand_copysign (op0
, op1
, target
);
5982 /* Emit a call to __builtin___clear_cache. */
5985 default_emit_call_builtin___clear_cache (rtx begin
, rtx end
)
5987 rtx callee
= gen_rtx_SYMBOL_REF (Pmode
,
5988 BUILTIN_ASM_NAME_PTR
5989 (BUILT_IN_CLEAR_CACHE
));
5991 emit_library_call (callee
,
5992 LCT_NORMAL
, VOIDmode
,
5993 convert_memory_address (ptr_mode
, begin
), ptr_mode
,
5994 convert_memory_address (ptr_mode
, end
), ptr_mode
);
5997 /* Emit a call to __builtin___clear_cache, unless the target specifies
5998 it as do-nothing. This function can be used by trampoline
5999 finalizers to duplicate the effects of expanding a call to the
6000 clear_cache builtin. */
6003 maybe_emit_call_builtin___clear_cache (rtx begin
, rtx end
)
6005 gcc_assert ((GET_MODE (begin
) == ptr_mode
|| GET_MODE (begin
) == Pmode
6006 || CONST_INT_P (begin
))
6007 && (GET_MODE (end
) == ptr_mode
|| GET_MODE (end
) == Pmode
6008 || CONST_INT_P (end
)));
6010 if (targetm
.have_clear_cache ())
6012 /* We have a "clear_cache" insn, and it will handle everything. */
6013 class expand_operand ops
[2];
6015 create_address_operand (&ops
[0], begin
);
6016 create_address_operand (&ops
[1], end
);
6018 if (maybe_expand_insn (targetm
.code_for_clear_cache
, 2, ops
))
6023 #ifndef CLEAR_INSN_CACHE
6024 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
6025 does nothing. There is no need to call it. Do nothing. */
6027 #endif /* CLEAR_INSN_CACHE */
6030 targetm
.calls
.emit_call_builtin___clear_cache (begin
, end
);
6033 /* Expand a call to __builtin___clear_cache. */
6036 expand_builtin___clear_cache (tree exp
)
6039 rtx begin_rtx
, end_rtx
;
6041 /* We must not expand to a library call. If we did, any
6042 fallback library function in libgcc that might contain a call to
6043 __builtin___clear_cache() would recurse infinitely. */
6044 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
6046 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
6050 begin
= CALL_EXPR_ARG (exp
, 0);
6051 begin_rtx
= expand_expr (begin
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
6053 end
= CALL_EXPR_ARG (exp
, 1);
6054 end_rtx
= expand_expr (end
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
6056 maybe_emit_call_builtin___clear_cache (begin_rtx
, end_rtx
);
6059 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
6062 round_trampoline_addr (rtx tramp
)
6064 rtx temp
, addend
, mask
;
6066 /* If we don't need too much alignment, we'll have been guaranteed
6067 proper alignment by get_trampoline_type. */
6068 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
6071 /* Round address up to desired boundary. */
6072 temp
= gen_reg_rtx (Pmode
);
6073 addend
= gen_int_mode (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1, Pmode
);
6074 mask
= gen_int_mode (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
, Pmode
);
6076 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
6077 temp
, 0, OPTAB_LIB_WIDEN
);
6078 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
6079 temp
, 0, OPTAB_LIB_WIDEN
);
6085 expand_builtin_init_trampoline (tree exp
, bool onstack
)
6087 tree t_tramp
, t_func
, t_chain
;
6088 rtx m_tramp
, r_tramp
, r_chain
, tmp
;
6090 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
,
6091 POINTER_TYPE
, VOID_TYPE
))
6094 t_tramp
= CALL_EXPR_ARG (exp
, 0);
6095 t_func
= CALL_EXPR_ARG (exp
, 1);
6096 t_chain
= CALL_EXPR_ARG (exp
, 2);
6098 r_tramp
= expand_normal (t_tramp
);
6099 m_tramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
6100 MEM_NOTRAP_P (m_tramp
) = 1;
6102 /* If ONSTACK, the TRAMP argument should be the address of a field
6103 within the local function's FRAME decl. Either way, let's see if
6104 we can fill in the MEM_ATTRs for this memory. */
6105 if (TREE_CODE (t_tramp
) == ADDR_EXPR
)
6106 set_mem_attributes (m_tramp
, TREE_OPERAND (t_tramp
, 0), true);
6108 /* Creator of a heap trampoline is responsible for making sure the
6109 address is aligned to at least STACK_BOUNDARY. Normally malloc
6110 will ensure this anyhow. */
6111 tmp
= round_trampoline_addr (r_tramp
);
6114 m_tramp
= change_address (m_tramp
, BLKmode
, tmp
);
6115 set_mem_align (m_tramp
, TRAMPOLINE_ALIGNMENT
);
6116 set_mem_size (m_tramp
, TRAMPOLINE_SIZE
);
6119 /* The FUNC argument should be the address of the nested function.
6120 Extract the actual function decl to pass to the hook. */
6121 gcc_assert (TREE_CODE (t_func
) == ADDR_EXPR
);
6122 t_func
= TREE_OPERAND (t_func
, 0);
6123 gcc_assert (TREE_CODE (t_func
) == FUNCTION_DECL
);
6125 r_chain
= expand_normal (t_chain
);
6127 /* Generate insns to initialize the trampoline. */
6128 targetm
.calls
.trampoline_init (m_tramp
, t_func
, r_chain
);
6132 trampolines_created
= 1;
6134 if (targetm
.calls
.custom_function_descriptors
!= 0)
6135 warning_at (DECL_SOURCE_LOCATION (t_func
), OPT_Wtrampolines
,
6136 "trampoline generated for nested function %qD", t_func
);
6143 expand_builtin_adjust_trampoline (tree exp
)
6147 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6150 tramp
= expand_normal (CALL_EXPR_ARG (exp
, 0));
6151 tramp
= round_trampoline_addr (tramp
);
6152 if (targetm
.calls
.trampoline_adjust_address
)
6153 tramp
= targetm
.calls
.trampoline_adjust_address (tramp
);
6158 /* Expand a call to the builtin descriptor initialization routine.
6159 A descriptor is made up of a couple of pointers to the static
6160 chain and the code entry in this order. */
6163 expand_builtin_init_descriptor (tree exp
)
6165 tree t_descr
, t_func
, t_chain
;
6166 rtx m_descr
, r_descr
, r_func
, r_chain
;
6168 if (!validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, POINTER_TYPE
,
6172 t_descr
= CALL_EXPR_ARG (exp
, 0);
6173 t_func
= CALL_EXPR_ARG (exp
, 1);
6174 t_chain
= CALL_EXPR_ARG (exp
, 2);
6176 r_descr
= expand_normal (t_descr
);
6177 m_descr
= gen_rtx_MEM (BLKmode
, r_descr
);
6178 MEM_NOTRAP_P (m_descr
) = 1;
6179 set_mem_align (m_descr
, GET_MODE_ALIGNMENT (ptr_mode
));
6181 r_func
= expand_normal (t_func
);
6182 r_chain
= expand_normal (t_chain
);
6184 /* Generate insns to initialize the descriptor. */
6185 emit_move_insn (adjust_address_nv (m_descr
, ptr_mode
, 0), r_chain
);
6186 emit_move_insn (adjust_address_nv (m_descr
, ptr_mode
,
6187 POINTER_SIZE
/ BITS_PER_UNIT
), r_func
);
6192 /* Expand a call to the builtin descriptor adjustment routine. */
6195 expand_builtin_adjust_descriptor (tree exp
)
6199 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
6202 tramp
= expand_normal (CALL_EXPR_ARG (exp
, 0));
6204 /* Unalign the descriptor to allow runtime identification. */
6205 tramp
= plus_constant (ptr_mode
, tramp
,
6206 targetm
.calls
.custom_function_descriptors
);
6208 return force_operand (tramp
, NULL_RTX
);
6211 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
6212 function. The function first checks whether the back end provides
6213 an insn to implement signbit for the respective mode. If not, it
6214 checks whether the floating point format of the value is such that
6215 the sign bit can be extracted. If that is not the case, error out.
6216 EXP is the expression that is a call to the builtin function; if
6217 convenient, the result should be placed in TARGET. */
6219 expand_builtin_signbit (tree exp
, rtx target
)
6221 const struct real_format
*fmt
;
6222 scalar_float_mode fmode
;
6223 scalar_int_mode rmode
, imode
;
6226 enum insn_code icode
;
6228 location_t loc
= EXPR_LOCATION (exp
);
6230 if (!validate_arglist (exp
, REAL_TYPE
, VOID_TYPE
))
6233 arg
= CALL_EXPR_ARG (exp
, 0);
6234 fmode
= SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (arg
));
6235 rmode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
6236 fmt
= REAL_MODE_FORMAT (fmode
);
6238 arg
= builtin_save_expr (arg
);
6240 /* Expand the argument yielding a RTX expression. */
6241 temp
= expand_normal (arg
);
6243 /* Check if the back end provides an insn that handles signbit for the
6245 icode
= optab_handler (signbit_optab
, fmode
);
6246 if (icode
!= CODE_FOR_nothing
)
6248 rtx_insn
*last
= get_last_insn ();
6249 rtx this_target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
6250 if (maybe_emit_unop_insn (icode
, this_target
, temp
, UNKNOWN
))
6252 delete_insns_since (last
);
6255 /* For floating point formats without a sign bit, implement signbit
6257 bitpos
= fmt
->signbit_ro
;
6260 /* But we can't do this if the format supports signed zero. */
6261 gcc_assert (!fmt
->has_signed_zero
|| !HONOR_SIGNED_ZEROS (fmode
));
6263 arg
= fold_build2_loc (loc
, LT_EXPR
, TREE_TYPE (exp
), arg
,
6264 build_real (TREE_TYPE (arg
), dconst0
));
6265 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
6268 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
6270 imode
= int_mode_for_mode (fmode
).require ();
6271 temp
= gen_lowpart (imode
, temp
);
6276 /* Handle targets with different FP word orders. */
6277 if (FLOAT_WORDS_BIG_ENDIAN
)
6278 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
6280 word
= bitpos
/ BITS_PER_WORD
;
6281 temp
= operand_subword_force (temp
, word
, fmode
);
6282 bitpos
= bitpos
% BITS_PER_WORD
;
6285 /* Force the intermediate word_mode (or narrower) result into a
6286 register. This avoids attempting to create paradoxical SUBREGs
6287 of floating point modes below. */
6288 temp
= force_reg (imode
, temp
);
6290 /* If the bitpos is within the "result mode" lowpart, the operation
6291 can be implement with a single bitwise AND. Otherwise, we need
6292 a right shift and an AND. */
6294 if (bitpos
< GET_MODE_BITSIZE (rmode
))
6296 wide_int mask
= wi::set_bit_in_zero (bitpos
, GET_MODE_PRECISION (rmode
));
6298 if (GET_MODE_SIZE (imode
) > GET_MODE_SIZE (rmode
))
6299 temp
= gen_lowpart (rmode
, temp
);
6300 temp
= expand_binop (rmode
, and_optab
, temp
,
6301 immed_wide_int_const (mask
, rmode
),
6302 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
6306 /* Perform a logical right shift to place the signbit in the least
6307 significant bit, then truncate the result to the desired mode
6308 and mask just this bit. */
6309 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
, bitpos
, NULL_RTX
, 1);
6310 temp
= gen_lowpart (rmode
, temp
);
6311 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
6312 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
6318 /* Expand fork or exec calls. TARGET is the desired target of the
6319 call. EXP is the call. FN is the
6320 identificator of the actual function. IGNORE is nonzero if the
6321 value is to be ignored. */
6324 expand_builtin_fork_or_exec (tree fn
, tree exp
, rtx target
, int ignore
)
6329 /* If we are not profiling, just call the function. */
6330 if (!profile_arc_flag
)
6333 /* Otherwise call the wrapper. This should be equivalent for the rest of
6334 compiler, so the code does not diverge, and the wrapper may run the
6335 code necessary for keeping the profiling sane. */
6337 switch (DECL_FUNCTION_CODE (fn
))
6340 id
= get_identifier ("__gcov_fork");
6343 case BUILT_IN_EXECL
:
6344 id
= get_identifier ("__gcov_execl");
6347 case BUILT_IN_EXECV
:
6348 id
= get_identifier ("__gcov_execv");
6351 case BUILT_IN_EXECLP
:
6352 id
= get_identifier ("__gcov_execlp");
6355 case BUILT_IN_EXECLE
:
6356 id
= get_identifier ("__gcov_execle");
6359 case BUILT_IN_EXECVP
:
6360 id
= get_identifier ("__gcov_execvp");
6363 case BUILT_IN_EXECVE
:
6364 id
= get_identifier ("__gcov_execve");
6371 decl
= build_decl (DECL_SOURCE_LOCATION (fn
),
6372 FUNCTION_DECL
, id
, TREE_TYPE (fn
));
6373 DECL_EXTERNAL (decl
) = 1;
6374 TREE_PUBLIC (decl
) = 1;
6375 DECL_ARTIFICIAL (decl
) = 1;
6376 TREE_NOTHROW (decl
) = 1;
6377 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
6378 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6379 call
= rewrite_call_expr (EXPR_LOCATION (exp
), exp
, 0, decl
, 0);
6380 return expand_call (call
, target
, ignore
);
6385 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
6386 the pointer in these functions is void*, the tree optimizers may remove
6387 casts. The mode computed in expand_builtin isn't reliable either, due
6388 to __sync_bool_compare_and_swap.
6390 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
6391 group of builtins. This gives us log2 of the mode size. */
6393 static inline machine_mode
6394 get_builtin_sync_mode (int fcode_diff
)
6396 /* The size is not negotiable, so ask not to get BLKmode in return
6397 if the target indicates that a smaller size would be better. */
6398 return int_mode_for_size (BITS_PER_UNIT
<< fcode_diff
, 0).require ();
6401 /* Expand the memory expression LOC and return the appropriate memory operand
6402 for the builtin_sync operations. */
6405 get_builtin_sync_mem (tree loc
, machine_mode mode
)
6408 int addr_space
= TYPE_ADDR_SPACE (POINTER_TYPE_P (TREE_TYPE (loc
))
6409 ? TREE_TYPE (TREE_TYPE (loc
))
6411 scalar_int_mode addr_mode
= targetm
.addr_space
.address_mode (addr_space
);
6413 addr
= expand_expr (loc
, NULL_RTX
, addr_mode
, EXPAND_SUM
);
6414 addr
= convert_memory_address (addr_mode
, addr
);
6416 /* Note that we explicitly do not want any alias information for this
6417 memory, so that we kill all other live memories. Otherwise we don't
6418 satisfy the full barrier semantics of the intrinsic. */
6419 mem
= gen_rtx_MEM (mode
, addr
);
6421 set_mem_addr_space (mem
, addr_space
);
6423 mem
= validize_mem (mem
);
6425 /* The alignment needs to be at least according to that of the mode. */
6426 set_mem_align (mem
, MAX (GET_MODE_ALIGNMENT (mode
),
6427 get_pointer_alignment (loc
)));
6428 set_mem_alias_set (mem
, ALIAS_SET_MEMORY_BARRIER
);
6429 MEM_VOLATILE_P (mem
) = 1;
6434 /* Make sure an argument is in the right mode.
6435 EXP is the tree argument.
6436 MODE is the mode it should be in. */
6439 expand_expr_force_mode (tree exp
, machine_mode mode
)
6442 machine_mode old_mode
;
6444 if (TREE_CODE (exp
) == SSA_NAME
6445 && TYPE_MODE (TREE_TYPE (exp
)) != mode
)
6447 /* Undo argument promotion if possible, as combine might not
6448 be able to do it later due to MEM_VOLATILE_P uses in the
6450 gimple
*g
= get_gimple_for_ssa_name (exp
);
6451 if (g
&& gimple_assign_cast_p (g
))
6453 tree rhs
= gimple_assign_rhs1 (g
);
6454 tree_code code
= gimple_assign_rhs_code (g
);
6455 if (CONVERT_EXPR_CODE_P (code
)
6456 && TYPE_MODE (TREE_TYPE (rhs
)) == mode
6457 && INTEGRAL_TYPE_P (TREE_TYPE (exp
))
6458 && INTEGRAL_TYPE_P (TREE_TYPE (rhs
))
6459 && (TYPE_PRECISION (TREE_TYPE (exp
))
6460 > TYPE_PRECISION (TREE_TYPE (rhs
))))
6465 val
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_NORMAL
);
6466 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
6467 of CONST_INTs, where we know the old_mode only from the call argument. */
6469 old_mode
= GET_MODE (val
);
6470 if (old_mode
== VOIDmode
)
6471 old_mode
= TYPE_MODE (TREE_TYPE (exp
));
6472 val
= convert_modes (mode
, old_mode
, val
, 1);
6477 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
6478 EXP is the CALL_EXPR. CODE is the rtx code
6479 that corresponds to the arithmetic or logical operation from the name;
6480 an exception here is that NOT actually means NAND. TARGET is an optional
6481 place for us to store the results; AFTER is true if this is the
6482 fetch_and_xxx form. */
6485 expand_builtin_sync_operation (machine_mode mode
, tree exp
,
6486 enum rtx_code code
, bool after
,
6490 location_t loc
= EXPR_LOCATION (exp
);
6492 if (code
== NOT
&& warn_sync_nand
)
6494 tree fndecl
= get_callee_fndecl (exp
);
6495 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6497 static bool warned_f_a_n
, warned_n_a_f
;
6501 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
6502 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
6503 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
6504 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
6505 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
6509 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N
);
6510 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
6511 warned_f_a_n
= true;
6514 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
6515 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
6516 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
6517 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
6518 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
6522 fndecl
= builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N
);
6523 inform (loc
, "%qD changed semantics in GCC 4.4", fndecl
);
6524 warned_n_a_f
= true;
6532 /* Expand the operands. */
6533 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6534 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
6536 return expand_atomic_fetch_op (target
, mem
, val
, code
, MEMMODEL_SYNC_SEQ_CST
,
6540 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
6541 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
6542 true if this is the boolean form. TARGET is a place for us to store the
6543 results; this is NOT optional if IS_BOOL is true. */
6546 expand_builtin_compare_and_swap (machine_mode mode
, tree exp
,
6547 bool is_bool
, rtx target
)
6549 rtx old_val
, new_val
, mem
;
6552 /* Expand the operands. */
6553 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6554 old_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
6555 new_val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
6557 pbool
= poval
= NULL
;
6558 if (target
!= const0_rtx
)
6565 if (!expand_atomic_compare_and_swap (pbool
, poval
, mem
, old_val
, new_val
,
6566 false, MEMMODEL_SYNC_SEQ_CST
,
6567 MEMMODEL_SYNC_SEQ_CST
))
6573 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
6574 general form is actually an atomic exchange, and some targets only
6575 support a reduced form with the second argument being a constant 1.
6576 EXP is the CALL_EXPR; TARGET is an optional place for us to store
6580 expand_builtin_sync_lock_test_and_set (machine_mode mode
, tree exp
,
6585 /* Expand the operands. */
6586 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6587 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
6589 return expand_sync_lock_test_and_set (target
, mem
, val
);
6592 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
6595 expand_builtin_sync_lock_release (machine_mode mode
, tree exp
)
6599 /* Expand the operands. */
6600 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6602 expand_atomic_store (mem
, const0_rtx
, MEMMODEL_SYNC_RELEASE
, true);
6605 /* Given an integer representing an ``enum memmodel'', verify its
6606 correctness and return the memory model enum. */
6608 static enum memmodel
6609 get_memmodel (tree exp
)
6611 /* If the parameter is not a constant, it's a run time value so we'll just
6612 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
6613 if (TREE_CODE (exp
) != INTEGER_CST
)
6614 return MEMMODEL_SEQ_CST
;
6616 rtx op
= expand_normal (exp
);
6618 unsigned HOST_WIDE_INT val
= INTVAL (op
);
6619 if (targetm
.memmodel_check
)
6620 val
= targetm
.memmodel_check (val
);
6621 else if (val
& ~MEMMODEL_MASK
)
6622 return MEMMODEL_SEQ_CST
;
6624 /* Should never see a user explicit SYNC memodel model, so >= LAST works. */
6625 if (memmodel_base (val
) >= MEMMODEL_LAST
)
6626 return MEMMODEL_SEQ_CST
;
6628 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
6629 be conservative and promote consume to acquire. */
6630 if (val
== MEMMODEL_CONSUME
)
6631 val
= MEMMODEL_ACQUIRE
;
6633 return (enum memmodel
) val
;
6636 /* Expand the __atomic_exchange intrinsic:
6637 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
6638 EXP is the CALL_EXPR.
6639 TARGET is an optional place for us to store the results. */
6642 expand_builtin_atomic_exchange (machine_mode mode
, tree exp
, rtx target
)
6645 enum memmodel model
;
6647 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
6649 if (!flag_inline_atomics
)
6652 /* Expand the operands. */
6653 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6654 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
6656 return expand_atomic_exchange (target
, mem
, val
, model
);
6659 /* Expand the __atomic_compare_exchange intrinsic:
6660 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
6661 TYPE desired, BOOL weak,
6662 enum memmodel success,
6663 enum memmodel failure)
6664 EXP is the CALL_EXPR.
6665 TARGET is an optional place for us to store the results. */
6668 expand_builtin_atomic_compare_exchange (machine_mode mode
, tree exp
,
6671 rtx expect
, desired
, mem
, oldval
;
6672 rtx_code_label
*label
;
6676 memmodel success
= get_memmodel (CALL_EXPR_ARG (exp
, 4));
6677 memmodel failure
= get_memmodel (CALL_EXPR_ARG (exp
, 5));
6679 if (failure
> success
)
6680 success
= MEMMODEL_SEQ_CST
;
6682 if (is_mm_release (failure
) || is_mm_acq_rel (failure
))
6684 failure
= MEMMODEL_SEQ_CST
;
6685 success
= MEMMODEL_SEQ_CST
;
6689 if (!flag_inline_atomics
)
6692 /* Expand the operands. */
6693 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6695 expect
= expand_normal (CALL_EXPR_ARG (exp
, 1));
6696 expect
= convert_memory_address (Pmode
, expect
);
6697 expect
= gen_rtx_MEM (mode
, expect
);
6698 desired
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 2), mode
);
6700 weak
= CALL_EXPR_ARG (exp
, 3);
6702 if (tree_fits_shwi_p (weak
) && tree_to_shwi (weak
) != 0)
6705 if (target
== const0_rtx
)
6708 /* Lest the rtl backend create a race condition with an imporoper store
6709 to memory, always create a new pseudo for OLDVAL. */
6712 if (!expand_atomic_compare_and_swap (&target
, &oldval
, mem
, expect
, desired
,
6713 is_weak
, success
, failure
))
6716 /* Conditionally store back to EXPECT, lest we create a race condition
6717 with an improper store to memory. */
6718 /* ??? With a rearrangement of atomics at the gimple level, we can handle
6719 the normal case where EXPECT is totally private, i.e. a register. At
6720 which point the store can be unconditional. */
6721 label
= gen_label_rtx ();
6722 emit_cmp_and_jump_insns (target
, const0_rtx
, NE
, NULL
,
6723 GET_MODE (target
), 1, label
);
6724 emit_move_insn (expect
, oldval
);
6730 /* Helper function for expand_ifn_atomic_compare_exchange - expand
6731 internal ATOMIC_COMPARE_EXCHANGE call into __atomic_compare_exchange_N
6732 call. The weak parameter must be dropped to match the expected parameter
6733 list and the expected argument changed from value to pointer to memory
6737 expand_ifn_atomic_compare_exchange_into_call (gcall
*call
, machine_mode mode
)
6740 vec
<tree
, va_gc
> *vec
;
6743 vec
->quick_push (gimple_call_arg (call
, 0));
6744 tree expected
= gimple_call_arg (call
, 1);
6745 rtx x
= assign_stack_temp_for_type (mode
, GET_MODE_SIZE (mode
),
6746 TREE_TYPE (expected
));
6747 rtx expd
= expand_expr (expected
, x
, mode
, EXPAND_NORMAL
);
6749 emit_move_insn (x
, expd
);
6750 tree v
= make_tree (TREE_TYPE (expected
), x
);
6751 vec
->quick_push (build1 (ADDR_EXPR
,
6752 build_pointer_type (TREE_TYPE (expected
)), v
));
6753 vec
->quick_push (gimple_call_arg (call
, 2));
6754 /* Skip the boolean weak parameter. */
6755 for (z
= 4; z
< 6; z
++)
6756 vec
->quick_push (gimple_call_arg (call
, z
));
6757 /* At present we only have BUILT_IN_ATOMIC_COMPARE_EXCHANGE_{1,2,4,8,16}. */
6758 unsigned int bytes_log2
= exact_log2 (GET_MODE_SIZE (mode
).to_constant ());
6759 gcc_assert (bytes_log2
< 5);
6760 built_in_function fncode
6761 = (built_in_function
) ((int) BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
6763 tree fndecl
= builtin_decl_explicit (fncode
);
6764 tree fn
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fndecl
)),
6766 tree exp
= build_call_vec (boolean_type_node
, fn
, vec
);
6767 tree lhs
= gimple_call_lhs (call
);
6768 rtx boolret
= expand_call (exp
, NULL_RTX
, lhs
== NULL_TREE
);
6771 rtx target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
6772 if (GET_MODE (boolret
) != mode
)
6773 boolret
= convert_modes (mode
, GET_MODE (boolret
), boolret
, 1);
6774 x
= force_reg (mode
, x
);
6775 write_complex_part (target
, boolret
, true, true);
6776 write_complex_part (target
, x
, false, false);
6780 /* Expand IFN_ATOMIC_COMPARE_EXCHANGE internal function. */
6783 expand_ifn_atomic_compare_exchange (gcall
*call
)
6785 int size
= tree_to_shwi (gimple_call_arg (call
, 3)) & 255;
6786 gcc_assert (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16);
6787 machine_mode mode
= int_mode_for_size (BITS_PER_UNIT
* size
, 0).require ();
6789 memmodel success
= get_memmodel (gimple_call_arg (call
, 4));
6790 memmodel failure
= get_memmodel (gimple_call_arg (call
, 5));
6792 if (failure
> success
)
6793 success
= MEMMODEL_SEQ_CST
;
6795 if (is_mm_release (failure
) || is_mm_acq_rel (failure
))
6797 failure
= MEMMODEL_SEQ_CST
;
6798 success
= MEMMODEL_SEQ_CST
;
6801 if (!flag_inline_atomics
)
6803 expand_ifn_atomic_compare_exchange_into_call (call
, mode
);
6807 /* Expand the operands. */
6808 rtx mem
= get_builtin_sync_mem (gimple_call_arg (call
, 0), mode
);
6810 rtx expect
= expand_expr_force_mode (gimple_call_arg (call
, 1), mode
);
6811 rtx desired
= expand_expr_force_mode (gimple_call_arg (call
, 2), mode
);
6813 bool is_weak
= (tree_to_shwi (gimple_call_arg (call
, 3)) & 256) != 0;
6818 if (!expand_atomic_compare_and_swap (&boolret
, &oldval
, mem
, expect
, desired
,
6819 is_weak
, success
, failure
))
6821 expand_ifn_atomic_compare_exchange_into_call (call
, mode
);
6825 tree lhs
= gimple_call_lhs (call
);
6828 rtx target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
6829 if (GET_MODE (boolret
) != mode
)
6830 boolret
= convert_modes (mode
, GET_MODE (boolret
), boolret
, 1);
6831 write_complex_part (target
, boolret
, true, true);
6832 write_complex_part (target
, oldval
, false, false);
6836 /* Expand the __atomic_load intrinsic:
6837 TYPE __atomic_load (TYPE *object, enum memmodel)
6838 EXP is the CALL_EXPR.
6839 TARGET is an optional place for us to store the results. */
6842 expand_builtin_atomic_load (machine_mode mode
, tree exp
, rtx target
)
6844 memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
6845 if (is_mm_release (model
) || is_mm_acq_rel (model
))
6846 model
= MEMMODEL_SEQ_CST
;
6848 if (!flag_inline_atomics
)
6851 /* Expand the operand. */
6852 rtx mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6854 return expand_atomic_load (target
, mem
, model
);
6858 /* Expand the __atomic_store intrinsic:
6859 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
6860 EXP is the CALL_EXPR.
6861 TARGET is an optional place for us to store the results. */
6864 expand_builtin_atomic_store (machine_mode mode
, tree exp
)
6866 memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
6867 if (!(is_mm_relaxed (model
) || is_mm_seq_cst (model
)
6868 || is_mm_release (model
)))
6869 model
= MEMMODEL_SEQ_CST
;
6871 if (!flag_inline_atomics
)
6874 /* Expand the operands. */
6875 rtx mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6876 rtx val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
6878 return expand_atomic_store (mem
, val
, model
, false);
6881 /* Expand the __atomic_fetch_XXX intrinsic:
6882 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
6883 EXP is the CALL_EXPR.
6884 TARGET is an optional place for us to store the results.
6885 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
6886 FETCH_AFTER is true if returning the result of the operation.
6887 FETCH_AFTER is false if returning the value before the operation.
6888 IGNORE is true if the result is not used.
6889 EXT_CALL is the correct builtin for an external call if this cannot be
6890 resolved to an instruction sequence. */
6893 expand_builtin_atomic_fetch_op (machine_mode mode
, tree exp
, rtx target
,
6894 enum rtx_code code
, bool fetch_after
,
6895 bool ignore
, enum built_in_function ext_call
)
6898 enum memmodel model
;
6902 model
= get_memmodel (CALL_EXPR_ARG (exp
, 2));
6904 /* Expand the operands. */
6905 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
6906 val
= expand_expr_force_mode (CALL_EXPR_ARG (exp
, 1), mode
);
6908 /* Only try generating instructions if inlining is turned on. */
6909 if (flag_inline_atomics
)
6911 ret
= expand_atomic_fetch_op (target
, mem
, val
, code
, model
, fetch_after
);
6916 /* Return if a different routine isn't needed for the library call. */
6917 if (ext_call
== BUILT_IN_NONE
)
6920 /* Change the call to the specified function. */
6921 fndecl
= get_callee_fndecl (exp
);
6922 addr
= CALL_EXPR_FN (exp
);
6925 gcc_assert (TREE_OPERAND (addr
, 0) == fndecl
);
6926 TREE_OPERAND (addr
, 0) = builtin_decl_explicit (ext_call
);
6928 /* If we will emit code after the call, the call cannot be a tail call.
6929 If it is emitted as a tail call, a barrier is emitted after it, and
6930 then all trailing code is removed. */
6932 CALL_EXPR_TAILCALL (exp
) = 0;
6934 /* Expand the call here so we can emit trailing code. */
6935 ret
= expand_call (exp
, target
, ignore
);
6937 /* Replace the original function just in case it matters. */
6938 TREE_OPERAND (addr
, 0) = fndecl
;
6940 /* Then issue the arithmetic correction to return the right result. */
6945 ret
= expand_simple_binop (mode
, AND
, ret
, val
, NULL_RTX
, true,
6947 ret
= expand_simple_unop (mode
, NOT
, ret
, target
, true);
6950 ret
= expand_simple_binop (mode
, code
, ret
, val
, target
, true,
6956 /* Expand IFN_ATOMIC_BIT_TEST_AND_* internal function. */
6959 expand_ifn_atomic_bit_test_and (gcall
*call
)
6961 tree ptr
= gimple_call_arg (call
, 0);
6962 tree bit
= gimple_call_arg (call
, 1);
6963 tree flag
= gimple_call_arg (call
, 2);
6964 tree lhs
= gimple_call_lhs (call
);
6965 enum memmodel model
= MEMMODEL_SYNC_SEQ_CST
;
6966 machine_mode mode
= TYPE_MODE (TREE_TYPE (flag
));
6969 class expand_operand ops
[5];
6971 gcc_assert (flag_inline_atomics
);
6973 if (gimple_call_num_args (call
) == 5)
6974 model
= get_memmodel (gimple_call_arg (call
, 3));
6976 rtx mem
= get_builtin_sync_mem (ptr
, mode
);
6977 rtx val
= expand_expr_force_mode (bit
, mode
);
6979 switch (gimple_call_internal_fn (call
))
6981 case IFN_ATOMIC_BIT_TEST_AND_SET
:
6983 optab
= atomic_bit_test_and_set_optab
;
6985 case IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
:
6987 optab
= atomic_bit_test_and_complement_optab
;
6989 case IFN_ATOMIC_BIT_TEST_AND_RESET
:
6991 optab
= atomic_bit_test_and_reset_optab
;
6997 if (lhs
== NULL_TREE
)
6999 rtx val2
= expand_simple_binop (mode
, ASHIFT
, const1_rtx
,
7000 val
, NULL_RTX
, true, OPTAB_DIRECT
);
7002 val2
= expand_simple_unop (mode
, NOT
, val2
, NULL_RTX
, true);
7003 if (expand_atomic_fetch_op (const0_rtx
, mem
, val2
, code
, model
, false))
7009 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
7011 target
= gen_reg_rtx (mode
);
7012 enum insn_code icode
= direct_optab_handler (optab
, mode
);
7013 gcc_assert (icode
!= CODE_FOR_nothing
);
7014 create_output_operand (&ops
[0], target
, mode
);
7015 create_fixed_operand (&ops
[1], mem
);
7016 create_convert_operand_to (&ops
[2], val
, mode
, true);
7017 create_integer_operand (&ops
[3], model
);
7018 create_integer_operand (&ops
[4], integer_onep (flag
));
7019 if (maybe_expand_insn (icode
, 5, ops
))
7023 val
= expand_simple_binop (mode
, ASHIFT
, const1_rtx
,
7024 val
, NULL_RTX
, true, OPTAB_DIRECT
);
7027 val
= expand_simple_unop (mode
, NOT
, val
, NULL_RTX
, true);
7028 rtx result
= expand_atomic_fetch_op (gen_reg_rtx (mode
), mem
, val
,
7029 code
, model
, false);
7032 bool is_atomic
= gimple_call_num_args (call
) == 5;
7033 tree tcall
= gimple_call_arg (call
, 3 + is_atomic
);
7034 tree fndecl
= gimple_call_addr_fndecl (tcall
);
7035 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7036 tree exp
= build_call_nary (type
, tcall
, 2 + is_atomic
, ptr
,
7037 make_tree (type
, val
),
7039 ? gimple_call_arg (call
, 3)
7040 : integer_zero_node
);
7041 result
= expand_builtin (exp
, gen_reg_rtx (mode
), NULL_RTX
,
7046 if (integer_onep (flag
))
7048 result
= expand_simple_binop (mode
, ASHIFTRT
, result
, bitval
,
7049 NULL_RTX
, true, OPTAB_DIRECT
);
7050 result
= expand_simple_binop (mode
, AND
, result
, const1_rtx
, target
,
7051 true, OPTAB_DIRECT
);
7054 result
= expand_simple_binop (mode
, AND
, result
, maskval
, target
, true,
7056 if (result
!= target
)
7057 emit_move_insn (target
, result
);
7060 /* Expand IFN_ATOMIC_*_FETCH_CMP_0 internal function. */
7063 expand_ifn_atomic_op_fetch_cmp_0 (gcall
*call
)
7065 tree cmp
= gimple_call_arg (call
, 0);
7066 tree ptr
= gimple_call_arg (call
, 1);
7067 tree arg
= gimple_call_arg (call
, 2);
7068 tree lhs
= gimple_call_lhs (call
);
7069 enum memmodel model
= MEMMODEL_SYNC_SEQ_CST
;
7070 machine_mode mode
= TYPE_MODE (TREE_TYPE (cmp
));
7073 class expand_operand ops
[5];
7075 gcc_assert (flag_inline_atomics
);
7077 if (gimple_call_num_args (call
) == 5)
7078 model
= get_memmodel (gimple_call_arg (call
, 3));
7080 rtx mem
= get_builtin_sync_mem (ptr
, mode
);
7081 rtx op
= expand_expr_force_mode (arg
, mode
);
7083 switch (gimple_call_internal_fn (call
))
7085 case IFN_ATOMIC_ADD_FETCH_CMP_0
:
7087 optab
= atomic_add_fetch_cmp_0_optab
;
7089 case IFN_ATOMIC_SUB_FETCH_CMP_0
:
7091 optab
= atomic_sub_fetch_cmp_0_optab
;
7093 case IFN_ATOMIC_AND_FETCH_CMP_0
:
7095 optab
= atomic_and_fetch_cmp_0_optab
;
7097 case IFN_ATOMIC_OR_FETCH_CMP_0
:
7099 optab
= atomic_or_fetch_cmp_0_optab
;
7101 case IFN_ATOMIC_XOR_FETCH_CMP_0
:
7103 optab
= atomic_xor_fetch_cmp_0_optab
;
7109 enum rtx_code comp
= UNKNOWN
;
7110 switch (tree_to_uhwi (cmp
))
7112 case ATOMIC_OP_FETCH_CMP_0_EQ
: comp
= EQ
; break;
7113 case ATOMIC_OP_FETCH_CMP_0_NE
: comp
= NE
; break;
7114 case ATOMIC_OP_FETCH_CMP_0_GT
: comp
= GT
; break;
7115 case ATOMIC_OP_FETCH_CMP_0_GE
: comp
= GE
; break;
7116 case ATOMIC_OP_FETCH_CMP_0_LT
: comp
= LT
; break;
7117 case ATOMIC_OP_FETCH_CMP_0_LE
: comp
= LE
; break;
7118 default: gcc_unreachable ();
7122 if (lhs
== NULL_TREE
)
7123 target
= gen_reg_rtx (TYPE_MODE (boolean_type_node
));
7125 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
7126 enum insn_code icode
= direct_optab_handler (optab
, mode
);
7127 gcc_assert (icode
!= CODE_FOR_nothing
);
7128 create_output_operand (&ops
[0], target
, TYPE_MODE (boolean_type_node
));
7129 create_fixed_operand (&ops
[1], mem
);
7130 create_convert_operand_to (&ops
[2], op
, mode
, true);
7131 create_integer_operand (&ops
[3], model
);
7132 create_integer_operand (&ops
[4], comp
);
7133 if (maybe_expand_insn (icode
, 5, ops
))
7136 rtx result
= expand_atomic_fetch_op (gen_reg_rtx (mode
), mem
, op
,
7140 bool is_atomic
= gimple_call_num_args (call
) == 5;
7141 tree tcall
= gimple_call_arg (call
, 3 + is_atomic
);
7142 tree fndecl
= gimple_call_addr_fndecl (tcall
);
7143 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7144 tree exp
= build_call_nary (type
, tcall
,
7145 2 + is_atomic
, ptr
, arg
,
7147 ? gimple_call_arg (call
, 3)
7148 : integer_zero_node
);
7149 result
= expand_builtin (exp
, gen_reg_rtx (mode
), NULL_RTX
,
7155 result
= emit_store_flag_force (target
, comp
, result
, const0_rtx
, mode
,
7157 if (result
!= target
)
7158 emit_move_insn (target
, result
);
7162 /* Expand an atomic clear operation.
7163 void _atomic_clear (BOOL *obj, enum memmodel)
7164 EXP is the call expression. */
7167 expand_builtin_atomic_clear (tree exp
)
7169 machine_mode mode
= int_mode_for_size (BOOL_TYPE_SIZE
, 0).require ();
7170 rtx mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
7171 memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
7173 if (is_mm_consume (model
) || is_mm_acquire (model
) || is_mm_acq_rel (model
))
7174 model
= MEMMODEL_SEQ_CST
;
7176 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
7177 Failing that, a store is issued by __atomic_store. The only way this can
7178 fail is if the bool type is larger than a word size. Unlikely, but
7179 handle it anyway for completeness. Assume a single threaded model since
7180 there is no atomic support in this case, and no barriers are required. */
7181 rtx ret
= expand_atomic_store (mem
, const0_rtx
, model
, true);
7183 emit_move_insn (mem
, const0_rtx
);
7187 /* Expand an atomic test_and_set operation.
7188 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
7189 EXP is the call expression. */
7192 expand_builtin_atomic_test_and_set (tree exp
, rtx target
)
7195 enum memmodel model
;
7198 mode
= int_mode_for_size (BOOL_TYPE_SIZE
, 0).require ();
7199 mem
= get_builtin_sync_mem (CALL_EXPR_ARG (exp
, 0), mode
);
7200 model
= get_memmodel (CALL_EXPR_ARG (exp
, 1));
7202 return expand_atomic_test_and_set (target
, mem
, model
);
7206 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
7207 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
7210 fold_builtin_atomic_always_lock_free (tree arg0
, tree arg1
)
7214 unsigned int mode_align
, type_align
;
7216 if (TREE_CODE (arg0
) != INTEGER_CST
)
7219 /* We need a corresponding integer mode for the access to be lock-free. */
7220 size
= INTVAL (expand_normal (arg0
)) * BITS_PER_UNIT
;
7221 if (!int_mode_for_size (size
, 0).exists (&mode
))
7222 return boolean_false_node
;
7224 mode_align
= GET_MODE_ALIGNMENT (mode
);
7226 if (TREE_CODE (arg1
) == INTEGER_CST
)
7228 unsigned HOST_WIDE_INT val
= UINTVAL (expand_normal (arg1
));
7230 /* Either this argument is null, or it's a fake pointer encoding
7231 the alignment of the object. */
7232 val
= least_bit_hwi (val
);
7233 val
*= BITS_PER_UNIT
;
7235 if (val
== 0 || mode_align
< val
)
7236 type_align
= mode_align
;
7242 tree ttype
= TREE_TYPE (arg1
);
7244 /* This function is usually invoked and folded immediately by the front
7245 end before anything else has a chance to look at it. The pointer
7246 parameter at this point is usually cast to a void *, so check for that
7247 and look past the cast. */
7248 if (CONVERT_EXPR_P (arg1
)
7249 && POINTER_TYPE_P (ttype
)
7250 && VOID_TYPE_P (TREE_TYPE (ttype
))
7251 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
7252 arg1
= TREE_OPERAND (arg1
, 0);
7254 ttype
= TREE_TYPE (arg1
);
7255 gcc_assert (POINTER_TYPE_P (ttype
));
7257 /* Get the underlying type of the object. */
7258 ttype
= TREE_TYPE (ttype
);
7259 type_align
= TYPE_ALIGN (ttype
);
7262 /* If the object has smaller alignment, the lock free routines cannot
7264 if (type_align
< mode_align
)
7265 return boolean_false_node
;
7267 /* Check if a compare_and_swap pattern exists for the mode which represents
7268 the required size. The pattern is not allowed to fail, so the existence
7269 of the pattern indicates support is present. Also require that an
7270 atomic load exists for the required size. */
7271 if (can_compare_and_swap_p (mode
, true) && can_atomic_load_p (mode
))
7272 return boolean_true_node
;
7274 return boolean_false_node
;
7277 /* Return true if the parameters to call EXP represent an object which will
7278 always generate lock free instructions. The first argument represents the
7279 size of the object, and the second parameter is a pointer to the object
7280 itself. If NULL is passed for the object, then the result is based on
7281 typical alignment for an object of the specified size. Otherwise return
7285 expand_builtin_atomic_always_lock_free (tree exp
)
7288 tree arg0
= CALL_EXPR_ARG (exp
, 0);
7289 tree arg1
= CALL_EXPR_ARG (exp
, 1);
7291 if (TREE_CODE (arg0
) != INTEGER_CST
)
7293 error ("non-constant argument 1 to %qs", "__atomic_always_lock_free");
7297 size
= fold_builtin_atomic_always_lock_free (arg0
, arg1
);
7298 if (size
== boolean_true_node
)
7303 /* Return a one or zero if it can be determined that object ARG1 of size ARG
7304 is lock free on this architecture. */
7307 fold_builtin_atomic_is_lock_free (tree arg0
, tree arg1
)
7309 if (!flag_inline_atomics
)
7312 /* If it isn't always lock free, don't generate a result. */
7313 if (fold_builtin_atomic_always_lock_free (arg0
, arg1
) == boolean_true_node
)
7314 return boolean_true_node
;
7319 /* Return true if the parameters to call EXP represent an object which will
7320 always generate lock free instructions. The first argument represents the
7321 size of the object, and the second parameter is a pointer to the object
7322 itself. If NULL is passed for the object, then the result is based on
7323 typical alignment for an object of the specified size. Otherwise return
7327 expand_builtin_atomic_is_lock_free (tree exp
)
7330 tree arg0
= CALL_EXPR_ARG (exp
, 0);
7331 tree arg1
= CALL_EXPR_ARG (exp
, 1);
7333 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
7335 error ("non-integer argument 1 to %qs", "__atomic_is_lock_free");
7339 if (!flag_inline_atomics
)
7342 /* If the value is known at compile time, return the RTX for it. */
7343 size
= fold_builtin_atomic_is_lock_free (arg0
, arg1
);
7344 if (size
== boolean_true_node
)
7350 /* Expand the __atomic_thread_fence intrinsic:
7351 void __atomic_thread_fence (enum memmodel)
7352 EXP is the CALL_EXPR. */
7355 expand_builtin_atomic_thread_fence (tree exp
)
7357 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
7358 expand_mem_thread_fence (model
);
7361 /* Expand the __atomic_signal_fence intrinsic:
7362 void __atomic_signal_fence (enum memmodel)
7363 EXP is the CALL_EXPR. */
7366 expand_builtin_atomic_signal_fence (tree exp
)
7368 enum memmodel model
= get_memmodel (CALL_EXPR_ARG (exp
, 0));
7369 expand_mem_signal_fence (model
);
7372 /* Expand the __sync_synchronize intrinsic. */
7375 expand_builtin_sync_synchronize (void)
7377 expand_mem_thread_fence (MEMMODEL_SYNC_SEQ_CST
);
7381 expand_builtin_thread_pointer (tree exp
, rtx target
)
7383 enum insn_code icode
;
7384 if (!validate_arglist (exp
, VOID_TYPE
))
7386 icode
= direct_optab_handler (get_thread_pointer_optab
, Pmode
);
7387 if (icode
!= CODE_FOR_nothing
)
7389 class expand_operand op
;
7390 /* If the target is not sutitable then create a new target. */
7391 if (target
== NULL_RTX
7393 || GET_MODE (target
) != Pmode
)
7394 target
= gen_reg_rtx (Pmode
);
7395 create_output_operand (&op
, target
, Pmode
);
7396 expand_insn (icode
, 1, &op
);
7399 error ("%<__builtin_thread_pointer%> is not supported on this target");
7404 expand_builtin_set_thread_pointer (tree exp
)
7406 enum insn_code icode
;
7407 if (!validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
7409 icode
= direct_optab_handler (set_thread_pointer_optab
, Pmode
);
7410 if (icode
!= CODE_FOR_nothing
)
7412 class expand_operand op
;
7413 rtx val
= expand_expr (CALL_EXPR_ARG (exp
, 0), NULL_RTX
,
7414 Pmode
, EXPAND_NORMAL
);
7415 create_input_operand (&op
, val
, Pmode
);
7416 expand_insn (icode
, 1, &op
);
7419 error ("%<__builtin_set_thread_pointer%> is not supported on this target");
7423 /* Emit code to restore the current value of stack. */
7426 expand_stack_restore (tree var
)
7429 rtx sa
= expand_normal (var
);
7431 sa
= convert_memory_address (Pmode
, sa
);
7433 prev
= get_last_insn ();
7434 emit_stack_restore (SAVE_BLOCK
, sa
);
7436 record_new_stack_level ();
7438 fixup_args_size_notes (prev
, get_last_insn (), 0);
7441 /* Emit code to save the current value of stack. */
7444 expand_stack_save (void)
7448 emit_stack_save (SAVE_BLOCK
, &ret
);
7452 /* Emit code to get the openacc gang, worker or vector id or size. */
7455 expand_builtin_goacc_parlevel_id_size (tree exp
, rtx target
, int ignore
)
7458 rtx fallback_retval
;
7459 rtx_insn
*(*gen_fn
) (rtx
, rtx
);
7460 switch (DECL_FUNCTION_CODE (get_callee_fndecl (exp
)))
7462 case BUILT_IN_GOACC_PARLEVEL_ID
:
7463 name
= "__builtin_goacc_parlevel_id";
7464 fallback_retval
= const0_rtx
;
7465 gen_fn
= targetm
.gen_oacc_dim_pos
;
7467 case BUILT_IN_GOACC_PARLEVEL_SIZE
:
7468 name
= "__builtin_goacc_parlevel_size";
7469 fallback_retval
= const1_rtx
;
7470 gen_fn
= targetm
.gen_oacc_dim_size
;
7476 if (oacc_get_fn_attrib (current_function_decl
) == NULL_TREE
)
7478 error ("%qs only supported in OpenACC code", name
);
7482 tree arg
= CALL_EXPR_ARG (exp
, 0);
7483 if (TREE_CODE (arg
) != INTEGER_CST
)
7485 error ("non-constant argument 0 to %qs", name
);
7489 int dim
= TREE_INT_CST_LOW (arg
);
7493 case GOMP_DIM_WORKER
:
7494 case GOMP_DIM_VECTOR
:
7497 error ("illegal argument 0 to %qs", name
);
7504 if (target
== NULL_RTX
)
7505 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
7507 if (!targetm
.have_oacc_dim_size ())
7509 emit_move_insn (target
, fallback_retval
);
7513 rtx reg
= MEM_P (target
) ? gen_reg_rtx (GET_MODE (target
)) : target
;
7514 emit_insn (gen_fn (reg
, GEN_INT (dim
)));
7516 emit_move_insn (target
, reg
);
7521 /* Expand a string compare operation using a sequence of char comparison
7522 to get rid of the calling overhead, with result going to TARGET if
7525 VAR_STR is the variable string source;
7526 CONST_STR is the constant string source;
7527 LENGTH is the number of chars to compare;
7528 CONST_STR_N indicates which source string is the constant string;
7529 IS_MEMCMP indicates whether it's a memcmp or strcmp.
7531 to: (assume const_str_n is 2, i.e., arg2 is a constant string)
7533 target = (int) (unsigned char) var_str[0]
7534 - (int) (unsigned char) const_str[0];
7538 target = (int) (unsigned char) var_str[length - 2]
7539 - (int) (unsigned char) const_str[length - 2];
7542 target = (int) (unsigned char) var_str[length - 1]
7543 - (int) (unsigned char) const_str[length - 1];
7548 inline_string_cmp (rtx target
, tree var_str
, const char *const_str
,
7549 unsigned HOST_WIDE_INT length
,
7550 int const_str_n
, machine_mode mode
)
7552 HOST_WIDE_INT offset
= 0;
7554 = get_memory_rtx (var_str
, build_int_cst (unsigned_type_node
,length
));
7555 rtx var_rtx
= NULL_RTX
;
7556 rtx const_rtx
= NULL_RTX
;
7557 rtx result
= target
? target
: gen_reg_rtx (mode
);
7558 rtx_code_label
*ne_label
= gen_label_rtx ();
7559 tree unit_type_node
= unsigned_char_type_node
;
7560 scalar_int_mode unit_mode
7561 = as_a
<scalar_int_mode
> TYPE_MODE (unit_type_node
);
7565 for (unsigned HOST_WIDE_INT i
= 0; i
< length
; i
++)
7568 = adjust_address (var_rtx_array
, TYPE_MODE (unit_type_node
), offset
);
7569 const_rtx
= c_readstr (const_str
+ offset
, unit_mode
);
7570 rtx op0
= (const_str_n
== 1) ? const_rtx
: var_rtx
;
7571 rtx op1
= (const_str_n
== 1) ? var_rtx
: const_rtx
;
7573 op0
= convert_modes (mode
, unit_mode
, op0
, 1);
7574 op1
= convert_modes (mode
, unit_mode
, op1
, 1);
7575 rtx diff
= expand_simple_binop (mode
, MINUS
, op0
, op1
,
7576 result
, 1, OPTAB_WIDEN
);
7578 /* Force the difference into result register. We cannot reassign
7579 result here ("result = diff") or we may end up returning
7580 uninitialized result when expand_simple_binop allocates a new
7581 pseudo-register for returning. */
7583 emit_move_insn (result
, diff
);
7586 emit_cmp_and_jump_insns (result
, CONST0_RTX (mode
), NE
, NULL_RTX
,
7587 mode
, true, ne_label
);
7588 offset
+= GET_MODE_SIZE (unit_mode
);
7591 emit_label (ne_label
);
7592 rtx_insn
*insns
= get_insns ();
7599 /* Inline expansion of a call to str(n)cmp and memcmp, with result going
7600 to TARGET if that's convenient.
7601 If the call is not been inlined, return NULL_RTX. */
7604 inline_expand_builtin_bytecmp (tree exp
, rtx target
)
7606 tree fndecl
= get_callee_fndecl (exp
);
7607 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7608 bool is_ncmp
= (fcode
== BUILT_IN_STRNCMP
|| fcode
== BUILT_IN_MEMCMP
);
7610 /* Do NOT apply this inlining expansion when optimizing for size or
7611 optimization level below 2 or if unused *cmp hasn't been DCEd. */
7612 if (optimize
< 2 || optimize_insn_for_size_p () || target
== const0_rtx
)
7615 gcc_checking_assert (fcode
== BUILT_IN_STRCMP
7616 || fcode
== BUILT_IN_STRNCMP
7617 || fcode
== BUILT_IN_MEMCMP
);
7619 /* On a target where the type of the call (int) has same or narrower presicion
7620 than unsigned char, give up the inlining expansion. */
7621 if (TYPE_PRECISION (unsigned_char_type_node
)
7622 >= TYPE_PRECISION (TREE_TYPE (exp
)))
7625 tree arg1
= CALL_EXPR_ARG (exp
, 0);
7626 tree arg2
= CALL_EXPR_ARG (exp
, 1);
7627 tree len3_tree
= is_ncmp
? CALL_EXPR_ARG (exp
, 2) : NULL_TREE
;
7629 unsigned HOST_WIDE_INT len1
= 0;
7630 unsigned HOST_WIDE_INT len2
= 0;
7631 unsigned HOST_WIDE_INT len3
= 0;
7633 /* Get the object representation of the initializers of ARG1 and ARG2
7634 as strings, provided they refer to constant objects, with their byte
7635 sizes in LEN1 and LEN2, respectively. */
7636 const char *bytes1
= getbyterep (arg1
, &len1
);
7637 const char *bytes2
= getbyterep (arg2
, &len2
);
7639 /* Fail if neither argument refers to an initialized constant. */
7640 if (!bytes1
&& !bytes2
)
7645 /* Fail if the memcmp/strncmp bound is not a constant. */
7646 if (!tree_fits_uhwi_p (len3_tree
))
7649 len3
= tree_to_uhwi (len3_tree
);
7651 if (fcode
== BUILT_IN_MEMCMP
)
7653 /* Fail if the memcmp bound is greater than the size of either
7654 of the two constant objects. */
7655 if ((bytes1
&& len1
< len3
)
7656 || (bytes2
&& len2
< len3
))
7661 if (fcode
!= BUILT_IN_MEMCMP
)
7663 /* For string functions (i.e., strcmp and strncmp) reduce LEN1
7664 and LEN2 to the length of the nul-terminated string stored
7667 len1
= strnlen (bytes1
, len1
) + 1;
7669 len2
= strnlen (bytes2
, len2
) + 1;
7672 /* See inline_string_cmp. */
7678 else if (len2
> len1
)
7683 /* For strncmp only, compute the new bound as the smallest of
7684 the lengths of the two strings (plus 1) and the bound provided
7686 unsigned HOST_WIDE_INT bound
= (const_str_n
== 1) ? len1
: len2
;
7687 if (is_ncmp
&& len3
< bound
)
7690 /* If the bound of the comparison is larger than the threshold,
7692 if (bound
> (unsigned HOST_WIDE_INT
) param_builtin_string_cmp_inline_length
)
7695 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
7697 /* Now, start inline expansion the call. */
7698 return inline_string_cmp (target
, (const_str_n
== 1) ? arg2
: arg1
,
7699 (const_str_n
== 1) ? bytes1
: bytes2
, bound
,
7703 /* Expand a call to __builtin_speculation_safe_value_<N>. MODE
7704 represents the size of the first argument to that call, or VOIDmode
7705 if the argument is a pointer. IGNORE will be true if the result
7708 expand_speculation_safe_value (machine_mode mode
, tree exp
, rtx target
,
7712 unsigned nargs
= call_expr_nargs (exp
);
7714 tree arg0
= CALL_EXPR_ARG (exp
, 0);
7716 if (mode
== VOIDmode
)
7718 mode
= TYPE_MODE (TREE_TYPE (arg0
));
7719 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
7722 val
= expand_expr (arg0
, NULL_RTX
, mode
, EXPAND_NORMAL
);
7724 /* An optional second argument can be used as a failsafe value on
7725 some machines. If it isn't present, then the failsafe value is
7729 tree arg1
= CALL_EXPR_ARG (exp
, 1);
7730 failsafe
= expand_expr (arg1
, NULL_RTX
, mode
, EXPAND_NORMAL
);
7733 failsafe
= const0_rtx
;
7735 /* If the result isn't used, the behavior is undefined. It would be
7736 nice to emit a warning here, but path splitting means this might
7737 happen with legitimate code. So simply drop the builtin
7738 expansion in that case; we've handled any side-effects above. */
7742 /* If we don't have a suitable target, create one to hold the result. */
7743 if (target
== NULL
|| GET_MODE (target
) != mode
)
7744 target
= gen_reg_rtx (mode
);
7746 if (GET_MODE (val
) != mode
&& GET_MODE (val
) != VOIDmode
)
7747 val
= convert_modes (mode
, VOIDmode
, val
, false);
7749 return targetm
.speculation_safe_value (mode
, target
, val
, failsafe
);
7752 /* Expand an expression EXP that calls a built-in function,
7753 with result going to TARGET if that's convenient
7754 (and in mode MODE if that's convenient).
7755 SUBTARGET may be used as the target for computing one of EXP's operands.
7756 IGNORE is nonzero if the value is to be ignored. */
7759 expand_builtin (tree exp
, rtx target
, rtx subtarget
, machine_mode mode
,
7762 tree fndecl
= get_callee_fndecl (exp
);
7763 machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
7766 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7767 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
7769 /* When ASan is enabled, we don't want to expand some memory/string
7770 builtins and rely on libsanitizer's hooks. This allows us to avoid
7771 redundant checks and be sure, that possible overflow will be detected
7774 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
7775 if (param_asan_kernel_mem_intrinsic_prefix
7776 && sanitize_flags_p (SANITIZE_KERNEL_ADDRESS
7777 | SANITIZE_KERNEL_HWADDRESS
))
7780 rtx save_decl_rtl
, ret
;
7781 case BUILT_IN_MEMCPY
:
7782 case BUILT_IN_MEMMOVE
:
7783 case BUILT_IN_MEMSET
:
7784 save_decl_rtl
= DECL_RTL (fndecl
);
7785 DECL_RTL (fndecl
) = asan_memfn_rtl (fndecl
);
7786 ret
= expand_call (exp
, target
, ignore
);
7787 DECL_RTL (fndecl
) = save_decl_rtl
;
7792 if (sanitize_flags_p (SANITIZE_ADDRESS
) && asan_intercepted_p (fcode
))
7793 return expand_call (exp
, target
, ignore
);
7795 /* When not optimizing, generate calls to library functions for a certain
7798 && !called_as_built_in (fndecl
)
7799 && fcode
!= BUILT_IN_FORK
7800 && fcode
!= BUILT_IN_EXECL
7801 && fcode
!= BUILT_IN_EXECV
7802 && fcode
!= BUILT_IN_EXECLP
7803 && fcode
!= BUILT_IN_EXECLE
7804 && fcode
!= BUILT_IN_EXECVP
7805 && fcode
!= BUILT_IN_EXECVE
7806 && fcode
!= BUILT_IN_CLEAR_CACHE
7807 && !ALLOCA_FUNCTION_CODE_P (fcode
)
7808 && fcode
!= BUILT_IN_FREE
7809 && (fcode
!= BUILT_IN_MEMSET
7810 || !(flag_inline_stringops
& ILSOP_MEMSET
))
7811 && (fcode
!= BUILT_IN_MEMCPY
7812 || !(flag_inline_stringops
& ILSOP_MEMCPY
))
7813 && (fcode
!= BUILT_IN_MEMMOVE
7814 || !(flag_inline_stringops
& ILSOP_MEMMOVE
))
7815 && (fcode
!= BUILT_IN_MEMCMP
7816 || !(flag_inline_stringops
& ILSOP_MEMCMP
)))
7817 return expand_call (exp
, target
, ignore
);
7819 /* The built-in function expanders test for target == const0_rtx
7820 to determine whether the function's result will be ignored. */
7822 target
= const0_rtx
;
7824 /* If the result of a pure or const built-in function is ignored, and
7825 none of its arguments are volatile, we can avoid expanding the
7826 built-in call and just evaluate the arguments for side-effects. */
7827 if (target
== const0_rtx
7828 && ((flags
= flags_from_decl_or_type (fndecl
)) & (ECF_CONST
| ECF_PURE
))
7829 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
7831 bool volatilep
= false;
7833 call_expr_arg_iterator iter
;
7835 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
7836 if (TREE_THIS_VOLATILE (arg
))
7844 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
7845 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
7852 CASE_FLT_FN (BUILT_IN_FABS
):
7853 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS
):
7854 case BUILT_IN_FABSD32
:
7855 case BUILT_IN_FABSD64
:
7856 case BUILT_IN_FABSD128
:
7857 target
= expand_builtin_fabs (exp
, target
, subtarget
);
7862 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
7863 CASE_FLT_FN_FLOATN_NX (BUILT_IN_COPYSIGN
):
7864 target
= expand_builtin_copysign (exp
, target
, subtarget
);
7869 /* Just do a normal library call if we were unable to fold
7871 CASE_FLT_FN (BUILT_IN_CABS
):
7872 CASE_FLT_FN_FLOATN_NX (BUILT_IN_CABS
):
7875 CASE_FLT_FN (BUILT_IN_FMA
):
7876 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMA
):
7877 target
= expand_builtin_mathfn_ternary (exp
, target
, subtarget
);
7882 CASE_FLT_FN (BUILT_IN_ILOGB
):
7883 if (! flag_unsafe_math_optimizations
)
7886 CASE_FLT_FN (BUILT_IN_ISINF
):
7887 CASE_FLT_FN (BUILT_IN_FINITE
):
7888 case BUILT_IN_ISFINITE
:
7889 case BUILT_IN_ISNORMAL
:
7890 target
= expand_builtin_interclass_mathfn (exp
, target
);
7895 case BUILT_IN_ISSIGNALING
:
7896 target
= expand_builtin_issignaling (exp
, target
);
7901 CASE_FLT_FN (BUILT_IN_ICEIL
):
7902 CASE_FLT_FN (BUILT_IN_LCEIL
):
7903 CASE_FLT_FN (BUILT_IN_LLCEIL
):
7904 CASE_FLT_FN (BUILT_IN_LFLOOR
):
7905 CASE_FLT_FN (BUILT_IN_IFLOOR
):
7906 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7907 target
= expand_builtin_int_roundingfn (exp
, target
);
7912 CASE_FLT_FN (BUILT_IN_IRINT
):
7913 CASE_FLT_FN (BUILT_IN_LRINT
):
7914 CASE_FLT_FN (BUILT_IN_LLRINT
):
7915 CASE_FLT_FN (BUILT_IN_IROUND
):
7916 CASE_FLT_FN (BUILT_IN_LROUND
):
7917 CASE_FLT_FN (BUILT_IN_LLROUND
):
7918 target
= expand_builtin_int_roundingfn_2 (exp
, target
);
7923 CASE_FLT_FN (BUILT_IN_POWI
):
7924 target
= expand_builtin_powi (exp
, target
);
7929 CASE_FLT_FN (BUILT_IN_CEXPI
):
7930 target
= expand_builtin_cexpi (exp
, target
);
7931 gcc_assert (target
);
7934 CASE_FLT_FN (BUILT_IN_SIN
):
7935 CASE_FLT_FN (BUILT_IN_COS
):
7936 if (! flag_unsafe_math_optimizations
)
7938 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
7943 CASE_FLT_FN (BUILT_IN_SINCOS
):
7944 if (! flag_unsafe_math_optimizations
)
7946 target
= expand_builtin_sincos (exp
);
7951 case BUILT_IN_FEGETROUND
:
7952 target
= expand_builtin_fegetround (exp
, target
, target_mode
);
7957 case BUILT_IN_FECLEAREXCEPT
:
7958 target
= expand_builtin_feclear_feraise_except (exp
, target
, target_mode
,
7959 feclearexcept_optab
);
7964 case BUILT_IN_FERAISEEXCEPT
:
7965 target
= expand_builtin_feclear_feraise_except (exp
, target
, target_mode
,
7966 feraiseexcept_optab
);
7971 case BUILT_IN_APPLY_ARGS
:
7972 return expand_builtin_apply_args ();
7974 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
7975 FUNCTION with a copy of the parameters described by
7976 ARGUMENTS, and ARGSIZE. It returns a block of memory
7977 allocated on the stack into which is stored all the registers
7978 that might possibly be used for returning the result of a
7979 function. ARGUMENTS is the value returned by
7980 __builtin_apply_args. ARGSIZE is the number of bytes of
7981 arguments that must be copied. ??? How should this value be
7982 computed? We'll also need a safe worst case value for varargs
7984 case BUILT_IN_APPLY
:
7985 if (!validate_arglist (exp
, POINTER_TYPE
,
7986 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
7987 && !validate_arglist (exp
, REFERENCE_TYPE
,
7988 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7994 ops
[0] = expand_normal (CALL_EXPR_ARG (exp
, 0));
7995 ops
[1] = expand_normal (CALL_EXPR_ARG (exp
, 1));
7996 ops
[2] = expand_normal (CALL_EXPR_ARG (exp
, 2));
7998 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
8001 /* __builtin_return (RESULT) causes the function to return the
8002 value described by RESULT. RESULT is address of the block of
8003 memory returned by __builtin_apply. */
8004 case BUILT_IN_RETURN
:
8005 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
8006 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp
, 0)));
8009 case BUILT_IN_SAVEREGS
:
8010 return expand_builtin_saveregs ();
8012 case BUILT_IN_VA_ARG_PACK
:
8013 /* All valid uses of __builtin_va_arg_pack () are removed during
8015 error ("invalid use of %<__builtin_va_arg_pack ()%>");
8018 case BUILT_IN_VA_ARG_PACK_LEN
:
8019 /* All valid uses of __builtin_va_arg_pack_len () are removed during
8021 error ("invalid use of %<__builtin_va_arg_pack_len ()%>");
8024 /* Return the address of the first anonymous stack arg. */
8025 case BUILT_IN_NEXT_ARG
:
8026 if (fold_builtin_next_arg (exp
, false))
8028 return expand_builtin_next_arg ();
8030 case BUILT_IN_CLEAR_CACHE
:
8031 expand_builtin___clear_cache (exp
);
8034 case BUILT_IN_CLASSIFY_TYPE
:
8035 return expand_builtin_classify_type (exp
);
8037 case BUILT_IN_CONSTANT_P
:
8040 case BUILT_IN_FRAME_ADDRESS
:
8041 case BUILT_IN_RETURN_ADDRESS
:
8042 return expand_builtin_frame_address (fndecl
, exp
);
8044 case BUILT_IN_STACK_ADDRESS
:
8045 return expand_builtin_stack_address ();
8047 case BUILT_IN___STRUB_ENTER
:
8048 target
= expand_builtin_strub_enter (exp
);
8053 case BUILT_IN___STRUB_UPDATE
:
8054 target
= expand_builtin_strub_update (exp
);
8059 case BUILT_IN___STRUB_LEAVE
:
8060 target
= expand_builtin_strub_leave (exp
);
8065 /* Returns the address of the area where the structure is returned.
8067 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
8068 if (call_expr_nargs (exp
) != 0
8069 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
8070 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
8073 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
8075 CASE_BUILT_IN_ALLOCA
:
8076 target
= expand_builtin_alloca (exp
);
8081 case BUILT_IN_ASAN_ALLOCAS_UNPOISON
:
8082 return expand_asan_emit_allocas_unpoison (exp
);
8084 case BUILT_IN_STACK_SAVE
:
8085 return expand_stack_save ();
8087 case BUILT_IN_STACK_RESTORE
:
8088 expand_stack_restore (CALL_EXPR_ARG (exp
, 0));
8091 case BUILT_IN_BSWAP16
:
8092 case BUILT_IN_BSWAP32
:
8093 case BUILT_IN_BSWAP64
:
8094 case BUILT_IN_BSWAP128
:
8095 target
= expand_builtin_bswap (target_mode
, exp
, target
, subtarget
);
8100 CASE_INT_FN (BUILT_IN_FFS
):
8101 target
= expand_builtin_unop (target_mode
, exp
, target
,
8102 subtarget
, ffs_optab
);
8107 CASE_INT_FN (BUILT_IN_CLZ
):
8108 target
= expand_builtin_unop (target_mode
, exp
, target
,
8109 subtarget
, clz_optab
);
8114 CASE_INT_FN (BUILT_IN_CTZ
):
8115 target
= expand_builtin_unop (target_mode
, exp
, target
,
8116 subtarget
, ctz_optab
);
8121 CASE_INT_FN (BUILT_IN_CLRSB
):
8122 target
= expand_builtin_unop (target_mode
, exp
, target
,
8123 subtarget
, clrsb_optab
);
8128 CASE_INT_FN (BUILT_IN_POPCOUNT
):
8129 target
= expand_builtin_unop (target_mode
, exp
, target
,
8130 subtarget
, popcount_optab
);
8135 CASE_INT_FN (BUILT_IN_PARITY
):
8136 target
= expand_builtin_unop (target_mode
, exp
, target
,
8137 subtarget
, parity_optab
);
8142 case BUILT_IN_STRLEN
:
8143 target
= expand_builtin_strlen (exp
, target
, target_mode
);
8148 case BUILT_IN_STRNLEN
:
8149 target
= expand_builtin_strnlen (exp
, target
, target_mode
);
8154 case BUILT_IN_STRCPY
:
8155 target
= expand_builtin_strcpy (exp
, target
);
8160 case BUILT_IN_STRNCPY
:
8161 target
= expand_builtin_strncpy (exp
, target
);
8166 case BUILT_IN_STPCPY
:
8167 target
= expand_builtin_stpcpy (exp
, target
, mode
);
8172 case BUILT_IN_MEMCPY
:
8173 target
= expand_builtin_memcpy (exp
, target
);
8178 case BUILT_IN_MEMMOVE
:
8179 target
= expand_builtin_memmove (exp
, target
);
8184 case BUILT_IN_MEMPCPY
:
8185 target
= expand_builtin_mempcpy (exp
, target
);
8190 case BUILT_IN_MEMSET
:
8191 target
= expand_builtin_memset (exp
, target
, mode
);
8196 case BUILT_IN_BZERO
:
8197 target
= expand_builtin_bzero (exp
);
8202 /* Expand it as BUILT_IN_MEMCMP_EQ first. If not successful, change it
8203 back to a BUILT_IN_STRCMP. Remember to delete the 3rd parameter
8204 when changing it to a strcmp call. */
8205 case BUILT_IN_STRCMP_EQ
:
8206 target
= expand_builtin_memcmp (exp
, target
, true);
8210 /* Change this call back to a BUILT_IN_STRCMP. */
8211 TREE_OPERAND (exp
, 1)
8212 = build_fold_addr_expr (builtin_decl_explicit (BUILT_IN_STRCMP
));
8214 /* Delete the last parameter. */
8216 vec
<tree
, va_gc
> *arg_vec
;
8217 vec_alloc (arg_vec
, 2);
8218 for (i
= 0; i
< 2; i
++)
8219 arg_vec
->quick_push (CALL_EXPR_ARG (exp
, i
));
8220 exp
= build_call_vec (TREE_TYPE (exp
), CALL_EXPR_FN (exp
), arg_vec
);
8223 case BUILT_IN_STRCMP
:
8224 target
= expand_builtin_strcmp (exp
, target
);
8229 /* Expand it as BUILT_IN_MEMCMP_EQ first. If not successful, change it
8230 back to a BUILT_IN_STRNCMP. */
8231 case BUILT_IN_STRNCMP_EQ
:
8232 target
= expand_builtin_memcmp (exp
, target
, true);
8236 /* Change it back to a BUILT_IN_STRNCMP. */
8237 TREE_OPERAND (exp
, 1)
8238 = build_fold_addr_expr (builtin_decl_explicit (BUILT_IN_STRNCMP
));
8241 case BUILT_IN_STRNCMP
:
8242 target
= expand_builtin_strncmp (exp
, target
, mode
);
8248 case BUILT_IN_MEMCMP
:
8249 case BUILT_IN_MEMCMP_EQ
:
8250 target
= expand_builtin_memcmp (exp
, target
, fcode
== BUILT_IN_MEMCMP_EQ
);
8253 if (fcode
== BUILT_IN_MEMCMP_EQ
)
8255 tree newdecl
= builtin_decl_explicit (BUILT_IN_MEMCMP
);
8256 TREE_OPERAND (exp
, 1) = build_fold_addr_expr (newdecl
);
8260 case BUILT_IN_SETJMP
:
8261 /* This should have been lowered to the builtins below. */
8264 case BUILT_IN_SETJMP_SETUP
:
8265 /* __builtin_setjmp_setup is passed a pointer to an array of five words
8266 and the receiver label. */
8267 if (validate_arglist (exp
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8269 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
8270 VOIDmode
, EXPAND_NORMAL
);
8271 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 1), 0);
8272 rtx_insn
*label_r
= label_rtx (label
);
8274 expand_builtin_setjmp_setup (buf_addr
, label_r
);
8279 case BUILT_IN_SETJMP_RECEIVER
:
8280 /* __builtin_setjmp_receiver is passed the receiver label. */
8281 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
8283 tree label
= TREE_OPERAND (CALL_EXPR_ARG (exp
, 0), 0);
8284 rtx_insn
*label_r
= label_rtx (label
);
8286 expand_builtin_setjmp_receiver (label_r
);
8287 nonlocal_goto_handler_labels
8288 = gen_rtx_INSN_LIST (VOIDmode
, label_r
,
8289 nonlocal_goto_handler_labels
);
8290 /* ??? Do not let expand_label treat us as such since we would
8291 not want to be both on the list of non-local labels and on
8292 the list of forced labels. */
8293 FORCED_LABEL (label
) = 0;
8298 /* __builtin_longjmp is passed a pointer to an array of five words.
8299 It's similar to the C library longjmp function but works with
8300 __builtin_setjmp above. */
8301 case BUILT_IN_LONGJMP
:
8302 if (validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8304 rtx buf_addr
= expand_expr (CALL_EXPR_ARG (exp
, 0), subtarget
,
8305 VOIDmode
, EXPAND_NORMAL
);
8306 rtx value
= expand_normal (CALL_EXPR_ARG (exp
, 1));
8308 if (value
!= const1_rtx
)
8310 error ("%<__builtin_longjmp%> second argument must be 1");
8314 expand_builtin_longjmp (buf_addr
, value
);
8319 case BUILT_IN_NONLOCAL_GOTO
:
8320 target
= expand_builtin_nonlocal_goto (exp
);
8325 /* This updates the setjmp buffer that is its argument with the value
8326 of the current stack pointer. */
8327 case BUILT_IN_UPDATE_SETJMP_BUF
:
8328 if (validate_arglist (exp
, POINTER_TYPE
, VOID_TYPE
))
8331 = expand_normal (CALL_EXPR_ARG (exp
, 0));
8333 expand_builtin_update_setjmp_buf (buf_addr
);
8339 case BUILT_IN_UNREACHABLE_TRAP
:
8340 expand_builtin_trap ();
8343 case BUILT_IN_UNREACHABLE
:
8344 expand_builtin_unreachable ();
8347 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
8348 case BUILT_IN_SIGNBITD32
:
8349 case BUILT_IN_SIGNBITD64
:
8350 case BUILT_IN_SIGNBITD128
:
8351 target
= expand_builtin_signbit (exp
, target
);
8356 /* Various hooks for the DWARF 2 __throw routine. */
8357 case BUILT_IN_UNWIND_INIT
:
8358 expand_builtin_unwind_init ();
8360 case BUILT_IN_DWARF_CFA
:
8361 return virtual_cfa_rtx
;
8362 #ifdef DWARF2_UNWIND_INFO
8363 case BUILT_IN_DWARF_SP_COLUMN
:
8364 return expand_builtin_dwarf_sp_column ();
8365 case BUILT_IN_INIT_DWARF_REG_SIZES
:
8366 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp
, 0));
8369 case BUILT_IN_FROB_RETURN_ADDR
:
8370 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp
, 0));
8371 case BUILT_IN_EXTRACT_RETURN_ADDR
:
8372 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp
, 0));
8373 case BUILT_IN_EH_RETURN
:
8374 expand_builtin_eh_return (CALL_EXPR_ARG (exp
, 0),
8375 CALL_EXPR_ARG (exp
, 1));
8377 case BUILT_IN_EH_RETURN_DATA_REGNO
:
8378 return expand_builtin_eh_return_data_regno (exp
);
8379 case BUILT_IN_EXTEND_POINTER
:
8380 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp
, 0));
8381 case BUILT_IN_EH_POINTER
:
8382 return expand_builtin_eh_pointer (exp
);
8383 case BUILT_IN_EH_FILTER
:
8384 return expand_builtin_eh_filter (exp
);
8385 case BUILT_IN_EH_COPY_VALUES
:
8386 return expand_builtin_eh_copy_values (exp
);
8388 case BUILT_IN_VA_START
:
8389 return expand_builtin_va_start (exp
);
8390 case BUILT_IN_VA_END
:
8391 return expand_builtin_va_end (exp
);
8392 case BUILT_IN_VA_COPY
:
8393 return expand_builtin_va_copy (exp
);
8394 case BUILT_IN_EXPECT
:
8395 return expand_builtin_expect (exp
, target
);
8396 case BUILT_IN_EXPECT_WITH_PROBABILITY
:
8397 return expand_builtin_expect_with_probability (exp
, target
);
8398 case BUILT_IN_ASSUME_ALIGNED
:
8399 return expand_builtin_assume_aligned (exp
, target
);
8400 case BUILT_IN_PREFETCH
:
8401 expand_builtin_prefetch (exp
);
8404 case BUILT_IN_INIT_TRAMPOLINE
:
8405 return expand_builtin_init_trampoline (exp
, true);
8406 case BUILT_IN_INIT_HEAP_TRAMPOLINE
:
8407 return expand_builtin_init_trampoline (exp
, false);
8408 case BUILT_IN_ADJUST_TRAMPOLINE
:
8409 return expand_builtin_adjust_trampoline (exp
);
8411 case BUILT_IN_INIT_DESCRIPTOR
:
8412 return expand_builtin_init_descriptor (exp
);
8413 case BUILT_IN_ADJUST_DESCRIPTOR
:
8414 return expand_builtin_adjust_descriptor (exp
);
8417 case BUILT_IN_EXECL
:
8418 case BUILT_IN_EXECV
:
8419 case BUILT_IN_EXECLP
:
8420 case BUILT_IN_EXECLE
:
8421 case BUILT_IN_EXECVP
:
8422 case BUILT_IN_EXECVE
:
8423 target
= expand_builtin_fork_or_exec (fndecl
, exp
, target
, ignore
);
8428 case BUILT_IN_SYNC_FETCH_AND_ADD_1
:
8429 case BUILT_IN_SYNC_FETCH_AND_ADD_2
:
8430 case BUILT_IN_SYNC_FETCH_AND_ADD_4
:
8431 case BUILT_IN_SYNC_FETCH_AND_ADD_8
:
8432 case BUILT_IN_SYNC_FETCH_AND_ADD_16
:
8433 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_ADD_1
);
8434 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, false, target
);
8439 case BUILT_IN_SYNC_FETCH_AND_SUB_1
:
8440 case BUILT_IN_SYNC_FETCH_AND_SUB_2
:
8441 case BUILT_IN_SYNC_FETCH_AND_SUB_4
:
8442 case BUILT_IN_SYNC_FETCH_AND_SUB_8
:
8443 case BUILT_IN_SYNC_FETCH_AND_SUB_16
:
8444 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_SUB_1
);
8445 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, false, target
);
8450 case BUILT_IN_SYNC_FETCH_AND_OR_1
:
8451 case BUILT_IN_SYNC_FETCH_AND_OR_2
:
8452 case BUILT_IN_SYNC_FETCH_AND_OR_4
:
8453 case BUILT_IN_SYNC_FETCH_AND_OR_8
:
8454 case BUILT_IN_SYNC_FETCH_AND_OR_16
:
8455 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_OR_1
);
8456 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, false, target
);
8461 case BUILT_IN_SYNC_FETCH_AND_AND_1
:
8462 case BUILT_IN_SYNC_FETCH_AND_AND_2
:
8463 case BUILT_IN_SYNC_FETCH_AND_AND_4
:
8464 case BUILT_IN_SYNC_FETCH_AND_AND_8
:
8465 case BUILT_IN_SYNC_FETCH_AND_AND_16
:
8466 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_AND_1
);
8467 target
= expand_builtin_sync_operation (mode
, exp
, AND
, false, target
);
8472 case BUILT_IN_SYNC_FETCH_AND_XOR_1
:
8473 case BUILT_IN_SYNC_FETCH_AND_XOR_2
:
8474 case BUILT_IN_SYNC_FETCH_AND_XOR_4
:
8475 case BUILT_IN_SYNC_FETCH_AND_XOR_8
:
8476 case BUILT_IN_SYNC_FETCH_AND_XOR_16
:
8477 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_XOR_1
);
8478 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, false, target
);
8483 case BUILT_IN_SYNC_FETCH_AND_NAND_1
:
8484 case BUILT_IN_SYNC_FETCH_AND_NAND_2
:
8485 case BUILT_IN_SYNC_FETCH_AND_NAND_4
:
8486 case BUILT_IN_SYNC_FETCH_AND_NAND_8
:
8487 case BUILT_IN_SYNC_FETCH_AND_NAND_16
:
8488 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_FETCH_AND_NAND_1
);
8489 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, false, target
);
8494 case BUILT_IN_SYNC_ADD_AND_FETCH_1
:
8495 case BUILT_IN_SYNC_ADD_AND_FETCH_2
:
8496 case BUILT_IN_SYNC_ADD_AND_FETCH_4
:
8497 case BUILT_IN_SYNC_ADD_AND_FETCH_8
:
8498 case BUILT_IN_SYNC_ADD_AND_FETCH_16
:
8499 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_ADD_AND_FETCH_1
);
8500 target
= expand_builtin_sync_operation (mode
, exp
, PLUS
, true, target
);
8505 case BUILT_IN_SYNC_SUB_AND_FETCH_1
:
8506 case BUILT_IN_SYNC_SUB_AND_FETCH_2
:
8507 case BUILT_IN_SYNC_SUB_AND_FETCH_4
:
8508 case BUILT_IN_SYNC_SUB_AND_FETCH_8
:
8509 case BUILT_IN_SYNC_SUB_AND_FETCH_16
:
8510 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_SUB_AND_FETCH_1
);
8511 target
= expand_builtin_sync_operation (mode
, exp
, MINUS
, true, target
);
8516 case BUILT_IN_SYNC_OR_AND_FETCH_1
:
8517 case BUILT_IN_SYNC_OR_AND_FETCH_2
:
8518 case BUILT_IN_SYNC_OR_AND_FETCH_4
:
8519 case BUILT_IN_SYNC_OR_AND_FETCH_8
:
8520 case BUILT_IN_SYNC_OR_AND_FETCH_16
:
8521 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_OR_AND_FETCH_1
);
8522 target
= expand_builtin_sync_operation (mode
, exp
, IOR
, true, target
);
8527 case BUILT_IN_SYNC_AND_AND_FETCH_1
:
8528 case BUILT_IN_SYNC_AND_AND_FETCH_2
:
8529 case BUILT_IN_SYNC_AND_AND_FETCH_4
:
8530 case BUILT_IN_SYNC_AND_AND_FETCH_8
:
8531 case BUILT_IN_SYNC_AND_AND_FETCH_16
:
8532 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_AND_AND_FETCH_1
);
8533 target
= expand_builtin_sync_operation (mode
, exp
, AND
, true, target
);
8538 case BUILT_IN_SYNC_XOR_AND_FETCH_1
:
8539 case BUILT_IN_SYNC_XOR_AND_FETCH_2
:
8540 case BUILT_IN_SYNC_XOR_AND_FETCH_4
:
8541 case BUILT_IN_SYNC_XOR_AND_FETCH_8
:
8542 case BUILT_IN_SYNC_XOR_AND_FETCH_16
:
8543 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_XOR_AND_FETCH_1
);
8544 target
= expand_builtin_sync_operation (mode
, exp
, XOR
, true, target
);
8549 case BUILT_IN_SYNC_NAND_AND_FETCH_1
:
8550 case BUILT_IN_SYNC_NAND_AND_FETCH_2
:
8551 case BUILT_IN_SYNC_NAND_AND_FETCH_4
:
8552 case BUILT_IN_SYNC_NAND_AND_FETCH_8
:
8553 case BUILT_IN_SYNC_NAND_AND_FETCH_16
:
8554 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_NAND_AND_FETCH_1
);
8555 target
= expand_builtin_sync_operation (mode
, exp
, NOT
, true, target
);
8560 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
:
8561 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2
:
8562 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4
:
8563 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8
:
8564 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16
:
8565 if (mode
== VOIDmode
)
8566 mode
= TYPE_MODE (boolean_type_node
);
8567 if (!target
|| !register_operand (target
, mode
))
8568 target
= gen_reg_rtx (mode
);
8570 mode
= get_builtin_sync_mode
8571 (fcode
- BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1
);
8572 target
= expand_builtin_compare_and_swap (mode
, exp
, true, target
);
8577 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
:
8578 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2
:
8579 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4
:
8580 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8
:
8581 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16
:
8582 mode
= get_builtin_sync_mode
8583 (fcode
- BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1
);
8584 target
= expand_builtin_compare_and_swap (mode
, exp
, false, target
);
8589 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
:
8590 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2
:
8591 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4
:
8592 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8
:
8593 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16
:
8594 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_TEST_AND_SET_1
);
8595 target
= expand_builtin_sync_lock_test_and_set (mode
, exp
, target
);
8600 case BUILT_IN_SYNC_LOCK_RELEASE_1
:
8601 case BUILT_IN_SYNC_LOCK_RELEASE_2
:
8602 case BUILT_IN_SYNC_LOCK_RELEASE_4
:
8603 case BUILT_IN_SYNC_LOCK_RELEASE_8
:
8604 case BUILT_IN_SYNC_LOCK_RELEASE_16
:
8605 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SYNC_LOCK_RELEASE_1
);
8606 expand_builtin_sync_lock_release (mode
, exp
);
8609 case BUILT_IN_SYNC_SYNCHRONIZE
:
8610 expand_builtin_sync_synchronize ();
8613 case BUILT_IN_ATOMIC_EXCHANGE_1
:
8614 case BUILT_IN_ATOMIC_EXCHANGE_2
:
8615 case BUILT_IN_ATOMIC_EXCHANGE_4
:
8616 case BUILT_IN_ATOMIC_EXCHANGE_8
:
8617 case BUILT_IN_ATOMIC_EXCHANGE_16
:
8618 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_EXCHANGE_1
);
8619 target
= expand_builtin_atomic_exchange (mode
, exp
, target
);
8624 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
8625 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
8626 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
8627 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
8628 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
8630 unsigned int nargs
, z
;
8631 vec
<tree
, va_gc
> *vec
;
8634 get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
);
8635 target
= expand_builtin_atomic_compare_exchange (mode
, exp
, target
);
8639 /* If this is turned into an external library call, the weak parameter
8640 must be dropped to match the expected parameter list. */
8641 nargs
= call_expr_nargs (exp
);
8642 vec_alloc (vec
, nargs
- 1);
8643 for (z
= 0; z
< 3; z
++)
8644 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
8645 /* Skip the boolean weak parameter. */
8646 for (z
= 4; z
< 6; z
++)
8647 vec
->quick_push (CALL_EXPR_ARG (exp
, z
));
8648 exp
= build_call_vec (TREE_TYPE (exp
), CALL_EXPR_FN (exp
), vec
);
8652 case BUILT_IN_ATOMIC_LOAD_1
:
8653 case BUILT_IN_ATOMIC_LOAD_2
:
8654 case BUILT_IN_ATOMIC_LOAD_4
:
8655 case BUILT_IN_ATOMIC_LOAD_8
:
8656 case BUILT_IN_ATOMIC_LOAD_16
:
8657 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_LOAD_1
);
8658 target
= expand_builtin_atomic_load (mode
, exp
, target
);
8663 case BUILT_IN_ATOMIC_STORE_1
:
8664 case BUILT_IN_ATOMIC_STORE_2
:
8665 case BUILT_IN_ATOMIC_STORE_4
:
8666 case BUILT_IN_ATOMIC_STORE_8
:
8667 case BUILT_IN_ATOMIC_STORE_16
:
8668 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_STORE_1
);
8669 target
= expand_builtin_atomic_store (mode
, exp
);
8674 case BUILT_IN_ATOMIC_ADD_FETCH_1
:
8675 case BUILT_IN_ATOMIC_ADD_FETCH_2
:
8676 case BUILT_IN_ATOMIC_ADD_FETCH_4
:
8677 case BUILT_IN_ATOMIC_ADD_FETCH_8
:
8678 case BUILT_IN_ATOMIC_ADD_FETCH_16
:
8680 enum built_in_function lib
;
8681 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
);
8682 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_ADD_1
+
8683 (fcode
- BUILT_IN_ATOMIC_ADD_FETCH_1
));
8684 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, true,
8690 case BUILT_IN_ATOMIC_SUB_FETCH_1
:
8691 case BUILT_IN_ATOMIC_SUB_FETCH_2
:
8692 case BUILT_IN_ATOMIC_SUB_FETCH_4
:
8693 case BUILT_IN_ATOMIC_SUB_FETCH_8
:
8694 case BUILT_IN_ATOMIC_SUB_FETCH_16
:
8696 enum built_in_function lib
;
8697 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
);
8698 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_SUB_1
+
8699 (fcode
- BUILT_IN_ATOMIC_SUB_FETCH_1
));
8700 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, true,
8706 case BUILT_IN_ATOMIC_AND_FETCH_1
:
8707 case BUILT_IN_ATOMIC_AND_FETCH_2
:
8708 case BUILT_IN_ATOMIC_AND_FETCH_4
:
8709 case BUILT_IN_ATOMIC_AND_FETCH_8
:
8710 case BUILT_IN_ATOMIC_AND_FETCH_16
:
8712 enum built_in_function lib
;
8713 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
);
8714 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_AND_1
+
8715 (fcode
- BUILT_IN_ATOMIC_AND_FETCH_1
));
8716 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, true,
8722 case BUILT_IN_ATOMIC_NAND_FETCH_1
:
8723 case BUILT_IN_ATOMIC_NAND_FETCH_2
:
8724 case BUILT_IN_ATOMIC_NAND_FETCH_4
:
8725 case BUILT_IN_ATOMIC_NAND_FETCH_8
:
8726 case BUILT_IN_ATOMIC_NAND_FETCH_16
:
8728 enum built_in_function lib
;
8729 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
);
8730 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_NAND_1
+
8731 (fcode
- BUILT_IN_ATOMIC_NAND_FETCH_1
));
8732 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, true,
8738 case BUILT_IN_ATOMIC_XOR_FETCH_1
:
8739 case BUILT_IN_ATOMIC_XOR_FETCH_2
:
8740 case BUILT_IN_ATOMIC_XOR_FETCH_4
:
8741 case BUILT_IN_ATOMIC_XOR_FETCH_8
:
8742 case BUILT_IN_ATOMIC_XOR_FETCH_16
:
8744 enum built_in_function lib
;
8745 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
);
8746 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_XOR_1
+
8747 (fcode
- BUILT_IN_ATOMIC_XOR_FETCH_1
));
8748 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, true,
8754 case BUILT_IN_ATOMIC_OR_FETCH_1
:
8755 case BUILT_IN_ATOMIC_OR_FETCH_2
:
8756 case BUILT_IN_ATOMIC_OR_FETCH_4
:
8757 case BUILT_IN_ATOMIC_OR_FETCH_8
:
8758 case BUILT_IN_ATOMIC_OR_FETCH_16
:
8760 enum built_in_function lib
;
8761 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
);
8762 lib
= (enum built_in_function
)((int)BUILT_IN_ATOMIC_FETCH_OR_1
+
8763 (fcode
- BUILT_IN_ATOMIC_OR_FETCH_1
));
8764 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, true,
8770 case BUILT_IN_ATOMIC_FETCH_ADD_1
:
8771 case BUILT_IN_ATOMIC_FETCH_ADD_2
:
8772 case BUILT_IN_ATOMIC_FETCH_ADD_4
:
8773 case BUILT_IN_ATOMIC_FETCH_ADD_8
:
8774 case BUILT_IN_ATOMIC_FETCH_ADD_16
:
8775 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_ADD_1
);
8776 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, PLUS
, false,
8777 ignore
, BUILT_IN_NONE
);
8782 case BUILT_IN_ATOMIC_FETCH_SUB_1
:
8783 case BUILT_IN_ATOMIC_FETCH_SUB_2
:
8784 case BUILT_IN_ATOMIC_FETCH_SUB_4
:
8785 case BUILT_IN_ATOMIC_FETCH_SUB_8
:
8786 case BUILT_IN_ATOMIC_FETCH_SUB_16
:
8787 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_SUB_1
);
8788 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, MINUS
, false,
8789 ignore
, BUILT_IN_NONE
);
8794 case BUILT_IN_ATOMIC_FETCH_AND_1
:
8795 case BUILT_IN_ATOMIC_FETCH_AND_2
:
8796 case BUILT_IN_ATOMIC_FETCH_AND_4
:
8797 case BUILT_IN_ATOMIC_FETCH_AND_8
:
8798 case BUILT_IN_ATOMIC_FETCH_AND_16
:
8799 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_AND_1
);
8800 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, AND
, false,
8801 ignore
, BUILT_IN_NONE
);
8806 case BUILT_IN_ATOMIC_FETCH_NAND_1
:
8807 case BUILT_IN_ATOMIC_FETCH_NAND_2
:
8808 case BUILT_IN_ATOMIC_FETCH_NAND_4
:
8809 case BUILT_IN_ATOMIC_FETCH_NAND_8
:
8810 case BUILT_IN_ATOMIC_FETCH_NAND_16
:
8811 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_NAND_1
);
8812 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, NOT
, false,
8813 ignore
, BUILT_IN_NONE
);
8818 case BUILT_IN_ATOMIC_FETCH_XOR_1
:
8819 case BUILT_IN_ATOMIC_FETCH_XOR_2
:
8820 case BUILT_IN_ATOMIC_FETCH_XOR_4
:
8821 case BUILT_IN_ATOMIC_FETCH_XOR_8
:
8822 case BUILT_IN_ATOMIC_FETCH_XOR_16
:
8823 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_XOR_1
);
8824 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, XOR
, false,
8825 ignore
, BUILT_IN_NONE
);
8830 case BUILT_IN_ATOMIC_FETCH_OR_1
:
8831 case BUILT_IN_ATOMIC_FETCH_OR_2
:
8832 case BUILT_IN_ATOMIC_FETCH_OR_4
:
8833 case BUILT_IN_ATOMIC_FETCH_OR_8
:
8834 case BUILT_IN_ATOMIC_FETCH_OR_16
:
8835 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ATOMIC_FETCH_OR_1
);
8836 target
= expand_builtin_atomic_fetch_op (mode
, exp
, target
, IOR
, false,
8837 ignore
, BUILT_IN_NONE
);
8842 case BUILT_IN_ATOMIC_TEST_AND_SET
:
8843 target
= expand_builtin_atomic_test_and_set (exp
, target
);
8848 case BUILT_IN_ATOMIC_CLEAR
:
8849 return expand_builtin_atomic_clear (exp
);
8851 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
8852 return expand_builtin_atomic_always_lock_free (exp
);
8854 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
8855 target
= expand_builtin_atomic_is_lock_free (exp
);
8860 case BUILT_IN_ATOMIC_THREAD_FENCE
:
8861 expand_builtin_atomic_thread_fence (exp
);
8864 case BUILT_IN_ATOMIC_SIGNAL_FENCE
:
8865 expand_builtin_atomic_signal_fence (exp
);
8868 case BUILT_IN_OBJECT_SIZE
:
8869 case BUILT_IN_DYNAMIC_OBJECT_SIZE
:
8870 return expand_builtin_object_size (exp
);
8872 case BUILT_IN_MEMCPY_CHK
:
8873 case BUILT_IN_MEMPCPY_CHK
:
8874 case BUILT_IN_MEMMOVE_CHK
:
8875 case BUILT_IN_MEMSET_CHK
:
8876 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
8881 case BUILT_IN_STRCPY_CHK
:
8882 case BUILT_IN_STPCPY_CHK
:
8883 case BUILT_IN_STRNCPY_CHK
:
8884 case BUILT_IN_STPNCPY_CHK
:
8885 case BUILT_IN_STRCAT_CHK
:
8886 case BUILT_IN_STRNCAT_CHK
:
8887 case BUILT_IN_SNPRINTF_CHK
:
8888 case BUILT_IN_VSNPRINTF_CHK
:
8889 maybe_emit_chk_warning (exp
, fcode
);
8892 case BUILT_IN_SPRINTF_CHK
:
8893 case BUILT_IN_VSPRINTF_CHK
:
8894 maybe_emit_sprintf_chk_warning (exp
, fcode
);
8897 case BUILT_IN_THREAD_POINTER
:
8898 return expand_builtin_thread_pointer (exp
, target
);
8900 case BUILT_IN_SET_THREAD_POINTER
:
8901 expand_builtin_set_thread_pointer (exp
);
8904 case BUILT_IN_ACC_ON_DEVICE
:
8905 /* Do library call, if we failed to expand the builtin when
8909 case BUILT_IN_GOACC_PARLEVEL_ID
:
8910 case BUILT_IN_GOACC_PARLEVEL_SIZE
:
8911 return expand_builtin_goacc_parlevel_id_size (exp
, target
, ignore
);
8913 case BUILT_IN_SPECULATION_SAFE_VALUE_PTR
:
8914 return expand_speculation_safe_value (VOIDmode
, exp
, target
, ignore
);
8916 case BUILT_IN_SPECULATION_SAFE_VALUE_1
:
8917 case BUILT_IN_SPECULATION_SAFE_VALUE_2
:
8918 case BUILT_IN_SPECULATION_SAFE_VALUE_4
:
8919 case BUILT_IN_SPECULATION_SAFE_VALUE_8
:
8920 case BUILT_IN_SPECULATION_SAFE_VALUE_16
:
8921 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SPECULATION_SAFE_VALUE_1
);
8922 return expand_speculation_safe_value (mode
, exp
, target
, ignore
);
8924 default: /* just do library call, if unknown builtin */
8928 /* The switch statement above can drop through to cause the function
8929 to be called normally. */
8930 return expand_call (exp
, target
, ignore
);
8933 /* Determine whether a tree node represents a call to a built-in
8934 function. If the tree T is a call to a built-in function with
8935 the right number of arguments of the appropriate types, return
8936 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
8937 Otherwise the return value is END_BUILTINS. */
8939 enum built_in_function
8940 builtin_mathfn_code (const_tree t
)
8942 const_tree fndecl
, arg
, parmlist
;
8943 const_tree argtype
, parmtype
;
8944 const_call_expr_arg_iterator iter
;
8946 if (TREE_CODE (t
) != CALL_EXPR
)
8947 return END_BUILTINS
;
8949 fndecl
= get_callee_fndecl (t
);
8950 if (fndecl
== NULL_TREE
|| !fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
8951 return END_BUILTINS
;
8953 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
8954 init_const_call_expr_arg_iterator (t
, &iter
);
8955 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
8957 /* If a function doesn't take a variable number of arguments,
8958 the last element in the list will have type `void'. */
8959 parmtype
= TREE_VALUE (parmlist
);
8960 if (VOID_TYPE_P (parmtype
))
8962 if (more_const_call_expr_args_p (&iter
))
8963 return END_BUILTINS
;
8964 return DECL_FUNCTION_CODE (fndecl
);
8967 if (! more_const_call_expr_args_p (&iter
))
8968 return END_BUILTINS
;
8970 arg
= next_const_call_expr_arg (&iter
);
8971 argtype
= TREE_TYPE (arg
);
8973 if (SCALAR_FLOAT_TYPE_P (parmtype
))
8975 if (! SCALAR_FLOAT_TYPE_P (argtype
))
8976 return END_BUILTINS
;
8978 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
8980 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
8981 return END_BUILTINS
;
8983 else if (POINTER_TYPE_P (parmtype
))
8985 if (! POINTER_TYPE_P (argtype
))
8986 return END_BUILTINS
;
8988 else if (INTEGRAL_TYPE_P (parmtype
))
8990 if (! INTEGRAL_TYPE_P (argtype
))
8991 return END_BUILTINS
;
8994 return END_BUILTINS
;
8997 /* Variable-length argument list. */
8998 return DECL_FUNCTION_CODE (fndecl
);
9001 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
9002 evaluate to a constant. */
9005 fold_builtin_constant_p (tree arg
)
9007 /* We return 1 for a numeric type that's known to be a constant
9008 value at compile-time or for an aggregate type that's a
9009 literal constant. */
9012 /* If we know this is a constant, emit the constant of one. */
9013 if (CONSTANT_CLASS_P (arg
)
9014 || (TREE_CODE (arg
) == CONSTRUCTOR
9015 && TREE_CONSTANT (arg
)))
9016 return integer_one_node
;
9017 if (TREE_CODE (arg
) == ADDR_EXPR
)
9019 tree op
= TREE_OPERAND (arg
, 0);
9020 if (TREE_CODE (op
) == STRING_CST
9021 || (TREE_CODE (op
) == ARRAY_REF
9022 && integer_zerop (TREE_OPERAND (op
, 1))
9023 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
9024 return integer_one_node
;
9027 /* If this expression has side effects, show we don't know it to be a
9028 constant. Likewise if it's a pointer or aggregate type since in
9029 those case we only want literals, since those are only optimized
9030 when generating RTL, not later.
9031 And finally, if we are compiling an initializer, not code, we
9032 need to return a definite result now; there's not going to be any
9033 more optimization done. */
9034 if (TREE_SIDE_EFFECTS (arg
)
9035 || AGGREGATE_TYPE_P (TREE_TYPE (arg
))
9036 || POINTER_TYPE_P (TREE_TYPE (arg
))
9038 || folding_initializer
9039 || force_folding_builtin_constant_p
)
9040 return integer_zero_node
;
9045 /* Create builtin_expect or builtin_expect_with_probability
9046 with PRED and EXPECTED as its arguments and return it as a truthvalue.
9047 Fortran FE can also produce builtin_expect with PREDICTOR as third argument.
9048 builtin_expect_with_probability instead uses third argument as PROBABILITY
9052 build_builtin_expect_predicate (location_t loc
, tree pred
, tree expected
,
9053 tree predictor
, tree probability
)
9055 tree fn
, arg_types
, pred_type
, expected_type
, call_expr
, ret_type
;
9057 fn
= builtin_decl_explicit (probability
== NULL_TREE
? BUILT_IN_EXPECT
9058 : BUILT_IN_EXPECT_WITH_PROBABILITY
);
9059 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
9060 ret_type
= TREE_TYPE (TREE_TYPE (fn
));
9061 pred_type
= TREE_VALUE (arg_types
);
9062 expected_type
= TREE_VALUE (TREE_CHAIN (arg_types
));
9064 pred
= fold_convert_loc (loc
, pred_type
, pred
);
9065 expected
= fold_convert_loc (loc
, expected_type
, expected
);
9068 call_expr
= build_call_expr_loc (loc
, fn
, 3, pred
, expected
, probability
);
9070 call_expr
= build_call_expr_loc (loc
, fn
, predictor
? 3 : 2, pred
, expected
,
9073 return build2 (NE_EXPR
, TREE_TYPE (pred
), call_expr
,
9074 build_int_cst (ret_type
, 0));
9077 /* Fold a call to builtin_expect with arguments ARG0, ARG1, ARG2, ARG3. Return
9078 NULL_TREE if no simplification is possible. */
9081 fold_builtin_expect (location_t loc
, tree arg0
, tree arg1
, tree arg2
,
9084 tree inner
, fndecl
, inner_arg0
;
9085 enum tree_code code
;
9087 /* Distribute the expected value over short-circuiting operators.
9088 See through the cast from truthvalue_type_node to long. */
9090 while (CONVERT_EXPR_P (inner_arg0
)
9091 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0
))
9092 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0
, 0))))
9093 inner_arg0
= TREE_OPERAND (inner_arg0
, 0);
9095 /* If this is a builtin_expect within a builtin_expect keep the
9096 inner one. See through a comparison against a constant. It
9097 might have been added to create a thruthvalue. */
9100 if (COMPARISON_CLASS_P (inner
)
9101 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
)
9102 inner
= TREE_OPERAND (inner
, 0);
9104 if (TREE_CODE (inner
) == CALL_EXPR
9105 && (fndecl
= get_callee_fndecl (inner
))
9106 && fndecl_built_in_p (fndecl
, BUILT_IN_EXPECT
,
9107 BUILT_IN_EXPECT_WITH_PROBABILITY
))
9111 code
= TREE_CODE (inner
);
9112 if (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
9114 tree op0
= TREE_OPERAND (inner
, 0);
9115 tree op1
= TREE_OPERAND (inner
, 1);
9116 arg1
= save_expr (arg1
);
9118 op0
= build_builtin_expect_predicate (loc
, op0
, arg1
, arg2
, arg3
);
9119 op1
= build_builtin_expect_predicate (loc
, op1
, arg1
, arg2
, arg3
);
9120 inner
= build2 (code
, TREE_TYPE (inner
), op0
, op1
);
9122 return fold_convert_loc (loc
, TREE_TYPE (arg0
), inner
);
9125 /* If the argument isn't invariant then there's nothing else we can do. */
9126 if (!TREE_CONSTANT (inner_arg0
))
9129 /* If we expect that a comparison against the argument will fold to
9130 a constant return the constant. In practice, this means a true
9131 constant or the address of a non-weak symbol. */
9134 if (TREE_CODE (inner
) == ADDR_EXPR
)
9138 inner
= TREE_OPERAND (inner
, 0);
9140 while (TREE_CODE (inner
) == COMPONENT_REF
9141 || TREE_CODE (inner
) == ARRAY_REF
);
9142 if (VAR_OR_FUNCTION_DECL_P (inner
) && DECL_WEAK (inner
))
9146 /* Otherwise, ARG0 already has the proper type for the return value. */
9150 /* Fold a call to __builtin_classify_type with argument ARG. */
9153 fold_builtin_classify_type (tree arg
)
9156 return build_int_cst (integer_type_node
, no_type_class
);
9158 return build_int_cst (integer_type_node
, type_to_class (TREE_TYPE (arg
)));
9161 /* Fold a call EXPR (which may be null) to __builtin_strlen with argument
9165 fold_builtin_strlen (location_t loc
, tree expr
, tree type
, tree arg
)
9167 if (!validate_arg (arg
, POINTER_TYPE
))
9171 c_strlen_data lendata
= { };
9172 tree len
= c_strlen (arg
, 0, &lendata
);
9175 return fold_convert_loc (loc
, type
, len
);
9177 /* TODO: Move this to gimple-ssa-warn-access once the pass runs
9178 also early enough to detect invalid reads in multimensional
9179 arrays and struct members. */
9181 c_strlen (arg
, 1, &lendata
);
9185 if (EXPR_HAS_LOCATION (arg
))
9186 loc
= EXPR_LOCATION (arg
);
9187 else if (loc
== UNKNOWN_LOCATION
)
9188 loc
= input_location
;
9189 warn_string_no_nul (loc
, expr
, "strlen", arg
, lendata
.decl
);
9196 /* Fold a call to __builtin_inf or __builtin_huge_val. */
9199 fold_builtin_inf (location_t loc
, tree type
, int warn
)
9201 /* __builtin_inff is intended to be usable to define INFINITY on all
9202 targets. If an infinity is not available, INFINITY expands "to a
9203 positive constant of type float that overflows at translation
9204 time", footnote "In this case, using INFINITY will violate the
9205 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
9206 Thus we pedwarn to ensure this constraint violation is
9208 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
9209 pedwarn (loc
, 0, "target format does not support infinity");
9211 return build_real (type
, dconstinf
);
9214 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
9215 NULL_TREE if no simplification can be made. */
9218 fold_builtin_sincos (location_t loc
,
9219 tree arg0
, tree arg1
, tree arg2
)
9222 tree fndecl
, call
= NULL_TREE
;
9224 if (!validate_arg (arg0
, REAL_TYPE
)
9225 || !validate_arg (arg1
, POINTER_TYPE
)
9226 || !validate_arg (arg2
, POINTER_TYPE
))
9229 type
= TREE_TYPE (arg0
);
9231 /* Calculate the result when the argument is a constant. */
9232 built_in_function fn
= mathfn_built_in_2 (type
, CFN_BUILT_IN_CEXPI
);
9233 if (fn
== END_BUILTINS
)
9236 /* Canonicalize sincos to cexpi. */
9237 if (TREE_CODE (arg0
) == REAL_CST
)
9239 tree complex_type
= build_complex_type (type
);
9240 call
= fold_const_call (as_combined_fn (fn
), complex_type
, arg0
);
9244 if (!targetm
.libc_has_function (function_c99_math_complex
, type
)
9245 || !builtin_decl_implicit_p (fn
))
9247 fndecl
= builtin_decl_explicit (fn
);
9248 call
= build_call_expr_loc (loc
, fndecl
, 1, arg0
);
9249 call
= builtin_save_expr (call
);
9252 tree ptype
= build_pointer_type (type
);
9253 arg1
= fold_convert (ptype
, arg1
);
9254 arg2
= fold_convert (ptype
, arg2
);
9255 return build2 (COMPOUND_EXPR
, void_type_node
,
9256 build2 (MODIFY_EXPR
, void_type_node
,
9257 build_fold_indirect_ref_loc (loc
, arg1
),
9258 fold_build1_loc (loc
, IMAGPART_EXPR
, type
, call
)),
9259 build2 (MODIFY_EXPR
, void_type_node
,
9260 build_fold_indirect_ref_loc (loc
, arg2
),
9261 fold_build1_loc (loc
, REALPART_EXPR
, type
, call
)));
9264 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
9265 Return NULL_TREE if no simplification can be made. */
9268 fold_builtin_memcmp (location_t loc
, tree arg1
, tree arg2
, tree len
)
9270 if (!validate_arg (arg1
, POINTER_TYPE
)
9271 || !validate_arg (arg2
, POINTER_TYPE
)
9272 || !validate_arg (len
, INTEGER_TYPE
))
9275 /* If the LEN parameter is zero, return zero. */
9276 if (integer_zerop (len
))
9277 return omit_two_operands_loc (loc
, integer_type_node
, integer_zero_node
,
9280 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
9281 if (operand_equal_p (arg1
, arg2
, 0))
9282 return omit_one_operand_loc (loc
, integer_type_node
, integer_zero_node
, len
);
9284 /* If len parameter is one, return an expression corresponding to
9285 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
9286 if (tree_fits_uhwi_p (len
) && tree_to_uhwi (len
) == 1)
9288 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
9289 tree cst_uchar_ptr_node
9290 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
9293 = fold_convert_loc (loc
, integer_type_node
,
9294 build1 (INDIRECT_REF
, cst_uchar_node
,
9295 fold_convert_loc (loc
,
9299 = fold_convert_loc (loc
, integer_type_node
,
9300 build1 (INDIRECT_REF
, cst_uchar_node
,
9301 fold_convert_loc (loc
,
9304 return fold_build2_loc (loc
, MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
9310 /* Fold a call to builtin isascii with argument ARG. */
9313 fold_builtin_isascii (location_t loc
, tree arg
)
9315 if (!validate_arg (arg
, INTEGER_TYPE
))
9319 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
9320 arg
= fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
9321 build_int_cst (integer_type_node
,
9322 ~ (unsigned HOST_WIDE_INT
) 0x7f));
9323 return fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
,
9324 arg
, integer_zero_node
);
9328 /* Fold a call to builtin toascii with argument ARG. */
9331 fold_builtin_toascii (location_t loc
, tree arg
)
9333 if (!validate_arg (arg
, INTEGER_TYPE
))
9336 /* Transform toascii(c) -> (c & 0x7f). */
9337 return fold_build2_loc (loc
, BIT_AND_EXPR
, integer_type_node
, arg
,
9338 build_int_cst (integer_type_node
, 0x7f));
9341 /* Fold a call to builtin isdigit with argument ARG. */
9344 fold_builtin_isdigit (location_t loc
, tree arg
)
9346 if (!validate_arg (arg
, INTEGER_TYPE
))
9350 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
9351 /* According to the C standard, isdigit is unaffected by locale.
9352 However, it definitely is affected by the target character set. */
9353 unsigned HOST_WIDE_INT target_digit0
9354 = lang_hooks
.to_target_charset ('0');
9356 if (target_digit0
== 0)
9359 arg
= fold_convert_loc (loc
, unsigned_type_node
, arg
);
9360 arg
= fold_build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
9361 build_int_cst (unsigned_type_node
, target_digit0
));
9362 return fold_build2_loc (loc
, LE_EXPR
, integer_type_node
, arg
,
9363 build_int_cst (unsigned_type_node
, 9));
9367 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
9370 fold_builtin_fabs (location_t loc
, tree arg
, tree type
)
9372 if (!validate_arg (arg
, REAL_TYPE
))
9375 arg
= fold_convert_loc (loc
, type
, arg
);
9376 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9379 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9382 fold_builtin_abs (location_t loc
, tree arg
, tree type
)
9384 if (!validate_arg (arg
, INTEGER_TYPE
))
9387 arg
= fold_convert_loc (loc
, type
, arg
);
9388 return fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9391 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9394 fold_builtin_carg (location_t loc
, tree arg
, tree type
)
9396 if (validate_arg (arg
, COMPLEX_TYPE
)
9397 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TREE_TYPE (arg
))))
9399 tree atan2_fn
= mathfn_built_in (type
, BUILT_IN_ATAN2
);
9403 tree new_arg
= builtin_save_expr (arg
);
9404 tree r_arg
= fold_build1_loc (loc
, REALPART_EXPR
, type
, new_arg
);
9405 tree i_arg
= fold_build1_loc (loc
, IMAGPART_EXPR
, type
, new_arg
);
9406 return build_call_expr_loc (loc
, atan2_fn
, 2, i_arg
, r_arg
);
9413 /* Fold a call to builtin frexp, we can assume the base is 2. */
9416 fold_builtin_frexp (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9418 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9423 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9426 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9428 /* Proceed if a valid pointer type was passed in. */
9429 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == integer_type_node
)
9431 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9432 tree frac
, exp
, res
;
9437 /* For +-0, return (*exp = 0, +-0). */
9438 exp
= integer_zero_node
;
9443 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9444 return omit_one_operand_loc (loc
, rettype
, arg0
, arg1
);
9447 /* Since the frexp function always expects base 2, and in
9448 GCC normalized significands are already in the range
9449 [0.5, 1.0), we have exactly what frexp wants. */
9450 REAL_VALUE_TYPE frac_rvt
= *value
;
9451 SET_REAL_EXP (&frac_rvt
, 0);
9452 frac
= build_real (rettype
, frac_rvt
);
9453 exp
= build_int_cst (integer_type_node
, REAL_EXP (value
));
9460 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9461 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
, exp
);
9462 TREE_SIDE_EFFECTS (arg1
) = 1;
9463 res
= fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
, frac
);
9464 suppress_warning (res
, OPT_Wunused_value
);
9471 /* Fold a call to builtin modf. */
9474 fold_builtin_modf (location_t loc
, tree arg0
, tree arg1
, tree rettype
)
9476 if (! validate_arg (arg0
, REAL_TYPE
) || ! validate_arg (arg1
, POINTER_TYPE
))
9481 if (!(TREE_CODE (arg0
) == REAL_CST
&& ! TREE_OVERFLOW (arg0
)))
9484 arg1
= build_fold_indirect_ref_loc (loc
, arg1
);
9486 /* Proceed if a valid pointer type was passed in. */
9487 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1
)) == TYPE_MAIN_VARIANT (rettype
))
9489 const REAL_VALUE_TYPE
*const value
= TREE_REAL_CST_PTR (arg0
);
9490 REAL_VALUE_TYPE trunc
, frac
;
9497 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9498 trunc
= frac
= *value
;
9501 /* For +-Inf, return (*arg1 = arg0, +-0). */
9503 frac
.sign
= value
->sign
;
9507 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9508 real_trunc (&trunc
, VOIDmode
, value
);
9509 real_arithmetic (&frac
, MINUS_EXPR
, value
, &trunc
);
9510 /* If the original number was negative and already
9511 integral, then the fractional part is -0.0. */
9512 if (value
->sign
&& frac
.cl
== rvc_zero
)
9513 frac
.sign
= value
->sign
;
9517 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9518 arg1
= fold_build2_loc (loc
, MODIFY_EXPR
, rettype
, arg1
,
9519 build_real (rettype
, trunc
));
9520 TREE_SIDE_EFFECTS (arg1
) = 1;
9521 res
= fold_build2_loc (loc
, COMPOUND_EXPR
, rettype
, arg1
,
9522 build_real (rettype
, frac
));
9523 suppress_warning (res
, OPT_Wunused_value
);
9530 /* Given a location LOC, an interclass builtin function decl FNDECL
9531 and its single argument ARG, return an folded expression computing
9532 the same, or NULL_TREE if we either couldn't or didn't want to fold
9533 (the latter happen if there's an RTL instruction available). */
9536 fold_builtin_interclass_mathfn (location_t loc
, tree fndecl
, tree arg
)
9540 if (!validate_arg (arg
, REAL_TYPE
))
9543 if (interclass_mathfn_icode (arg
, fndecl
) != CODE_FOR_nothing
)
9546 mode
= TYPE_MODE (TREE_TYPE (arg
));
9548 bool is_ibm_extended
= MODE_COMPOSITE_P (mode
);
9550 /* If there is no optab, try generic code. */
9551 switch (DECL_FUNCTION_CODE (fndecl
))
9555 CASE_FLT_FN (BUILT_IN_ISINF
):
9557 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
9558 tree
const isgr_fn
= builtin_decl_explicit (BUILT_IN_ISGREATER
);
9559 tree type
= TREE_TYPE (arg
);
9563 if (is_ibm_extended
)
9565 /* NaN and Inf are encoded in the high-order double value
9566 only. The low-order value is not significant. */
9567 type
= double_type_node
;
9569 arg
= fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
9571 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
), false);
9572 real_from_string (&r
, buf
);
9573 result
= build_call_expr (isgr_fn
, 2,
9574 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9575 build_real (type
, r
));
9578 CASE_FLT_FN (BUILT_IN_FINITE
):
9579 case BUILT_IN_ISFINITE
:
9581 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
9582 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
9583 tree type
= TREE_TYPE (arg
);
9587 if (is_ibm_extended
)
9589 /* NaN and Inf are encoded in the high-order double value
9590 only. The low-order value is not significant. */
9591 type
= double_type_node
;
9593 arg
= fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
9595 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
), false);
9596 real_from_string (&r
, buf
);
9597 result
= build_call_expr (isle_fn
, 2,
9598 fold_build1_loc (loc
, ABS_EXPR
, type
, arg
),
9599 build_real (type
, r
));
9600 /*result = fold_build2_loc (loc, UNGT_EXPR,
9601 TREE_TYPE (TREE_TYPE (fndecl)),
9602 fold_build1_loc (loc, ABS_EXPR, type, arg),
9603 build_real (type, r));
9604 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9605 TREE_TYPE (TREE_TYPE (fndecl)),
9609 case BUILT_IN_ISNORMAL
:
9611 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9612 islessequal(fabs(x),DBL_MAX). */
9613 tree
const isle_fn
= builtin_decl_explicit (BUILT_IN_ISLESSEQUAL
);
9614 tree type
= TREE_TYPE (arg
);
9615 tree orig_arg
, max_exp
, min_exp
;
9616 machine_mode orig_mode
= mode
;
9617 REAL_VALUE_TYPE rmax
, rmin
;
9620 orig_arg
= arg
= builtin_save_expr (arg
);
9621 if (is_ibm_extended
)
9623 /* Use double to test the normal range of IBM extended
9624 precision. Emin for IBM extended precision is
9625 different to emin for IEEE double, being 53 higher
9626 since the low double exponent is at least 53 lower
9627 than the high double exponent. */
9628 type
= double_type_node
;
9630 arg
= fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
9632 arg
= fold_build1_loc (loc
, ABS_EXPR
, type
, arg
);
9634 get_max_float (REAL_MODE_FORMAT (mode
), buf
, sizeof (buf
), false);
9635 real_from_string (&rmax
, buf
);
9636 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (orig_mode
)->emin
- 1);
9637 real_from_string (&rmin
, buf
);
9638 max_exp
= build_real (type
, rmax
);
9639 min_exp
= build_real (type
, rmin
);
9641 max_exp
= build_call_expr (isle_fn
, 2, arg
, max_exp
);
9642 if (is_ibm_extended
)
9644 /* Testing the high end of the range is done just using
9645 the high double, using the same test as isfinite().
9646 For the subnormal end of the range we first test the
9647 high double, then if its magnitude is equal to the
9648 limit of 0x1p-969, we test whether the low double is
9649 non-zero and opposite sign to the high double. */
9650 tree
const islt_fn
= builtin_decl_explicit (BUILT_IN_ISLESS
);
9651 tree
const isgt_fn
= builtin_decl_explicit (BUILT_IN_ISGREATER
);
9652 tree gt_min
= build_call_expr (isgt_fn
, 2, arg
, min_exp
);
9653 tree eq_min
= fold_build2 (EQ_EXPR
, integer_type_node
,
9655 tree as_complex
= build1 (VIEW_CONVERT_EXPR
,
9656 complex_double_type_node
, orig_arg
);
9657 tree hi_dbl
= build1 (REALPART_EXPR
, type
, as_complex
);
9658 tree lo_dbl
= build1 (IMAGPART_EXPR
, type
, as_complex
);
9659 tree zero
= build_real (type
, dconst0
);
9660 tree hilt
= build_call_expr (islt_fn
, 2, hi_dbl
, zero
);
9661 tree lolt
= build_call_expr (islt_fn
, 2, lo_dbl
, zero
);
9662 tree logt
= build_call_expr (isgt_fn
, 2, lo_dbl
, zero
);
9663 tree ok_lo
= fold_build1 (TRUTH_NOT_EXPR
, integer_type_node
,
9664 fold_build3 (COND_EXPR
,
9667 eq_min
= fold_build2 (TRUTH_ANDIF_EXPR
, integer_type_node
,
9669 min_exp
= fold_build2 (TRUTH_ORIF_EXPR
, integer_type_node
,
9675 = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL
);
9676 min_exp
= build_call_expr (isge_fn
, 2, arg
, min_exp
);
9678 result
= fold_build2 (BIT_AND_EXPR
, integer_type_node
,
9689 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9690 ARG is the argument for the call. */
9693 fold_builtin_classify (location_t loc
, tree fndecl
, tree arg
, int builtin_index
)
9695 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9697 if (!validate_arg (arg
, REAL_TYPE
))
9700 switch (builtin_index
)
9702 case BUILT_IN_ISINF
:
9703 if (tree_expr_infinite_p (arg
))
9704 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
9705 if (!tree_expr_maybe_infinite_p (arg
))
9706 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9709 case BUILT_IN_ISINF_SIGN
:
9711 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9712 /* In a boolean context, GCC will fold the inner COND_EXPR to
9713 1. So e.g. "if (isinf_sign(x))" would be folded to just
9714 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9715 tree signbit_fn
= builtin_decl_explicit (BUILT_IN_SIGNBIT
);
9716 tree isinf_fn
= builtin_decl_explicit (BUILT_IN_ISINF
);
9717 tree tmp
= NULL_TREE
;
9719 arg
= builtin_save_expr (arg
);
9721 if (signbit_fn
&& isinf_fn
)
9723 tree signbit_call
= build_call_expr_loc (loc
, signbit_fn
, 1, arg
);
9724 tree isinf_call
= build_call_expr_loc (loc
, isinf_fn
, 1, arg
);
9726 signbit_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9727 signbit_call
, integer_zero_node
);
9728 isinf_call
= fold_build2_loc (loc
, NE_EXPR
, integer_type_node
,
9729 isinf_call
, integer_zero_node
);
9731 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, signbit_call
,
9732 integer_minus_one_node
, integer_one_node
);
9733 tmp
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9741 case BUILT_IN_ISFINITE
:
9742 if (tree_expr_finite_p (arg
))
9743 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
9744 if (tree_expr_nan_p (arg
) || tree_expr_infinite_p (arg
))
9745 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9748 case BUILT_IN_ISNAN
:
9749 if (tree_expr_nan_p (arg
))
9750 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
9751 if (!tree_expr_maybe_nan_p (arg
))
9752 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9755 bool is_ibm_extended
= MODE_COMPOSITE_P (TYPE_MODE (TREE_TYPE (arg
)));
9756 if (is_ibm_extended
)
9758 /* NaN and Inf are encoded in the high-order double value
9759 only. The low-order value is not significant. */
9760 arg
= fold_build1_loc (loc
, NOP_EXPR
, double_type_node
, arg
);
9763 arg
= builtin_save_expr (arg
);
9764 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg
, arg
);
9766 case BUILT_IN_ISSIGNALING
:
9767 /* Folding to true for REAL_CST is done in fold_const_call_ss.
9768 Don't use tree_expr_signaling_nan_p (arg) -> integer_one_node
9769 and !tree_expr_maybe_signaling_nan_p (arg) -> integer_zero_node
9770 here, so there is some possibility of __builtin_issignaling working
9771 without -fsignaling-nans. Especially when -fno-signaling-nans is
9773 if (!tree_expr_maybe_nan_p (arg
))
9774 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
9782 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9783 This builtin will generate code to return the appropriate floating
9784 point classification depending on the value of the floating point
9785 number passed in. The possible return values must be supplied as
9786 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9787 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
9788 one floating point argument which is "type generic". */
9791 fold_builtin_fpclassify (location_t loc
, tree
*args
, int nargs
)
9793 tree fp_nan
, fp_infinite
, fp_normal
, fp_subnormal
, fp_zero
,
9794 arg
, type
, res
, tmp
;
9799 /* Verify the required arguments in the original call. */
9801 || !validate_arg (args
[0], INTEGER_TYPE
)
9802 || !validate_arg (args
[1], INTEGER_TYPE
)
9803 || !validate_arg (args
[2], INTEGER_TYPE
)
9804 || !validate_arg (args
[3], INTEGER_TYPE
)
9805 || !validate_arg (args
[4], INTEGER_TYPE
)
9806 || !validate_arg (args
[5], REAL_TYPE
))
9810 fp_infinite
= args
[1];
9811 fp_normal
= args
[2];
9812 fp_subnormal
= args
[3];
9815 type
= TREE_TYPE (arg
);
9816 mode
= TYPE_MODE (type
);
9817 arg
= builtin_save_expr (fold_build1_loc (loc
, ABS_EXPR
, type
, arg
));
9821 (fabs(x) == Inf ? FP_INFINITE :
9822 (fabs(x) >= DBL_MIN ? FP_NORMAL :
9823 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9825 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9826 build_real (type
, dconst0
));
9827 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
,
9828 tmp
, fp_zero
, fp_subnormal
);
9830 sprintf (buf
, "0x1p%d", REAL_MODE_FORMAT (mode
)->emin
- 1);
9831 real_from_string (&r
, buf
);
9832 tmp
= fold_build2_loc (loc
, GE_EXPR
, integer_type_node
,
9833 arg
, build_real (type
, r
));
9834 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, fp_normal
, res
);
9836 if (tree_expr_maybe_infinite_p (arg
))
9838 tmp
= fold_build2_loc (loc
, EQ_EXPR
, integer_type_node
, arg
,
9839 build_real (type
, dconstinf
));
9840 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
,
9844 if (tree_expr_maybe_nan_p (arg
))
9846 tmp
= fold_build2_loc (loc
, ORDERED_EXPR
, integer_type_node
, arg
, arg
);
9847 res
= fold_build3_loc (loc
, COND_EXPR
, integer_type_node
, tmp
, res
, fp_nan
);
9853 /* Fold a call to an unordered comparison function such as
9854 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9855 being called and ARG0 and ARG1 are the arguments for the call.
9856 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9857 the opposite of the desired result. UNORDERED_CODE is used
9858 for modes that can hold NaNs and ORDERED_CODE is used for
9862 fold_builtin_unordered_cmp (location_t loc
, tree fndecl
, tree arg0
, tree arg1
,
9863 enum tree_code unordered_code
,
9864 enum tree_code ordered_code
)
9866 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
9867 enum tree_code code
;
9869 enum tree_code code0
, code1
;
9870 tree cmp_type
= NULL_TREE
;
9872 type0
= TREE_TYPE (arg0
);
9873 type1
= TREE_TYPE (arg1
);
9875 code0
= TREE_CODE (type0
);
9876 code1
= TREE_CODE (type1
);
9878 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
9879 /* Choose the wider of two real types. */
9880 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
9882 else if (code0
== REAL_TYPE
9883 && (code1
== INTEGER_TYPE
|| code1
== BITINT_TYPE
))
9885 else if ((code0
== INTEGER_TYPE
|| code0
== BITINT_TYPE
)
9886 && code1
== REAL_TYPE
)
9889 arg0
= fold_convert_loc (loc
, cmp_type
, arg0
);
9890 arg1
= fold_convert_loc (loc
, cmp_type
, arg1
);
9892 if (unordered_code
== UNORDERED_EXPR
)
9894 if (tree_expr_nan_p (arg0
) || tree_expr_nan_p (arg1
))
9895 return omit_two_operands_loc (loc
, type
, integer_one_node
, arg0
, arg1
);
9896 if (!tree_expr_maybe_nan_p (arg0
) && !tree_expr_maybe_nan_p (arg1
))
9897 return omit_two_operands_loc (loc
, type
, integer_zero_node
, arg0
, arg1
);
9898 return fold_build2_loc (loc
, UNORDERED_EXPR
, type
, arg0
, arg1
);
9901 code
= (tree_expr_maybe_nan_p (arg0
) || tree_expr_maybe_nan_p (arg1
))
9902 ? unordered_code
: ordered_code
;
9903 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
,
9904 fold_build2_loc (loc
, code
, type
, arg0
, arg1
));
9907 /* Fold a call to __builtin_iseqsig(). ARG0 and ARG1 are the arguments.
9908 After choosing the wider floating-point type for the comparison,
9909 the code is folded to:
9910 SAVE_EXPR<ARG0> >= SAVE_EXPR<ARG1> && SAVE_EXPR<ARG0> <= SAVE_EXPR<ARG1> */
9913 fold_builtin_iseqsig (location_t loc
, tree arg0
, tree arg1
)
9916 enum tree_code code0
, code1
;
9917 tree cmp1
, cmp2
, cmp_type
= NULL_TREE
;
9919 type0
= TREE_TYPE (arg0
);
9920 type1
= TREE_TYPE (arg1
);
9922 code0
= TREE_CODE (type0
);
9923 code1
= TREE_CODE (type1
);
9925 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
9926 /* Choose the wider of two real types. */
9927 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
9929 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
9931 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
9934 arg0
= builtin_save_expr (fold_convert_loc (loc
, cmp_type
, arg0
));
9935 arg1
= builtin_save_expr (fold_convert_loc (loc
, cmp_type
, arg1
));
9937 cmp1
= fold_build2_loc (loc
, GE_EXPR
, integer_type_node
, arg0
, arg1
);
9938 cmp2
= fold_build2_loc (loc
, LE_EXPR
, integer_type_node
, arg0
, arg1
);
9940 return fold_build2_loc (loc
, TRUTH_AND_EXPR
, integer_type_node
, cmp1
, cmp2
);
9943 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
9944 arithmetics if it can never overflow, or into internal functions that
9945 return both result of arithmetics and overflowed boolean flag in
9946 a complex integer result, or some other check for overflow.
9947 Similarly fold __builtin_{add,sub,mul}_overflow_p to just the overflow
9948 checking part of that. */
9951 fold_builtin_arith_overflow (location_t loc
, enum built_in_function fcode
,
9952 tree arg0
, tree arg1
, tree arg2
)
9954 enum internal_fn ifn
= IFN_LAST
;
9955 /* The code of the expression corresponding to the built-in. */
9956 enum tree_code opcode
= ERROR_MARK
;
9957 bool ovf_only
= false;
9961 case BUILT_IN_ADD_OVERFLOW_P
:
9964 case BUILT_IN_ADD_OVERFLOW
:
9965 case BUILT_IN_SADD_OVERFLOW
:
9966 case BUILT_IN_SADDL_OVERFLOW
:
9967 case BUILT_IN_SADDLL_OVERFLOW
:
9968 case BUILT_IN_UADD_OVERFLOW
:
9969 case BUILT_IN_UADDL_OVERFLOW
:
9970 case BUILT_IN_UADDLL_OVERFLOW
:
9972 ifn
= IFN_ADD_OVERFLOW
;
9974 case BUILT_IN_SUB_OVERFLOW_P
:
9977 case BUILT_IN_SUB_OVERFLOW
:
9978 case BUILT_IN_SSUB_OVERFLOW
:
9979 case BUILT_IN_SSUBL_OVERFLOW
:
9980 case BUILT_IN_SSUBLL_OVERFLOW
:
9981 case BUILT_IN_USUB_OVERFLOW
:
9982 case BUILT_IN_USUBL_OVERFLOW
:
9983 case BUILT_IN_USUBLL_OVERFLOW
:
9984 opcode
= MINUS_EXPR
;
9985 ifn
= IFN_SUB_OVERFLOW
;
9987 case BUILT_IN_MUL_OVERFLOW_P
:
9990 case BUILT_IN_MUL_OVERFLOW
:
9991 case BUILT_IN_SMUL_OVERFLOW
:
9992 case BUILT_IN_SMULL_OVERFLOW
:
9993 case BUILT_IN_SMULLL_OVERFLOW
:
9994 case BUILT_IN_UMUL_OVERFLOW
:
9995 case BUILT_IN_UMULL_OVERFLOW
:
9996 case BUILT_IN_UMULLL_OVERFLOW
:
9998 ifn
= IFN_MUL_OVERFLOW
;
10001 gcc_unreachable ();
10004 /* For the "generic" overloads, the first two arguments can have different
10005 types and the last argument determines the target type to use to check
10006 for overflow. The arguments of the other overloads all have the same
10008 tree type
= ovf_only
? TREE_TYPE (arg2
) : TREE_TYPE (TREE_TYPE (arg2
));
10010 /* For the __builtin_{add,sub,mul}_overflow_p builtins, when the first two
10011 arguments are constant, attempt to fold the built-in call into a constant
10012 expression indicating whether or not it detected an overflow. */
10014 && TREE_CODE (arg0
) == INTEGER_CST
10015 && TREE_CODE (arg1
) == INTEGER_CST
)
10016 /* Perform the computation in the target type and check for overflow. */
10017 return omit_one_operand_loc (loc
, boolean_type_node
,
10018 arith_overflowed_p (opcode
, type
, arg0
, arg1
)
10019 ? boolean_true_node
: boolean_false_node
,
10022 tree intres
, ovfres
;
10023 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
10025 intres
= fold_binary_loc (loc
, opcode
, type
,
10026 fold_convert_loc (loc
, type
, arg0
),
10027 fold_convert_loc (loc
, type
, arg1
));
10028 if (TREE_OVERFLOW (intres
))
10029 intres
= drop_tree_overflow (intres
);
10030 ovfres
= (arith_overflowed_p (opcode
, type
, arg0
, arg1
)
10031 ? boolean_true_node
: boolean_false_node
);
10035 tree ctype
= build_complex_type (type
);
10036 tree call
= build_call_expr_internal_loc (loc
, ifn
, ctype
, 2,
10038 tree tgt
= save_expr (call
);
10039 intres
= build1_loc (loc
, REALPART_EXPR
, type
, tgt
);
10040 ovfres
= build1_loc (loc
, IMAGPART_EXPR
, type
, tgt
);
10041 ovfres
= fold_convert_loc (loc
, boolean_type_node
, ovfres
);
10045 return omit_one_operand_loc (loc
, boolean_type_node
, ovfres
, arg2
);
10047 tree mem_arg2
= build_fold_indirect_ref_loc (loc
, arg2
);
10049 = fold_build2_loc (loc
, MODIFY_EXPR
, void_type_node
, mem_arg2
, intres
);
10050 return build2_loc (loc
, COMPOUND_EXPR
, boolean_type_node
, store
, ovfres
);
10053 /* Fold __builtin_{clz,ctz,clrsb,ffs,parity,popcount}g into corresponding
10054 internal function. */
10057 fold_builtin_bit_query (location_t loc
, enum built_in_function fcode
,
10058 tree arg0
, tree arg1
)
10060 enum internal_fn ifn
;
10061 enum built_in_function fcodei
, fcodel
, fcodell
;
10062 tree arg0_type
= TREE_TYPE (arg0
);
10063 tree cast_type
= NULL_TREE
;
10068 case BUILT_IN_CLZG
:
10069 if (arg1
&& TREE_CODE (arg1
) != INTEGER_CST
)
10072 fcodei
= BUILT_IN_CLZ
;
10073 fcodel
= BUILT_IN_CLZL
;
10074 fcodell
= BUILT_IN_CLZLL
;
10076 case BUILT_IN_CTZG
:
10077 if (arg1
&& TREE_CODE (arg1
) != INTEGER_CST
)
10080 fcodei
= BUILT_IN_CTZ
;
10081 fcodel
= BUILT_IN_CTZL
;
10082 fcodell
= BUILT_IN_CTZLL
;
10084 case BUILT_IN_CLRSBG
:
10086 fcodei
= BUILT_IN_CLRSB
;
10087 fcodel
= BUILT_IN_CLRSBL
;
10088 fcodell
= BUILT_IN_CLRSBLL
;
10090 case BUILT_IN_FFSG
:
10092 fcodei
= BUILT_IN_FFS
;
10093 fcodel
= BUILT_IN_FFSL
;
10094 fcodell
= BUILT_IN_FFSLL
;
10096 case BUILT_IN_PARITYG
:
10098 fcodei
= BUILT_IN_PARITY
;
10099 fcodel
= BUILT_IN_PARITYL
;
10100 fcodell
= BUILT_IN_PARITYLL
;
10102 case BUILT_IN_POPCOUNTG
:
10103 ifn
= IFN_POPCOUNT
;
10104 fcodei
= BUILT_IN_POPCOUNT
;
10105 fcodel
= BUILT_IN_POPCOUNTL
;
10106 fcodell
= BUILT_IN_POPCOUNTLL
;
10109 gcc_unreachable ();
10112 if (TYPE_PRECISION (arg0_type
)
10113 <= TYPE_PRECISION (long_long_unsigned_type_node
))
10115 if (TYPE_PRECISION (arg0_type
) <= TYPE_PRECISION (unsigned_type_node
))
10117 cast_type
= (TYPE_UNSIGNED (arg0_type
)
10118 ? unsigned_type_node
: integer_type_node
);
10119 else if (TYPE_PRECISION (arg0_type
)
10120 <= TYPE_PRECISION (long_unsigned_type_node
))
10122 cast_type
= (TYPE_UNSIGNED (arg0_type
)
10123 ? long_unsigned_type_node
: long_integer_type_node
);
10128 cast_type
= (TYPE_UNSIGNED (arg0_type
)
10129 ? long_long_unsigned_type_node
10130 : long_long_integer_type_node
);
10134 else if (TYPE_PRECISION (arg0_type
) <= MAX_FIXED_MODE_SIZE
)
10137 = build_nonstandard_integer_type (MAX_FIXED_MODE_SIZE
,
10138 TYPE_UNSIGNED (arg0_type
));
10139 gcc_assert (TYPE_PRECISION (cast_type
)
10140 == 2 * TYPE_PRECISION (long_long_unsigned_type_node
));
10141 fcodei
= END_BUILTINS
;
10144 fcodei
= END_BUILTINS
;
10149 case BUILT_IN_CLZG
:
10150 case BUILT_IN_CLRSBG
:
10151 addend
= TYPE_PRECISION (arg0_type
) - TYPE_PRECISION (cast_type
);
10156 arg0
= fold_convert (cast_type
, arg0
);
10157 arg0_type
= cast_type
;
10161 arg1
= fold_convert (integer_type_node
, arg1
);
10164 if (fcode
== BUILT_IN_CLZG
&& addend
)
10167 arg0
= save_expr (arg0
);
10170 tree call
= NULL_TREE
, tem
;
10171 if (TYPE_PRECISION (arg0_type
) == MAX_FIXED_MODE_SIZE
10172 && (TYPE_PRECISION (arg0_type
)
10173 == 2 * TYPE_PRECISION (long_long_unsigned_type_node
)))
10175 /* __int128 expansions using up to 2 long long builtins. */
10176 arg0
= save_expr (arg0
);
10177 tree type
= (TYPE_UNSIGNED (arg0_type
)
10178 ? long_long_unsigned_type_node
10179 : long_long_integer_type_node
);
10180 tree hi
= fold_build2 (RSHIFT_EXPR
, arg0_type
, arg0
,
10181 build_int_cst (integer_type_node
,
10182 MAX_FIXED_MODE_SIZE
/ 2));
10183 hi
= fold_convert (type
, hi
);
10184 tree lo
= fold_convert (type
, arg0
);
10187 case BUILT_IN_CLZG
:
10188 call
= fold_builtin_bit_query (loc
, fcode
, lo
, NULL_TREE
);
10189 call
= fold_build2 (PLUS_EXPR
, integer_type_node
, call
,
10190 build_int_cst (integer_type_node
,
10191 MAX_FIXED_MODE_SIZE
/ 2));
10193 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10194 fold_build2 (NE_EXPR
, boolean_type_node
,
10195 lo
, build_zero_cst (type
)),
10197 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10198 fold_build2 (NE_EXPR
, boolean_type_node
,
10199 hi
, build_zero_cst (type
)),
10200 fold_builtin_bit_query (loc
, fcode
, hi
,
10204 case BUILT_IN_CTZG
:
10205 call
= fold_builtin_bit_query (loc
, fcode
, hi
, NULL_TREE
);
10206 call
= fold_build2 (PLUS_EXPR
, integer_type_node
, call
,
10207 build_int_cst (integer_type_node
,
10208 MAX_FIXED_MODE_SIZE
/ 2));
10210 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10211 fold_build2 (NE_EXPR
, boolean_type_node
,
10212 hi
, build_zero_cst (type
)),
10214 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10215 fold_build2 (NE_EXPR
, boolean_type_node
,
10216 lo
, build_zero_cst (type
)),
10217 fold_builtin_bit_query (loc
, fcode
, lo
,
10221 case BUILT_IN_CLRSBG
:
10222 tem
= fold_builtin_bit_query (loc
, fcode
, lo
, NULL_TREE
);
10223 tem
= fold_build2 (PLUS_EXPR
, integer_type_node
, tem
,
10224 build_int_cst (integer_type_node
,
10225 MAX_FIXED_MODE_SIZE
/ 2));
10226 tem
= fold_build3 (COND_EXPR
, integer_type_node
,
10227 fold_build2 (LT_EXPR
, boolean_type_node
,
10228 fold_build2 (BIT_XOR_EXPR
, type
,
10230 build_zero_cst (type
)),
10231 build_int_cst (integer_type_node
,
10232 MAX_FIXED_MODE_SIZE
/ 2 - 1),
10234 call
= fold_builtin_bit_query (loc
, fcode
, hi
, NULL_TREE
);
10235 call
= save_expr (call
);
10236 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10237 fold_build2 (NE_EXPR
, boolean_type_node
,
10239 build_int_cst (integer_type_node
,
10240 MAX_FIXED_MODE_SIZE
10244 case BUILT_IN_FFSG
:
10245 call
= fold_builtin_bit_query (loc
, fcode
, hi
, NULL_TREE
);
10246 call
= fold_build2 (PLUS_EXPR
, integer_type_node
, call
,
10247 build_int_cst (integer_type_node
,
10248 MAX_FIXED_MODE_SIZE
/ 2));
10249 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10250 fold_build2 (NE_EXPR
, boolean_type_node
,
10251 hi
, build_zero_cst (type
)),
10252 call
, integer_zero_node
);
10253 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10254 fold_build2 (NE_EXPR
, boolean_type_node
,
10255 lo
, build_zero_cst (type
)),
10256 fold_builtin_bit_query (loc
, fcode
, lo
,
10260 case BUILT_IN_PARITYG
:
10261 call
= fold_builtin_bit_query (loc
, fcode
,
10262 fold_build2 (BIT_XOR_EXPR
, type
,
10263 lo
, hi
), NULL_TREE
);
10265 case BUILT_IN_POPCOUNTG
:
10266 call
= fold_build2 (PLUS_EXPR
, integer_type_node
,
10267 fold_builtin_bit_query (loc
, fcode
, hi
,
10269 fold_builtin_bit_query (loc
, fcode
, lo
,
10273 gcc_unreachable ();
10278 /* Only keep second argument to IFN_CLZ/IFN_CTZ if it is the
10279 value defined at zero during GIMPLE, or for large/huge _BitInt
10280 (which are then lowered during bitint lowering). */
10281 if (arg2
&& TREE_CODE (TREE_TYPE (arg0
)) != BITINT_TYPE
)
10284 if (fcode
== BUILT_IN_CLZG
)
10286 if (CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (arg0_type
),
10288 || wi::to_widest (arg2
) != val
)
10291 else if (CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_TYPE_MODE (arg0_type
),
10293 || wi::to_widest (arg2
) != val
)
10295 if (!direct_internal_fn_supported_p (ifn
, arg0_type
,
10296 OPTIMIZE_FOR_BOTH
))
10298 if (arg2
== NULL_TREE
)
10299 arg0
= save_expr (arg0
);
10301 if (fcodei
== END_BUILTINS
|| arg2
)
10302 call
= build_call_expr_internal_loc (loc
, ifn
, integer_type_node
,
10303 arg2
? 2 : 1, arg0
, arg2
);
10305 call
= build_call_expr_loc (loc
, builtin_decl_explicit (fcodei
), 1,
10309 call
= fold_build2 (PLUS_EXPR
, integer_type_node
, call
,
10310 build_int_cst (integer_type_node
, addend
));
10311 if (arg1
&& arg2
== NULL_TREE
)
10312 call
= fold_build3 (COND_EXPR
, integer_type_node
,
10313 fold_build2 (NE_EXPR
, boolean_type_node
,
10314 arg0
, build_zero_cst (arg0_type
)),
10320 /* Fold __builtin_{add,sub}c{,l,ll} into pair of internal functions
10321 that return both result of arithmetics and overflowed boolean
10322 flag in a complex integer result. */
10325 fold_builtin_addc_subc (location_t loc
, enum built_in_function fcode
,
10328 enum internal_fn ifn
;
10332 case BUILT_IN_ADDC
:
10333 case BUILT_IN_ADDCL
:
10334 case BUILT_IN_ADDCLL
:
10335 ifn
= IFN_ADD_OVERFLOW
;
10337 case BUILT_IN_SUBC
:
10338 case BUILT_IN_SUBCL
:
10339 case BUILT_IN_SUBCLL
:
10340 ifn
= IFN_SUB_OVERFLOW
;
10343 gcc_unreachable ();
10346 tree type
= TREE_TYPE (args
[0]);
10347 tree ctype
= build_complex_type (type
);
10348 tree call
= build_call_expr_internal_loc (loc
, ifn
, ctype
, 2,
10350 tree tgt
= save_expr (call
);
10351 tree intres
= build1_loc (loc
, REALPART_EXPR
, type
, tgt
);
10352 tree ovfres
= build1_loc (loc
, IMAGPART_EXPR
, type
, tgt
);
10353 call
= build_call_expr_internal_loc (loc
, ifn
, ctype
, 2,
10355 tgt
= save_expr (call
);
10356 intres
= build1_loc (loc
, REALPART_EXPR
, type
, tgt
);
10357 tree ovfres2
= build1_loc (loc
, IMAGPART_EXPR
, type
, tgt
);
10358 ovfres
= build2_loc (loc
, BIT_IOR_EXPR
, type
, ovfres
, ovfres2
);
10359 tree mem_arg3
= build_fold_indirect_ref_loc (loc
, args
[3]);
10361 = fold_build2_loc (loc
, MODIFY_EXPR
, void_type_node
, mem_arg3
, ovfres
);
10362 return build2_loc (loc
, COMPOUND_EXPR
, type
, store
, intres
);
10365 /* Fold a call to __builtin_FILE to a constant string. */
10368 fold_builtin_FILE (location_t loc
)
10370 if (const char *fname
= LOCATION_FILE (loc
))
10372 /* The documentation says this builtin is equivalent to the preprocessor
10373 __FILE__ macro so it appears appropriate to use the same file prefix
10375 fname
= remap_macro_filename (fname
);
10376 return build_string_literal (fname
);
10379 return build_string_literal ("");
10382 /* Fold a call to __builtin_FUNCTION to a constant string. */
10385 fold_builtin_FUNCTION ()
10387 const char *name
= "";
10389 if (current_function_decl
)
10390 name
= lang_hooks
.decl_printable_name (current_function_decl
, 0);
10392 return build_string_literal (name
);
10395 /* Fold a call to __builtin_LINE to an integer constant. */
10398 fold_builtin_LINE (location_t loc
, tree type
)
10400 return build_int_cst (type
, LOCATION_LINE (loc
));
10403 /* Fold a call to built-in function FNDECL with 0 arguments.
10404 This function returns NULL_TREE if no simplification was possible. */
10407 fold_builtin_0 (location_t loc
, tree fndecl
)
10409 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10410 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10413 case BUILT_IN_FILE
:
10414 return fold_builtin_FILE (loc
);
10416 case BUILT_IN_FUNCTION
:
10417 return fold_builtin_FUNCTION ();
10419 case BUILT_IN_LINE
:
10420 return fold_builtin_LINE (loc
, type
);
10422 CASE_FLT_FN (BUILT_IN_INF
):
10423 CASE_FLT_FN_FLOATN_NX (BUILT_IN_INF
):
10424 case BUILT_IN_INFD32
:
10425 case BUILT_IN_INFD64
:
10426 case BUILT_IN_INFD128
:
10427 return fold_builtin_inf (loc
, type
, true);
10429 CASE_FLT_FN (BUILT_IN_HUGE_VAL
):
10430 CASE_FLT_FN_FLOATN_NX (BUILT_IN_HUGE_VAL
):
10431 return fold_builtin_inf (loc
, type
, false);
10433 case BUILT_IN_CLASSIFY_TYPE
:
10434 return fold_builtin_classify_type (NULL_TREE
);
10436 case BUILT_IN_UNREACHABLE
:
10437 /* Rewrite any explicit calls to __builtin_unreachable. */
10438 if (sanitize_flags_p (SANITIZE_UNREACHABLE
))
10439 return build_builtin_unreachable (loc
);
10448 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
10449 This function returns NULL_TREE if no simplification was possible. */
10452 fold_builtin_1 (location_t loc
, tree expr
, tree fndecl
, tree arg0
)
10454 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10455 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10457 if (TREE_CODE (arg0
) == ERROR_MARK
)
10460 if (tree ret
= fold_const_call (as_combined_fn (fcode
), type
, arg0
))
10465 case BUILT_IN_CONSTANT_P
:
10467 tree val
= fold_builtin_constant_p (arg0
);
10469 /* Gimplification will pull the CALL_EXPR for the builtin out of
10470 an if condition. When not optimizing, we'll not CSE it back.
10471 To avoid link error types of regressions, return false now. */
10472 if (!val
&& !optimize
)
10473 val
= integer_zero_node
;
10478 case BUILT_IN_CLASSIFY_TYPE
:
10479 return fold_builtin_classify_type (arg0
);
10481 case BUILT_IN_STRLEN
:
10482 return fold_builtin_strlen (loc
, expr
, type
, arg0
);
10484 CASE_FLT_FN (BUILT_IN_FABS
):
10485 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS
):
10486 case BUILT_IN_FABSD32
:
10487 case BUILT_IN_FABSD64
:
10488 case BUILT_IN_FABSD128
:
10489 return fold_builtin_fabs (loc
, arg0
, type
);
10492 case BUILT_IN_LABS
:
10493 case BUILT_IN_LLABS
:
10494 case BUILT_IN_IMAXABS
:
10495 return fold_builtin_abs (loc
, arg0
, type
);
10497 CASE_FLT_FN (BUILT_IN_CONJ
):
10498 if (validate_arg (arg0
, COMPLEX_TYPE
)
10499 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10500 return fold_build1_loc (loc
, CONJ_EXPR
, type
, arg0
);
10503 CASE_FLT_FN (BUILT_IN_CREAL
):
10504 if (validate_arg (arg0
, COMPLEX_TYPE
)
10505 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10506 return non_lvalue_loc (loc
, fold_build1_loc (loc
, REALPART_EXPR
, type
, arg0
));
10509 CASE_FLT_FN (BUILT_IN_CIMAG
):
10510 if (validate_arg (arg0
, COMPLEX_TYPE
)
10511 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0
))) == REAL_TYPE
)
10512 return non_lvalue_loc (loc
, fold_build1_loc (loc
, IMAGPART_EXPR
, type
, arg0
));
10515 CASE_FLT_FN (BUILT_IN_CARG
):
10516 CASE_FLT_FN_FLOATN_NX (BUILT_IN_CARG
):
10517 return fold_builtin_carg (loc
, arg0
, type
);
10519 case BUILT_IN_ISASCII
:
10520 return fold_builtin_isascii (loc
, arg0
);
10522 case BUILT_IN_TOASCII
:
10523 return fold_builtin_toascii (loc
, arg0
);
10525 case BUILT_IN_ISDIGIT
:
10526 return fold_builtin_isdigit (loc
, arg0
);
10528 CASE_FLT_FN (BUILT_IN_FINITE
):
10529 case BUILT_IN_FINITED32
:
10530 case BUILT_IN_FINITED64
:
10531 case BUILT_IN_FINITED128
:
10532 case BUILT_IN_ISFINITE
:
10534 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISFINITE
);
10537 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10540 CASE_FLT_FN (BUILT_IN_ISINF
):
10541 case BUILT_IN_ISINFD32
:
10542 case BUILT_IN_ISINFD64
:
10543 case BUILT_IN_ISINFD128
:
10545 tree ret
= fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF
);
10548 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10551 case BUILT_IN_ISNORMAL
:
10552 return fold_builtin_interclass_mathfn (loc
, fndecl
, arg0
);
10554 case BUILT_IN_ISINF_SIGN
:
10555 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISINF_SIGN
);
10557 CASE_FLT_FN (BUILT_IN_ISNAN
):
10558 case BUILT_IN_ISNAND32
:
10559 case BUILT_IN_ISNAND64
:
10560 case BUILT_IN_ISNAND128
:
10561 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISNAN
);
10563 case BUILT_IN_ISSIGNALING
:
10564 return fold_builtin_classify (loc
, fndecl
, arg0
, BUILT_IN_ISSIGNALING
);
10566 case BUILT_IN_FREE
:
10567 if (integer_zerop (arg0
))
10568 return build_empty_stmt (loc
);
10571 case BUILT_IN_CLZG
:
10572 case BUILT_IN_CTZG
:
10573 case BUILT_IN_CLRSBG
:
10574 case BUILT_IN_FFSG
:
10575 case BUILT_IN_PARITYG
:
10576 case BUILT_IN_POPCOUNTG
:
10577 return fold_builtin_bit_query (loc
, fcode
, arg0
, NULL_TREE
);
10587 /* Folds a call EXPR (which may be null) to built-in function FNDECL
10588 with 2 arguments, ARG0 and ARG1. This function returns NULL_TREE
10589 if no simplification was possible. */
10592 fold_builtin_2 (location_t loc
, tree expr
, tree fndecl
, tree arg0
, tree arg1
)
10594 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10595 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10597 if (TREE_CODE (arg0
) == ERROR_MARK
10598 || TREE_CODE (arg1
) == ERROR_MARK
)
10601 if (tree ret
= fold_const_call (as_combined_fn (fcode
), type
, arg0
, arg1
))
10606 CASE_FLT_FN_REENT (BUILT_IN_GAMMA
): /* GAMMA_R */
10607 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA
): /* LGAMMA_R */
10608 if (validate_arg (arg0
, REAL_TYPE
)
10609 && validate_arg (arg1
, POINTER_TYPE
))
10610 return do_mpfr_lgamma_r (arg0
, arg1
, type
);
10613 CASE_FLT_FN (BUILT_IN_FREXP
):
10614 return fold_builtin_frexp (loc
, arg0
, arg1
, type
);
10616 CASE_FLT_FN (BUILT_IN_MODF
):
10617 return fold_builtin_modf (loc
, arg0
, arg1
, type
);
10619 case BUILT_IN_STRSPN
:
10620 return fold_builtin_strspn (loc
, expr
, arg0
, arg1
);
10622 case BUILT_IN_STRCSPN
:
10623 return fold_builtin_strcspn (loc
, expr
, arg0
, arg1
);
10625 case BUILT_IN_STRPBRK
:
10626 return fold_builtin_strpbrk (loc
, expr
, arg0
, arg1
, type
);
10628 case BUILT_IN_EXPECT
:
10629 return fold_builtin_expect (loc
, arg0
, arg1
, NULL_TREE
, NULL_TREE
);
10631 case BUILT_IN_ISGREATER
:
10632 return fold_builtin_unordered_cmp (loc
, fndecl
,
10633 arg0
, arg1
, UNLE_EXPR
, LE_EXPR
);
10634 case BUILT_IN_ISGREATEREQUAL
:
10635 return fold_builtin_unordered_cmp (loc
, fndecl
,
10636 arg0
, arg1
, UNLT_EXPR
, LT_EXPR
);
10637 case BUILT_IN_ISLESS
:
10638 return fold_builtin_unordered_cmp (loc
, fndecl
,
10639 arg0
, arg1
, UNGE_EXPR
, GE_EXPR
);
10640 case BUILT_IN_ISLESSEQUAL
:
10641 return fold_builtin_unordered_cmp (loc
, fndecl
,
10642 arg0
, arg1
, UNGT_EXPR
, GT_EXPR
);
10643 case BUILT_IN_ISLESSGREATER
:
10644 return fold_builtin_unordered_cmp (loc
, fndecl
,
10645 arg0
, arg1
, UNEQ_EXPR
, EQ_EXPR
);
10646 case BUILT_IN_ISUNORDERED
:
10647 return fold_builtin_unordered_cmp (loc
, fndecl
,
10648 arg0
, arg1
, UNORDERED_EXPR
,
10651 case BUILT_IN_ISEQSIG
:
10652 return fold_builtin_iseqsig (loc
, arg0
, arg1
);
10654 /* We do the folding for va_start in the expander. */
10655 case BUILT_IN_VA_START
:
10658 case BUILT_IN_OBJECT_SIZE
:
10659 case BUILT_IN_DYNAMIC_OBJECT_SIZE
:
10660 return fold_builtin_object_size (arg0
, arg1
, fcode
);
10662 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
10663 return fold_builtin_atomic_always_lock_free (arg0
, arg1
);
10665 case BUILT_IN_ATOMIC_IS_LOCK_FREE
:
10666 return fold_builtin_atomic_is_lock_free (arg0
, arg1
);
10668 case BUILT_IN_CLZG
:
10669 case BUILT_IN_CTZG
:
10670 return fold_builtin_bit_query (loc
, fcode
, arg0
, arg1
);
10678 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10680 This function returns NULL_TREE if no simplification was possible. */
10683 fold_builtin_3 (location_t loc
, tree fndecl
,
10684 tree arg0
, tree arg1
, tree arg2
)
10686 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
10687 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
10689 if (TREE_CODE (arg0
) == ERROR_MARK
10690 || TREE_CODE (arg1
) == ERROR_MARK
10691 || TREE_CODE (arg2
) == ERROR_MARK
)
10694 if (tree ret
= fold_const_call (as_combined_fn (fcode
), type
,
10701 CASE_FLT_FN (BUILT_IN_SINCOS
):
10702 return fold_builtin_sincos (loc
, arg0
, arg1
, arg2
);
10704 CASE_FLT_FN (BUILT_IN_REMQUO
):
10705 if (validate_arg (arg0
, REAL_TYPE
)
10706 && validate_arg (arg1
, REAL_TYPE
)
10707 && validate_arg (arg2
, POINTER_TYPE
))
10708 return do_mpfr_remquo (arg0
, arg1
, arg2
);
10711 case BUILT_IN_MEMCMP
:
10712 return fold_builtin_memcmp (loc
, arg0
, arg1
, arg2
);
10714 case BUILT_IN_EXPECT
:
10715 return fold_builtin_expect (loc
, arg0
, arg1
, arg2
, NULL_TREE
);
10717 case BUILT_IN_EXPECT_WITH_PROBABILITY
:
10718 return fold_builtin_expect (loc
, arg0
, arg1
, NULL_TREE
, arg2
);
10720 case BUILT_IN_ADD_OVERFLOW
:
10721 case BUILT_IN_SUB_OVERFLOW
:
10722 case BUILT_IN_MUL_OVERFLOW
:
10723 case BUILT_IN_ADD_OVERFLOW_P
:
10724 case BUILT_IN_SUB_OVERFLOW_P
:
10725 case BUILT_IN_MUL_OVERFLOW_P
:
10726 case BUILT_IN_SADD_OVERFLOW
:
10727 case BUILT_IN_SADDL_OVERFLOW
:
10728 case BUILT_IN_SADDLL_OVERFLOW
:
10729 case BUILT_IN_SSUB_OVERFLOW
:
10730 case BUILT_IN_SSUBL_OVERFLOW
:
10731 case BUILT_IN_SSUBLL_OVERFLOW
:
10732 case BUILT_IN_SMUL_OVERFLOW
:
10733 case BUILT_IN_SMULL_OVERFLOW
:
10734 case BUILT_IN_SMULLL_OVERFLOW
:
10735 case BUILT_IN_UADD_OVERFLOW
:
10736 case BUILT_IN_UADDL_OVERFLOW
:
10737 case BUILT_IN_UADDLL_OVERFLOW
:
10738 case BUILT_IN_USUB_OVERFLOW
:
10739 case BUILT_IN_USUBL_OVERFLOW
:
10740 case BUILT_IN_USUBLL_OVERFLOW
:
10741 case BUILT_IN_UMUL_OVERFLOW
:
10742 case BUILT_IN_UMULL_OVERFLOW
:
10743 case BUILT_IN_UMULLL_OVERFLOW
:
10744 return fold_builtin_arith_overflow (loc
, fcode
, arg0
, arg1
, arg2
);
10752 /* Folds a call EXPR (which may be null) to built-in function FNDECL.
10753 ARGS is an array of NARGS arguments. IGNORE is true if the result
10754 of the function call is ignored. This function returns NULL_TREE
10755 if no simplification was possible. */
10758 fold_builtin_n (location_t loc
, tree expr
, tree fndecl
, tree
*args
,
10761 tree ret
= NULL_TREE
;
10766 ret
= fold_builtin_0 (loc
, fndecl
);
10769 ret
= fold_builtin_1 (loc
, expr
, fndecl
, args
[0]);
10772 ret
= fold_builtin_2 (loc
, expr
, fndecl
, args
[0], args
[1]);
10775 ret
= fold_builtin_3 (loc
, fndecl
, args
[0], args
[1], args
[2]);
10778 ret
= fold_builtin_varargs (loc
, fndecl
, args
, nargs
);
10783 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
10784 SET_EXPR_LOCATION (ret
, loc
);
10790 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10791 list ARGS along with N new arguments in NEWARGS. SKIP is the number
10792 of arguments in ARGS to be omitted. OLDNARGS is the number of
10793 elements in ARGS. */
10796 rewrite_call_expr_valist (location_t loc
, int oldnargs
, tree
*args
,
10797 int skip
, tree fndecl
, int n
, va_list newargs
)
10799 int nargs
= oldnargs
- skip
+ n
;
10806 buffer
= XALLOCAVEC (tree
, nargs
);
10807 for (i
= 0; i
< n
; i
++)
10808 buffer
[i
] = va_arg (newargs
, tree
);
10809 for (j
= skip
; j
< oldnargs
; j
++, i
++)
10810 buffer
[i
] = args
[j
];
10813 buffer
= args
+ skip
;
10815 return build_call_expr_loc_array (loc
, fndecl
, nargs
, buffer
);
10818 /* Return true if FNDECL shouldn't be folded right now.
10819 If a built-in function has an inline attribute always_inline
10820 wrapper, defer folding it after always_inline functions have
10821 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10822 might not be performed. */
10825 avoid_folding_inline_builtin (tree fndecl
)
10827 return (DECL_DECLARED_INLINE_P (fndecl
)
10828 && DECL_DISREGARD_INLINE_LIMITS (fndecl
)
10830 && !cfun
->always_inline_functions_inlined
10831 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl
)));
10834 /* A wrapper function for builtin folding that prevents warnings for
10835 "statement without effect" and the like, caused by removing the
10836 call node earlier than the warning is generated. */
10839 fold_call_expr (location_t loc
, tree exp
, bool ignore
)
10841 tree ret
= NULL_TREE
;
10842 tree fndecl
= get_callee_fndecl (exp
);
10843 if (fndecl
&& fndecl_built_in_p (fndecl
)
10844 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10845 yet. Defer folding until we see all the arguments
10846 (after inlining). */
10847 && !CALL_EXPR_VA_ARG_PACK (exp
))
10849 int nargs
= call_expr_nargs (exp
);
10851 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10852 instead last argument is __builtin_va_arg_pack (). Defer folding
10853 even in that case, until arguments are finalized. */
10854 if (nargs
&& TREE_CODE (CALL_EXPR_ARG (exp
, nargs
- 1)) == CALL_EXPR
)
10856 tree fndecl2
= get_callee_fndecl (CALL_EXPR_ARG (exp
, nargs
- 1));
10857 if (fndecl2
&& fndecl_built_in_p (fndecl2
, BUILT_IN_VA_ARG_PACK
))
10861 if (avoid_folding_inline_builtin (fndecl
))
10864 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10865 return targetm
.fold_builtin (fndecl
, call_expr_nargs (exp
),
10866 CALL_EXPR_ARGP (exp
), ignore
);
10869 tree
*args
= CALL_EXPR_ARGP (exp
);
10870 ret
= fold_builtin_n (loc
, exp
, fndecl
, args
, nargs
, ignore
);
10878 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
10879 N arguments are passed in the array ARGARRAY. Return a folded
10880 expression or NULL_TREE if no simplification was possible. */
10883 fold_builtin_call_array (location_t loc
, tree
,
10888 if (TREE_CODE (fn
) != ADDR_EXPR
)
10891 tree fndecl
= TREE_OPERAND (fn
, 0);
10892 if (TREE_CODE (fndecl
) == FUNCTION_DECL
10893 && fndecl_built_in_p (fndecl
))
10895 /* If last argument is __builtin_va_arg_pack (), arguments to this
10896 function are not finalized yet. Defer folding until they are. */
10897 if (n
&& TREE_CODE (argarray
[n
- 1]) == CALL_EXPR
)
10899 tree fndecl2
= get_callee_fndecl (argarray
[n
- 1]);
10900 if (fndecl2
&& fndecl_built_in_p (fndecl2
, BUILT_IN_VA_ARG_PACK
))
10903 if (avoid_folding_inline_builtin (fndecl
))
10905 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
10906 return targetm
.fold_builtin (fndecl
, n
, argarray
, false);
10908 return fold_builtin_n (loc
, NULL_TREE
, fndecl
, argarray
, n
, false);
10914 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10915 along with N new arguments specified as the "..." parameters. SKIP
10916 is the number of arguments in EXP to be omitted. This function is used
10917 to do varargs-to-varargs transformations. */
10920 rewrite_call_expr (location_t loc
, tree exp
, int skip
, tree fndecl
, int n
, ...)
10926 t
= rewrite_call_expr_valist (loc
, call_expr_nargs (exp
),
10927 CALL_EXPR_ARGP (exp
), skip
, fndecl
, n
, ap
);
10933 /* Validate a single argument ARG against a tree code CODE representing
10934 a type. Return true when argument is valid. */
10937 validate_arg (const_tree arg
, enum tree_code code
)
10941 else if (code
== POINTER_TYPE
)
10942 return POINTER_TYPE_P (TREE_TYPE (arg
));
10943 else if (code
== INTEGER_TYPE
)
10944 return INTEGRAL_TYPE_P (TREE_TYPE (arg
));
10945 return code
== TREE_CODE (TREE_TYPE (arg
));
10948 /* This function validates the types of a function call argument list
10949 against a specified list of tree_codes. If the last specifier is a 0,
10950 that represents an ellipses, otherwise the last specifier must be a
10953 This is the GIMPLE version of validate_arglist. Eventually we want to
10954 completely convert builtins.cc to work from GIMPLEs and the tree based
10955 validate_arglist will then be removed. */
10958 validate_gimple_arglist (const gcall
*call
, ...)
10960 enum tree_code code
;
10966 va_start (ap
, call
);
10971 code
= (enum tree_code
) va_arg (ap
, int);
10975 /* This signifies an ellipses, any further arguments are all ok. */
10979 /* This signifies an endlink, if no arguments remain, return
10980 true, otherwise return false. */
10981 res
= (i
== gimple_call_num_args (call
));
10984 /* If no parameters remain or the parameter's code does not
10985 match the specified code, return false. Otherwise continue
10986 checking any remaining arguments. */
10987 arg
= gimple_call_arg (call
, i
++);
10988 if (!validate_arg (arg
, code
))
10995 /* We need gotos here since we can only have one VA_CLOSE in a
11003 /* Default target-specific builtin expander that does nothing. */
11006 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
11007 rtx target ATTRIBUTE_UNUSED
,
11008 rtx subtarget ATTRIBUTE_UNUSED
,
11009 machine_mode mode ATTRIBUTE_UNUSED
,
11010 int ignore ATTRIBUTE_UNUSED
)
11015 /* Returns true is EXP represents data that would potentially reside
11016 in a readonly section. */
11019 readonly_data_expr (tree exp
)
11023 if (TREE_CODE (exp
) != ADDR_EXPR
)
11026 exp
= get_base_address (TREE_OPERAND (exp
, 0));
11030 /* Make sure we call decl_readonly_section only for trees it
11031 can handle (since it returns true for everything it doesn't
11033 if (TREE_CODE (exp
) == STRING_CST
11034 || TREE_CODE (exp
) == CONSTRUCTOR
11035 || (VAR_P (exp
) && TREE_STATIC (exp
)))
11036 return decl_readonly_section (exp
, 0);
11041 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
11042 to the call, and TYPE is its return type.
11044 Return NULL_TREE if no simplification was possible, otherwise return the
11045 simplified form of the call as a tree.
11047 The simplified form may be a constant or other expression which
11048 computes the same value, but in a more efficient manner (including
11049 calls to other builtin functions).
11051 The call may contain arguments which need to be evaluated, but
11052 which are not useful to determine the result of the call. In
11053 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11054 COMPOUND_EXPR will be an argument which must be evaluated.
11055 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11056 COMPOUND_EXPR in the chain will contain the tree for the simplified
11057 form of the builtin function call. */
11060 fold_builtin_strpbrk (location_t loc
, tree
, tree s1
, tree s2
, tree type
)
11062 if (!validate_arg (s1
, POINTER_TYPE
)
11063 || !validate_arg (s2
, POINTER_TYPE
))
11067 const char *p1
, *p2
;
11069 p2
= c_getstr (s2
);
11073 p1
= c_getstr (s1
);
11076 const char *r
= strpbrk (p1
, p2
);
11080 return build_int_cst (TREE_TYPE (s1
), 0);
11082 /* Return an offset into the constant string argument. */
11083 tem
= fold_build_pointer_plus_hwi_loc (loc
, s1
, r
- p1
);
11084 return fold_convert_loc (loc
, type
, tem
);
11088 /* strpbrk(x, "") == NULL.
11089 Evaluate and ignore s1 in case it had side-effects. */
11090 return omit_one_operand_loc (loc
, type
, integer_zero_node
, s1
);
11093 return NULL_TREE
; /* Really call strpbrk. */
11095 fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
11099 /* New argument list transforming strpbrk(s1, s2) to
11100 strchr(s1, s2[0]). */
11101 return build_call_expr_loc (loc
, fn
, 2, s1
,
11102 build_int_cst (integer_type_node
, p2
[0]));
11105 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
11108 Return NULL_TREE if no simplification was possible, otherwise return the
11109 simplified form of the call as a tree.
11111 The simplified form may be a constant or other expression which
11112 computes the same value, but in a more efficient manner (including
11113 calls to other builtin functions).
11115 The call may contain arguments which need to be evaluated, but
11116 which are not useful to determine the result of the call. In
11117 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11118 COMPOUND_EXPR will be an argument which must be evaluated.
11119 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11120 COMPOUND_EXPR in the chain will contain the tree for the simplified
11121 form of the builtin function call. */
11124 fold_builtin_strspn (location_t loc
, tree expr
, tree s1
, tree s2
)
11126 if (!validate_arg (s1
, POINTER_TYPE
)
11127 || !validate_arg (s2
, POINTER_TYPE
))
11130 if (!check_nul_terminated_array (expr
, s1
)
11131 || !check_nul_terminated_array (expr
, s2
))
11134 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
11136 /* If either argument is "", return NULL_TREE. */
11137 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
11138 /* Evaluate and ignore both arguments in case either one has
11140 return omit_two_operands_loc (loc
, size_type_node
, size_zero_node
,
11145 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
11148 Return NULL_TREE if no simplification was possible, otherwise return the
11149 simplified form of the call as a tree.
11151 The simplified form may be a constant or other expression which
11152 computes the same value, but in a more efficient manner (including
11153 calls to other builtin functions).
11155 The call may contain arguments which need to be evaluated, but
11156 which are not useful to determine the result of the call. In
11157 this case we return a chain of COMPOUND_EXPRs. The LHS of each
11158 COMPOUND_EXPR will be an argument which must be evaluated.
11159 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
11160 COMPOUND_EXPR in the chain will contain the tree for the simplified
11161 form of the builtin function call. */
11164 fold_builtin_strcspn (location_t loc
, tree expr
, tree s1
, tree s2
)
11166 if (!validate_arg (s1
, POINTER_TYPE
)
11167 || !validate_arg (s2
, POINTER_TYPE
))
11170 if (!check_nul_terminated_array (expr
, s1
)
11171 || !check_nul_terminated_array (expr
, s2
))
11174 /* If the first argument is "", return NULL_TREE. */
11175 const char *p1
= c_getstr (s1
);
11176 if (p1
&& *p1
== '\0')
11178 /* Evaluate and ignore argument s2 in case it has
11180 return omit_one_operand_loc (loc
, size_type_node
,
11181 size_zero_node
, s2
);
11184 /* If the second argument is "", return __builtin_strlen(s1). */
11185 const char *p2
= c_getstr (s2
);
11186 if (p2
&& *p2
== '\0')
11188 tree fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
11190 /* If the replacement _DECL isn't initialized, don't do the
11195 return build_call_expr_loc (loc
, fn
, 1, s1
);
11200 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11201 produced. False otherwise. This is done so that we don't output the error
11202 or warning twice or three times. */
11205 fold_builtin_next_arg (tree exp
, bool va_start_p
)
11207 tree fntype
= TREE_TYPE (current_function_decl
);
11208 int nargs
= call_expr_nargs (exp
);
11210 /* There is good chance the current input_location points inside the
11211 definition of the va_start macro (perhaps on the token for
11212 builtin) in a system header, so warnings will not be emitted.
11213 Use the location in real source code. */
11214 location_t current_location
=
11215 linemap_unwind_to_first_non_reserved_loc (line_table
, input_location
,
11218 if (!stdarg_p (fntype
))
11220 error ("%<va_start%> used in function with fixed arguments");
11226 if (va_start_p
&& (nargs
!= 2))
11228 error ("wrong number of arguments to function %<va_start%>");
11231 arg
= CALL_EXPR_ARG (exp
, 1);
11233 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11234 when we checked the arguments and if needed issued a warning. */
11239 /* Evidently an out of date version of <stdarg.h>; can't validate
11240 va_start's second argument, but can still work as intended. */
11241 warning_at (current_location
,
11243 "%<__builtin_next_arg%> called without an argument");
11246 else if (nargs
> 1)
11248 error ("wrong number of arguments to function %<__builtin_next_arg%>");
11251 arg
= CALL_EXPR_ARG (exp
, 0);
11254 if (TREE_CODE (arg
) == SSA_NAME
11255 && SSA_NAME_VAR (arg
))
11256 arg
= SSA_NAME_VAR (arg
);
11258 /* We destructively modify the call to be __builtin_va_start (ap, 0)
11259 or __builtin_next_arg (0) the first time we see it, after checking
11260 the arguments and if needed issuing a warning. */
11261 if (!integer_zerop (arg
))
11263 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
11265 /* Strip off all nops for the sake of the comparison. This
11266 is not quite the same as STRIP_NOPS. It does more.
11267 We must also strip off INDIRECT_EXPR for C++ reference
11269 while (CONVERT_EXPR_P (arg
)
11270 || INDIRECT_REF_P (arg
))
11271 arg
= TREE_OPERAND (arg
, 0);
11272 if (arg
!= last_parm
)
11274 /* FIXME: Sometimes with the tree optimizers we can get the
11275 not the last argument even though the user used the last
11276 argument. We just warn and set the arg to be the last
11277 argument so that we will get wrong-code because of
11279 warning_at (current_location
,
11281 "second parameter of %<va_start%> not last named argument");
11284 /* Undefined by C99 7.15.1.4p4 (va_start):
11285 "If the parameter parmN is declared with the register storage
11286 class, with a function or array type, or with a type that is
11287 not compatible with the type that results after application of
11288 the default argument promotions, the behavior is undefined."
11290 else if (DECL_REGISTER (arg
))
11292 warning_at (current_location
,
11294 "undefined behavior when second parameter of "
11295 "%<va_start%> is declared with %<register%> storage");
11298 /* We want to verify the second parameter just once before the tree
11299 optimizers are run and then avoid keeping it in the tree,
11300 as otherwise we could warn even for correct code like:
11301 void foo (int i, ...)
11302 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
11304 CALL_EXPR_ARG (exp
, 1) = integer_zero_node
;
11306 CALL_EXPR_ARG (exp
, 0) = integer_zero_node
;
11312 /* Expand a call EXP to __builtin_object_size. */
11315 expand_builtin_object_size (tree exp
)
11318 int object_size_type
;
11319 tree fndecl
= get_callee_fndecl (exp
);
11321 if (!validate_arglist (exp
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11323 error ("first argument of %qD must be a pointer, second integer constant",
11325 expand_builtin_trap ();
11329 ost
= CALL_EXPR_ARG (exp
, 1);
11332 if (TREE_CODE (ost
) != INTEGER_CST
11333 || tree_int_cst_sgn (ost
) < 0
11334 || compare_tree_int (ost
, 3) > 0)
11336 error ("last argument of %qD is not integer constant between 0 and 3",
11338 expand_builtin_trap ();
11342 object_size_type
= tree_to_shwi (ost
);
11344 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
11347 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11348 FCODE is the BUILT_IN_* to use.
11349 Return NULL_RTX if we failed; the caller should emit a normal call,
11350 otherwise try to get the result in TARGET, if convenient (and in
11351 mode MODE if that's convenient). */
11354 expand_builtin_memory_chk (tree exp
, rtx target
, machine_mode mode
,
11355 enum built_in_function fcode
)
11357 if (!validate_arglist (exp
,
11359 fcode
== BUILT_IN_MEMSET_CHK
11360 ? INTEGER_TYPE
: POINTER_TYPE
,
11361 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
11364 tree dest
= CALL_EXPR_ARG (exp
, 0);
11365 tree src
= CALL_EXPR_ARG (exp
, 1);
11366 tree len
= CALL_EXPR_ARG (exp
, 2);
11367 tree size
= CALL_EXPR_ARG (exp
, 3);
11369 /* FIXME: Set access mode to write only for memset et al. */
11370 bool sizes_ok
= check_access (exp
, len
, /*maxread=*/NULL_TREE
,
11371 /*srcstr=*/NULL_TREE
, size
, access_read_write
);
11373 if (!tree_fits_uhwi_p (size
))
11376 if (tree_fits_uhwi_p (len
) || integer_all_onesp (size
))
11378 /* Avoid transforming the checking call to an ordinary one when
11379 an overflow has been detected or when the call couldn't be
11380 validated because the size is not constant. */
11381 if (!sizes_ok
&& !integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
11384 tree fn
= NULL_TREE
;
11385 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11386 mem{cpy,pcpy,move,set} is available. */
11389 case BUILT_IN_MEMCPY_CHK
:
11390 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
11392 case BUILT_IN_MEMPCPY_CHK
:
11393 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
11395 case BUILT_IN_MEMMOVE_CHK
:
11396 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
11398 case BUILT_IN_MEMSET_CHK
:
11399 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
11408 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 3, dest
, src
, len
);
11409 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11410 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11411 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11413 else if (fcode
== BUILT_IN_MEMSET_CHK
)
11417 unsigned int dest_align
= get_pointer_alignment (dest
);
11419 /* If DEST is not a pointer type, call the normal function. */
11420 if (dest_align
== 0)
11423 /* If SRC and DEST are the same (and not volatile), do nothing. */
11424 if (operand_equal_p (src
, dest
, 0))
11428 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
11430 /* Evaluate and ignore LEN in case it has side-effects. */
11431 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
11432 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
11435 expr
= fold_build_pointer_plus (dest
, len
);
11436 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
11439 /* __memmove_chk special case. */
11440 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
11442 unsigned int src_align
= get_pointer_alignment (src
);
11444 if (src_align
== 0)
11447 /* If src is categorized for a readonly section we can use
11448 normal __memcpy_chk. */
11449 if (readonly_data_expr (src
))
11451 tree fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
11454 fn
= build_call_nofold_loc (EXPR_LOCATION (exp
), fn
, 4,
11455 dest
, src
, len
, size
);
11456 gcc_assert (TREE_CODE (fn
) == CALL_EXPR
);
11457 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
11458 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
11465 /* Emit warning if a buffer overflow is detected at compile time. */
11468 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
11470 /* The source string. */
11471 tree srcstr
= NULL_TREE
;
11472 /* The size of the destination object returned by __builtin_object_size. */
11473 tree objsize
= NULL_TREE
;
11474 /* The string that is being concatenated with (as in __strcat_chk)
11475 or null if it isn't. */
11476 tree catstr
= NULL_TREE
;
11477 /* The maximum length of the source sequence in a bounded operation
11478 (such as __strncat_chk) or null if the operation isn't bounded
11479 (such as __strcat_chk). */
11480 tree maxread
= NULL_TREE
;
11481 /* The exact size of the access (such as in __strncpy_chk). */
11482 tree size
= NULL_TREE
;
11483 /* The access by the function that's checked. Except for snprintf
11484 both writing and reading is checked. */
11485 access_mode mode
= access_read_write
;
11489 case BUILT_IN_STRCPY_CHK
:
11490 case BUILT_IN_STPCPY_CHK
:
11491 srcstr
= CALL_EXPR_ARG (exp
, 1);
11492 objsize
= CALL_EXPR_ARG (exp
, 2);
11495 case BUILT_IN_STRCAT_CHK
:
11496 /* For __strcat_chk the warning will be emitted only if overflowing
11497 by at least strlen (dest) + 1 bytes. */
11498 catstr
= CALL_EXPR_ARG (exp
, 0);
11499 srcstr
= CALL_EXPR_ARG (exp
, 1);
11500 objsize
= CALL_EXPR_ARG (exp
, 2);
11503 case BUILT_IN_STRNCAT_CHK
:
11504 catstr
= CALL_EXPR_ARG (exp
, 0);
11505 srcstr
= CALL_EXPR_ARG (exp
, 1);
11506 maxread
= CALL_EXPR_ARG (exp
, 2);
11507 objsize
= CALL_EXPR_ARG (exp
, 3);
11510 case BUILT_IN_STRNCPY_CHK
:
11511 case BUILT_IN_STPNCPY_CHK
:
11512 srcstr
= CALL_EXPR_ARG (exp
, 1);
11513 size
= CALL_EXPR_ARG (exp
, 2);
11514 objsize
= CALL_EXPR_ARG (exp
, 3);
11517 case BUILT_IN_SNPRINTF_CHK
:
11518 case BUILT_IN_VSNPRINTF_CHK
:
11519 maxread
= CALL_EXPR_ARG (exp
, 1);
11520 objsize
= CALL_EXPR_ARG (exp
, 3);
11521 /* The only checked access the write to the destination. */
11522 mode
= access_write_only
;
11525 gcc_unreachable ();
11528 if (catstr
&& maxread
)
11530 /* Check __strncat_chk. There is no way to determine the length
11531 of the string to which the source string is being appended so
11532 just warn when the length of the source string is not known. */
11533 check_strncat_sizes (exp
, objsize
);
11537 check_access (exp
, size
, maxread
, srcstr
, objsize
, mode
);
11540 /* Emit warning if a buffer overflow is detected at compile time
11541 in __sprintf_chk/__vsprintf_chk calls. */
11544 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
11546 tree size
, len
, fmt
;
11547 const char *fmt_str
;
11548 int nargs
= call_expr_nargs (exp
);
11550 /* Verify the required arguments in the original call. */
11554 size
= CALL_EXPR_ARG (exp
, 2);
11555 fmt
= CALL_EXPR_ARG (exp
, 3);
11557 if (! tree_fits_uhwi_p (size
) || integer_all_onesp (size
))
11560 /* Check whether the format is a literal string constant. */
11561 fmt_str
= c_getstr (fmt
);
11562 if (fmt_str
== NULL
)
11565 if (!init_target_chars ())
11568 /* If the format doesn't contain % args or %%, we know its size. */
11569 if (strchr (fmt_str
, target_percent
) == 0)
11570 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
11571 /* If the format is "%s" and first ... argument is a string literal,
11573 else if (fcode
== BUILT_IN_SPRINTF_CHK
11574 && strcmp (fmt_str
, target_percent_s
) == 0)
11580 arg
= CALL_EXPR_ARG (exp
, 4);
11581 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
11584 len
= c_strlen (arg
, 1);
11585 if (!len
|| ! tree_fits_uhwi_p (len
))
11591 /* Add one for the terminating nul. */
11592 len
= fold_build2 (PLUS_EXPR
, TREE_TYPE (len
), len
, size_one_node
);
11594 check_access (exp
, /*size=*/NULL_TREE
, /*maxread=*/NULL_TREE
, len
, size
,
11595 access_write_only
);
11598 /* Fold a call to __builtin_object_size with arguments PTR and OST,
11602 fold_builtin_object_size (tree ptr
, tree ost
, enum built_in_function fcode
)
11605 int object_size_type
;
11607 if (!validate_arg (ptr
, POINTER_TYPE
)
11608 || !validate_arg (ost
, INTEGER_TYPE
))
11613 if (TREE_CODE (ost
) != INTEGER_CST
11614 || tree_int_cst_sgn (ost
) < 0
11615 || compare_tree_int (ost
, 3) > 0)
11618 object_size_type
= tree_to_shwi (ost
);
11620 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
11621 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
11622 and (size_t) 0 for types 2 and 3. */
11623 if (TREE_SIDE_EFFECTS (ptr
))
11624 return build_int_cst_type (size_type_node
, object_size_type
< 2 ? -1 : 0);
11626 if (fcode
== BUILT_IN_DYNAMIC_OBJECT_SIZE
)
11627 object_size_type
|= OST_DYNAMIC
;
11629 if (TREE_CODE (ptr
) == ADDR_EXPR
)
11631 compute_builtin_object_size (ptr
, object_size_type
, &bytes
);
11632 if ((object_size_type
& OST_DYNAMIC
)
11633 || int_fits_type_p (bytes
, size_type_node
))
11634 return fold_convert (size_type_node
, bytes
);
11636 else if (TREE_CODE (ptr
) == SSA_NAME
)
11638 /* If object size is not known yet, delay folding until
11639 later. Maybe subsequent passes will help determining
11641 if (compute_builtin_object_size (ptr
, object_size_type
, &bytes
)
11642 && ((object_size_type
& OST_DYNAMIC
)
11643 || int_fits_type_p (bytes
, size_type_node
)))
11644 return fold_convert (size_type_node
, bytes
);
11650 /* Builtins with folding operations that operate on "..." arguments
11651 need special handling; we need to store the arguments in a convenient
11652 data structure before attempting any folding. Fortunately there are
11653 only a few builtins that fall into this category. FNDECL is the
11654 function, EXP is the CALL_EXPR for the call. */
11657 fold_builtin_varargs (location_t loc
, tree fndecl
, tree
*args
, int nargs
)
11659 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
11660 tree ret
= NULL_TREE
;
11664 case BUILT_IN_FPCLASSIFY
:
11665 ret
= fold_builtin_fpclassify (loc
, args
, nargs
);
11668 case BUILT_IN_ADDC
:
11669 case BUILT_IN_ADDCL
:
11670 case BUILT_IN_ADDCLL
:
11671 case BUILT_IN_SUBC
:
11672 case BUILT_IN_SUBCL
:
11673 case BUILT_IN_SUBCLL
:
11674 return fold_builtin_addc_subc (loc
, fcode
, args
);
11681 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
11682 SET_EXPR_LOCATION (ret
, loc
);
11683 suppress_warning (ret
);
11689 /* Initialize format string characters in the target charset. */
11692 init_target_chars (void)
11697 target_newline
= lang_hooks
.to_target_charset ('\n');
11698 target_percent
= lang_hooks
.to_target_charset ('%');
11699 target_c
= lang_hooks
.to_target_charset ('c');
11700 target_s
= lang_hooks
.to_target_charset ('s');
11701 if (target_newline
== 0 || target_percent
== 0 || target_c
== 0
11705 target_percent_c
[0] = target_percent
;
11706 target_percent_c
[1] = target_c
;
11707 target_percent_c
[2] = '\0';
11709 target_percent_s
[0] = target_percent
;
11710 target_percent_s
[1] = target_s
;
11711 target_percent_s
[2] = '\0';
11713 target_percent_s_newline
[0] = target_percent
;
11714 target_percent_s_newline
[1] = target_s
;
11715 target_percent_s_newline
[2] = target_newline
;
11716 target_percent_s_newline
[3] = '\0';
11723 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
11724 and no overflow/underflow occurred. INEXACT is true if M was not
11725 exactly calculated. TYPE is the tree type for the result. This
11726 function assumes that you cleared the MPFR flags and then
11727 calculated M to see if anything subsequently set a flag prior to
11728 entering this function. Return NULL_TREE if any checks fail. */
11731 do_mpfr_ckconv (mpfr_srcptr m
, tree type
, int inexact
)
11733 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
11734 overflow/underflow occurred. If -frounding-math, proceed iff the
11735 result of calling FUNC was exact. */
11736 if (mpfr_number_p (m
) && !mpfr_overflow_p () && !mpfr_underflow_p ()
11737 && (!flag_rounding_math
|| !inexact
))
11739 REAL_VALUE_TYPE rr
;
11741 real_from_mpfr (&rr
, m
, type
, MPFR_RNDN
);
11742 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
11743 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
11744 but the mpfr_t is not, then we underflowed in the
11746 if (real_isfinite (&rr
)
11747 && (rr
.cl
== rvc_zero
) == (mpfr_zero_p (m
) != 0))
11749 REAL_VALUE_TYPE rmode
;
11751 real_convert (&rmode
, TYPE_MODE (type
), &rr
);
11752 /* Proceed iff the specified mode can hold the value. */
11753 if (real_identical (&rmode
, &rr
))
11754 return build_real (type
, rmode
);
11760 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
11761 number and no overflow/underflow occurred. INEXACT is true if M
11762 was not exactly calculated. TYPE is the tree type for the result.
11763 This function assumes that you cleared the MPFR flags and then
11764 calculated M to see if anything subsequently set a flag prior to
11765 entering this function. Return NULL_TREE if any checks fail, if
11766 FORCE_CONVERT is true, then bypass the checks. */
11769 do_mpc_ckconv (mpc_srcptr m
, tree type
, int inexact
, int force_convert
)
11771 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
11772 overflow/underflow occurred. If -frounding-math, proceed iff the
11773 result of calling FUNC was exact. */
11775 || (mpfr_number_p (mpc_realref (m
)) && mpfr_number_p (mpc_imagref (m
))
11776 && !mpfr_overflow_p () && !mpfr_underflow_p ()
11777 && (!flag_rounding_math
|| !inexact
)))
11779 REAL_VALUE_TYPE re
, im
;
11781 real_from_mpfr (&re
, mpc_realref (m
), TREE_TYPE (type
), MPFR_RNDN
);
11782 real_from_mpfr (&im
, mpc_imagref (m
), TREE_TYPE (type
), MPFR_RNDN
);
11783 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
11784 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
11785 but the mpfr_t is not, then we underflowed in the
11788 || (real_isfinite (&re
) && real_isfinite (&im
)
11789 && (re
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_realref (m
)) != 0)
11790 && (im
.cl
== rvc_zero
) == (mpfr_zero_p (mpc_imagref (m
)) != 0)))
11792 REAL_VALUE_TYPE re_mode
, im_mode
;
11794 real_convert (&re_mode
, TYPE_MODE (TREE_TYPE (type
)), &re
);
11795 real_convert (&im_mode
, TYPE_MODE (TREE_TYPE (type
)), &im
);
11796 /* Proceed iff the specified mode can hold the value. */
11798 || (real_identical (&re_mode
, &re
)
11799 && real_identical (&im_mode
, &im
)))
11800 return build_complex (type
, build_real (TREE_TYPE (type
), re_mode
),
11801 build_real (TREE_TYPE (type
), im_mode
));
11807 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
11808 the pointer *(ARG_QUO) and return the result. The type is taken
11809 from the type of ARG0 and is used for setting the precision of the
11810 calculation and results. */
11813 do_mpfr_remquo (tree arg0
, tree arg1
, tree arg_quo
)
11815 tree
const type
= TREE_TYPE (arg0
);
11816 tree result
= NULL_TREE
;
11821 /* To proceed, MPFR must exactly represent the target floating point
11822 format, which only happens when the target base equals two. */
11823 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11824 && TREE_CODE (arg0
) == REAL_CST
&& !TREE_OVERFLOW (arg0
)
11825 && TREE_CODE (arg1
) == REAL_CST
&& !TREE_OVERFLOW (arg1
))
11827 const REAL_VALUE_TYPE
*const ra0
= TREE_REAL_CST_PTR (arg0
);
11828 const REAL_VALUE_TYPE
*const ra1
= TREE_REAL_CST_PTR (arg1
);
11830 if (real_isfinite (ra0
) && real_isfinite (ra1
))
11832 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11833 const int prec
= fmt
->p
;
11834 const mpfr_rnd_t rnd
= fmt
->round_towards_zero
? MPFR_RNDZ
: MPFR_RNDN
;
11839 mpfr_inits2 (prec
, m0
, m1
, NULL
);
11840 mpfr_from_real (m0
, ra0
, MPFR_RNDN
);
11841 mpfr_from_real (m1
, ra1
, MPFR_RNDN
);
11842 mpfr_clear_flags ();
11843 mpfr_remquo (m0
, &integer_quo
, m0
, m1
, rnd
);
11844 /* Remquo is independent of the rounding mode, so pass
11845 inexact=0 to do_mpfr_ckconv(). */
11846 result_rem
= do_mpfr_ckconv (m0
, type
, /*inexact=*/ 0);
11847 mpfr_clears (m0
, m1
, NULL
);
11850 /* MPFR calculates quo in the host's long so it may
11851 return more bits in quo than the target int can hold
11852 if sizeof(host long) > sizeof(target int). This can
11853 happen even for native compilers in LP64 mode. In
11854 these cases, modulo the quo value with the largest
11855 number that the target int can hold while leaving one
11856 bit for the sign. */
11857 if (sizeof (integer_quo
) * CHAR_BIT
> INT_TYPE_SIZE
)
11858 integer_quo
%= (long)(1UL << (INT_TYPE_SIZE
- 1));
11860 /* Dereference the quo pointer argument. */
11861 arg_quo
= build_fold_indirect_ref (arg_quo
);
11862 /* Proceed iff a valid pointer type was passed in. */
11863 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo
)) == integer_type_node
)
11865 /* Set the value. */
11867 = fold_build2 (MODIFY_EXPR
, TREE_TYPE (arg_quo
), arg_quo
,
11868 build_int_cst (TREE_TYPE (arg_quo
),
11870 TREE_SIDE_EFFECTS (result_quo
) = 1;
11871 /* Combine the quo assignment with the rem. */
11872 result
= fold_build2 (COMPOUND_EXPR
, type
,
11873 result_quo
, result_rem
);
11874 suppress_warning (result
, OPT_Wunused_value
);
11875 result
= non_lvalue (result
);
11883 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
11884 resulting value as a tree with type TYPE. The mpfr precision is
11885 set to the precision of TYPE. We assume that this mpfr function
11886 returns zero if the result could be calculated exactly within the
11887 requested precision. In addition, the integer pointer represented
11888 by ARG_SG will be dereferenced and set to the appropriate signgam
11892 do_mpfr_lgamma_r (tree arg
, tree arg_sg
, tree type
)
11894 tree result
= NULL_TREE
;
11898 /* To proceed, MPFR must exactly represent the target floating point
11899 format, which only happens when the target base equals two. Also
11900 verify ARG is a constant and that ARG_SG is an int pointer. */
11901 if (REAL_MODE_FORMAT (TYPE_MODE (type
))->b
== 2
11902 && TREE_CODE (arg
) == REAL_CST
&& !TREE_OVERFLOW (arg
)
11903 && TREE_CODE (TREE_TYPE (arg_sg
)) == POINTER_TYPE
11904 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg
))) == integer_type_node
)
11906 const REAL_VALUE_TYPE
*const ra
= TREE_REAL_CST_PTR (arg
);
11908 /* In addition to NaN and Inf, the argument cannot be zero or a
11909 negative integer. */
11910 if (real_isfinite (ra
)
11911 && ra
->cl
!= rvc_zero
11912 && !(real_isneg (ra
) && real_isinteger (ra
, TYPE_MODE (type
))))
11914 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
11915 const int prec
= fmt
->p
;
11916 const mpfr_rnd_t rnd
= fmt
->round_towards_zero
? MPFR_RNDZ
: MPFR_RNDN
;
11920 auto_mpfr
m (prec
);
11921 mpfr_from_real (m
, ra
, MPFR_RNDN
);
11922 mpfr_clear_flags ();
11923 inexact
= mpfr_lgamma (m
, &sg
, m
, rnd
);
11924 result_lg
= do_mpfr_ckconv (m
, type
, inexact
);
11929 /* Dereference the arg_sg pointer argument. */
11930 arg_sg
= build_fold_indirect_ref (arg_sg
);
11931 /* Assign the signgam value into *arg_sg. */
11932 result_sg
= fold_build2 (MODIFY_EXPR
,
11933 TREE_TYPE (arg_sg
), arg_sg
,
11934 build_int_cst (TREE_TYPE (arg_sg
), sg
));
11935 TREE_SIDE_EFFECTS (result_sg
) = 1;
11936 /* Combine the signgam assignment with the lgamma result. */
11937 result
= non_lvalue (fold_build2 (COMPOUND_EXPR
, type
,
11938 result_sg
, result_lg
));
11946 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
11947 mpc function FUNC on it and return the resulting value as a tree
11948 with type TYPE. The mpfr precision is set to the precision of
11949 TYPE. We assume that function FUNC returns zero if the result
11950 could be calculated exactly within the requested precision. If
11951 DO_NONFINITE is true, then fold expressions containing Inf or NaN
11952 in the arguments and/or results. */
11955 do_mpc_arg2 (tree arg0
, tree arg1
, tree type
, int do_nonfinite
,
11956 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
))
11958 tree result
= NULL_TREE
;
11963 /* To proceed, MPFR must exactly represent the target floating point
11964 format, which only happens when the target base equals two. */
11965 if (TREE_CODE (arg0
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg0
)
11966 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TREE_TYPE (arg0
)))
11967 && TREE_CODE (arg1
) == COMPLEX_CST
&& !TREE_OVERFLOW (arg1
)
11968 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TREE_TYPE (arg1
)))
11969 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0
))))->b
== 2)
11971 const REAL_VALUE_TYPE
*const re0
= TREE_REAL_CST_PTR (TREE_REALPART (arg0
));
11972 const REAL_VALUE_TYPE
*const im0
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg0
));
11973 const REAL_VALUE_TYPE
*const re1
= TREE_REAL_CST_PTR (TREE_REALPART (arg1
));
11974 const REAL_VALUE_TYPE
*const im1
= TREE_REAL_CST_PTR (TREE_IMAGPART (arg1
));
11977 || (real_isfinite (re0
) && real_isfinite (im0
)
11978 && real_isfinite (re1
) && real_isfinite (im1
)))
11980 const struct real_format
*const fmt
=
11981 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type
)));
11982 const int prec
= fmt
->p
;
11983 const mpfr_rnd_t rnd
= fmt
->round_towards_zero
11984 ? MPFR_RNDZ
: MPFR_RNDN
;
11985 const mpc_rnd_t crnd
= fmt
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
11989 mpc_init2 (m0
, prec
);
11990 mpc_init2 (m1
, prec
);
11991 mpfr_from_real (mpc_realref (m0
), re0
, rnd
);
11992 mpfr_from_real (mpc_imagref (m0
), im0
, rnd
);
11993 mpfr_from_real (mpc_realref (m1
), re1
, rnd
);
11994 mpfr_from_real (mpc_imagref (m1
), im1
, rnd
);
11995 mpfr_clear_flags ();
11996 inexact
= func (m0
, m0
, m1
, crnd
);
11997 result
= do_mpc_ckconv (m0
, type
, inexact
, do_nonfinite
);
12006 /* A wrapper function for builtin folding that prevents warnings for
12007 "statement without effect" and the like, caused by removing the
12008 call node earlier than the warning is generated. */
12011 fold_call_stmt (gcall
*stmt
, bool ignore
)
12013 tree ret
= NULL_TREE
;
12014 tree fndecl
= gimple_call_fndecl (stmt
);
12015 location_t loc
= gimple_location (stmt
);
12016 if (fndecl
&& fndecl_built_in_p (fndecl
)
12017 && !gimple_call_va_arg_pack_p (stmt
))
12019 int nargs
= gimple_call_num_args (stmt
);
12020 tree
*args
= (nargs
> 0
12021 ? gimple_call_arg_ptr (stmt
, 0)
12022 : &error_mark_node
);
12024 if (avoid_folding_inline_builtin (fndecl
))
12026 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
12028 return targetm
.fold_builtin (fndecl
, nargs
, args
, ignore
);
12032 ret
= fold_builtin_n (loc
, NULL_TREE
, fndecl
, args
, nargs
, ignore
);
12035 /* Propagate location information from original call to
12036 expansion of builtin. Otherwise things like
12037 maybe_emit_chk_warning, that operate on the expansion
12038 of a builtin, will use the wrong location information. */
12039 if (gimple_has_location (stmt
))
12041 tree realret
= ret
;
12042 if (TREE_CODE (ret
) == NOP_EXPR
)
12043 realret
= TREE_OPERAND (ret
, 0);
12044 if (CAN_HAVE_LOCATION_P (realret
)
12045 && !EXPR_HAS_LOCATION (realret
))
12046 SET_EXPR_LOCATION (realret
, loc
);
12056 /* Look up the function in builtin_decl that corresponds to DECL
12057 and set ASMSPEC as its user assembler name. DECL must be a
12058 function decl that declares a builtin. */
12061 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
12063 gcc_assert (fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
12066 tree builtin
= builtin_decl_explicit (DECL_FUNCTION_CODE (decl
));
12067 set_user_assembler_name (builtin
, asmspec
);
12069 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_FFS
12070 && INT_TYPE_SIZE
< BITS_PER_WORD
)
12072 scalar_int_mode mode
= int_mode_for_size (INT_TYPE_SIZE
, 0).require ();
12073 set_user_assembler_libfunc ("ffs", asmspec
);
12074 set_optab_libfunc (ffs_optab
, mode
, "ffs");
12078 /* Return true if DECL is a builtin that expands to a constant or similarly
12081 is_simple_builtin (tree decl
)
12083 if (decl
&& fndecl_built_in_p (decl
, BUILT_IN_NORMAL
))
12084 switch (DECL_FUNCTION_CODE (decl
))
12086 /* Builtins that expand to constants. */
12087 case BUILT_IN_CONSTANT_P
:
12088 case BUILT_IN_EXPECT
:
12089 case BUILT_IN_OBJECT_SIZE
:
12090 case BUILT_IN_UNREACHABLE
:
12091 /* Simple register moves or loads from stack. */
12092 case BUILT_IN_ASSUME_ALIGNED
:
12093 case BUILT_IN_RETURN_ADDRESS
:
12094 case BUILT_IN_EXTRACT_RETURN_ADDR
:
12095 case BUILT_IN_FROB_RETURN_ADDR
:
12096 case BUILT_IN_RETURN
:
12097 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
12098 case BUILT_IN_FRAME_ADDRESS
:
12099 case BUILT_IN_VA_END
:
12100 case BUILT_IN_STACK_SAVE
:
12101 case BUILT_IN_STACK_RESTORE
:
12102 case BUILT_IN_DWARF_CFA
:
12103 /* Exception state returns or moves registers around. */
12104 case BUILT_IN_EH_FILTER
:
12105 case BUILT_IN_EH_POINTER
:
12106 case BUILT_IN_EH_COPY_VALUES
:
12116 /* Return true if DECL is a builtin that is not expensive, i.e., they are
12117 most probably expanded inline into reasonably simple code. This is a
12118 superset of is_simple_builtin. */
12120 is_inexpensive_builtin (tree decl
)
12124 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_MD
)
12126 else if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
12127 switch (DECL_FUNCTION_CODE (decl
))
12130 CASE_BUILT_IN_ALLOCA
:
12131 case BUILT_IN_BSWAP16
:
12132 case BUILT_IN_BSWAP32
:
12133 case BUILT_IN_BSWAP64
:
12134 case BUILT_IN_BSWAP128
:
12136 case BUILT_IN_CLZIMAX
:
12137 case BUILT_IN_CLZL
:
12138 case BUILT_IN_CLZLL
:
12140 case BUILT_IN_CTZIMAX
:
12141 case BUILT_IN_CTZL
:
12142 case BUILT_IN_CTZLL
:
12144 case BUILT_IN_FFSIMAX
:
12145 case BUILT_IN_FFSL
:
12146 case BUILT_IN_FFSLL
:
12147 case BUILT_IN_IMAXABS
:
12148 case BUILT_IN_FINITE
:
12149 case BUILT_IN_FINITEF
:
12150 case BUILT_IN_FINITEL
:
12151 case BUILT_IN_FINITED32
:
12152 case BUILT_IN_FINITED64
:
12153 case BUILT_IN_FINITED128
:
12154 case BUILT_IN_FPCLASSIFY
:
12155 case BUILT_IN_ISFINITE
:
12156 case BUILT_IN_ISINF_SIGN
:
12157 case BUILT_IN_ISINF
:
12158 case BUILT_IN_ISINFF
:
12159 case BUILT_IN_ISINFL
:
12160 case BUILT_IN_ISINFD32
:
12161 case BUILT_IN_ISINFD64
:
12162 case BUILT_IN_ISINFD128
:
12163 case BUILT_IN_ISNAN
:
12164 case BUILT_IN_ISNANF
:
12165 case BUILT_IN_ISNANL
:
12166 case BUILT_IN_ISNAND32
:
12167 case BUILT_IN_ISNAND64
:
12168 case BUILT_IN_ISNAND128
:
12169 case BUILT_IN_ISNORMAL
:
12170 case BUILT_IN_ISGREATER
:
12171 case BUILT_IN_ISGREATEREQUAL
:
12172 case BUILT_IN_ISLESS
:
12173 case BUILT_IN_ISLESSEQUAL
:
12174 case BUILT_IN_ISLESSGREATER
:
12175 case BUILT_IN_ISUNORDERED
:
12176 case BUILT_IN_ISEQSIG
:
12177 case BUILT_IN_VA_ARG_PACK
:
12178 case BUILT_IN_VA_ARG_PACK_LEN
:
12179 case BUILT_IN_VA_COPY
:
12180 case BUILT_IN_TRAP
:
12181 case BUILT_IN_UNREACHABLE_TRAP
:
12182 case BUILT_IN_SAVEREGS
:
12183 case BUILT_IN_POPCOUNTL
:
12184 case BUILT_IN_POPCOUNTLL
:
12185 case BUILT_IN_POPCOUNTIMAX
:
12186 case BUILT_IN_POPCOUNT
:
12187 case BUILT_IN_PARITYL
:
12188 case BUILT_IN_PARITYLL
:
12189 case BUILT_IN_PARITYIMAX
:
12190 case BUILT_IN_PARITY
:
12191 case BUILT_IN_LABS
:
12192 case BUILT_IN_LLABS
:
12193 case BUILT_IN_PREFETCH
:
12194 case BUILT_IN_ACC_ON_DEVICE
:
12198 return is_simple_builtin (decl
);
12204 /* Return true if T is a constant and the value cast to a target char
12205 can be represented by a host char.
12206 Store the casted char constant in *P if so. */
12209 target_char_cst_p (tree t
, char *p
)
12211 if (!tree_fits_uhwi_p (t
) || CHAR_TYPE_SIZE
!= HOST_BITS_PER_CHAR
)
12214 *p
= (char)tree_to_uhwi (t
);
12218 /* Return true if the builtin DECL is implemented in a standard library.
12219 Otherwise return false which doesn't guarantee it is not (thus the list
12220 of handled builtins below may be incomplete). */
12223 builtin_with_linkage_p (tree decl
)
12225 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
12226 switch (DECL_FUNCTION_CODE (decl
))
12228 CASE_FLT_FN (BUILT_IN_ACOS
):
12229 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ACOS
):
12230 CASE_FLT_FN (BUILT_IN_ACOSH
):
12231 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ACOSH
):
12232 CASE_FLT_FN (BUILT_IN_ASIN
):
12233 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ASIN
):
12234 CASE_FLT_FN (BUILT_IN_ASINH
):
12235 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ASINH
):
12236 CASE_FLT_FN (BUILT_IN_ATAN
):
12237 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ATAN
):
12238 CASE_FLT_FN (BUILT_IN_ATANH
):
12239 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ATANH
):
12240 CASE_FLT_FN (BUILT_IN_ATAN2
):
12241 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ATAN2
):
12242 CASE_FLT_FN (BUILT_IN_CBRT
):
12243 CASE_FLT_FN_FLOATN_NX (BUILT_IN_CBRT
):
12244 CASE_FLT_FN (BUILT_IN_CEIL
):
12245 CASE_FLT_FN_FLOATN_NX (BUILT_IN_CEIL
):
12246 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
12247 CASE_FLT_FN_FLOATN_NX (BUILT_IN_COPYSIGN
):
12248 CASE_FLT_FN (BUILT_IN_COS
):
12249 CASE_FLT_FN_FLOATN_NX (BUILT_IN_COS
):
12250 CASE_FLT_FN (BUILT_IN_COSH
):
12251 CASE_FLT_FN_FLOATN_NX (BUILT_IN_COSH
):
12252 CASE_FLT_FN (BUILT_IN_ERF
):
12253 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ERF
):
12254 CASE_FLT_FN (BUILT_IN_ERFC
):
12255 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ERFC
):
12256 CASE_FLT_FN (BUILT_IN_EXP
):
12257 CASE_FLT_FN_FLOATN_NX (BUILT_IN_EXP
):
12258 CASE_FLT_FN (BUILT_IN_EXP2
):
12259 CASE_FLT_FN_FLOATN_NX (BUILT_IN_EXP2
):
12260 CASE_FLT_FN (BUILT_IN_EXPM1
):
12261 CASE_FLT_FN_FLOATN_NX (BUILT_IN_EXPM1
):
12262 CASE_FLT_FN (BUILT_IN_FABS
):
12263 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FABS
):
12264 CASE_FLT_FN (BUILT_IN_FDIM
):
12265 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FDIM
):
12266 CASE_FLT_FN (BUILT_IN_FLOOR
):
12267 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FLOOR
):
12268 CASE_FLT_FN (BUILT_IN_FMA
):
12269 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMA
):
12270 CASE_FLT_FN (BUILT_IN_FMAX
):
12271 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMAX
):
12272 CASE_FLT_FN (BUILT_IN_FMIN
):
12273 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMIN
):
12274 CASE_FLT_FN (BUILT_IN_FMOD
):
12275 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FMOD
):
12276 CASE_FLT_FN (BUILT_IN_FREXP
):
12277 CASE_FLT_FN_FLOATN_NX (BUILT_IN_FREXP
):
12278 CASE_FLT_FN (BUILT_IN_HYPOT
):
12279 CASE_FLT_FN_FLOATN_NX (BUILT_IN_HYPOT
):
12280 CASE_FLT_FN (BUILT_IN_ILOGB
):
12281 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ILOGB
):
12282 CASE_FLT_FN (BUILT_IN_LDEXP
):
12283 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LDEXP
):
12284 CASE_FLT_FN (BUILT_IN_LGAMMA
):
12285 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LGAMMA
):
12286 CASE_FLT_FN (BUILT_IN_LLRINT
):
12287 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LLRINT
):
12288 CASE_FLT_FN (BUILT_IN_LLROUND
):
12289 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LLROUND
):
12290 CASE_FLT_FN (BUILT_IN_LOG
):
12291 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LOG
):
12292 CASE_FLT_FN (BUILT_IN_LOG10
):
12293 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LOG10
):
12294 CASE_FLT_FN (BUILT_IN_LOG1P
):
12295 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LOG1P
):
12296 CASE_FLT_FN (BUILT_IN_LOG2
):
12297 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LOG2
):
12298 CASE_FLT_FN (BUILT_IN_LOGB
):
12299 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LOGB
):
12300 CASE_FLT_FN (BUILT_IN_LRINT
):
12301 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LRINT
):
12302 CASE_FLT_FN (BUILT_IN_LROUND
):
12303 CASE_FLT_FN_FLOATN_NX (BUILT_IN_LROUND
):
12304 CASE_FLT_FN (BUILT_IN_MODF
):
12305 CASE_FLT_FN_FLOATN_NX (BUILT_IN_MODF
):
12306 CASE_FLT_FN (BUILT_IN_NAN
):
12307 CASE_FLT_FN_FLOATN_NX (BUILT_IN_NAN
):
12308 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
12309 CASE_FLT_FN_FLOATN_NX (BUILT_IN_NEARBYINT
):
12310 CASE_FLT_FN (BUILT_IN_NEXTAFTER
):
12311 CASE_FLT_FN_FLOATN_NX (BUILT_IN_NEXTAFTER
):
12312 CASE_FLT_FN (BUILT_IN_NEXTTOWARD
):
12313 CASE_FLT_FN (BUILT_IN_POW
):
12314 CASE_FLT_FN_FLOATN_NX (BUILT_IN_POW
):
12315 CASE_FLT_FN (BUILT_IN_REMAINDER
):
12316 CASE_FLT_FN_FLOATN_NX (BUILT_IN_REMAINDER
):
12317 CASE_FLT_FN (BUILT_IN_REMQUO
):
12318 CASE_FLT_FN_FLOATN_NX (BUILT_IN_REMQUO
):
12319 CASE_FLT_FN (BUILT_IN_RINT
):
12320 CASE_FLT_FN_FLOATN_NX (BUILT_IN_RINT
):
12321 CASE_FLT_FN (BUILT_IN_ROUND
):
12322 CASE_FLT_FN_FLOATN_NX (BUILT_IN_ROUND
):
12323 CASE_FLT_FN (BUILT_IN_SCALBLN
):
12324 CASE_FLT_FN_FLOATN_NX (BUILT_IN_SCALBLN
):
12325 CASE_FLT_FN (BUILT_IN_SCALBN
):
12326 CASE_FLT_FN_FLOATN_NX (BUILT_IN_SCALBN
):
12327 CASE_FLT_FN (BUILT_IN_SIN
):
12328 CASE_FLT_FN_FLOATN_NX (BUILT_IN_SIN
):
12329 CASE_FLT_FN (BUILT_IN_SINH
):
12330 CASE_FLT_FN_FLOATN_NX (BUILT_IN_SINH
):
12331 CASE_FLT_FN (BUILT_IN_SINCOS
):
12332 CASE_FLT_FN (BUILT_IN_SQRT
):
12333 CASE_FLT_FN_FLOATN_NX (BUILT_IN_SQRT
):
12334 CASE_FLT_FN (BUILT_IN_TAN
):
12335 CASE_FLT_FN_FLOATN_NX (BUILT_IN_TAN
):
12336 CASE_FLT_FN (BUILT_IN_TANH
):
12337 CASE_FLT_FN_FLOATN_NX (BUILT_IN_TANH
):
12338 CASE_FLT_FN (BUILT_IN_TGAMMA
):
12339 CASE_FLT_FN_FLOATN_NX (BUILT_IN_TGAMMA
):
12340 CASE_FLT_FN (BUILT_IN_TRUNC
):
12341 CASE_FLT_FN_FLOATN_NX (BUILT_IN_TRUNC
):
12344 case BUILT_IN_STPCPY
:
12345 case BUILT_IN_STPNCPY
:
12346 /* stpcpy is both referenced in libiberty's pex-win32.c and provided
12347 by libiberty's stpcpy.c for MinGW targets so we need to return true
12348 in order to be able to build libiberty in LTO mode for them. */
12357 /* Return true if OFFRNG is bounded to a subrange of offset values
12358 valid for the largest possible object. */
12361 access_ref::offset_bounded () const
12363 tree min
= TYPE_MIN_VALUE (ptrdiff_type_node
);
12364 tree max
= TYPE_MAX_VALUE (ptrdiff_type_node
);
12365 return wi::to_offset (min
) <= offrng
[0] && offrng
[1] <= wi::to_offset (max
);
12368 /* If CALLEE has known side effects, fill in INFO and return true.
12369 See tree-ssa-structalias.cc:find_func_aliases
12370 for the list of builtins we might need to handle here. */
12373 builtin_fnspec (tree callee
)
12375 built_in_function code
= DECL_FUNCTION_CODE (callee
);
12379 /* All the following functions read memory pointed to by
12380 their second argument and write memory pointed to by first
12382 strcat/strncat additionally reads memory pointed to by the first
12384 case BUILT_IN_STRCAT
:
12385 case BUILT_IN_STRCAT_CHK
:
12387 case BUILT_IN_STRNCAT
:
12388 case BUILT_IN_STRNCAT_CHK
:
12390 case BUILT_IN_STRCPY
:
12391 case BUILT_IN_STRCPY_CHK
:
12393 case BUILT_IN_STPCPY
:
12394 case BUILT_IN_STPCPY_CHK
:
12396 case BUILT_IN_STRNCPY
:
12397 case BUILT_IN_MEMCPY
:
12398 case BUILT_IN_MEMMOVE
:
12399 case BUILT_IN_TM_MEMCPY
:
12400 case BUILT_IN_TM_MEMMOVE
:
12401 case BUILT_IN_STRNCPY_CHK
:
12402 case BUILT_IN_MEMCPY_CHK
:
12403 case BUILT_IN_MEMMOVE_CHK
:
12405 case BUILT_IN_MEMPCPY
:
12406 case BUILT_IN_MEMPCPY_CHK
:
12408 case BUILT_IN_STPNCPY
:
12409 case BUILT_IN_STPNCPY_CHK
:
12411 case BUILT_IN_BCOPY
:
12413 case BUILT_IN_BZERO
:
12415 case BUILT_IN_MEMCMP
:
12416 case BUILT_IN_MEMCMP_EQ
:
12417 case BUILT_IN_BCMP
:
12418 case BUILT_IN_STRNCMP
:
12419 case BUILT_IN_STRNCMP_EQ
:
12420 case BUILT_IN_STRNCASECMP
:
12423 /* The following functions read memory pointed to by their
12425 CASE_BUILT_IN_TM_LOAD (1):
12426 CASE_BUILT_IN_TM_LOAD (2):
12427 CASE_BUILT_IN_TM_LOAD (4):
12428 CASE_BUILT_IN_TM_LOAD (8):
12429 CASE_BUILT_IN_TM_LOAD (FLOAT
):
12430 CASE_BUILT_IN_TM_LOAD (DOUBLE
):
12431 CASE_BUILT_IN_TM_LOAD (LDOUBLE
):
12432 CASE_BUILT_IN_TM_LOAD (M64
):
12433 CASE_BUILT_IN_TM_LOAD (M128
):
12434 CASE_BUILT_IN_TM_LOAD (M256
):
12435 case BUILT_IN_TM_LOG
:
12436 case BUILT_IN_TM_LOG_1
:
12437 case BUILT_IN_TM_LOG_2
:
12438 case BUILT_IN_TM_LOG_4
:
12439 case BUILT_IN_TM_LOG_8
:
12440 case BUILT_IN_TM_LOG_FLOAT
:
12441 case BUILT_IN_TM_LOG_DOUBLE
:
12442 case BUILT_IN_TM_LOG_LDOUBLE
:
12443 case BUILT_IN_TM_LOG_M64
:
12444 case BUILT_IN_TM_LOG_M128
:
12445 case BUILT_IN_TM_LOG_M256
:
12448 case BUILT_IN_INDEX
:
12449 case BUILT_IN_RINDEX
:
12450 case BUILT_IN_STRCHR
:
12451 case BUILT_IN_STRLEN
:
12452 case BUILT_IN_STRRCHR
:
12454 case BUILT_IN_STRNLEN
:
12457 /* These read memory pointed to by the first argument.
12458 Allocating memory does not have any side-effects apart from
12459 being the definition point for the pointer.
12460 Unix98 specifies that errno is set on allocation failure. */
12461 case BUILT_IN_STRDUP
:
12463 case BUILT_IN_STRNDUP
:
12465 /* Allocating memory does not have any side-effects apart from
12466 being the definition point for the pointer. */
12467 case BUILT_IN_MALLOC
:
12468 case BUILT_IN_ALIGNED_ALLOC
:
12469 case BUILT_IN_CALLOC
:
12470 case BUILT_IN_GOMP_ALLOC
:
12472 CASE_BUILT_IN_ALLOCA
:
12474 /* These read memory pointed to by the first argument with size
12475 in the third argument. */
12476 case BUILT_IN_MEMCHR
:
12478 /* These read memory pointed to by the first and second arguments. */
12479 case BUILT_IN_STRSTR
:
12480 case BUILT_IN_STRPBRK
:
12481 case BUILT_IN_STRCASECMP
:
12482 case BUILT_IN_STRCSPN
:
12483 case BUILT_IN_STRSPN
:
12484 case BUILT_IN_STRCMP
:
12485 case BUILT_IN_STRCMP_EQ
:
12487 /* Freeing memory kills the pointed-to memory. More importantly
12488 the call has to serve as a barrier for moving loads and stores
12490 case BUILT_IN_STACK_RESTORE
:
12491 case BUILT_IN_FREE
:
12492 case BUILT_IN_GOMP_FREE
:
12494 case BUILT_IN_VA_END
:
12496 /* Realloc serves both as allocation point and deallocation point. */
12497 case BUILT_IN_REALLOC
:
12498 case BUILT_IN_GOMP_REALLOC
:
12500 case BUILT_IN_GAMMA_R
:
12501 case BUILT_IN_GAMMAF_R
:
12502 case BUILT_IN_GAMMAL_R
:
12503 case BUILT_IN_LGAMMA_R
:
12504 case BUILT_IN_LGAMMAF_R
:
12505 case BUILT_IN_LGAMMAL_R
:
12507 case BUILT_IN_FREXP
:
12508 case BUILT_IN_FREXPF
:
12509 case BUILT_IN_FREXPL
:
12510 case BUILT_IN_MODF
:
12511 case BUILT_IN_MODFF
:
12512 case BUILT_IN_MODFL
:
12514 case BUILT_IN_REMQUO
:
12515 case BUILT_IN_REMQUOF
:
12516 case BUILT_IN_REMQUOL
:
12518 case BUILT_IN_SINCOS
:
12519 case BUILT_IN_SINCOSF
:
12520 case BUILT_IN_SINCOSL
:
12522 case BUILT_IN_MEMSET
:
12523 case BUILT_IN_MEMSET_CHK
:
12524 case BUILT_IN_TM_MEMSET
:
12526 CASE_BUILT_IN_TM_STORE (1):
12527 CASE_BUILT_IN_TM_STORE (2):
12528 CASE_BUILT_IN_TM_STORE (4):
12529 CASE_BUILT_IN_TM_STORE (8):
12530 CASE_BUILT_IN_TM_STORE (FLOAT
):
12531 CASE_BUILT_IN_TM_STORE (DOUBLE
):
12532 CASE_BUILT_IN_TM_STORE (LDOUBLE
):
12533 CASE_BUILT_IN_TM_STORE (M64
):
12534 CASE_BUILT_IN_TM_STORE (M128
):
12535 CASE_BUILT_IN_TM_STORE (M256
):
12537 case BUILT_IN_STACK_SAVE
:
12538 case BUILT_IN_RETURN
:
12539 case BUILT_IN_EH_POINTER
:
12540 case BUILT_IN_EH_FILTER
:
12541 case BUILT_IN_UNWIND_RESUME
:
12542 case BUILT_IN_CXA_END_CLEANUP
:
12543 case BUILT_IN_EH_COPY_VALUES
:
12544 case BUILT_IN_FRAME_ADDRESS
:
12545 case BUILT_IN_APPLY_ARGS
:
12546 case BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT
:
12547 case BUILT_IN_ASAN_AFTER_DYNAMIC_INIT
:
12548 case BUILT_IN_PREFETCH
:
12549 case BUILT_IN_DWARF_CFA
:
12550 case BUILT_IN_RETURN_ADDRESS
:
12552 case BUILT_IN_ASSUME_ALIGNED
:
12553 case BUILT_IN_EXPECT
:
12554 case BUILT_IN_EXPECT_WITH_PROBABILITY
:
12556 /* But posix_memalign stores a pointer into the memory pointed to
12557 by its first argument. */
12558 case BUILT_IN_POSIX_MEMALIGN
: