1 /* Expand builtin functions.
2 Copyright (C) 1988-2016 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.c instead. */
26 #include "coretypes.h"
35 #include "stringpool.h"
36 #include "tree-ssanames.h"
41 #include "diagnostic-core.h"
43 #include "fold-const.h"
44 #include "fold-const-call.h"
45 #include "stor-layout.h"
48 #include "tree-object-size.h"
58 #include "typeclass.h"
59 #include "langhooks.h"
60 #include "value-prof.h"
64 #include "tree-chkp.h"
66 #include "internal-fn.h"
67 #include "case-cfn-macros.h"
70 struct target_builtins default_target_builtins;
72 struct target_builtins *this_target_builtins = &default_target_builtins;
75 /* Define the names of the builtin function types and codes. */
76 const char *const built_in_class_names[BUILT_IN_LAST]
77 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
79 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
80 const char * built_in_names[(int) END_BUILTINS] =
82 #include "builtins.def"
85 /* Setup an array of builtin_info_type, make sure each element decl is
86 initialized to NULL_TREE. */
87 builtin_info_type builtin_info[(int)END_BUILTINS];
89 /* Non-zero if __builtin_constant_p should be folded right away. */
90 bool force_folding_builtin_constant_p;
92 static rtx c_readstr (const char *, machine_mode);
93 static int target_char_cast (tree, char *);
94 static rtx get_memory_rtx (tree, tree);
95 static int apply_args_size (void);
96 static int apply_result_size (void);
97 static rtx result_vector (int, rtx);
98 static void expand_builtin_prefetch (tree);
99 static rtx expand_builtin_apply_args (void);
100 static rtx expand_builtin_apply_args_1 (void);
101 static rtx expand_builtin_apply (rtx, rtx, rtx);
102 static void expand_builtin_return (rtx);
103 static enum type_class type_to_class (tree);
104 static rtx expand_builtin_classify_type (tree);
105 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
106 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
107 static rtx expand_builtin_interclass_mathfn (tree, rtx);
108 static rtx expand_builtin_sincos (tree);
109 static rtx expand_builtin_cexpi (tree, rtx);
110 static rtx expand_builtin_int_roundingfn (tree, rtx);
111 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
112 static rtx expand_builtin_next_arg (void);
113 static rtx expand_builtin_va_start (tree);
114 static rtx expand_builtin_va_end (tree);
115 static rtx expand_builtin_va_copy (tree);
116 static rtx expand_builtin_strcmp (tree, rtx);
117 static rtx expand_builtin_strncmp (tree, rtx, machine_mode);
118 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, machine_mode);
119 static rtx expand_builtin_memcpy (tree, rtx);
120 static rtx expand_builtin_memcpy_with_bounds (tree, rtx);
121 static rtx expand_builtin_memcpy_args (tree, tree, tree, rtx, tree);
122 static rtx expand_builtin_mempcpy (tree, rtx, machine_mode);
123 static rtx expand_builtin_mempcpy_with_bounds (tree, rtx, machine_mode);
124 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
125 machine_mode, int, tree);
126 static rtx expand_builtin_strcpy (tree, rtx);
127 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
128 static rtx expand_builtin_stpcpy (tree, rtx, machine_mode);
129 static rtx expand_builtin_strncpy (tree, rtx);
130 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, machine_mode);
131 static rtx expand_builtin_memset (tree, rtx, machine_mode);
132 static rtx expand_builtin_memset_with_bounds (tree, rtx, machine_mode);
133 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, machine_mode, tree);
134 static rtx expand_builtin_bzero (tree);
135 static rtx expand_builtin_strlen (tree, rtx, machine_mode);
136 static rtx expand_builtin_alloca (tree, bool);
137 static rtx expand_builtin_unop (machine_mode, tree, rtx, rtx, optab);
138 static rtx expand_builtin_frame_address (tree, tree);
139 static tree stabilize_va_list_loc (location_t, tree, int);
140 static rtx expand_builtin_expect (tree, rtx);
141 static tree fold_builtin_constant_p (tree);
142 static tree fold_builtin_classify_type (tree);
143 static tree fold_builtin_strlen (location_t, tree, tree);
144 static tree fold_builtin_inf (location_t, tree, int);
145 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
146 static bool validate_arg (const_tree, enum tree_code code);
147 static rtx expand_builtin_fabs (tree, rtx, rtx);
148 static rtx expand_builtin_signbit (tree, rtx);
149 static tree fold_builtin_strchr (location_t, tree, tree, tree);
150 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
151 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
152 static tree fold_builtin_strcmp (location_t, tree, tree);
153 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
154 static tree fold_builtin_isascii (location_t, tree);
155 static tree fold_builtin_toascii (location_t, tree);
156 static tree fold_builtin_isdigit (location_t, tree);
157 static tree fold_builtin_fabs (location_t, tree, tree);
158 static tree fold_builtin_abs (location_t, tree, tree);
159 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
161 static tree fold_builtin_0 (location_t, tree);
162 static tree fold_builtin_1 (location_t, tree, tree);
163 static tree fold_builtin_2 (location_t, tree, tree, tree);
164 static tree fold_builtin_3 (location_t, tree, tree, tree, tree);
165 static tree fold_builtin_varargs (location_t, tree, tree*, int);
167 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
168 static tree fold_builtin_strstr (location_t, tree, tree, tree);
169 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
170 static tree fold_builtin_strspn (location_t, tree, tree);
171 static tree fold_builtin_strcspn (location_t, tree, tree);
173 static rtx expand_builtin_object_size (tree);
174 static rtx expand_builtin_memory_chk (tree, rtx, machine_mode,
175 enum built_in_function);
176 static void maybe_emit_chk_warning (tree, enum built_in_function);
177 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
178 static void maybe_emit_free_warning (tree);
179 static tree fold_builtin_object_size (tree, tree);
181 unsigned HOST_WIDE_INT target_newline;
182 unsigned HOST_WIDE_INT target_percent;
183 static unsigned HOST_WIDE_INT target_c;
184 static unsigned HOST_WIDE_INT target_s;
185 char target_percent_c[3];
186 char target_percent_s[3];
187 char target_percent_s_newline[4];
188 static tree do_mpfr_remquo (tree, tree, tree);
189 static tree do_mpfr_lgamma_r (tree, tree, tree);
190 static void expand_builtin_sync_synchronize (void);
192 /* Return true if NAME starts with __builtin_ or __sync_. */
195 is_builtin_name (const char *name)
197 if (strncmp (name, "__builtin_", 10) == 0)
199 if (strncmp (name, "__sync_", 7) == 0)
201 if (strncmp (name, "__atomic_", 9) == 0)
204 && (!strcmp (name, "__cilkrts_detach")
205 || !strcmp (name, "__cilkrts_pop_frame")))
211 /* Return true if DECL is a function symbol representing a built-in. */
214 is_builtin_fn (tree decl)
216 return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
219 /* Return true if NODE should be considered for inline expansion regardless
220 of the optimization level. This means whenever a function is invoked with
221 its "internal" name, which normally contains the prefix "__builtin". */
224 called_as_built_in (tree node)
226 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
227 we want the name used to call the function, not the name it
229 const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
230 return is_builtin_name (name);
233 /* Compute values M and N such that M divides (address of EXP - N) and such
234 that N < M. If these numbers can be determined, store M in alignp and N in
235 *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to
236 *alignp and any bit-offset to *bitposp.
238 Note that the address (and thus the alignment) computed here is based
239 on the address to which a symbol resolves, whereas DECL_ALIGN is based
240 on the address at which an object is actually located. These two
241 addresses are not always the same. For example, on ARM targets,
242 the address &foo of a Thumb function foo() has the lowest bit set,
243 whereas foo() itself starts on an even address.
245 If ADDR_P is true we are taking the address of the memory reference EXP
246 and thus cannot rely on the access taking place. */
249 get_object_alignment_2 (tree exp, unsigned int *alignp,
250 unsigned HOST_WIDE_INT *bitposp, bool addr_p)
252 HOST_WIDE_INT bitsize, bitpos;
255 int unsignedp, reversep, volatilep;
256 unsigned int align = BITS_PER_UNIT;
257 bool known_alignment = false;
259 /* Get the innermost object and the constant (bitpos) and possibly
260 variable (offset) offset of the access. */
261 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
262 &unsignedp, &reversep, &volatilep, true);
264 /* Extract alignment information from the innermost object and
265 possibly adjust bitpos and offset. */
266 if (TREE_CODE (exp) == FUNCTION_DECL)
268 /* Function addresses can encode extra information besides their
269 alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
270 allows the low bit to be used as a virtual bit, we know
271 that the address itself must be at least 2-byte aligned. */
272 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)
273 align = 2 * BITS_PER_UNIT;
275 else if (TREE_CODE (exp) == LABEL_DECL)
277 else if (TREE_CODE (exp) == CONST_DECL)
279 /* The alignment of a CONST_DECL is determined by its initializer. */
280 exp = DECL_INITIAL (exp);
281 align = TYPE_ALIGN (TREE_TYPE (exp));
282 if (CONSTANT_CLASS_P (exp))
283 align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
285 known_alignment = true;
287 else if (DECL_P (exp))
289 align = DECL_ALIGN (exp);
290 known_alignment = true;
292 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
294 align = TYPE_ALIGN (TREE_TYPE (exp));
296 else if (TREE_CODE (exp) == INDIRECT_REF
297 || TREE_CODE (exp) == MEM_REF
298 || TREE_CODE (exp) == TARGET_MEM_REF)
300 tree addr = TREE_OPERAND (exp, 0);
302 unsigned HOST_WIDE_INT ptr_bitpos;
303 unsigned HOST_WIDE_INT ptr_bitmask = ~0;
305 /* If the address is explicitely aligned, handle that. */
306 if (TREE_CODE (addr) == BIT_AND_EXPR
307 && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
309 ptr_bitmask = TREE_INT_CST_LOW (TREE_OPERAND (addr, 1));
310 ptr_bitmask *= BITS_PER_UNIT;
311 align = ptr_bitmask & -ptr_bitmask;
312 addr = TREE_OPERAND (addr, 0);
316 = get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos);
317 align = MAX (ptr_align, align);
319 /* Re-apply explicit alignment to the bitpos. */
320 ptr_bitpos &= ptr_bitmask;
322 /* The alignment of the pointer operand in a TARGET_MEM_REF
323 has to take the variable offset parts into account. */
324 if (TREE_CODE (exp) == TARGET_MEM_REF)
328 unsigned HOST_WIDE_INT step = 1;
330 step = TREE_INT_CST_LOW (TMR_STEP (exp));
331 align = MIN (align, (step & -step) * BITS_PER_UNIT);
333 if (TMR_INDEX2 (exp))
334 align = BITS_PER_UNIT;
335 known_alignment = false;
338 /* When EXP is an actual memory reference then we can use
339 TYPE_ALIGN of a pointer indirection to derive alignment.
340 Do so only if get_pointer_alignment_1 did not reveal absolute
341 alignment knowledge and if using that alignment would
342 improve the situation. */
343 if (!addr_p && !known_alignment
344 && TYPE_ALIGN (TREE_TYPE (exp)) > align)
345 align = TYPE_ALIGN (TREE_TYPE (exp));
348 /* Else adjust bitpos accordingly. */
349 bitpos += ptr_bitpos;
350 if (TREE_CODE (exp) == MEM_REF
351 || TREE_CODE (exp) == TARGET_MEM_REF)
352 bitpos += mem_ref_offset (exp).to_short_addr () * BITS_PER_UNIT;
355 else if (TREE_CODE (exp) == STRING_CST)
357 /* STRING_CST are the only constant objects we allow to be not
358 wrapped inside a CONST_DECL. */
359 align = TYPE_ALIGN (TREE_TYPE (exp));
360 if (CONSTANT_CLASS_P (exp))
361 align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
363 known_alignment = true;
366 /* If there is a non-constant offset part extract the maximum
367 alignment that can prevail. */
370 unsigned int trailing_zeros = tree_ctz (offset);
371 if (trailing_zeros < HOST_BITS_PER_INT)
373 unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT;
375 align = MIN (align, inner);
380 *bitposp = bitpos & (*alignp - 1);
381 return known_alignment;
384 /* For a memory reference expression EXP compute values M and N such that M
385 divides (&EXP - N) and such that N < M. If these numbers can be determined,
386 store M in alignp and N in *BITPOSP and return true. Otherwise return false
387 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
390 get_object_alignment_1 (tree exp, unsigned int *alignp,
391 unsigned HOST_WIDE_INT *bitposp)
393 return get_object_alignment_2 (exp, alignp, bitposp, false);
396 /* Return the alignment in bits of EXP, an object. */
399 get_object_alignment (tree exp)
401 unsigned HOST_WIDE_INT bitpos = 0;
404 get_object_alignment_1 (exp, &align, &bitpos);
406 /* align and bitpos now specify known low bits of the pointer.
407 ptr & (align - 1) == bitpos. */
410 align = (bitpos & -bitpos);
414 /* For a pointer valued expression EXP compute values M and N such that M
415 divides (EXP - N) and such that N < M. If these numbers can be determined,
416 store M in alignp and N in *BITPOSP and return true. Return false if
417 the results are just a conservative approximation.
419 If EXP is not a pointer, false is returned too. */
422 get_pointer_alignment_1 (tree exp, unsigned int *alignp,
423 unsigned HOST_WIDE_INT *bitposp)
427 if (TREE_CODE (exp) == ADDR_EXPR)
428 return get_object_alignment_2 (TREE_OPERAND (exp, 0),
429 alignp, bitposp, true);
430 else if (TREE_CODE (exp) == POINTER_PLUS_EXPR)
433 unsigned HOST_WIDE_INT bitpos;
434 bool res = get_pointer_alignment_1 (TREE_OPERAND (exp, 0),
436 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
437 bitpos += TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) * BITS_PER_UNIT;
440 unsigned int trailing_zeros = tree_ctz (TREE_OPERAND (exp, 1));
441 if (trailing_zeros < HOST_BITS_PER_INT)
443 unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT;
445 align = MIN (align, inner);
449 *bitposp = bitpos & (align - 1);
452 else if (TREE_CODE (exp) == SSA_NAME
453 && POINTER_TYPE_P (TREE_TYPE (exp)))
455 unsigned int ptr_align, ptr_misalign;
456 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
458 if (pi && get_ptr_info_alignment (pi, &ptr_align, &ptr_misalign))
460 *bitposp = ptr_misalign * BITS_PER_UNIT;
461 *alignp = ptr_align * BITS_PER_UNIT;
462 /* Make sure to return a sensible alignment when the multiplication
463 by BITS_PER_UNIT overflowed. */
465 *alignp = 1u << (HOST_BITS_PER_INT - 1);
466 /* We cannot really tell whether this result is an approximation. */
472 *alignp = BITS_PER_UNIT;
476 else if (TREE_CODE (exp) == INTEGER_CST)
478 *alignp = BIGGEST_ALIGNMENT;
479 *bitposp = ((TREE_INT_CST_LOW (exp) * BITS_PER_UNIT)
480 & (BIGGEST_ALIGNMENT - 1));
485 *alignp = BITS_PER_UNIT;
489 /* Return the alignment in bits of EXP, a pointer valued expression.
490 The alignment returned is, by default, the alignment of the thing that
491 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
493 Otherwise, look at the expression to see if we can do better, i.e., if the
494 expression is actually pointing at an object whose alignment is tighter. */
497 get_pointer_alignment (tree exp)
499 unsigned HOST_WIDE_INT bitpos = 0;
502 get_pointer_alignment_1 (exp, &align, &bitpos);
504 /* align and bitpos now specify known low bits of the pointer.
505 ptr & (align - 1) == bitpos. */
508 align = (bitpos & -bitpos);
513 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
514 way, because it could contain a zero byte in the middle.
515 TREE_STRING_LENGTH is the size of the character array, not the string.
517 ONLY_VALUE should be nonzero if the result is not going to be emitted
518 into the instruction stream and zero if it is going to be expanded.
519 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
520 is returned, otherwise NULL, since
521 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
522 evaluate the side-effects.
524 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
525 accesses. Note that this implies the result is not going to be emitted
526 into the instruction stream.
528 The value returned is of type `ssizetype'.
530 Unfortunately, string_constant can't access the values of const char
531 arrays with initializers, so neither can we do so here. */
534 c_strlen (tree src, int only_value)
537 HOST_WIDE_INT offset;
543 if (TREE_CODE (src) == COND_EXPR
544 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
548 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
549 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
550 if (tree_int_cst_equal (len1, len2))
554 if (TREE_CODE (src) == COMPOUND_EXPR
555 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
556 return c_strlen (TREE_OPERAND (src, 1), only_value);
558 loc = EXPR_LOC_OR_LOC (src, input_location);
560 src = string_constant (src, &offset_node);
564 max = TREE_STRING_LENGTH (src) - 1;
565 ptr = TREE_STRING_POINTER (src);
567 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
569 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
570 compute the offset to the following null if we don't know where to
571 start searching for it. */
574 for (i = 0; i < max; i++)
578 /* We don't know the starting offset, but we do know that the string
579 has no internal zero bytes. We can assume that the offset falls
580 within the bounds of the string; otherwise, the programmer deserves
581 what he gets. Subtract the offset from the length of the string,
582 and return that. This would perhaps not be valid if we were dealing
583 with named arrays in addition to literal string constants. */
585 return size_diffop_loc (loc, size_int (max), offset_node);
588 /* We have a known offset into the string. Start searching there for
589 a null character if we can represent it as a single HOST_WIDE_INT. */
590 if (offset_node == 0)
592 else if (! tree_fits_shwi_p (offset_node))
595 offset = tree_to_shwi (offset_node);
597 /* If the offset is known to be out of bounds, warn, and call strlen at
599 if (offset < 0 || offset > max)
601 /* Suppress multiple warnings for propagated constant strings. */
603 && !TREE_NO_WARNING (src))
605 warning_at (loc, 0, "offset outside bounds of constant string");
606 TREE_NO_WARNING (src) = 1;
611 /* Use strlen to search for the first zero byte. Since any strings
612 constructed with build_string will have nulls appended, we win even
613 if we get handed something like (char[4])"abcd".
615 Since OFFSET is our starting index into the string, no further
616 calculation is needed. */
617 return ssize_int (strlen (ptr + offset));
620 /* Return a constant integer corresponding to target reading
621 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
624 c_readstr (const char *str, machine_mode mode)
628 HOST_WIDE_INT tmp[MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT];
630 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
631 unsigned int len = (GET_MODE_PRECISION (mode) + HOST_BITS_PER_WIDE_INT - 1)
632 / HOST_BITS_PER_WIDE_INT;
634 gcc_assert (len <= MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT);
635 for (i = 0; i < len; i++)
639 for (i = 0; i < GET_MODE_SIZE (mode); i++)
642 if (WORDS_BIG_ENDIAN)
643 j = GET_MODE_SIZE (mode) - i - 1;
644 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
645 && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
646 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
650 ch = (unsigned char) str[i];
651 tmp[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
654 wide_int c = wide_int::from_array (tmp, len, GET_MODE_PRECISION (mode));
655 return immed_wide_int_const (c, mode);
658 /* Cast a target constant CST to target CHAR and if that value fits into
659 host char type, return zero and put that value into variable pointed to by
663 target_char_cast (tree cst, char *p)
665 unsigned HOST_WIDE_INT val, hostval;
667 if (TREE_CODE (cst) != INTEGER_CST
668 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
671 /* Do not care if it fits or not right here. */
672 val = TREE_INT_CST_LOW (cst);
674 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
675 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
678 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
679 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
688 /* Similar to save_expr, but assumes that arbitrary code is not executed
689 in between the multiple evaluations. In particular, we assume that a
690 non-addressable local variable will not be modified. */
693 builtin_save_expr (tree exp)
695 if (TREE_CODE (exp) == SSA_NAME
696 || (TREE_ADDRESSABLE (exp) == 0
697 && (TREE_CODE (exp) == PARM_DECL
698 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
701 return save_expr (exp);
704 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
705 times to get the address of either a higher stack frame, or a return
706 address located within it (depending on FNDECL_CODE). */
709 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
712 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
715 /* For a zero count with __builtin_return_address, we don't care what
716 frame address we return, because target-specific definitions will
717 override us. Therefore frame pointer elimination is OK, and using
718 the soft frame pointer is OK.
720 For a nonzero count, or a zero count with __builtin_frame_address,
721 we require a stable offset from the current frame pointer to the
722 previous one, so we must use the hard frame pointer, and
723 we must disable frame pointer elimination. */
724 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
725 tem = frame_pointer_rtx;
728 tem = hard_frame_pointer_rtx;
730 /* Tell reload not to eliminate the frame pointer. */
731 crtl->accesses_prior_frames = 1;
736 SETUP_FRAME_ADDRESSES ();
738 /* On the SPARC, the return address is not in the frame, it is in a
739 register. There is no way to access it off of the current frame
740 pointer, but it can be accessed off the previous frame pointer by
741 reading the value from the register window save area. */
742 if (RETURN_ADDR_IN_PREVIOUS_FRAME && fndecl_code == BUILT_IN_RETURN_ADDRESS)
745 /* Scan back COUNT frames to the specified frame. */
746 for (i = 0; i < count; i++)
748 /* Assume the dynamic chain pointer is in the word that the
749 frame address points to, unless otherwise specified. */
750 tem = DYNAMIC_CHAIN_ADDRESS (tem);
751 tem = memory_address (Pmode, tem);
752 tem = gen_frame_mem (Pmode, tem);
753 tem = copy_to_reg (tem);
756 /* For __builtin_frame_address, return what we've got. But, on
757 the SPARC for example, we may have to add a bias. */
758 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
759 return FRAME_ADDR_RTX (tem);
761 /* For __builtin_return_address, get the return address from that frame. */
762 #ifdef RETURN_ADDR_RTX
763 tem = RETURN_ADDR_RTX (count, tem);
765 tem = memory_address (Pmode,
766 plus_constant (Pmode, tem, GET_MODE_SIZE (Pmode)));
767 tem = gen_frame_mem (Pmode, tem);
772 /* Alias set used for setjmp buffer. */
773 static alias_set_type setjmp_alias_set = -1;
775 /* Construct the leading half of a __builtin_setjmp call. Control will
776 return to RECEIVER_LABEL. This is also called directly by the SJLJ
777 exception handling code. */
780 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
782 machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
786 if (setjmp_alias_set == -1)
787 setjmp_alias_set = new_alias_set ();
789 buf_addr = convert_memory_address (Pmode, buf_addr);
791 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
793 /* We store the frame pointer and the address of receiver_label in
794 the buffer and use the rest of it for the stack save area, which
795 is machine-dependent. */
797 mem = gen_rtx_MEM (Pmode, buf_addr);
798 set_mem_alias_set (mem, setjmp_alias_set);
799 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
801 mem = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr,
802 GET_MODE_SIZE (Pmode))),
803 set_mem_alias_set (mem, setjmp_alias_set);
805 emit_move_insn (validize_mem (mem),
806 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
808 stack_save = gen_rtx_MEM (sa_mode,
809 plus_constant (Pmode, buf_addr,
810 2 * GET_MODE_SIZE (Pmode)));
811 set_mem_alias_set (stack_save, setjmp_alias_set);
812 emit_stack_save (SAVE_NONLOCAL, &stack_save);
814 /* If there is further processing to do, do it. */
815 if (targetm.have_builtin_setjmp_setup ())
816 emit_insn (targetm.gen_builtin_setjmp_setup (buf_addr));
818 /* We have a nonlocal label. */
819 cfun->has_nonlocal_label = 1;
822 /* Construct the trailing part of a __builtin_setjmp call. This is
823 also called directly by the SJLJ exception handling code.
824 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
827 expand_builtin_setjmp_receiver (rtx receiver_label)
831 /* Mark the FP as used when we get here, so we have to make sure it's
832 marked as used by this function. */
833 emit_use (hard_frame_pointer_rtx);
835 /* Mark the static chain as clobbered here so life information
836 doesn't get messed up for it. */
837 chain = targetm.calls.static_chain (current_function_decl, true);
838 if (chain && REG_P (chain))
839 emit_clobber (chain);
841 /* Now put in the code to restore the frame pointer, and argument
842 pointer, if needed. */
843 if (! targetm.have_nonlocal_goto ())
845 /* First adjust our frame pointer to its actual value. It was
846 previously set to the start of the virtual area corresponding to
847 the stacked variables when we branched here and now needs to be
848 adjusted to the actual hardware fp value.
850 Assignments to virtual registers are converted by
851 instantiate_virtual_regs into the corresponding assignment
852 to the underlying register (fp in this case) that makes
853 the original assignment true.
854 So the following insn will actually be decrementing fp by
855 STARTING_FRAME_OFFSET. */
856 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
858 /* Restoring the frame pointer also modifies the hard frame pointer.
859 Mark it used (so that the previous assignment remains live once
860 the frame pointer is eliminated) and clobbered (to represent the
861 implicit update from the assignment). */
862 emit_use (hard_frame_pointer_rtx);
863 emit_clobber (hard_frame_pointer_rtx);
866 if (!HARD_FRAME_POINTER_IS_ARG_POINTER && fixed_regs[ARG_POINTER_REGNUM])
868 #ifdef ELIMINABLE_REGS
869 /* If the argument pointer can be eliminated in favor of the
870 frame pointer, we don't need to restore it. We assume here
871 that if such an elimination is present, it can always be used.
872 This is the case on all known machines; if we don't make this
873 assumption, we do unnecessary saving on many machines. */
875 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
877 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
878 if (elim_regs[i].from == ARG_POINTER_REGNUM
879 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
882 if (i == ARRAY_SIZE (elim_regs))
885 /* Now restore our arg pointer from the address at which it
886 was saved in our stack frame. */
887 emit_move_insn (crtl->args.internal_arg_pointer,
888 copy_to_reg (get_arg_pointer_save_area ()));
892 if (receiver_label != NULL && targetm.have_builtin_setjmp_receiver ())
893 emit_insn (targetm.gen_builtin_setjmp_receiver (receiver_label));
894 else if (targetm.have_nonlocal_goto_receiver ())
895 emit_insn (targetm.gen_nonlocal_goto_receiver ());
899 /* We must not allow the code we just generated to be reordered by
900 scheduling. Specifically, the update of the frame pointer must
901 happen immediately, not later. */
902 emit_insn (gen_blockage ());
905 /* __builtin_longjmp is passed a pointer to an array of five words (not
906 all will be used on all machines). It operates similarly to the C
907 library function of the same name, but is more efficient. Much of
908 the code below is copied from the handling of non-local gotos. */
911 expand_builtin_longjmp (rtx buf_addr, rtx value)
914 rtx_insn *insn, *last;
915 machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
917 /* DRAP is needed for stack realign if longjmp is expanded to current
919 if (SUPPORTS_STACK_ALIGNMENT)
920 crtl->need_drap = true;
922 if (setjmp_alias_set == -1)
923 setjmp_alias_set = new_alias_set ();
925 buf_addr = convert_memory_address (Pmode, buf_addr);
927 buf_addr = force_reg (Pmode, buf_addr);
929 /* We require that the user must pass a second argument of 1, because
930 that is what builtin_setjmp will return. */
931 gcc_assert (value == const1_rtx);
933 last = get_last_insn ();
934 if (targetm.have_builtin_longjmp ())
935 emit_insn (targetm.gen_builtin_longjmp (buf_addr));
938 fp = gen_rtx_MEM (Pmode, buf_addr);
939 lab = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr,
940 GET_MODE_SIZE (Pmode)));
942 stack = gen_rtx_MEM (sa_mode, plus_constant (Pmode, buf_addr,
943 2 * GET_MODE_SIZE (Pmode)));
944 set_mem_alias_set (fp, setjmp_alias_set);
945 set_mem_alias_set (lab, setjmp_alias_set);
946 set_mem_alias_set (stack, setjmp_alias_set);
948 /* Pick up FP, label, and SP from the block and jump. This code is
949 from expand_goto in stmt.c; see there for detailed comments. */
950 if (targetm.have_nonlocal_goto ())
951 /* We have to pass a value to the nonlocal_goto pattern that will
952 get copied into the static_chain pointer, but it does not matter
953 what that value is, because builtin_setjmp does not use it. */
954 emit_insn (targetm.gen_nonlocal_goto (value, lab, stack, fp));
957 lab = copy_to_reg (lab);
959 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
960 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
962 emit_move_insn (hard_frame_pointer_rtx, fp);
963 emit_stack_restore (SAVE_NONLOCAL, stack);
965 emit_use (hard_frame_pointer_rtx);
966 emit_use (stack_pointer_rtx);
967 emit_indirect_jump (lab);
971 /* Search backwards and mark the jump insn as a non-local goto.
972 Note that this precludes the use of __builtin_longjmp to a
973 __builtin_setjmp target in the same function. However, we've
974 already cautioned the user that these functions are for
975 internal exception handling use only. */
976 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
978 gcc_assert (insn != last);
982 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
985 else if (CALL_P (insn))
991 more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter)
993 return (iter->i < iter->n);
996 /* This function validates the types of a function call argument list
997 against a specified list of tree_codes. If the last specifier is a 0,
998 that represents an ellipses, otherwise the last specifier must be a
1002 validate_arglist (const_tree callexpr, ...)
1004 enum tree_code code;
1007 const_call_expr_arg_iterator iter;
1010 va_start (ap, callexpr);
1011 init_const_call_expr_arg_iterator (callexpr, &iter);
1015 code = (enum tree_code) va_arg (ap, int);
1019 /* This signifies an ellipses, any further arguments are all ok. */
1023 /* This signifies an endlink, if no arguments remain, return
1024 true, otherwise return false. */
1025 res = !more_const_call_expr_args_p (&iter);
1028 /* If no parameters remain or the parameter's code does not
1029 match the specified code, return false. Otherwise continue
1030 checking any remaining arguments. */
1031 arg = next_const_call_expr_arg (&iter);
1032 if (!validate_arg (arg, code))
1039 /* We need gotos here since we can only have one VA_CLOSE in a
1047 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1048 and the address of the save area. */
1051 expand_builtin_nonlocal_goto (tree exp)
1053 tree t_label, t_save_area;
1054 rtx r_label, r_save_area, r_fp, r_sp;
1057 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1060 t_label = CALL_EXPR_ARG (exp, 0);
1061 t_save_area = CALL_EXPR_ARG (exp, 1);
1063 r_label = expand_normal (t_label);
1064 r_label = convert_memory_address (Pmode, r_label);
1065 r_save_area = expand_normal (t_save_area);
1066 r_save_area = convert_memory_address (Pmode, r_save_area);
1067 /* Copy the address of the save location to a register just in case it was
1068 based on the frame pointer. */
1069 r_save_area = copy_to_reg (r_save_area);
1070 r_fp = gen_rtx_MEM (Pmode, r_save_area);
1071 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
1072 plus_constant (Pmode, r_save_area,
1073 GET_MODE_SIZE (Pmode)));
1075 crtl->has_nonlocal_goto = 1;
1077 /* ??? We no longer need to pass the static chain value, afaik. */
1078 if (targetm.have_nonlocal_goto ())
1079 emit_insn (targetm.gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1082 r_label = copy_to_reg (r_label);
1084 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1085 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1087 /* Restore frame pointer for containing function. */
1088 emit_move_insn (hard_frame_pointer_rtx, r_fp);
1089 emit_stack_restore (SAVE_NONLOCAL, r_sp);
1091 /* USE of hard_frame_pointer_rtx added for consistency;
1092 not clear if really needed. */
1093 emit_use (hard_frame_pointer_rtx);
1094 emit_use (stack_pointer_rtx);
1096 /* If the architecture is using a GP register, we must
1097 conservatively assume that the target function makes use of it.
1098 The prologue of functions with nonlocal gotos must therefore
1099 initialize the GP register to the appropriate value, and we
1100 must then make sure that this value is live at the point
1101 of the jump. (Note that this doesn't necessarily apply
1102 to targets with a nonlocal_goto pattern; they are free
1103 to implement it in their own way. Note also that this is
1104 a no-op if the GP register is a global invariant.) */
1105 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1106 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1107 emit_use (pic_offset_table_rtx);
1109 emit_indirect_jump (r_label);
1112 /* Search backwards to the jump insn and mark it as a
1114 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1118 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1121 else if (CALL_P (insn))
1128 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1129 (not all will be used on all machines) that was passed to __builtin_setjmp.
1130 It updates the stack pointer in that block to the current value. This is
1131 also called directly by the SJLJ exception handling code. */
1134 expand_builtin_update_setjmp_buf (rtx buf_addr)
1136 machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1138 = gen_rtx_MEM (sa_mode,
1141 plus_constant (Pmode, buf_addr,
1142 2 * GET_MODE_SIZE (Pmode))));
1144 emit_stack_save (SAVE_NONLOCAL, &stack_save);
1147 /* Expand a call to __builtin_prefetch. For a target that does not support
1148 data prefetch, evaluate the memory address argument in case it has side
1152 expand_builtin_prefetch (tree exp)
1154 tree arg0, arg1, arg2;
1158 if (!validate_arglist (exp, POINTER_TYPE, 0))
1161 arg0 = CALL_EXPR_ARG (exp, 0);
1163 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1164 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1166 nargs = call_expr_nargs (exp);
1168 arg1 = CALL_EXPR_ARG (exp, 1);
1170 arg1 = integer_zero_node;
1172 arg2 = CALL_EXPR_ARG (exp, 2);
1174 arg2 = integer_three_node;
1176 /* Argument 0 is an address. */
1177 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1179 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1180 if (TREE_CODE (arg1) != INTEGER_CST)
1182 error ("second argument to %<__builtin_prefetch%> must be a constant");
1183 arg1 = integer_zero_node;
1185 op1 = expand_normal (arg1);
1186 /* Argument 1 must be either zero or one. */
1187 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1189 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1194 /* Argument 2 (locality) must be a compile-time constant int. */
1195 if (TREE_CODE (arg2) != INTEGER_CST)
1197 error ("third argument to %<__builtin_prefetch%> must be a constant");
1198 arg2 = integer_zero_node;
1200 op2 = expand_normal (arg2);
1201 /* Argument 2 must be 0, 1, 2, or 3. */
1202 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1204 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1208 if (targetm.have_prefetch ())
1210 struct expand_operand ops[3];
1212 create_address_operand (&ops[0], op0);
1213 create_integer_operand (&ops[1], INTVAL (op1));
1214 create_integer_operand (&ops[2], INTVAL (op2));
1215 if (maybe_expand_insn (targetm.code_for_prefetch, 3, ops))
1219 /* Don't do anything with direct references to volatile memory, but
1220 generate code to handle other side effects. */
1221 if (!MEM_P (op0) && side_effects_p (op0))
1225 /* Get a MEM rtx for expression EXP which is the address of an operand
1226 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1227 the maximum length of the block of memory that might be accessed or
1231 get_memory_rtx (tree exp, tree len)
1233 tree orig_exp = exp;
1236 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1237 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1238 if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1239 exp = TREE_OPERAND (exp, 0);
1241 addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1242 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1244 /* Get an expression we can use to find the attributes to assign to MEM.
1245 First remove any nops. */
1246 while (CONVERT_EXPR_P (exp)
1247 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1248 exp = TREE_OPERAND (exp, 0);
1250 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1251 (as builtin stringops may alias with anything). */
1252 exp = fold_build2 (MEM_REF,
1253 build_array_type (char_type_node,
1254 build_range_type (sizetype,
1255 size_one_node, len)),
1256 exp, build_int_cst (ptr_type_node, 0));
1258 /* If the MEM_REF has no acceptable address, try to get the base object
1259 from the original address we got, and build an all-aliasing
1260 unknown-sized access to that one. */
1261 if (is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
1262 set_mem_attributes (mem, exp, 0);
1263 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1264 && (exp = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0),
1267 exp = build_fold_addr_expr (exp);
1268 exp = fold_build2 (MEM_REF,
1269 build_array_type (char_type_node,
1270 build_range_type (sizetype,
1273 exp, build_int_cst (ptr_type_node, 0));
1274 set_mem_attributes (mem, exp, 0);
1276 set_mem_alias_set (mem, 0);
1280 /* Built-in functions to perform an untyped call and return. */
1282 #define apply_args_mode \
1283 (this_target_builtins->x_apply_args_mode)
1284 #define apply_result_mode \
1285 (this_target_builtins->x_apply_result_mode)
1287 /* Return the size required for the block returned by __builtin_apply_args,
1288 and initialize apply_args_mode. */
1291 apply_args_size (void)
1293 static int size = -1;
1298 /* The values computed by this function never change. */
1301 /* The first value is the incoming arg-pointer. */
1302 size = GET_MODE_SIZE (Pmode);
1304 /* The second value is the structure value address unless this is
1305 passed as an "invisible" first argument. */
1306 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1307 size += GET_MODE_SIZE (Pmode);
1309 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1310 if (FUNCTION_ARG_REGNO_P (regno))
1312 mode = targetm.calls.get_raw_arg_mode (regno);
1314 gcc_assert (mode != VOIDmode);
1316 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1317 if (size % align != 0)
1318 size = CEIL (size, align) * align;
1319 size += GET_MODE_SIZE (mode);
1320 apply_args_mode[regno] = mode;
1324 apply_args_mode[regno] = VOIDmode;
1330 /* Return the size required for the block returned by __builtin_apply,
1331 and initialize apply_result_mode. */
1334 apply_result_size (void)
1336 static int size = -1;
1340 /* The values computed by this function never change. */
1345 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1346 if (targetm.calls.function_value_regno_p (regno))
1348 mode = targetm.calls.get_raw_result_mode (regno);
1350 gcc_assert (mode != VOIDmode);
1352 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1353 if (size % align != 0)
1354 size = CEIL (size, align) * align;
1355 size += GET_MODE_SIZE (mode);
1356 apply_result_mode[regno] = mode;
1359 apply_result_mode[regno] = VOIDmode;
1361 /* Allow targets that use untyped_call and untyped_return to override
1362 the size so that machine-specific information can be stored here. */
1363 #ifdef APPLY_RESULT_SIZE
1364 size = APPLY_RESULT_SIZE;
1370 /* Create a vector describing the result block RESULT. If SAVEP is true,
1371 the result block is used to save the values; otherwise it is used to
1372 restore the values. */
1375 result_vector (int savep, rtx result)
1377 int regno, size, align, nelts;
1380 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1383 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1384 if ((mode = apply_result_mode[regno]) != VOIDmode)
1386 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1387 if (size % align != 0)
1388 size = CEIL (size, align) * align;
1389 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1390 mem = adjust_address (result, mode, size);
1391 savevec[nelts++] = (savep
1392 ? gen_rtx_SET (mem, reg)
1393 : gen_rtx_SET (reg, mem));
1394 size += GET_MODE_SIZE (mode);
1396 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1399 /* Save the state required to perform an untyped call with the same
1400 arguments as were passed to the current function. */
1403 expand_builtin_apply_args_1 (void)
1406 int size, align, regno;
1408 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1410 /* Create a block where the arg-pointer, structure value address,
1411 and argument registers can be saved. */
1412 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1414 /* Walk past the arg-pointer and structure value address. */
1415 size = GET_MODE_SIZE (Pmode);
1416 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1417 size += GET_MODE_SIZE (Pmode);
1419 /* Save each register used in calling a function to the block. */
1420 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1421 if ((mode = apply_args_mode[regno]) != VOIDmode)
1423 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1424 if (size % align != 0)
1425 size = CEIL (size, align) * align;
1427 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1429 emit_move_insn (adjust_address (registers, mode, size), tem);
1430 size += GET_MODE_SIZE (mode);
1433 /* Save the arg pointer to the block. */
1434 tem = copy_to_reg (crtl->args.internal_arg_pointer);
1435 /* We need the pointer as the caller actually passed them to us, not
1436 as we might have pretended they were passed. Make sure it's a valid
1437 operand, as emit_move_insn isn't expected to handle a PLUS. */
1438 if (STACK_GROWS_DOWNWARD)
1440 = force_operand (plus_constant (Pmode, tem,
1441 crtl->args.pretend_args_size),
1443 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1445 size = GET_MODE_SIZE (Pmode);
1447 /* Save the structure value address unless this is passed as an
1448 "invisible" first argument. */
1449 if (struct_incoming_value)
1451 emit_move_insn (adjust_address (registers, Pmode, size),
1452 copy_to_reg (struct_incoming_value));
1453 size += GET_MODE_SIZE (Pmode);
1456 /* Return the address of the block. */
1457 return copy_addr_to_reg (XEXP (registers, 0));
1460 /* __builtin_apply_args returns block of memory allocated on
1461 the stack into which is stored the arg pointer, structure
1462 value address, static chain, and all the registers that might
1463 possibly be used in performing a function call. The code is
1464 moved to the start of the function so the incoming values are
1468 expand_builtin_apply_args (void)
1470 /* Don't do __builtin_apply_args more than once in a function.
1471 Save the result of the first call and reuse it. */
1472 if (apply_args_value != 0)
1473 return apply_args_value;
1475 /* When this function is called, it means that registers must be
1476 saved on entry to this function. So we migrate the
1477 call to the first insn of this function. */
1481 temp = expand_builtin_apply_args_1 ();
1482 rtx_insn *seq = get_insns ();
1485 apply_args_value = temp;
1487 /* Put the insns after the NOTE that starts the function.
1488 If this is inside a start_sequence, make the outer-level insn
1489 chain current, so the code is placed at the start of the
1490 function. If internal_arg_pointer is a non-virtual pseudo,
1491 it needs to be placed after the function that initializes
1493 push_topmost_sequence ();
1494 if (REG_P (crtl->args.internal_arg_pointer)
1495 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1496 emit_insn_before (seq, parm_birth_insn);
1498 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1499 pop_topmost_sequence ();
1504 /* Perform an untyped call and save the state required to perform an
1505 untyped return of whatever value was returned by the given function. */
1508 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1510 int size, align, regno;
1512 rtx incoming_args, result, reg, dest, src;
1513 rtx_call_insn *call_insn;
1514 rtx old_stack_level = 0;
1515 rtx call_fusage = 0;
1516 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1518 arguments = convert_memory_address (Pmode, arguments);
1520 /* Create a block where the return registers can be saved. */
1521 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1523 /* Fetch the arg pointer from the ARGUMENTS block. */
1524 incoming_args = gen_reg_rtx (Pmode);
1525 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1526 if (!STACK_GROWS_DOWNWARD)
1527 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1528 incoming_args, 0, OPTAB_LIB_WIDEN);
1530 /* Push a new argument block and copy the arguments. Do not allow
1531 the (potential) memcpy call below to interfere with our stack
1533 do_pending_stack_adjust ();
1536 /* Save the stack with nonlocal if available. */
1537 if (targetm.have_save_stack_nonlocal ())
1538 emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1540 emit_stack_save (SAVE_BLOCK, &old_stack_level);
1542 /* Allocate a block of memory onto the stack and copy the memory
1543 arguments to the outgoing arguments address. We can pass TRUE
1544 as the 4th argument because we just saved the stack pointer
1545 and will restore it right after the call. */
1546 allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1548 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1549 may have already set current_function_calls_alloca to true.
1550 current_function_calls_alloca won't be set if argsize is zero,
1551 so we have to guarantee need_drap is true here. */
1552 if (SUPPORTS_STACK_ALIGNMENT)
1553 crtl->need_drap = true;
1555 dest = virtual_outgoing_args_rtx;
1556 if (!STACK_GROWS_DOWNWARD)
1558 if (CONST_INT_P (argsize))
1559 dest = plus_constant (Pmode, dest, -INTVAL (argsize));
1561 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1563 dest = gen_rtx_MEM (BLKmode, dest);
1564 set_mem_align (dest, PARM_BOUNDARY);
1565 src = gen_rtx_MEM (BLKmode, incoming_args);
1566 set_mem_align (src, PARM_BOUNDARY);
1567 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1569 /* Refer to the argument block. */
1571 arguments = gen_rtx_MEM (BLKmode, arguments);
1572 set_mem_align (arguments, PARM_BOUNDARY);
1574 /* Walk past the arg-pointer and structure value address. */
1575 size = GET_MODE_SIZE (Pmode);
1577 size += GET_MODE_SIZE (Pmode);
1579 /* Restore each of the registers previously saved. Make USE insns
1580 for each of these registers for use in making the call. */
1581 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1582 if ((mode = apply_args_mode[regno]) != VOIDmode)
1584 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1585 if (size % align != 0)
1586 size = CEIL (size, align) * align;
1587 reg = gen_rtx_REG (mode, regno);
1588 emit_move_insn (reg, adjust_address (arguments, mode, size));
1589 use_reg (&call_fusage, reg);
1590 size += GET_MODE_SIZE (mode);
1593 /* Restore the structure value address unless this is passed as an
1594 "invisible" first argument. */
1595 size = GET_MODE_SIZE (Pmode);
1598 rtx value = gen_reg_rtx (Pmode);
1599 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1600 emit_move_insn (struct_value, value);
1601 if (REG_P (struct_value))
1602 use_reg (&call_fusage, struct_value);
1603 size += GET_MODE_SIZE (Pmode);
1606 /* All arguments and registers used for the call are set up by now! */
1607 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1609 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1610 and we don't want to load it into a register as an optimization,
1611 because prepare_call_address already did it if it should be done. */
1612 if (GET_CODE (function) != SYMBOL_REF)
1613 function = memory_address (FUNCTION_MODE, function);
1615 /* Generate the actual call instruction and save the return value. */
1616 if (targetm.have_untyped_call ())
1618 rtx mem = gen_rtx_MEM (FUNCTION_MODE, function);
1619 emit_call_insn (targetm.gen_untyped_call (mem, result,
1620 result_vector (1, result)));
1622 else if (targetm.have_call_value ())
1626 /* Locate the unique return register. It is not possible to
1627 express a call that sets more than one return register using
1628 call_value; use untyped_call for that. In fact, untyped_call
1629 only needs to save the return registers in the given block. */
1630 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1631 if ((mode = apply_result_mode[regno]) != VOIDmode)
1633 gcc_assert (!valreg); /* have_untyped_call required. */
1635 valreg = gen_rtx_REG (mode, regno);
1638 emit_insn (targetm.gen_call_value (valreg,
1639 gen_rtx_MEM (FUNCTION_MODE, function),
1640 const0_rtx, NULL_RTX, const0_rtx));
1642 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1647 /* Find the CALL insn we just emitted, and attach the register usage
1649 call_insn = last_call_insn ();
1650 add_function_usage_to (call_insn, call_fusage);
1652 /* Restore the stack. */
1653 if (targetm.have_save_stack_nonlocal ())
1654 emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1656 emit_stack_restore (SAVE_BLOCK, old_stack_level);
1657 fixup_args_size_notes (call_insn, get_last_insn (), 0);
1661 /* Return the address of the result block. */
1662 result = copy_addr_to_reg (XEXP (result, 0));
1663 return convert_memory_address (ptr_mode, result);
1666 /* Perform an untyped return. */
1669 expand_builtin_return (rtx result)
1671 int size, align, regno;
1674 rtx_insn *call_fusage = 0;
1676 result = convert_memory_address (Pmode, result);
1678 apply_result_size ();
1679 result = gen_rtx_MEM (BLKmode, result);
1681 if (targetm.have_untyped_return ())
1683 rtx vector = result_vector (0, result);
1684 emit_jump_insn (targetm.gen_untyped_return (result, vector));
1689 /* Restore the return value and note that each value is used. */
1691 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1692 if ((mode = apply_result_mode[regno]) != VOIDmode)
1694 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1695 if (size % align != 0)
1696 size = CEIL (size, align) * align;
1697 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1698 emit_move_insn (reg, adjust_address (result, mode, size));
1700 push_to_sequence (call_fusage);
1702 call_fusage = get_insns ();
1704 size += GET_MODE_SIZE (mode);
1707 /* Put the USE insns before the return. */
1708 emit_insn (call_fusage);
1710 /* Return whatever values was restored by jumping directly to the end
1712 expand_naked_return ();
1715 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1717 static enum type_class
1718 type_to_class (tree type)
1720 switch (TREE_CODE (type))
1722 case VOID_TYPE: return void_type_class;
1723 case INTEGER_TYPE: return integer_type_class;
1724 case ENUMERAL_TYPE: return enumeral_type_class;
1725 case BOOLEAN_TYPE: return boolean_type_class;
1726 case POINTER_TYPE: return pointer_type_class;
1727 case REFERENCE_TYPE: return reference_type_class;
1728 case OFFSET_TYPE: return offset_type_class;
1729 case REAL_TYPE: return real_type_class;
1730 case COMPLEX_TYPE: return complex_type_class;
1731 case FUNCTION_TYPE: return function_type_class;
1732 case METHOD_TYPE: return method_type_class;
1733 case RECORD_TYPE: return record_type_class;
1735 case QUAL_UNION_TYPE: return union_type_class;
1736 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1737 ? string_type_class : array_type_class);
1738 case LANG_TYPE: return lang_type_class;
1739 default: return no_type_class;
1743 /* Expand a call EXP to __builtin_classify_type. */
1746 expand_builtin_classify_type (tree exp)
1748 if (call_expr_nargs (exp))
1749 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1750 return GEN_INT (no_type_class);
1753 /* This helper macro, meant to be used in mathfn_built_in below,
1754 determines which among a set of three builtin math functions is
1755 appropriate for a given type mode. The `F' and `L' cases are
1756 automatically generated from the `double' case. */
1757 #define CASE_MATHFN(MATHFN) \
1758 CASE_CFN_##MATHFN: \
1759 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1760 fcodel = BUILT_IN_##MATHFN##L ; break;
1761 /* Similar to above, but appends _R after any F/L suffix. */
1762 #define CASE_MATHFN_REENT(MATHFN) \
1763 case CFN_BUILT_IN_##MATHFN##_R: \
1764 case CFN_BUILT_IN_##MATHFN##F_R: \
1765 case CFN_BUILT_IN_##MATHFN##L_R: \
1766 fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \
1767 fcodel = BUILT_IN_##MATHFN##L_R ; break;
1769 /* Return a function equivalent to FN but operating on floating-point
1770 values of type TYPE, or END_BUILTINS if no such function exists.
1771 This is purely an operation on function codes; it does not guarantee
1772 that the target actually has an implementation of the function. */
1774 static built_in_function
1775 mathfn_built_in_2 (tree type, combined_fn fn)
1777 built_in_function fcode, fcodef, fcodel;
1791 CASE_MATHFN (COPYSIGN)
1810 CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */
1811 CASE_MATHFN (HUGE_VAL)
1815 CASE_MATHFN (IFLOOR)
1818 CASE_MATHFN (IROUND)
1825 CASE_MATHFN (LFLOOR)
1826 CASE_MATHFN (LGAMMA)
1827 CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */
1828 CASE_MATHFN (LLCEIL)
1829 CASE_MATHFN (LLFLOOR)
1830 CASE_MATHFN (LLRINT)
1831 CASE_MATHFN (LLROUND)
1838 CASE_MATHFN (LROUND)
1842 CASE_MATHFN (NEARBYINT)
1843 CASE_MATHFN (NEXTAFTER)
1844 CASE_MATHFN (NEXTTOWARD)
1848 CASE_MATHFN (REMAINDER)
1849 CASE_MATHFN (REMQUO)
1853 CASE_MATHFN (SCALBLN)
1854 CASE_MATHFN (SCALBN)
1855 CASE_MATHFN (SIGNBIT)
1856 CASE_MATHFN (SIGNIFICAND)
1858 CASE_MATHFN (SINCOS)
1863 CASE_MATHFN (TGAMMA)
1870 return END_BUILTINS;
1873 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1875 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1877 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1880 return END_BUILTINS;
1883 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1884 if available. If IMPLICIT_P is true use the implicit builtin declaration,
1885 otherwise use the explicit declaration. If we can't do the conversion,
1889 mathfn_built_in_1 (tree type, combined_fn fn, bool implicit_p)
1891 built_in_function fcode2 = mathfn_built_in_2 (type, fn);
1892 if (fcode2 == END_BUILTINS)
1895 if (implicit_p && !builtin_decl_implicit_p (fcode2))
1898 return builtin_decl_explicit (fcode2);
1901 /* Like mathfn_built_in_1, but always use the implicit array. */
1904 mathfn_built_in (tree type, combined_fn fn)
1906 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1909 /* Like mathfn_built_in_1, but take a built_in_function and
1910 always use the implicit array. */
1913 mathfn_built_in (tree type, enum built_in_function fn)
1915 return mathfn_built_in_1 (type, as_combined_fn (fn), /*implicit=*/ 1);
1918 /* If BUILT_IN_NORMAL function FNDECL has an associated internal function,
1919 return its code, otherwise return IFN_LAST. Note that this function
1920 only tests whether the function is defined in internals.def, not whether
1921 it is actually available on the target. */
1924 associated_internal_fn (tree fndecl)
1926 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL);
1927 tree return_type = TREE_TYPE (TREE_TYPE (fndecl));
1928 switch (DECL_FUNCTION_CODE (fndecl))
1930 #define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \
1931 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME;
1932 #define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \
1933 CASE_INT_FN (BUILT_IN_##NAME): return IFN_##NAME;
1934 #include "internal-fn.def"
1936 CASE_FLT_FN (BUILT_IN_POW10):
1939 CASE_FLT_FN (BUILT_IN_DREM):
1940 return IFN_REMAINDER;
1942 CASE_FLT_FN (BUILT_IN_SCALBN):
1943 CASE_FLT_FN (BUILT_IN_SCALBLN):
1944 if (REAL_MODE_FORMAT (TYPE_MODE (return_type))->b == 2)
1953 /* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced
1954 on the current target by a call to an internal function, return the
1955 code of that internal function, otherwise return IFN_LAST. The caller
1956 is responsible for ensuring that any side-effects of the built-in
1957 call are dealt with correctly. E.g. if CALL sets errno, the caller
1958 must decide that the errno result isn't needed or make it available
1959 in some other way. */
1962 replacement_internal_fn (gcall *call)
1964 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL))
1966 internal_fn ifn = associated_internal_fn (gimple_call_fndecl (call));
1967 if (ifn != IFN_LAST)
1969 tree_pair types = direct_internal_fn_types (ifn, call);
1970 optimization_type opt_type = bb_optimization_type (gimple_bb (call));
1971 if (direct_internal_fn_supported_p (ifn, types, opt_type))
1978 /* Expand a call to the builtin trinary math functions (fma).
1979 Return NULL_RTX if a normal call should be emitted rather than expanding the
1980 function in-line. EXP is the expression that is a call to the builtin
1981 function; if convenient, the result should be placed in TARGET.
1982 SUBTARGET may be used as the target for computing one of EXP's
1986 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
1988 optab builtin_optab;
1989 rtx op0, op1, op2, result;
1991 tree fndecl = get_callee_fndecl (exp);
1992 tree arg0, arg1, arg2;
1995 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
1998 arg0 = CALL_EXPR_ARG (exp, 0);
1999 arg1 = CALL_EXPR_ARG (exp, 1);
2000 arg2 = CALL_EXPR_ARG (exp, 2);
2002 switch (DECL_FUNCTION_CODE (fndecl))
2004 CASE_FLT_FN (BUILT_IN_FMA):
2005 builtin_optab = fma_optab; break;
2010 /* Make a suitable register to place result in. */
2011 mode = TYPE_MODE (TREE_TYPE (exp));
2013 /* Before working hard, check whether the instruction is available. */
2014 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2017 result = gen_reg_rtx (mode);
2019 /* Always stabilize the argument list. */
2020 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2021 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2022 CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2024 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2025 op1 = expand_normal (arg1);
2026 op2 = expand_normal (arg2);
2030 /* Compute into RESULT.
2031 Set RESULT to wherever the result comes back. */
2032 result = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2035 /* If we were unable to expand via the builtin, stop the sequence
2036 (without outputting the insns) and call to the library function
2037 with the stabilized argument list. */
2041 return expand_call (exp, target, target == const0_rtx);
2044 /* Output the entire sequence. */
2045 insns = get_insns ();
2052 /* Expand a call to the builtin sin and cos math functions.
2053 Return NULL_RTX if a normal call should be emitted rather than expanding the
2054 function in-line. EXP is the expression that is a call to the builtin
2055 function; if convenient, the result should be placed in TARGET.
2056 SUBTARGET may be used as the target for computing one of EXP's
2060 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2062 optab builtin_optab;
2065 tree fndecl = get_callee_fndecl (exp);
2069 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2072 arg = CALL_EXPR_ARG (exp, 0);
2074 switch (DECL_FUNCTION_CODE (fndecl))
2076 CASE_FLT_FN (BUILT_IN_SIN):
2077 CASE_FLT_FN (BUILT_IN_COS):
2078 builtin_optab = sincos_optab; break;
2083 /* Make a suitable register to place result in. */
2084 mode = TYPE_MODE (TREE_TYPE (exp));
2086 /* Check if sincos insn is available, otherwise fallback
2087 to sin or cos insn. */
2088 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2089 switch (DECL_FUNCTION_CODE (fndecl))
2091 CASE_FLT_FN (BUILT_IN_SIN):
2092 builtin_optab = sin_optab; break;
2093 CASE_FLT_FN (BUILT_IN_COS):
2094 builtin_optab = cos_optab; break;
2099 /* Before working hard, check whether the instruction is available. */
2100 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2102 rtx result = gen_reg_rtx (mode);
2104 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2105 need to expand the argument again. This way, we will not perform
2106 side-effects more the once. */
2107 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2109 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2113 /* Compute into RESULT.
2114 Set RESULT to wherever the result comes back. */
2115 if (builtin_optab == sincos_optab)
2119 switch (DECL_FUNCTION_CODE (fndecl))
2121 CASE_FLT_FN (BUILT_IN_SIN):
2122 ok = expand_twoval_unop (builtin_optab, op0, 0, result, 0);
2124 CASE_FLT_FN (BUILT_IN_COS):
2125 ok = expand_twoval_unop (builtin_optab, op0, result, 0, 0);
2133 result = expand_unop (mode, builtin_optab, op0, result, 0);
2137 /* Output the entire sequence. */
2138 insns = get_insns ();
2144 /* If we were unable to expand via the builtin, stop the sequence
2145 (without outputting the insns) and call to the library function
2146 with the stabilized argument list. */
2150 return expand_call (exp, target, target == const0_rtx);
2153 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2154 return an RTL instruction code that implements the functionality.
2155 If that isn't possible or available return CODE_FOR_nothing. */
2157 static enum insn_code
2158 interclass_mathfn_icode (tree arg, tree fndecl)
2160 bool errno_set = false;
2161 optab builtin_optab = unknown_optab;
2164 switch (DECL_FUNCTION_CODE (fndecl))
2166 CASE_FLT_FN (BUILT_IN_ILOGB):
2167 errno_set = true; builtin_optab = ilogb_optab; break;
2168 CASE_FLT_FN (BUILT_IN_ISINF):
2169 builtin_optab = isinf_optab; break;
2170 case BUILT_IN_ISNORMAL:
2171 case BUILT_IN_ISFINITE:
2172 CASE_FLT_FN (BUILT_IN_FINITE):
2173 case BUILT_IN_FINITED32:
2174 case BUILT_IN_FINITED64:
2175 case BUILT_IN_FINITED128:
2176 case BUILT_IN_ISINFD32:
2177 case BUILT_IN_ISINFD64:
2178 case BUILT_IN_ISINFD128:
2179 /* These builtins have no optabs (yet). */
2185 /* There's no easy way to detect the case we need to set EDOM. */
2186 if (flag_errno_math && errno_set)
2187 return CODE_FOR_nothing;
2189 /* Optab mode depends on the mode of the input argument. */
2190 mode = TYPE_MODE (TREE_TYPE (arg));
2193 return optab_handler (builtin_optab, mode);
2194 return CODE_FOR_nothing;
2197 /* Expand a call to one of the builtin math functions that operate on
2198 floating point argument and output an integer result (ilogb, isinf,
2200 Return 0 if a normal call should be emitted rather than expanding the
2201 function in-line. EXP is the expression that is a call to the builtin
2202 function; if convenient, the result should be placed in TARGET. */
2205 expand_builtin_interclass_mathfn (tree exp, rtx target)
2207 enum insn_code icode = CODE_FOR_nothing;
2209 tree fndecl = get_callee_fndecl (exp);
2213 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2216 arg = CALL_EXPR_ARG (exp, 0);
2217 icode = interclass_mathfn_icode (arg, fndecl);
2218 mode = TYPE_MODE (TREE_TYPE (arg));
2220 if (icode != CODE_FOR_nothing)
2222 struct expand_operand ops[1];
2223 rtx_insn *last = get_last_insn ();
2224 tree orig_arg = arg;
2226 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2227 need to expand the argument again. This way, we will not perform
2228 side-effects more the once. */
2229 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2231 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2233 if (mode != GET_MODE (op0))
2234 op0 = convert_to_mode (mode, op0, 0);
2236 create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2237 if (maybe_legitimize_operands (icode, 0, 1, ops)
2238 && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2239 return ops[0].value;
2241 delete_insns_since (last);
2242 CALL_EXPR_ARG (exp, 0) = orig_arg;
2248 /* Expand a call to the builtin sincos math function.
2249 Return NULL_RTX if a normal call should be emitted rather than expanding the
2250 function in-line. EXP is the expression that is a call to the builtin
2254 expand_builtin_sincos (tree exp)
2256 rtx op0, op1, op2, target1, target2;
2258 tree arg, sinp, cosp;
2260 location_t loc = EXPR_LOCATION (exp);
2261 tree alias_type, alias_off;
2263 if (!validate_arglist (exp, REAL_TYPE,
2264 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2267 arg = CALL_EXPR_ARG (exp, 0);
2268 sinp = CALL_EXPR_ARG (exp, 1);
2269 cosp = CALL_EXPR_ARG (exp, 2);
2271 /* Make a suitable register to place result in. */
2272 mode = TYPE_MODE (TREE_TYPE (arg));
2274 /* Check if sincos insn is available, otherwise emit the call. */
2275 if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2278 target1 = gen_reg_rtx (mode);
2279 target2 = gen_reg_rtx (mode);
2281 op0 = expand_normal (arg);
2282 alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2283 alias_off = build_int_cst (alias_type, 0);
2284 op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2286 op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2289 /* Compute into target1 and target2.
2290 Set TARGET to wherever the result comes back. */
2291 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2292 gcc_assert (result);
2294 /* Move target1 and target2 to the memory locations indicated
2296 emit_move_insn (op1, target1);
2297 emit_move_insn (op2, target2);
2302 /* Expand a call to the internal cexpi builtin to the sincos math function.
2303 EXP is the expression that is a call to the builtin function; if convenient,
2304 the result should be placed in TARGET. */
2307 expand_builtin_cexpi (tree exp, rtx target)
2309 tree fndecl = get_callee_fndecl (exp);
2313 location_t loc = EXPR_LOCATION (exp);
2315 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2318 arg = CALL_EXPR_ARG (exp, 0);
2319 type = TREE_TYPE (arg);
2320 mode = TYPE_MODE (TREE_TYPE (arg));
2322 /* Try expanding via a sincos optab, fall back to emitting a libcall
2323 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2324 is only generated from sincos, cexp or if we have either of them. */
2325 if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2327 op1 = gen_reg_rtx (mode);
2328 op2 = gen_reg_rtx (mode);
2330 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2332 /* Compute into op1 and op2. */
2333 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2335 else if (targetm.libc_has_function (function_sincos))
2337 tree call, fn = NULL_TREE;
2341 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2342 fn = builtin_decl_explicit (BUILT_IN_SINCOSF);
2343 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2344 fn = builtin_decl_explicit (BUILT_IN_SINCOS);
2345 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2346 fn = builtin_decl_explicit (BUILT_IN_SINCOSL);
2350 op1 = assign_temp (TREE_TYPE (arg), 1, 1);
2351 op2 = assign_temp (TREE_TYPE (arg), 1, 1);
2352 op1a = copy_addr_to_reg (XEXP (op1, 0));
2353 op2a = copy_addr_to_reg (XEXP (op2, 0));
2354 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2355 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2357 /* Make sure not to fold the sincos call again. */
2358 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2359 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2360 call, 3, arg, top1, top2));
2364 tree call, fn = NULL_TREE, narg;
2365 tree ctype = build_complex_type (type);
2367 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2368 fn = builtin_decl_explicit (BUILT_IN_CEXPF);
2369 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2370 fn = builtin_decl_explicit (BUILT_IN_CEXP);
2371 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2372 fn = builtin_decl_explicit (BUILT_IN_CEXPL);
2376 /* If we don't have a decl for cexp create one. This is the
2377 friendliest fallback if the user calls __builtin_cexpi
2378 without full target C99 function support. */
2379 if (fn == NULL_TREE)
2382 const char *name = NULL;
2384 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2386 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2388 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2391 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2392 fn = build_fn_decl (name, fntype);
2395 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2396 build_real (type, dconst0), arg);
2398 /* Make sure not to fold the cexp call again. */
2399 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2400 return expand_expr (build_call_nary (ctype, call, 1, narg),
2401 target, VOIDmode, EXPAND_NORMAL);
2404 /* Now build the proper return type. */
2405 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2406 make_tree (TREE_TYPE (arg), op2),
2407 make_tree (TREE_TYPE (arg), op1)),
2408 target, VOIDmode, EXPAND_NORMAL);
2411 /* Conveniently construct a function call expression. FNDECL names the
2412 function to be called, N is the number of arguments, and the "..."
2413 parameters are the argument expressions. Unlike build_call_exr
2414 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2417 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2420 tree fntype = TREE_TYPE (fndecl);
2421 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2424 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2426 SET_EXPR_LOCATION (fn, loc);
2430 /* Expand a call to one of the builtin rounding functions gcc defines
2431 as an extension (lfloor and lceil). As these are gcc extensions we
2432 do not need to worry about setting errno to EDOM.
2433 If expanding via optab fails, lower expression to (int)(floor(x)).
2434 EXP is the expression that is a call to the builtin function;
2435 if convenient, the result should be placed in TARGET. */
2438 expand_builtin_int_roundingfn (tree exp, rtx target)
2440 convert_optab builtin_optab;
2443 tree fndecl = get_callee_fndecl (exp);
2444 enum built_in_function fallback_fn;
2445 tree fallback_fndecl;
2449 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2452 arg = CALL_EXPR_ARG (exp, 0);
2454 switch (DECL_FUNCTION_CODE (fndecl))
2456 CASE_FLT_FN (BUILT_IN_ICEIL):
2457 CASE_FLT_FN (BUILT_IN_LCEIL):
2458 CASE_FLT_FN (BUILT_IN_LLCEIL):
2459 builtin_optab = lceil_optab;
2460 fallback_fn = BUILT_IN_CEIL;
2463 CASE_FLT_FN (BUILT_IN_IFLOOR):
2464 CASE_FLT_FN (BUILT_IN_LFLOOR):
2465 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2466 builtin_optab = lfloor_optab;
2467 fallback_fn = BUILT_IN_FLOOR;
2474 /* Make a suitable register to place result in. */
2475 mode = TYPE_MODE (TREE_TYPE (exp));
2477 target = gen_reg_rtx (mode);
2479 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2480 need to expand the argument again. This way, we will not perform
2481 side-effects more the once. */
2482 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2484 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2488 /* Compute into TARGET. */
2489 if (expand_sfix_optab (target, op0, builtin_optab))
2491 /* Output the entire sequence. */
2492 insns = get_insns ();
2498 /* If we were unable to expand via the builtin, stop the sequence
2499 (without outputting the insns). */
2502 /* Fall back to floating point rounding optab. */
2503 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2505 /* For non-C99 targets we may end up without a fallback fndecl here
2506 if the user called __builtin_lfloor directly. In this case emit
2507 a call to the floor/ceil variants nevertheless. This should result
2508 in the best user experience for not full C99 targets. */
2509 if (fallback_fndecl == NULL_TREE)
2512 const char *name = NULL;
2514 switch (DECL_FUNCTION_CODE (fndecl))
2516 case BUILT_IN_ICEIL:
2517 case BUILT_IN_LCEIL:
2518 case BUILT_IN_LLCEIL:
2521 case BUILT_IN_ICEILF:
2522 case BUILT_IN_LCEILF:
2523 case BUILT_IN_LLCEILF:
2526 case BUILT_IN_ICEILL:
2527 case BUILT_IN_LCEILL:
2528 case BUILT_IN_LLCEILL:
2531 case BUILT_IN_IFLOOR:
2532 case BUILT_IN_LFLOOR:
2533 case BUILT_IN_LLFLOOR:
2536 case BUILT_IN_IFLOORF:
2537 case BUILT_IN_LFLOORF:
2538 case BUILT_IN_LLFLOORF:
2541 case BUILT_IN_IFLOORL:
2542 case BUILT_IN_LFLOORL:
2543 case BUILT_IN_LLFLOORL:
2550 fntype = build_function_type_list (TREE_TYPE (arg),
2551 TREE_TYPE (arg), NULL_TREE);
2552 fallback_fndecl = build_fn_decl (name, fntype);
2555 exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2557 tmp = expand_normal (exp);
2558 tmp = maybe_emit_group_store (tmp, TREE_TYPE (exp));
2560 /* Truncate the result of floating point optab to integer
2561 via expand_fix (). */
2562 target = gen_reg_rtx (mode);
2563 expand_fix (target, tmp, 0);
2568 /* Expand a call to one of the builtin math functions doing integer
2570 Return 0 if a normal call should be emitted rather than expanding the
2571 function in-line. EXP is the expression that is a call to the builtin
2572 function; if convenient, the result should be placed in TARGET. */
2575 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2577 convert_optab builtin_optab;
2580 tree fndecl = get_callee_fndecl (exp);
2583 enum built_in_function fallback_fn = BUILT_IN_NONE;
2585 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2588 arg = CALL_EXPR_ARG (exp, 0);
2590 switch (DECL_FUNCTION_CODE (fndecl))
2592 CASE_FLT_FN (BUILT_IN_IRINT):
2593 fallback_fn = BUILT_IN_LRINT;
2595 CASE_FLT_FN (BUILT_IN_LRINT):
2596 CASE_FLT_FN (BUILT_IN_LLRINT):
2597 builtin_optab = lrint_optab;
2600 CASE_FLT_FN (BUILT_IN_IROUND):
2601 fallback_fn = BUILT_IN_LROUND;
2603 CASE_FLT_FN (BUILT_IN_LROUND):
2604 CASE_FLT_FN (BUILT_IN_LLROUND):
2605 builtin_optab = lround_optab;
2612 /* There's no easy way to detect the case we need to set EDOM. */
2613 if (flag_errno_math && fallback_fn == BUILT_IN_NONE)
2616 /* Make a suitable register to place result in. */
2617 mode = TYPE_MODE (TREE_TYPE (exp));
2619 /* There's no easy way to detect the case we need to set EDOM. */
2620 if (!flag_errno_math)
2622 rtx result = gen_reg_rtx (mode);
2624 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2625 need to expand the argument again. This way, we will not perform
2626 side-effects more the once. */
2627 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2629 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2633 if (expand_sfix_optab (result, op0, builtin_optab))
2635 /* Output the entire sequence. */
2636 insns = get_insns ();
2642 /* If we were unable to expand via the builtin, stop the sequence
2643 (without outputting the insns) and call to the library function
2644 with the stabilized argument list. */
2648 if (fallback_fn != BUILT_IN_NONE)
2650 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2651 targets, (int) round (x) should never be transformed into
2652 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2653 a call to lround in the hope that the target provides at least some
2654 C99 functions. This should result in the best user experience for
2655 not full C99 targets. */
2656 tree fallback_fndecl = mathfn_built_in_1
2657 (TREE_TYPE (arg), as_combined_fn (fallback_fn), 0);
2659 exp = build_call_nofold_loc (EXPR_LOCATION (exp),
2660 fallback_fndecl, 1, arg);
2662 target = expand_call (exp, NULL_RTX, target == const0_rtx);
2663 target = maybe_emit_group_store (target, TREE_TYPE (exp));
2664 return convert_to_mode (mode, target, 0);
2667 return expand_call (exp, target, target == const0_rtx);
2670 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2671 a normal call should be emitted rather than expanding the function
2672 in-line. EXP is the expression that is a call to the builtin
2673 function; if convenient, the result should be placed in TARGET. */
2676 expand_builtin_powi (tree exp, rtx target)
2683 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2686 arg0 = CALL_EXPR_ARG (exp, 0);
2687 arg1 = CALL_EXPR_ARG (exp, 1);
2688 mode = TYPE_MODE (TREE_TYPE (exp));
2690 /* Emit a libcall to libgcc. */
2692 /* Mode of the 2nd argument must match that of an int. */
2693 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2695 if (target == NULL_RTX)
2696 target = gen_reg_rtx (mode);
2698 op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
2699 if (GET_MODE (op0) != mode)
2700 op0 = convert_to_mode (mode, op0, 0);
2701 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
2702 if (GET_MODE (op1) != mode2)
2703 op1 = convert_to_mode (mode2, op1, 0);
2705 target = emit_library_call_value (optab_libfunc (powi_optab, mode),
2706 target, LCT_CONST, mode, 2,
2707 op0, mode, op1, mode2);
2712 /* Expand expression EXP which is a call to the strlen builtin. Return
2713 NULL_RTX if we failed the caller should emit a normal call, otherwise
2714 try to get the result in TARGET, if convenient. */
2717 expand_builtin_strlen (tree exp, rtx target,
2718 machine_mode target_mode)
2720 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
2724 struct expand_operand ops[4];
2727 tree src = CALL_EXPR_ARG (exp, 0);
2729 rtx_insn *before_strlen;
2730 machine_mode insn_mode = target_mode;
2731 enum insn_code icode = CODE_FOR_nothing;
2734 /* If the length can be computed at compile-time, return it. */
2735 len = c_strlen (src, 0);
2737 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2739 /* If the length can be computed at compile-time and is constant
2740 integer, but there are side-effects in src, evaluate
2741 src for side-effects, then return len.
2742 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2743 can be optimized into: i++; x = 3; */
2744 len = c_strlen (src, 1);
2745 if (len && TREE_CODE (len) == INTEGER_CST)
2747 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2748 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2751 align = get_pointer_alignment (src) / BITS_PER_UNIT;
2753 /* If SRC is not a pointer type, don't do this operation inline. */
2757 /* Bail out if we can't compute strlen in the right mode. */
2758 while (insn_mode != VOIDmode)
2760 icode = optab_handler (strlen_optab, insn_mode);
2761 if (icode != CODE_FOR_nothing)
2764 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2766 if (insn_mode == VOIDmode)
2769 /* Make a place to hold the source address. We will not expand
2770 the actual source until we are sure that the expansion will
2771 not fail -- there are trees that cannot be expanded twice. */
2772 src_reg = gen_reg_rtx (Pmode);
2774 /* Mark the beginning of the strlen sequence so we can emit the
2775 source operand later. */
2776 before_strlen = get_last_insn ();
2778 create_output_operand (&ops[0], target, insn_mode);
2779 create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
2780 create_integer_operand (&ops[2], 0);
2781 create_integer_operand (&ops[3], align);
2782 if (!maybe_expand_insn (icode, 4, ops))
2785 /* Now that we are assured of success, expand the source. */
2787 pat = expand_expr (src, src_reg, Pmode, EXPAND_NORMAL);
2790 #ifdef POINTERS_EXTEND_UNSIGNED
2791 if (GET_MODE (pat) != Pmode)
2792 pat = convert_to_mode (Pmode, pat,
2793 POINTERS_EXTEND_UNSIGNED);
2795 emit_move_insn (src_reg, pat);
2801 emit_insn_after (pat, before_strlen);
2803 emit_insn_before (pat, get_insns ());
2805 /* Return the value in the proper mode for this function. */
2806 if (GET_MODE (ops[0].value) == target_mode)
2807 target = ops[0].value;
2808 else if (target != 0)
2809 convert_move (target, ops[0].value, 0);
2811 target = convert_to_mode (target_mode, ops[0].value, 0);
2817 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2818 bytes from constant string DATA + OFFSET and return it as target
2822 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2825 const char *str = (const char *) data;
2827 gcc_assert (offset >= 0
2828 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2829 <= strlen (str) + 1));
2831 return c_readstr (str + offset, mode);
2834 /* LEN specify length of the block of memcpy/memset operation.
2835 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
2836 In some cases we can make very likely guess on max size, then we
2837 set it into PROBABLE_MAX_SIZE. */
2840 determine_block_size (tree len, rtx len_rtx,
2841 unsigned HOST_WIDE_INT *min_size,
2842 unsigned HOST_WIDE_INT *max_size,
2843 unsigned HOST_WIDE_INT *probable_max_size)
2845 if (CONST_INT_P (len_rtx))
2847 *min_size = *max_size = *probable_max_size = UINTVAL (len_rtx);
2853 enum value_range_type range_type = VR_UNDEFINED;
2855 /* Determine bounds from the type. */
2856 if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len))))
2857 *min_size = tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len)));
2860 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len))))
2861 *probable_max_size = *max_size
2862 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len)));
2864 *probable_max_size = *max_size = GET_MODE_MASK (GET_MODE (len_rtx));
2866 if (TREE_CODE (len) == SSA_NAME)
2867 range_type = get_range_info (len, &min, &max);
2868 if (range_type == VR_RANGE)
2870 if (wi::fits_uhwi_p (min) && *min_size < min.to_uhwi ())
2871 *min_size = min.to_uhwi ();
2872 if (wi::fits_uhwi_p (max) && *max_size > max.to_uhwi ())
2873 *probable_max_size = *max_size = max.to_uhwi ();
2875 else if (range_type == VR_ANTI_RANGE)
2877 /* Anti range 0...N lets us to determine minimal size to N+1. */
2880 if (wi::fits_uhwi_p (max) && max.to_uhwi () + 1 != 0)
2881 *min_size = max.to_uhwi () + 1;
2889 Produce anti range allowing negative values of N. We still
2890 can use the information and make a guess that N is not negative.
2892 else if (!wi::leu_p (max, 1 << 30) && wi::fits_uhwi_p (min))
2893 *probable_max_size = min.to_uhwi () - 1;
2896 gcc_checking_assert (*max_size <=
2897 (unsigned HOST_WIDE_INT)
2898 GET_MODE_MASK (GET_MODE (len_rtx)));
2901 /* Helper function to do the actual work for expand_builtin_memcpy. */
2904 expand_builtin_memcpy_args (tree dest, tree src, tree len, rtx target, tree exp)
2906 const char *src_str;
2907 unsigned int src_align = get_pointer_alignment (src);
2908 unsigned int dest_align = get_pointer_alignment (dest);
2909 rtx dest_mem, src_mem, dest_addr, len_rtx;
2910 HOST_WIDE_INT expected_size = -1;
2911 unsigned int expected_align = 0;
2912 unsigned HOST_WIDE_INT min_size;
2913 unsigned HOST_WIDE_INT max_size;
2914 unsigned HOST_WIDE_INT probable_max_size;
2916 /* If DEST is not a pointer type, call the normal function. */
2917 if (dest_align == 0)
2920 /* If either SRC is not a pointer type, don't do this
2921 operation in-line. */
2925 if (currently_expanding_gimple_stmt)
2926 stringop_block_profile (currently_expanding_gimple_stmt,
2927 &expected_align, &expected_size);
2929 if (expected_align < dest_align)
2930 expected_align = dest_align;
2931 dest_mem = get_memory_rtx (dest, len);
2932 set_mem_align (dest_mem, dest_align);
2933 len_rtx = expand_normal (len);
2934 determine_block_size (len, len_rtx, &min_size, &max_size,
2935 &probable_max_size);
2936 src_str = c_getstr (src);
2938 /* If SRC is a string constant and block move would be done
2939 by pieces, we can avoid loading the string from memory
2940 and only stored the computed constants. */
2942 && CONST_INT_P (len_rtx)
2943 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2944 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2945 CONST_CAST (char *, src_str),
2948 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2949 builtin_memcpy_read_str,
2950 CONST_CAST (char *, src_str),
2951 dest_align, false, 0);
2952 dest_mem = force_operand (XEXP (dest_mem, 0), target);
2953 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2957 src_mem = get_memory_rtx (src, len);
2958 set_mem_align (src_mem, src_align);
2960 /* Copy word part most expediently. */
2961 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
2962 CALL_EXPR_TAILCALL (exp)
2963 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
2964 expected_align, expected_size,
2965 min_size, max_size, probable_max_size);
2969 dest_addr = force_operand (XEXP (dest_mem, 0), target);
2970 dest_addr = convert_memory_address (ptr_mode, dest_addr);
2976 /* Expand a call EXP to the memcpy builtin.
2977 Return NULL_RTX if we failed, the caller should emit a normal call,
2978 otherwise try to get the result in TARGET, if convenient (and in
2979 mode MODE if that's convenient). */
2982 expand_builtin_memcpy (tree exp, rtx target)
2984 if (!validate_arglist (exp,
2985 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2989 tree dest = CALL_EXPR_ARG (exp, 0);
2990 tree src = CALL_EXPR_ARG (exp, 1);
2991 tree len = CALL_EXPR_ARG (exp, 2);
2992 return expand_builtin_memcpy_args (dest, src, len, target, exp);
2996 /* Expand an instrumented call EXP to the memcpy builtin.
2997 Return NULL_RTX if we failed, the caller should emit a normal call,
2998 otherwise try to get the result in TARGET, if convenient (and in
2999 mode MODE if that's convenient). */
3002 expand_builtin_memcpy_with_bounds (tree exp, rtx target)
3004 if (!validate_arglist (exp,
3005 POINTER_TYPE, POINTER_BOUNDS_TYPE,
3006 POINTER_TYPE, POINTER_BOUNDS_TYPE,
3007 INTEGER_TYPE, VOID_TYPE))
3011 tree dest = CALL_EXPR_ARG (exp, 0);
3012 tree src = CALL_EXPR_ARG (exp, 2);
3013 tree len = CALL_EXPR_ARG (exp, 4);
3014 rtx res = expand_builtin_memcpy_args (dest, src, len, target, exp);
3016 /* Return src bounds with the result. */
3019 rtx bnd = force_reg (targetm.chkp_bound_mode (),
3020 expand_normal (CALL_EXPR_ARG (exp, 1)));
3021 res = chkp_join_splitted_slot (res, bnd);
3027 /* Expand a call EXP to the mempcpy builtin.
3028 Return NULL_RTX if we failed; the caller should emit a normal call,
3029 otherwise try to get the result in TARGET, if convenient (and in
3030 mode MODE if that's convenient). If ENDP is 0 return the
3031 destination pointer, if ENDP is 1 return the end pointer ala
3032 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3036 expand_builtin_mempcpy (tree exp, rtx target, machine_mode mode)
3038 if (!validate_arglist (exp,
3039 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3043 tree dest = CALL_EXPR_ARG (exp, 0);
3044 tree src = CALL_EXPR_ARG (exp, 1);
3045 tree len = CALL_EXPR_ARG (exp, 2);
3046 return expand_builtin_mempcpy_args (dest, src, len,
3047 target, mode, /*endp=*/ 1,
3052 /* Expand an instrumented call EXP to the mempcpy builtin.
3053 Return NULL_RTX if we failed, the caller should emit a normal call,
3054 otherwise try to get the result in TARGET, if convenient (and in
3055 mode MODE if that's convenient). */
3058 expand_builtin_mempcpy_with_bounds (tree exp, rtx target, machine_mode mode)
3060 if (!validate_arglist (exp,
3061 POINTER_TYPE, POINTER_BOUNDS_TYPE,
3062 POINTER_TYPE, POINTER_BOUNDS_TYPE,
3063 INTEGER_TYPE, VOID_TYPE))
3067 tree dest = CALL_EXPR_ARG (exp, 0);
3068 tree src = CALL_EXPR_ARG (exp, 2);
3069 tree len = CALL_EXPR_ARG (exp, 4);
3070 rtx res = expand_builtin_mempcpy_args (dest, src, len, target,
3073 /* Return src bounds with the result. */
3076 rtx bnd = force_reg (targetm.chkp_bound_mode (),
3077 expand_normal (CALL_EXPR_ARG (exp, 1)));
3078 res = chkp_join_splitted_slot (res, bnd);
3084 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3085 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3086 so that this can also be called without constructing an actual CALL_EXPR.
3087 The other arguments and return value are the same as for
3088 expand_builtin_mempcpy. */
3091 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3092 rtx target, machine_mode mode, int endp,
3095 tree fndecl = get_callee_fndecl (orig_exp);
3097 /* If return value is ignored, transform mempcpy into memcpy. */
3098 if (target == const0_rtx
3099 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP
3100 && builtin_decl_implicit_p (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP))
3102 tree fn = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP);
3103 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3105 return expand_expr (result, target, mode, EXPAND_NORMAL);
3107 else if (target == const0_rtx
3108 && builtin_decl_implicit_p (BUILT_IN_MEMCPY))
3110 tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
3111 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3113 return expand_expr (result, target, mode, EXPAND_NORMAL);
3117 const char *src_str;
3118 unsigned int src_align = get_pointer_alignment (src);
3119 unsigned int dest_align = get_pointer_alignment (dest);
3120 rtx dest_mem, src_mem, len_rtx;
3122 /* If either SRC or DEST is not a pointer type, don't do this
3123 operation in-line. */
3124 if (dest_align == 0 || src_align == 0)
3127 /* If LEN is not constant, call the normal function. */
3128 if (! tree_fits_uhwi_p (len))
3131 len_rtx = expand_normal (len);
3132 src_str = c_getstr (src);
3134 /* If SRC is a string constant and block move would be done
3135 by pieces, we can avoid loading the string from memory
3136 and only stored the computed constants. */
3138 && CONST_INT_P (len_rtx)
3139 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3140 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3141 CONST_CAST (char *, src_str),
3144 dest_mem = get_memory_rtx (dest, len);
3145 set_mem_align (dest_mem, dest_align);
3146 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3147 builtin_memcpy_read_str,
3148 CONST_CAST (char *, src_str),
3149 dest_align, false, endp);
3150 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3151 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3155 if (CONST_INT_P (len_rtx)
3156 && can_move_by_pieces (INTVAL (len_rtx),
3157 MIN (dest_align, src_align)))
3159 dest_mem = get_memory_rtx (dest, len);
3160 set_mem_align (dest_mem, dest_align);
3161 src_mem = get_memory_rtx (src, len);
3162 set_mem_align (src_mem, src_align);
3163 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3164 MIN (dest_align, src_align), endp);
3165 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3166 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3174 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3175 we failed, the caller should emit a normal call, otherwise try to
3176 get the result in TARGET, if convenient. If ENDP is 0 return the
3177 destination pointer, if ENDP is 1 return the end pointer ala
3178 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3182 expand_movstr (tree dest, tree src, rtx target, int endp)
3184 struct expand_operand ops[3];
3188 if (!targetm.have_movstr ())
3191 dest_mem = get_memory_rtx (dest, NULL);
3192 src_mem = get_memory_rtx (src, NULL);
3195 target = force_reg (Pmode, XEXP (dest_mem, 0));
3196 dest_mem = replace_equiv_address (dest_mem, target);
3199 create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3200 create_fixed_operand (&ops[1], dest_mem);
3201 create_fixed_operand (&ops[2], src_mem);
3202 if (!maybe_expand_insn (targetm.code_for_movstr, 3, ops))
3205 if (endp && target != const0_rtx)
3207 target = ops[0].value;
3208 /* movstr is supposed to set end to the address of the NUL
3209 terminator. If the caller requested a mempcpy-like return value,
3213 rtx tem = plus_constant (GET_MODE (target),
3214 gen_lowpart (GET_MODE (target), target), 1);
3215 emit_move_insn (target, force_operand (tem, NULL_RTX));
3221 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3222 NULL_RTX if we failed the caller should emit a normal call, otherwise
3223 try to get the result in TARGET, if convenient (and in mode MODE if that's
3227 expand_builtin_strcpy (tree exp, rtx target)
3229 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3231 tree dest = CALL_EXPR_ARG (exp, 0);
3232 tree src = CALL_EXPR_ARG (exp, 1);
3233 return expand_builtin_strcpy_args (dest, src, target);
3238 /* Helper function to do the actual work for expand_builtin_strcpy. The
3239 arguments to the builtin_strcpy call DEST and SRC are broken out
3240 so that this can also be called without constructing an actual CALL_EXPR.
3241 The other arguments and return value are the same as for
3242 expand_builtin_strcpy. */
3245 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3247 return expand_movstr (dest, src, target, /*endp=*/0);
3250 /* Expand a call EXP to the stpcpy builtin.
3251 Return NULL_RTX if we failed the caller should emit a normal call,
3252 otherwise try to get the result in TARGET, if convenient (and in
3253 mode MODE if that's convenient). */
3256 expand_builtin_stpcpy (tree exp, rtx target, machine_mode mode)
3259 location_t loc = EXPR_LOCATION (exp);
3261 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3264 dst = CALL_EXPR_ARG (exp, 0);
3265 src = CALL_EXPR_ARG (exp, 1);
3267 /* If return value is ignored, transform stpcpy into strcpy. */
3268 if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY))
3270 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3271 tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3272 return expand_expr (result, target, mode, EXPAND_NORMAL);
3279 /* Ensure we get an actual string whose length can be evaluated at
3280 compile-time, not an expression containing a string. This is
3281 because the latter will potentially produce pessimized code
3282 when used to produce the return value. */
3283 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3284 return expand_movstr (dst, src, target, /*endp=*/2);
3286 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3287 ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3288 target, mode, /*endp=*/2,
3294 if (TREE_CODE (len) == INTEGER_CST)
3296 rtx len_rtx = expand_normal (len);
3298 if (CONST_INT_P (len_rtx))
3300 ret = expand_builtin_strcpy_args (dst, src, target);
3306 if (mode != VOIDmode)
3307 target = gen_reg_rtx (mode);
3309 target = gen_reg_rtx (GET_MODE (ret));
3311 if (GET_MODE (target) != GET_MODE (ret))
3312 ret = gen_lowpart (GET_MODE (target), ret);
3314 ret = plus_constant (GET_MODE (ret), ret, INTVAL (len_rtx));
3315 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3323 return expand_movstr (dst, src, target, /*endp=*/2);
3327 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3328 bytes from constant string DATA + OFFSET and return it as target
3332 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3335 const char *str = (const char *) data;
3337 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3340 return c_readstr (str + offset, mode);
3343 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3344 NULL_RTX if we failed the caller should emit a normal call. */
3347 expand_builtin_strncpy (tree exp, rtx target)
3349 location_t loc = EXPR_LOCATION (exp);
3351 if (validate_arglist (exp,
3352 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3354 tree dest = CALL_EXPR_ARG (exp, 0);
3355 tree src = CALL_EXPR_ARG (exp, 1);
3356 tree len = CALL_EXPR_ARG (exp, 2);
3357 tree slen = c_strlen (src, 1);
3359 /* We must be passed a constant len and src parameter. */
3360 if (!tree_fits_uhwi_p (len) || !slen || !tree_fits_uhwi_p (slen))
3363 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3365 /* We're required to pad with trailing zeros if the requested
3366 len is greater than strlen(s2)+1. In that case try to
3367 use store_by_pieces, if it fails, punt. */
3368 if (tree_int_cst_lt (slen, len))
3370 unsigned int dest_align = get_pointer_alignment (dest);
3371 const char *p = c_getstr (src);
3374 if (!p || dest_align == 0 || !tree_fits_uhwi_p (len)
3375 || !can_store_by_pieces (tree_to_uhwi (len),
3376 builtin_strncpy_read_str,
3377 CONST_CAST (char *, p),
3381 dest_mem = get_memory_rtx (dest, len);
3382 store_by_pieces (dest_mem, tree_to_uhwi (len),
3383 builtin_strncpy_read_str,
3384 CONST_CAST (char *, p), dest_align, false, 0);
3385 dest_mem = force_operand (XEXP (dest_mem, 0), target);
3386 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3393 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3394 bytes from constant string DATA + OFFSET and return it as target
3398 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3401 const char *c = (const char *) data;
3402 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3404 memset (p, *c, GET_MODE_SIZE (mode));
3406 return c_readstr (p, mode);
3409 /* Callback routine for store_by_pieces. Return the RTL of a register
3410 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3411 char value given in the RTL register data. For example, if mode is
3412 4 bytes wide, return the RTL for 0x01010101*data. */
3415 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3422 size = GET_MODE_SIZE (mode);
3426 p = XALLOCAVEC (char, size);
3427 memset (p, 1, size);
3428 coeff = c_readstr (p, mode);
3430 target = convert_to_mode (mode, (rtx) data, 1);
3431 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3432 return force_reg (mode, target);
3435 /* Expand expression EXP, which is a call to the memset builtin. Return
3436 NULL_RTX if we failed the caller should emit a normal call, otherwise
3437 try to get the result in TARGET, if convenient (and in mode MODE if that's
3441 expand_builtin_memset (tree exp, rtx target, machine_mode mode)
3443 if (!validate_arglist (exp,
3444 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3448 tree dest = CALL_EXPR_ARG (exp, 0);
3449 tree val = CALL_EXPR_ARG (exp, 1);
3450 tree len = CALL_EXPR_ARG (exp, 2);
3451 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3455 /* Expand expression EXP, which is an instrumented call to the memset builtin.
3456 Return NULL_RTX if we failed the caller should emit a normal call, otherwise
3457 try to get the result in TARGET, if convenient (and in mode MODE if that's
3461 expand_builtin_memset_with_bounds (tree exp, rtx target, machine_mode mode)
3463 if (!validate_arglist (exp,
3464 POINTER_TYPE, POINTER_BOUNDS_TYPE,
3465 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3469 tree dest = CALL_EXPR_ARG (exp, 0);
3470 tree val = CALL_EXPR_ARG (exp, 2);
3471 tree len = CALL_EXPR_ARG (exp, 3);
3472 rtx res = expand_builtin_memset_args (dest, val, len, target, mode, exp);
3474 /* Return src bounds with the result. */
3477 rtx bnd = force_reg (targetm.chkp_bound_mode (),
3478 expand_normal (CALL_EXPR_ARG (exp, 1)));
3479 res = chkp_join_splitted_slot (res, bnd);
3485 /* Helper function to do the actual work for expand_builtin_memset. The
3486 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3487 so that this can also be called without constructing an actual CALL_EXPR.
3488 The other arguments and return value are the same as for
3489 expand_builtin_memset. */
3492 expand_builtin_memset_args (tree dest, tree val, tree len,
3493 rtx target, machine_mode mode, tree orig_exp)
3496 enum built_in_function fcode;
3497 machine_mode val_mode;
3499 unsigned int dest_align;
3500 rtx dest_mem, dest_addr, len_rtx;
3501 HOST_WIDE_INT expected_size = -1;
3502 unsigned int expected_align = 0;
3503 unsigned HOST_WIDE_INT min_size;
3504 unsigned HOST_WIDE_INT max_size;
3505 unsigned HOST_WIDE_INT probable_max_size;
3507 dest_align = get_pointer_alignment (dest);
3509 /* If DEST is not a pointer type, don't do this operation in-line. */
3510 if (dest_align == 0)
3513 if (currently_expanding_gimple_stmt)
3514 stringop_block_profile (currently_expanding_gimple_stmt,
3515 &expected_align, &expected_size);
3517 if (expected_align < dest_align)
3518 expected_align = dest_align;
3520 /* If the LEN parameter is zero, return DEST. */
3521 if (integer_zerop (len))
3523 /* Evaluate and ignore VAL in case it has side-effects. */
3524 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3525 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3528 /* Stabilize the arguments in case we fail. */
3529 dest = builtin_save_expr (dest);
3530 val = builtin_save_expr (val);
3531 len = builtin_save_expr (len);
3533 len_rtx = expand_normal (len);
3534 determine_block_size (len, len_rtx, &min_size, &max_size,
3535 &probable_max_size);
3536 dest_mem = get_memory_rtx (dest, len);
3537 val_mode = TYPE_MODE (unsigned_char_type_node);
3539 if (TREE_CODE (val) != INTEGER_CST)
3543 val_rtx = expand_normal (val);
3544 val_rtx = convert_to_mode (val_mode, val_rtx, 0);
3546 /* Assume that we can memset by pieces if we can store
3547 * the coefficients by pieces (in the required modes).
3548 * We can't pass builtin_memset_gen_str as that emits RTL. */
3550 if (tree_fits_uhwi_p (len)
3551 && can_store_by_pieces (tree_to_uhwi (len),
3552 builtin_memset_read_str, &c, dest_align,
3555 val_rtx = force_reg (val_mode, val_rtx);
3556 store_by_pieces (dest_mem, tree_to_uhwi (len),
3557 builtin_memset_gen_str, val_rtx, dest_align,
3560 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3561 dest_align, expected_align,
3562 expected_size, min_size, max_size,
3566 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3567 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3571 if (target_char_cast (val, &c))
3576 if (tree_fits_uhwi_p (len)
3577 && can_store_by_pieces (tree_to_uhwi (len),
3578 builtin_memset_read_str, &c, dest_align,
3580 store_by_pieces (dest_mem, tree_to_uhwi (len),
3581 builtin_memset_read_str, &c, dest_align, true, 0);
3582 else if (!set_storage_via_setmem (dest_mem, len_rtx,
3583 gen_int_mode (c, val_mode),
3584 dest_align, expected_align,
3585 expected_size, min_size, max_size,
3589 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3590 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3594 set_mem_align (dest_mem, dest_align);
3595 dest_addr = clear_storage_hints (dest_mem, len_rtx,
3596 CALL_EXPR_TAILCALL (orig_exp)
3597 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3598 expected_align, expected_size,
3604 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3605 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3611 fndecl = get_callee_fndecl (orig_exp);
3612 fcode = DECL_FUNCTION_CODE (fndecl);
3613 if (fcode == BUILT_IN_MEMSET
3614 || fcode == BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP)
3615 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
3617 else if (fcode == BUILT_IN_BZERO)
3618 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
3622 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3623 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3624 return expand_call (fn, target, target == const0_rtx);
3627 /* Expand expression EXP, which is a call to the bzero builtin. Return
3628 NULL_RTX if we failed the caller should emit a normal call. */
3631 expand_builtin_bzero (tree exp)
3634 location_t loc = EXPR_LOCATION (exp);
3636 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3639 dest = CALL_EXPR_ARG (exp, 0);
3640 size = CALL_EXPR_ARG (exp, 1);
3642 /* New argument list transforming bzero(ptr x, int y) to
3643 memset(ptr x, int 0, size_t y). This is done this way
3644 so that if it isn't expanded inline, we fallback to
3645 calling bzero instead of memset. */
3647 return expand_builtin_memset_args (dest, integer_zero_node,
3648 fold_convert_loc (loc,
3649 size_type_node, size),
3650 const0_rtx, VOIDmode, exp);
3653 /* Try to expand cmpstr operation ICODE with the given operands.
3654 Return the result rtx on success, otherwise return null. */
3657 expand_cmpstr (insn_code icode, rtx target, rtx arg1_rtx, rtx arg2_rtx,
3658 HOST_WIDE_INT align)
3660 machine_mode insn_mode = insn_data[icode].operand[0].mode;
3662 if (target && (!REG_P (target) || HARD_REGISTER_P (target)))
3665 struct expand_operand ops[4];
3666 create_output_operand (&ops[0], target, insn_mode);
3667 create_fixed_operand (&ops[1], arg1_rtx);
3668 create_fixed_operand (&ops[2], arg2_rtx);
3669 create_integer_operand (&ops[3], align);
3670 if (maybe_expand_insn (icode, 4, ops))
3671 return ops[0].value;
3675 /* Try to expand cmpstrn or cmpmem operation ICODE with the given operands.
3676 ARG3_TYPE is the type of ARG3_RTX. Return the result rtx on success,
3677 otherwise return null. */
3680 expand_cmpstrn_or_cmpmem (insn_code icode, rtx target, rtx arg1_rtx,
3681 rtx arg2_rtx, tree arg3_type, rtx arg3_rtx,
3682 HOST_WIDE_INT align)
3684 machine_mode insn_mode = insn_data[icode].operand[0].mode;
3686 if (target && (!REG_P (target) || HARD_REGISTER_P (target)))
3689 struct expand_operand ops[5];
3690 create_output_operand (&ops[0], target, insn_mode);
3691 create_fixed_operand (&ops[1], arg1_rtx);
3692 create_fixed_operand (&ops[2], arg2_rtx);
3693 create_convert_operand_from (&ops[3], arg3_rtx, TYPE_MODE (arg3_type),
3694 TYPE_UNSIGNED (arg3_type));
3695 create_integer_operand (&ops[4], align);
3696 if (maybe_expand_insn (icode, 5, ops))
3697 return ops[0].value;
3701 /* Expand expression EXP, which is a call to the memcmp built-in function.
3702 Return NULL_RTX if we failed and the caller should emit a normal call,
3703 otherwise try to get the result in TARGET, if convenient. */
3706 expand_builtin_memcmp (tree exp, rtx target)
3708 if (!validate_arglist (exp,
3709 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3712 /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3713 implementing memcmp because it will stop if it encounters two
3715 insn_code icode = direct_optab_handler (cmpmem_optab, SImode);
3716 if (icode == CODE_FOR_nothing)
3719 tree arg1 = CALL_EXPR_ARG (exp, 0);
3720 tree arg2 = CALL_EXPR_ARG (exp, 1);
3721 tree len = CALL_EXPR_ARG (exp, 2);
3723 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3724 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3726 /* If we don't have POINTER_TYPE, call the function. */
3727 if (arg1_align == 0 || arg2_align == 0)
3730 machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
3731 location_t loc = EXPR_LOCATION (exp);
3732 rtx arg1_rtx = get_memory_rtx (arg1, len);
3733 rtx arg2_rtx = get_memory_rtx (arg2, len);
3734 rtx arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3736 /* Set MEM_SIZE as appropriate. */
3737 if (CONST_INT_P (arg3_rtx))
3739 set_mem_size (arg1_rtx, INTVAL (arg3_rtx));
3740 set_mem_size (arg2_rtx, INTVAL (arg3_rtx));
3743 rtx result = expand_cmpstrn_or_cmpmem (icode, target, arg1_rtx, arg2_rtx,
3744 TREE_TYPE (len), arg3_rtx,
3745 MIN (arg1_align, arg2_align));
3748 /* Return the value in the proper mode for this function. */
3749 if (GET_MODE (result) == mode)
3754 convert_move (target, result, 0);
3758 return convert_to_mode (mode, result, 0);
3763 && REG_P (result) && GET_MODE (result) == mode
3764 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3765 result = gen_reg_rtx (mode);
3767 emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3768 TYPE_MODE (integer_type_node), 3,
3769 XEXP (arg1_rtx, 0), Pmode,
3770 XEXP (arg2_rtx, 0), Pmode,
3771 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3772 TYPE_UNSIGNED (sizetype)),
3773 TYPE_MODE (sizetype));
3777 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
3778 if we failed the caller should emit a normal call, otherwise try to get
3779 the result in TARGET, if convenient. */
3782 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
3784 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3787 insn_code cmpstr_icode = direct_optab_handler (cmpstr_optab, SImode);
3788 insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode);
3789 if (cmpstr_icode != CODE_FOR_nothing || cmpstrn_icode != CODE_FOR_nothing)
3791 rtx arg1_rtx, arg2_rtx;
3793 tree arg1 = CALL_EXPR_ARG (exp, 0);
3794 tree arg2 = CALL_EXPR_ARG (exp, 1);
3795 rtx result = NULL_RTX;
3797 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3798 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3800 /* If we don't have POINTER_TYPE, call the function. */
3801 if (arg1_align == 0 || arg2_align == 0)
3804 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
3805 arg1 = builtin_save_expr (arg1);
3806 arg2 = builtin_save_expr (arg2);
3808 arg1_rtx = get_memory_rtx (arg1, NULL);
3809 arg2_rtx = get_memory_rtx (arg2, NULL);
3811 /* Try to call cmpstrsi. */
3812 if (cmpstr_icode != CODE_FOR_nothing)
3813 result = expand_cmpstr (cmpstr_icode, target, arg1_rtx, arg2_rtx,
3814 MIN (arg1_align, arg2_align));
3816 /* Try to determine at least one length and call cmpstrnsi. */
3817 if (!result && cmpstrn_icode != CODE_FOR_nothing)
3822 tree len1 = c_strlen (arg1, 1);
3823 tree len2 = c_strlen (arg2, 1);
3826 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3828 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3830 /* If we don't have a constant length for the first, use the length
3831 of the second, if we know it. We don't require a constant for
3832 this case; some cost analysis could be done if both are available
3833 but neither is constant. For now, assume they're equally cheap,
3834 unless one has side effects. If both strings have constant lengths,
3841 else if (TREE_SIDE_EFFECTS (len1))
3843 else if (TREE_SIDE_EFFECTS (len2))
3845 else if (TREE_CODE (len1) != INTEGER_CST)
3847 else if (TREE_CODE (len2) != INTEGER_CST)
3849 else if (tree_int_cst_lt (len1, len2))
3854 /* If both arguments have side effects, we cannot optimize. */
3855 if (len && !TREE_SIDE_EFFECTS (len))
3857 arg3_rtx = expand_normal (len);
3858 result = expand_cmpstrn_or_cmpmem
3859 (cmpstrn_icode, target, arg1_rtx, arg2_rtx, TREE_TYPE (len),
3860 arg3_rtx, MIN (arg1_align, arg2_align));
3866 /* Return the value in the proper mode for this function. */
3867 machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
3868 if (GET_MODE (result) == mode)
3871 return convert_to_mode (mode, result, 0);
3872 convert_move (target, result, 0);
3876 /* Expand the library call ourselves using a stabilized argument
3877 list to avoid re-evaluating the function's arguments twice. */
3878 fndecl = get_callee_fndecl (exp);
3879 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
3880 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3881 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3882 return expand_call (fn, target, target == const0_rtx);
3887 /* Expand expression EXP, which is a call to the strncmp builtin. Return
3888 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
3889 the result in TARGET, if convenient. */
3892 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3893 ATTRIBUTE_UNUSED machine_mode mode)
3895 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3897 if (!validate_arglist (exp,
3898 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3901 /* If c_strlen can determine an expression for one of the string
3902 lengths, and it doesn't have side effects, then emit cmpstrnsi
3903 using length MIN(strlen(string)+1, arg3). */
3904 insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode);
3905 if (cmpstrn_icode != CODE_FOR_nothing)
3907 tree len, len1, len2;
3908 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3911 tree arg1 = CALL_EXPR_ARG (exp, 0);
3912 tree arg2 = CALL_EXPR_ARG (exp, 1);
3913 tree arg3 = CALL_EXPR_ARG (exp, 2);
3915 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3916 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3918 len1 = c_strlen (arg1, 1);
3919 len2 = c_strlen (arg2, 1);
3922 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
3924 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
3926 /* If we don't have a constant length for the first, use the length
3927 of the second, if we know it. We don't require a constant for
3928 this case; some cost analysis could be done if both are available
3929 but neither is constant. For now, assume they're equally cheap,
3930 unless one has side effects. If both strings have constant lengths,
3937 else if (TREE_SIDE_EFFECTS (len1))
3939 else if (TREE_SIDE_EFFECTS (len2))
3941 else if (TREE_CODE (len1) != INTEGER_CST)
3943 else if (TREE_CODE (len2) != INTEGER_CST)
3945 else if (tree_int_cst_lt (len1, len2))
3950 /* If both arguments have side effects, we cannot optimize. */
3951 if (!len || TREE_SIDE_EFFECTS (len))
3954 /* The actual new length parameter is MIN(len,arg3). */
3955 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
3956 fold_convert_loc (loc, TREE_TYPE (len), arg3));
3958 /* If we don't have POINTER_TYPE, call the function. */
3959 if (arg1_align == 0 || arg2_align == 0)
3962 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
3963 arg1 = builtin_save_expr (arg1);
3964 arg2 = builtin_save_expr (arg2);
3965 len = builtin_save_expr (len);
3967 arg1_rtx = get_memory_rtx (arg1, len);
3968 arg2_rtx = get_memory_rtx (arg2, len);
3969 arg3_rtx = expand_normal (len);
3970 result = expand_cmpstrn_or_cmpmem (cmpstrn_icode, target, arg1_rtx,
3971 arg2_rtx, TREE_TYPE (len), arg3_rtx,
3972 MIN (arg1_align, arg2_align));
3975 /* Return the value in the proper mode for this function. */
3976 mode = TYPE_MODE (TREE_TYPE (exp));
3977 if (GET_MODE (result) == mode)
3980 return convert_to_mode (mode, result, 0);
3981 convert_move (target, result, 0);
3985 /* Expand the library call ourselves using a stabilized argument
3986 list to avoid re-evaluating the function's arguments twice. */
3987 fndecl = get_callee_fndecl (exp);
3988 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
3990 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3991 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3992 return expand_call (fn, target, target == const0_rtx);
3997 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
3998 if that's convenient. */
4001 expand_builtin_saveregs (void)
4006 /* Don't do __builtin_saveregs more than once in a function.
4007 Save the result of the first call and reuse it. */
4008 if (saveregs_value != 0)
4009 return saveregs_value;
4011 /* When this function is called, it means that registers must be
4012 saved on entry to this function. So we migrate the call to the
4013 first insn of this function. */
4017 /* Do whatever the machine needs done in this case. */
4018 val = targetm.calls.expand_builtin_saveregs ();
4023 saveregs_value = val;
4025 /* Put the insns after the NOTE that starts the function. If this
4026 is inside a start_sequence, make the outer-level insn chain current, so
4027 the code is placed at the start of the function. */
4028 push_topmost_sequence ();
4029 emit_insn_after (seq, entry_of_function ());
4030 pop_topmost_sequence ();
4035 /* Expand a call to __builtin_next_arg. */
4038 expand_builtin_next_arg (void)
4040 /* Checking arguments is already done in fold_builtin_next_arg
4041 that must be called before this function. */
4042 return expand_binop (ptr_mode, add_optab,
4043 crtl->args.internal_arg_pointer,
4044 crtl->args.arg_offset_rtx,
4045 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4048 /* Make it easier for the backends by protecting the valist argument
4049 from multiple evaluations. */
4052 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4054 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4056 /* The current way of determining the type of valist is completely
4057 bogus. We should have the information on the va builtin instead. */
4059 vatype = targetm.fn_abi_va_list (cfun->decl);
4061 if (TREE_CODE (vatype) == ARRAY_TYPE)
4063 if (TREE_SIDE_EFFECTS (valist))
4064 valist = save_expr (valist);
4066 /* For this case, the backends will be expecting a pointer to
4067 vatype, but it's possible we've actually been given an array
4068 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4070 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4072 tree p1 = build_pointer_type (TREE_TYPE (vatype));
4073 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4078 tree pt = build_pointer_type (vatype);
4082 if (! TREE_SIDE_EFFECTS (valist))
4085 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4086 TREE_SIDE_EFFECTS (valist) = 1;
4089 if (TREE_SIDE_EFFECTS (valist))
4090 valist = save_expr (valist);
4091 valist = fold_build2_loc (loc, MEM_REF,
4092 vatype, valist, build_int_cst (pt, 0));
4098 /* The "standard" definition of va_list is void*. */
4101 std_build_builtin_va_list (void)
4103 return ptr_type_node;
4106 /* The "standard" abi va_list is va_list_type_node. */
4109 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4111 return va_list_type_node;
4114 /* The "standard" type of va_list is va_list_type_node. */
4117 std_canonical_va_list_type (tree type)
4121 if (INDIRECT_REF_P (type))
4122 type = TREE_TYPE (type);
4123 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE (type)))
4124 type = TREE_TYPE (type);
4125 wtype = va_list_type_node;
4127 /* Treat structure va_list types. */
4128 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4129 htype = TREE_TYPE (htype);
4130 else if (TREE_CODE (wtype) == ARRAY_TYPE)
4132 /* If va_list is an array type, the argument may have decayed
4133 to a pointer type, e.g. by being passed to another function.
4134 In that case, unwrap both types so that we can compare the
4135 underlying records. */
4136 if (TREE_CODE (htype) == ARRAY_TYPE
4137 || POINTER_TYPE_P (htype))
4139 wtype = TREE_TYPE (wtype);
4140 htype = TREE_TYPE (htype);
4143 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4144 return va_list_type_node;
4149 /* The "standard" implementation of va_start: just assign `nextarg' to
4153 std_expand_builtin_va_start (tree valist, rtx nextarg)
4155 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4156 convert_move (va_r, nextarg, 0);
4158 /* We do not have any valid bounds for the pointer, so
4159 just store zero bounds for it. */
4160 if (chkp_function_instrumented_p (current_function_decl))
4161 chkp_expand_bounds_reset_for_mem (valist,
4162 make_tree (TREE_TYPE (valist),
4166 /* Expand EXP, a call to __builtin_va_start. */
4169 expand_builtin_va_start (tree exp)
4173 location_t loc = EXPR_LOCATION (exp);
4175 if (call_expr_nargs (exp) < 2)
4177 error_at (loc, "too few arguments to function %<va_start%>");
4181 if (fold_builtin_next_arg (exp, true))
4184 nextarg = expand_builtin_next_arg ();
4185 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4187 if (targetm.expand_builtin_va_start)
4188 targetm.expand_builtin_va_start (valist, nextarg);
4190 std_expand_builtin_va_start (valist, nextarg);
4195 /* Expand EXP, a call to __builtin_va_end. */
4198 expand_builtin_va_end (tree exp)
4200 tree valist = CALL_EXPR_ARG (exp, 0);
4202 /* Evaluate for side effects, if needed. I hate macros that don't
4204 if (TREE_SIDE_EFFECTS (valist))
4205 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4210 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4211 builtin rather than just as an assignment in stdarg.h because of the
4212 nastiness of array-type va_list types. */
4215 expand_builtin_va_copy (tree exp)
4218 location_t loc = EXPR_LOCATION (exp);
4220 dst = CALL_EXPR_ARG (exp, 0);
4221 src = CALL_EXPR_ARG (exp, 1);
4223 dst = stabilize_va_list_loc (loc, dst, 1);
4224 src = stabilize_va_list_loc (loc, src, 0);
4226 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4228 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4230 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4231 TREE_SIDE_EFFECTS (t) = 1;
4232 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4236 rtx dstb, srcb, size;
4238 /* Evaluate to pointers. */
4239 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4240 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4241 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4242 NULL_RTX, VOIDmode, EXPAND_NORMAL);
4244 dstb = convert_memory_address (Pmode, dstb);
4245 srcb = convert_memory_address (Pmode, srcb);
4247 /* "Dereference" to BLKmode memories. */
4248 dstb = gen_rtx_MEM (BLKmode, dstb);
4249 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4250 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4251 srcb = gen_rtx_MEM (BLKmode, srcb);
4252 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4253 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4256 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4262 /* Expand a call to one of the builtin functions __builtin_frame_address or
4263 __builtin_return_address. */
4266 expand_builtin_frame_address (tree fndecl, tree exp)
4268 /* The argument must be a nonnegative integer constant.
4269 It counts the number of frames to scan up the stack.
4270 The value is either the frame pointer value or the return
4271 address saved in that frame. */
4272 if (call_expr_nargs (exp) == 0)
4273 /* Warning about missing arg was already issued. */
4275 else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp, 0)))
4277 error ("invalid argument to %qD", fndecl);
4282 /* Number of frames to scan up the stack. */
4283 unsigned HOST_WIDE_INT count = tree_to_uhwi (CALL_EXPR_ARG (exp, 0));
4285 rtx tem = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl), count);
4287 /* Some ports cannot access arbitrary stack frames. */
4290 warning (0, "unsupported argument to %qD", fndecl);
4296 /* Warn since no effort is made to ensure that any frame
4297 beyond the current one exists or can be safely reached. */
4298 warning (OPT_Wframe_address, "calling %qD with "
4299 "a nonzero argument is unsafe", fndecl);
4302 /* For __builtin_frame_address, return what we've got. */
4303 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4307 && ! CONSTANT_P (tem))
4308 tem = copy_addr_to_reg (tem);
4313 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4314 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4315 is the same as for allocate_dynamic_stack_space. */
4318 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4324 bool alloca_with_align = (DECL_FUNCTION_CODE (get_callee_fndecl (exp))
4325 == BUILT_IN_ALLOCA_WITH_ALIGN);
4328 = (alloca_with_align
4329 ? validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)
4330 : validate_arglist (exp, INTEGER_TYPE, VOID_TYPE));
4335 /* Compute the argument. */
4336 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4338 /* Compute the alignment. */
4339 align = (alloca_with_align
4340 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp, 1))
4341 : BIGGEST_ALIGNMENT);
4343 /* Allocate the desired space. */
4344 result = allocate_dynamic_stack_space (op0, 0, align, cannot_accumulate);
4345 result = convert_memory_address (ptr_mode, result);
4350 /* Expand a call to bswap builtin in EXP.
4351 Return NULL_RTX if a normal call should be emitted rather than expanding the
4352 function in-line. If convenient, the result should be placed in TARGET.
4353 SUBTARGET may be used as the target for computing one of EXP's operands. */
4356 expand_builtin_bswap (machine_mode target_mode, tree exp, rtx target,
4362 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4365 arg = CALL_EXPR_ARG (exp, 0);
4366 op0 = expand_expr (arg,
4367 subtarget && GET_MODE (subtarget) == target_mode
4368 ? subtarget : NULL_RTX,
4369 target_mode, EXPAND_NORMAL);
4370 if (GET_MODE (op0) != target_mode)
4371 op0 = convert_to_mode (target_mode, op0, 1);
4373 target = expand_unop (target_mode, bswap_optab, op0, target, 1);
4375 gcc_assert (target);
4377 return convert_to_mode (target_mode, target, 1);
4380 /* Expand a call to a unary builtin in EXP.
4381 Return NULL_RTX if a normal call should be emitted rather than expanding the
4382 function in-line. If convenient, the result should be placed in TARGET.
4383 SUBTARGET may be used as the target for computing one of EXP's operands. */
4386 expand_builtin_unop (machine_mode target_mode, tree exp, rtx target,
4387 rtx subtarget, optab op_optab)
4391 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4394 /* Compute the argument. */
4395 op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
4397 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
4398 == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
4399 VOIDmode, EXPAND_NORMAL);
4400 /* Compute op, into TARGET if possible.
4401 Set TARGET to wherever the result comes back. */
4402 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4403 op_optab, op0, target, op_optab != clrsb_optab);
4404 gcc_assert (target);
4406 return convert_to_mode (target_mode, target, 0);
4409 /* Expand a call to __builtin_expect. We just return our argument
4410 as the builtin_expect semantic should've been already executed by
4411 tree branch prediction pass. */
4414 expand_builtin_expect (tree exp, rtx target)
4418 if (call_expr_nargs (exp) < 2)
4420 arg = CALL_EXPR_ARG (exp, 0);
4422 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4423 /* When guessing was done, the hints should be already stripped away. */
4424 gcc_assert (!flag_guess_branch_prob
4425 || optimize == 0 || seen_error ());
4429 /* Expand a call to __builtin_assume_aligned. We just return our first
4430 argument as the builtin_assume_aligned semantic should've been already
4434 expand_builtin_assume_aligned (tree exp, rtx target)
4436 if (call_expr_nargs (exp) < 2)
4438 target = expand_expr (CALL_EXPR_ARG (exp, 0), target, VOIDmode,
4440 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 1))
4441 && (call_expr_nargs (exp) < 3
4442 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 2))));
4447 expand_builtin_trap (void)
4449 if (targetm.have_trap ())
4451 rtx_insn *insn = emit_insn (targetm.gen_trap ());
4452 /* For trap insns when not accumulating outgoing args force
4453 REG_ARGS_SIZE note to prevent crossjumping of calls with
4454 different args sizes. */
4455 if (!ACCUMULATE_OUTGOING_ARGS)
4456 add_reg_note (insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
4459 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4463 /* Expand a call to __builtin_unreachable. We do nothing except emit
4464 a barrier saying that control flow will not pass here.
4466 It is the responsibility of the program being compiled to ensure
4467 that control flow does never reach __builtin_unreachable. */
4469 expand_builtin_unreachable (void)
4474 /* Expand EXP, a call to fabs, fabsf or fabsl.
4475 Return NULL_RTX if a normal call should be emitted rather than expanding
4476 the function inline. If convenient, the result should be placed
4477 in TARGET. SUBTARGET may be used as the target for computing
4481 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4487 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4490 arg = CALL_EXPR_ARG (exp, 0);
4491 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4492 mode = TYPE_MODE (TREE_TYPE (arg));
4493 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4494 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4497 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4498 Return NULL is a normal call should be emitted rather than expanding the
4499 function inline. If convenient, the result should be placed in TARGET.
4500 SUBTARGET may be used as the target for computing the operand. */
4503 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4508 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4511 arg = CALL_EXPR_ARG (exp, 0);
4512 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4514 arg = CALL_EXPR_ARG (exp, 1);
4515 op1 = expand_normal (arg);
4517 return expand_copysign (op0, op1, target);
4520 /* Expand a call to __builtin___clear_cache. */
4523 expand_builtin___clear_cache (tree exp)
4525 if (!targetm.code_for_clear_cache)
4527 #ifdef CLEAR_INSN_CACHE
4528 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4529 does something. Just do the default expansion to a call to
4533 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4534 does nothing. There is no need to call it. Do nothing. */
4536 #endif /* CLEAR_INSN_CACHE */
4539 /* We have a "clear_cache" insn, and it will handle everything. */
4541 rtx begin_rtx, end_rtx;
4543 /* We must not expand to a library call. If we did, any
4544 fallback library function in libgcc that might contain a call to
4545 __builtin___clear_cache() would recurse infinitely. */
4546 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4548 error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4552 if (targetm.have_clear_cache ())
4554 struct expand_operand ops[2];
4556 begin = CALL_EXPR_ARG (exp, 0);
4557 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
4559 end = CALL_EXPR_ARG (exp, 1);
4560 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
4562 create_address_operand (&ops[0], begin_rtx);
4563 create_address_operand (&ops[1], end_rtx);
4564 if (maybe_expand_insn (targetm.code_for_clear_cache, 2, ops))
4570 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
4573 round_trampoline_addr (rtx tramp)
4575 rtx temp, addend, mask;
4577 /* If we don't need too much alignment, we'll have been guaranteed
4578 proper alignment by get_trampoline_type. */
4579 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
4582 /* Round address up to desired boundary. */
4583 temp = gen_reg_rtx (Pmode);
4584 addend = gen_int_mode (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1, Pmode);
4585 mask = gen_int_mode (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT, Pmode);
4587 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
4588 temp, 0, OPTAB_LIB_WIDEN);
4589 tramp = expand_simple_binop (Pmode, AND, temp, mask,
4590 temp, 0, OPTAB_LIB_WIDEN);
4596 expand_builtin_init_trampoline (tree exp, bool onstack)
4598 tree t_tramp, t_func, t_chain;
4599 rtx m_tramp, r_tramp, r_chain, tmp;
4601 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
4602 POINTER_TYPE, VOID_TYPE))
4605 t_tramp = CALL_EXPR_ARG (exp, 0);
4606 t_func = CALL_EXPR_ARG (exp, 1);
4607 t_chain = CALL_EXPR_ARG (exp, 2);
4609 r_tramp = expand_normal (t_tramp);
4610 m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
4611 MEM_NOTRAP_P (m_tramp) = 1;
4613 /* If ONSTACK, the TRAMP argument should be the address of a field
4614 within the local function's FRAME decl. Either way, let's see if
4615 we can fill in the MEM_ATTRs for this memory. */
4616 if (TREE_CODE (t_tramp) == ADDR_EXPR)
4617 set_mem_attributes (m_tramp, TREE_OPERAND (t_tramp, 0), true);
4619 /* Creator of a heap trampoline is responsible for making sure the
4620 address is aligned to at least STACK_BOUNDARY. Normally malloc
4621 will ensure this anyhow. */
4622 tmp = round_trampoline_addr (r_tramp);
4625 m_tramp = change_address (m_tramp, BLKmode, tmp);
4626 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
4627 set_mem_size (m_tramp, TRAMPOLINE_SIZE);
4630 /* The FUNC argument should be the address of the nested function.
4631 Extract the actual function decl to pass to the hook. */
4632 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
4633 t_func = TREE_OPERAND (t_func, 0);
4634 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
4636 r_chain = expand_normal (t_chain);
4638 /* Generate insns to initialize the trampoline. */
4639 targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
4643 trampolines_created = 1;
4645 warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
4646 "trampoline generated for nested function %qD", t_func);
4653 expand_builtin_adjust_trampoline (tree exp)
4657 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
4660 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
4661 tramp = round_trampoline_addr (tramp);
4662 if (targetm.calls.trampoline_adjust_address)
4663 tramp = targetm.calls.trampoline_adjust_address (tramp);
4668 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4669 function. The function first checks whether the back end provides
4670 an insn to implement signbit for the respective mode. If not, it
4671 checks whether the floating point format of the value is such that
4672 the sign bit can be extracted. If that is not the case, error out.
4673 EXP is the expression that is a call to the builtin function; if
4674 convenient, the result should be placed in TARGET. */
4676 expand_builtin_signbit (tree exp, rtx target)
4678 const struct real_format *fmt;
4679 machine_mode fmode, imode, rmode;
4682 enum insn_code icode;
4684 location_t loc = EXPR_LOCATION (exp);
4686 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4689 arg = CALL_EXPR_ARG (exp, 0);
4690 fmode = TYPE_MODE (TREE_TYPE (arg));
4691 rmode = TYPE_MODE (TREE_TYPE (exp));
4692 fmt = REAL_MODE_FORMAT (fmode);
4694 arg = builtin_save_expr (arg);
4696 /* Expand the argument yielding a RTX expression. */
4697 temp = expand_normal (arg);
4699 /* Check if the back end provides an insn that handles signbit for the
4701 icode = optab_handler (signbit_optab, fmode);
4702 if (icode != CODE_FOR_nothing)
4704 rtx_insn *last = get_last_insn ();
4705 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
4706 if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
4708 delete_insns_since (last);
4711 /* For floating point formats without a sign bit, implement signbit
4713 bitpos = fmt->signbit_ro;
4716 /* But we can't do this if the format supports signed zero. */
4717 gcc_assert (!fmt->has_signed_zero || !HONOR_SIGNED_ZEROS (fmode));
4719 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
4720 build_real (TREE_TYPE (arg), dconst0));
4721 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4724 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
4726 imode = int_mode_for_mode (fmode);
4727 gcc_assert (imode != BLKmode);
4728 temp = gen_lowpart (imode, temp);
4733 /* Handle targets with different FP word orders. */
4734 if (FLOAT_WORDS_BIG_ENDIAN)
4735 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
4737 word = bitpos / BITS_PER_WORD;
4738 temp = operand_subword_force (temp, word, fmode);
4739 bitpos = bitpos % BITS_PER_WORD;
4742 /* Force the intermediate word_mode (or narrower) result into a
4743 register. This avoids attempting to create paradoxical SUBREGs
4744 of floating point modes below. */
4745 temp = force_reg (imode, temp);
4747 /* If the bitpos is within the "result mode" lowpart, the operation
4748 can be implement with a single bitwise AND. Otherwise, we need
4749 a right shift and an AND. */
4751 if (bitpos < GET_MODE_BITSIZE (rmode))
4753 wide_int mask = wi::set_bit_in_zero (bitpos, GET_MODE_PRECISION (rmode));
4755 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
4756 temp = gen_lowpart (rmode, temp);
4757 temp = expand_binop (rmode, and_optab, temp,
4758 immed_wide_int_const (mask, rmode),
4759 NULL_RTX, 1, OPTAB_LIB_WIDEN);
4763 /* Perform a logical right shift to place the signbit in the least
4764 significant bit, then truncate the result to the desired mode
4765 and mask just this bit. */
4766 temp = expand_shift (RSHIFT_EXPR, imode, temp, bitpos, NULL_RTX, 1);
4767 temp = gen_lowpart (rmode, temp);
4768 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
4769 NULL_RTX, 1, OPTAB_LIB_WIDEN);
4775 /* Expand fork or exec calls. TARGET is the desired target of the
4776 call. EXP is the call. FN is the
4777 identificator of the actual function. IGNORE is nonzero if the
4778 value is to be ignored. */
4781 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
4786 /* If we are not profiling, just call the function. */
4787 if (!profile_arc_flag)
4790 /* Otherwise call the wrapper. This should be equivalent for the rest of
4791 compiler, so the code does not diverge, and the wrapper may run the
4792 code necessary for keeping the profiling sane. */
4794 switch (DECL_FUNCTION_CODE (fn))
4797 id = get_identifier ("__gcov_fork");
4800 case BUILT_IN_EXECL:
4801 id = get_identifier ("__gcov_execl");
4804 case BUILT_IN_EXECV:
4805 id = get_identifier ("__gcov_execv");
4808 case BUILT_IN_EXECLP:
4809 id = get_identifier ("__gcov_execlp");
4812 case BUILT_IN_EXECLE:
4813 id = get_identifier ("__gcov_execle");
4816 case BUILT_IN_EXECVP:
4817 id = get_identifier ("__gcov_execvp");
4820 case BUILT_IN_EXECVE:
4821 id = get_identifier ("__gcov_execve");
4828 decl = build_decl (DECL_SOURCE_LOCATION (fn),
4829 FUNCTION_DECL, id, TREE_TYPE (fn));
4830 DECL_EXTERNAL (decl) = 1;
4831 TREE_PUBLIC (decl) = 1;
4832 DECL_ARTIFICIAL (decl) = 1;
4833 TREE_NOTHROW (decl) = 1;
4834 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4835 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4836 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
4837 return expand_call (call, target, ignore);
4842 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
4843 the pointer in these functions is void*, the tree optimizers may remove
4844 casts. The mode computed in expand_builtin isn't reliable either, due
4845 to __sync_bool_compare_and_swap.
4847 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
4848 group of builtins. This gives us log2 of the mode size. */
4850 static inline machine_mode
4851 get_builtin_sync_mode (int fcode_diff)
4853 /* The size is not negotiable, so ask not to get BLKmode in return
4854 if the target indicates that a smaller size would be better. */
4855 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
4858 /* Expand the memory expression LOC and return the appropriate memory operand
4859 for the builtin_sync operations. */
4862 get_builtin_sync_mem (tree loc, machine_mode mode)
4866 addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
4867 addr = convert_memory_address (Pmode, addr);
4869 /* Note that we explicitly do not want any alias information for this
4870 memory, so that we kill all other live memories. Otherwise we don't
4871 satisfy the full barrier semantics of the intrinsic. */
4872 mem = validize_mem (gen_rtx_MEM (mode, addr));
4874 /* The alignment needs to be at least according to that of the mode. */
4875 set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
4876 get_pointer_alignment (loc)));
4877 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
4878 MEM_VOLATILE_P (mem) = 1;
4883 /* Make sure an argument is in the right mode.
4884 EXP is the tree argument.
4885 MODE is the mode it should be in. */
4888 expand_expr_force_mode (tree exp, machine_mode mode)
4891 machine_mode old_mode;
4893 val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL);
4894 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
4895 of CONST_INTs, where we know the old_mode only from the call argument. */
4897 old_mode = GET_MODE (val);
4898 if (old_mode == VOIDmode)
4899 old_mode = TYPE_MODE (TREE_TYPE (exp));
4900 val = convert_modes (mode, old_mode, val, 1);
4905 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
4906 EXP is the CALL_EXPR. CODE is the rtx code
4907 that corresponds to the arithmetic or logical operation from the name;
4908 an exception here is that NOT actually means NAND. TARGET is an optional
4909 place for us to store the results; AFTER is true if this is the
4910 fetch_and_xxx form. */
4913 expand_builtin_sync_operation (machine_mode mode, tree exp,
4914 enum rtx_code code, bool after,
4918 location_t loc = EXPR_LOCATION (exp);
4920 if (code == NOT && warn_sync_nand)
4922 tree fndecl = get_callee_fndecl (exp);
4923 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4925 static bool warned_f_a_n, warned_n_a_f;
4929 case BUILT_IN_SYNC_FETCH_AND_NAND_1:
4930 case BUILT_IN_SYNC_FETCH_AND_NAND_2:
4931 case BUILT_IN_SYNC_FETCH_AND_NAND_4:
4932 case BUILT_IN_SYNC_FETCH_AND_NAND_8:
4933 case BUILT_IN_SYNC_FETCH_AND_NAND_16:
4937 fndecl = builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N);
4938 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
4939 warned_f_a_n = true;
4942 case BUILT_IN_SYNC_NAND_AND_FETCH_1:
4943 case BUILT_IN_SYNC_NAND_AND_FETCH_2:
4944 case BUILT_IN_SYNC_NAND_AND_FETCH_4:
4945 case BUILT_IN_SYNC_NAND_AND_FETCH_8:
4946 case BUILT_IN_SYNC_NAND_AND_FETCH_16:
4950 fndecl = builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N);
4951 inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
4952 warned_n_a_f = true;
4960 /* Expand the operands. */
4961 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
4962 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
4964 return expand_atomic_fetch_op (target, mem, val, code, MEMMODEL_SYNC_SEQ_CST,
4968 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
4969 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
4970 true if this is the boolean form. TARGET is a place for us to store the
4971 results; this is NOT optional if IS_BOOL is true. */
4974 expand_builtin_compare_and_swap (machine_mode mode, tree exp,
4975 bool is_bool, rtx target)
4977 rtx old_val, new_val, mem;
4980 /* Expand the operands. */
4981 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
4982 old_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
4983 new_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
4985 pbool = poval = NULL;
4986 if (target != const0_rtx)
4993 if (!expand_atomic_compare_and_swap (pbool, poval, mem, old_val, new_val,
4994 false, MEMMODEL_SYNC_SEQ_CST,
4995 MEMMODEL_SYNC_SEQ_CST))
5001 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5002 general form is actually an atomic exchange, and some targets only
5003 support a reduced form with the second argument being a constant 1.
5004 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5008 expand_builtin_sync_lock_test_and_set (machine_mode mode, tree exp,
5013 /* Expand the operands. */
5014 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5015 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5017 return expand_sync_lock_test_and_set (target, mem, val);
5020 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5023 expand_builtin_sync_lock_release (machine_mode mode, tree exp)
5027 /* Expand the operands. */
5028 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5030 expand_atomic_store (mem, const0_rtx, MEMMODEL_SYNC_RELEASE, true);
5033 /* Given an integer representing an ``enum memmodel'', verify its
5034 correctness and return the memory model enum. */
5036 static enum memmodel
5037 get_memmodel (tree exp)
5040 unsigned HOST_WIDE_INT val;
5042 = expansion_point_location_if_in_system_header (input_location);
5044 /* If the parameter is not a constant, it's a run time value so we'll just
5045 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5046 if (TREE_CODE (exp) != INTEGER_CST)
5047 return MEMMODEL_SEQ_CST;
5049 op = expand_normal (exp);
5052 if (targetm.memmodel_check)
5053 val = targetm.memmodel_check (val);
5054 else if (val & ~MEMMODEL_MASK)
5056 warning_at (loc, OPT_Winvalid_memory_model,
5057 "unknown architecture specifier in memory model to builtin");
5058 return MEMMODEL_SEQ_CST;
5061 /* Should never see a user explicit SYNC memodel model, so >= LAST works. */
5062 if (memmodel_base (val) >= MEMMODEL_LAST)
5064 warning_at (loc, OPT_Winvalid_memory_model,
5065 "invalid memory model argument to builtin");
5066 return MEMMODEL_SEQ_CST;
5069 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
5070 be conservative and promote consume to acquire. */
5071 if (val == MEMMODEL_CONSUME)
5072 val = MEMMODEL_ACQUIRE;
5074 return (enum memmodel) val;
5077 /* Expand the __atomic_exchange intrinsic:
5078 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5079 EXP is the CALL_EXPR.
5080 TARGET is an optional place for us to store the results. */
5083 expand_builtin_atomic_exchange (machine_mode mode, tree exp, rtx target)
5086 enum memmodel model;
5088 model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5090 if (!flag_inline_atomics)
5093 /* Expand the operands. */
5094 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5095 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5097 return expand_atomic_exchange (target, mem, val, model);
5100 /* Expand the __atomic_compare_exchange intrinsic:
5101 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5102 TYPE desired, BOOL weak,
5103 enum memmodel success,
5104 enum memmodel failure)
5105 EXP is the CALL_EXPR.
5106 TARGET is an optional place for us to store the results. */
5109 expand_builtin_atomic_compare_exchange (machine_mode mode, tree exp,
5112 rtx expect, desired, mem, oldval;
5113 rtx_code_label *label;
5114 enum memmodel success, failure;
5118 = expansion_point_location_if_in_system_header (input_location);
5120 success = get_memmodel (CALL_EXPR_ARG (exp, 4));
5121 failure = get_memmodel (CALL_EXPR_ARG (exp, 5));
5123 if (failure > success)
5125 warning_at (loc, OPT_Winvalid_memory_model,
5126 "failure memory model cannot be stronger than success "
5127 "memory model for %<__atomic_compare_exchange%>");
5128 success = MEMMODEL_SEQ_CST;
5131 if (is_mm_release (failure) || is_mm_acq_rel (failure))
5133 warning_at (loc, OPT_Winvalid_memory_model,
5134 "invalid failure memory model for "
5135 "%<__atomic_compare_exchange%>");
5136 failure = MEMMODEL_SEQ_CST;
5137 success = MEMMODEL_SEQ_CST;
5141 if (!flag_inline_atomics)
5144 /* Expand the operands. */
5145 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5147 expect = expand_normal (CALL_EXPR_ARG (exp, 1));
5148 expect = convert_memory_address (Pmode, expect);
5149 expect = gen_rtx_MEM (mode, expect);
5150 desired = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5152 weak = CALL_EXPR_ARG (exp, 3);
5154 if (tree_fits_shwi_p (weak) && tree_to_shwi (weak) != 0)
5157 if (target == const0_rtx)
5160 /* Lest the rtl backend create a race condition with an imporoper store
5161 to memory, always create a new pseudo for OLDVAL. */
5164 if (!expand_atomic_compare_and_swap (&target, &oldval, mem, expect, desired,
5165 is_weak, success, failure))
5168 /* Conditionally store back to EXPECT, lest we create a race condition
5169 with an improper store to memory. */
5170 /* ??? With a rearrangement of atomics at the gimple level, we can handle
5171 the normal case where EXPECT is totally private, i.e. a register. At
5172 which point the store can be unconditional. */
5173 label = gen_label_rtx ();
5174 emit_cmp_and_jump_insns (target, const0_rtx, NE, NULL,
5175 GET_MODE (target), 1, label);
5176 emit_move_insn (expect, oldval);
5182 /* Expand the __atomic_load intrinsic:
5183 TYPE __atomic_load (TYPE *object, enum memmodel)
5184 EXP is the CALL_EXPR.
5185 TARGET is an optional place for us to store the results. */
5188 expand_builtin_atomic_load (machine_mode mode, tree exp, rtx target)
5191 enum memmodel model;
5193 model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5194 if (is_mm_release (model) || is_mm_acq_rel (model))
5197 = expansion_point_location_if_in_system_header (input_location);
5198 warning_at (loc, OPT_Winvalid_memory_model,
5199 "invalid memory model for %<__atomic_load%>");
5200 model = MEMMODEL_SEQ_CST;
5203 if (!flag_inline_atomics)
5206 /* Expand the operand. */
5207 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5209 return expand_atomic_load (target, mem, model);
5213 /* Expand the __atomic_store intrinsic:
5214 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5215 EXP is the CALL_EXPR.
5216 TARGET is an optional place for us to store the results. */
5219 expand_builtin_atomic_store (machine_mode mode, tree exp)
5222 enum memmodel model;
5224 model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5225 if (!(is_mm_relaxed (model) || is_mm_seq_cst (model)
5226 || is_mm_release (model)))
5229 = expansion_point_location_if_in_system_header (input_location);
5230 warning_at (loc, OPT_Winvalid_memory_model,
5231 "invalid memory model for %<__atomic_store%>");
5232 model = MEMMODEL_SEQ_CST;
5235 if (!flag_inline_atomics)
5238 /* Expand the operands. */
5239 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5240 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5242 return expand_atomic_store (mem, val, model, false);
5245 /* Expand the __atomic_fetch_XXX intrinsic:
5246 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5247 EXP is the CALL_EXPR.
5248 TARGET is an optional place for us to store the results.
5249 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5250 FETCH_AFTER is true if returning the result of the operation.
5251 FETCH_AFTER is false if returning the value before the operation.
5252 IGNORE is true if the result is not used.
5253 EXT_CALL is the correct builtin for an external call if this cannot be
5254 resolved to an instruction sequence. */
5257 expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target,
5258 enum rtx_code code, bool fetch_after,
5259 bool ignore, enum built_in_function ext_call)
5262 enum memmodel model;
5266 model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5268 /* Expand the operands. */
5269 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5270 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5272 /* Only try generating instructions if inlining is turned on. */
5273 if (flag_inline_atomics)
5275 ret = expand_atomic_fetch_op (target, mem, val, code, model, fetch_after);
5280 /* Return if a different routine isn't needed for the library call. */
5281 if (ext_call == BUILT_IN_NONE)
5284 /* Change the call to the specified function. */
5285 fndecl = get_callee_fndecl (exp);
5286 addr = CALL_EXPR_FN (exp);
5289 gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
5290 TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call);
5292 /* Expand the call here so we can emit trailing code. */
5293 ret = expand_call (exp, target, ignore);
5295 /* Replace the original function just in case it matters. */
5296 TREE_OPERAND (addr, 0) = fndecl;
5298 /* Then issue the arithmetic correction to return the right result. */
5303 ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true,
5305 ret = expand_simple_unop (mode, NOT, ret, target, true);
5308 ret = expand_simple_binop (mode, code, ret, val, target, true,
5314 /* Expand an atomic clear operation.
5315 void _atomic_clear (BOOL *obj, enum memmodel)
5316 EXP is the call expression. */
5319 expand_builtin_atomic_clear (tree exp)
5323 enum memmodel model;
5325 mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5326 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5327 model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5329 if (is_mm_consume (model) || is_mm_acquire (model) || is_mm_acq_rel (model))
5332 = expansion_point_location_if_in_system_header (input_location);
5333 warning_at (loc, OPT_Winvalid_memory_model,
5334 "invalid memory model for %<__atomic_store%>");
5335 model = MEMMODEL_SEQ_CST;
5338 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5339 Failing that, a store is issued by __atomic_store. The only way this can
5340 fail is if the bool type is larger than a word size. Unlikely, but
5341 handle it anyway for completeness. Assume a single threaded model since
5342 there is no atomic support in this case, and no barriers are required. */
5343 ret = expand_atomic_store (mem, const0_rtx, model, true);
5345 emit_move_insn (mem, const0_rtx);
5349 /* Expand an atomic test_and_set operation.
5350 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5351 EXP is the call expression. */
5354 expand_builtin_atomic_test_and_set (tree exp, rtx target)
5357 enum memmodel model;
5360 mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5361 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5362 model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5364 return expand_atomic_test_and_set (target, mem, model);
5368 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5369 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
5372 fold_builtin_atomic_always_lock_free (tree arg0, tree arg1)
5376 unsigned int mode_align, type_align;
5378 if (TREE_CODE (arg0) != INTEGER_CST)
5381 size = INTVAL (expand_normal (arg0)) * BITS_PER_UNIT;
5382 mode = mode_for_size (size, MODE_INT, 0);
5383 mode_align = GET_MODE_ALIGNMENT (mode);
5385 if (TREE_CODE (arg1) == INTEGER_CST)
5387 unsigned HOST_WIDE_INT val = UINTVAL (expand_normal (arg1));
5389 /* Either this argument is null, or it's a fake pointer encoding
5390 the alignment of the object. */
5392 val *= BITS_PER_UNIT;
5394 if (val == 0 || mode_align < val)
5395 type_align = mode_align;
5401 tree ttype = TREE_TYPE (arg1);
5403 /* This function is usually invoked and folded immediately by the front
5404 end before anything else has a chance to look at it. The pointer
5405 parameter at this point is usually cast to a void *, so check for that
5406 and look past the cast. */
5407 if (CONVERT_EXPR_P (arg1)
5408 && POINTER_TYPE_P (ttype)
5409 && VOID_TYPE_P (TREE_TYPE (ttype))
5410 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5411 arg1 = TREE_OPERAND (arg1, 0);
5413 ttype = TREE_TYPE (arg1);
5414 gcc_assert (POINTER_TYPE_P (ttype));
5416 /* Get the underlying type of the object. */
5417 ttype = TREE_TYPE (ttype);
5418 type_align = TYPE_ALIGN (ttype);
5421 /* If the object has smaller alignment, the lock free routines cannot
5423 if (type_align < mode_align)
5424 return boolean_false_node;
5426 /* Check if a compare_and_swap pattern exists for the mode which represents
5427 the required size. The pattern is not allowed to fail, so the existence
5428 of the pattern indicates support is present. */
5429 if (can_compare_and_swap_p (mode, true))
5430 return boolean_true_node;
5432 return boolean_false_node;
5435 /* Return true if the parameters to call EXP represent an object which will
5436 always generate lock free instructions. The first argument represents the
5437 size of the object, and the second parameter is a pointer to the object
5438 itself. If NULL is passed for the object, then the result is based on
5439 typical alignment for an object of the specified size. Otherwise return
5443 expand_builtin_atomic_always_lock_free (tree exp)
5446 tree arg0 = CALL_EXPR_ARG (exp, 0);
5447 tree arg1 = CALL_EXPR_ARG (exp, 1);
5449 if (TREE_CODE (arg0) != INTEGER_CST)
5451 error ("non-constant argument 1 to __atomic_always_lock_free");
5455 size = fold_builtin_atomic_always_lock_free (arg0, arg1);
5456 if (size == boolean_true_node)
5461 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5462 is lock free on this architecture. */
5465 fold_builtin_atomic_is_lock_free (tree arg0, tree arg1)
5467 if (!flag_inline_atomics)
5470 /* If it isn't always lock free, don't generate a result. */
5471 if (fold_builtin_atomic_always_lock_free (arg0, arg1) == boolean_true_node)
5472 return boolean_true_node;
5477 /* Return true if the parameters to call EXP represent an object which will
5478 always generate lock free instructions. The first argument represents the
5479 size of the object, and the second parameter is a pointer to the object
5480 itself. If NULL is passed for the object, then the result is based on
5481 typical alignment for an object of the specified size. Otherwise return
5485 expand_builtin_atomic_is_lock_free (tree exp)
5488 tree arg0 = CALL_EXPR_ARG (exp, 0);
5489 tree arg1 = CALL_EXPR_ARG (exp, 1);
5491 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5493 error ("non-integer argument 1 to __atomic_is_lock_free");
5497 if (!flag_inline_atomics)
5500 /* If the value is known at compile time, return the RTX for it. */
5501 size = fold_builtin_atomic_is_lock_free (arg0, arg1);
5502 if (size == boolean_true_node)
5508 /* Expand the __atomic_thread_fence intrinsic:
5509 void __atomic_thread_fence (enum memmodel)
5510 EXP is the CALL_EXPR. */
5513 expand_builtin_atomic_thread_fence (tree exp)
5515 enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5516 expand_mem_thread_fence (model);
5519 /* Expand the __atomic_signal_fence intrinsic:
5520 void __atomic_signal_fence (enum memmodel)
5521 EXP is the CALL_EXPR. */
5524 expand_builtin_atomic_signal_fence (tree exp)
5526 enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5527 expand_mem_signal_fence (model);
5530 /* Expand the __sync_synchronize intrinsic. */
5533 expand_builtin_sync_synchronize (void)
5535 expand_mem_thread_fence (MEMMODEL_SYNC_SEQ_CST);
5539 expand_builtin_thread_pointer (tree exp, rtx target)
5541 enum insn_code icode;
5542 if (!validate_arglist (exp, VOID_TYPE))
5544 icode = direct_optab_handler (get_thread_pointer_optab, Pmode);
5545 if (icode != CODE_FOR_nothing)
5547 struct expand_operand op;
5548 /* If the target is not sutitable then create a new target. */
5549 if (target == NULL_RTX
5551 || GET_MODE (target) != Pmode)
5552 target = gen_reg_rtx (Pmode);
5553 create_output_operand (&op, target, Pmode);
5554 expand_insn (icode, 1, &op);
5557 error ("__builtin_thread_pointer is not supported on this target");
5562 expand_builtin_set_thread_pointer (tree exp)
5564 enum insn_code icode;
5565 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5567 icode = direct_optab_handler (set_thread_pointer_optab, Pmode);
5568 if (icode != CODE_FOR_nothing)
5570 struct expand_operand op;
5571 rtx val = expand_expr (CALL_EXPR_ARG (exp, 0), NULL_RTX,
5572 Pmode, EXPAND_NORMAL);
5573 create_input_operand (&op, val, Pmode);
5574 expand_insn (icode, 1, &op);
5577 error ("__builtin_set_thread_pointer is not supported on this target");
5581 /* Emit code to restore the current value of stack. */
5584 expand_stack_restore (tree var)
5587 rtx sa = expand_normal (var);
5589 sa = convert_memory_address (Pmode, sa);
5591 prev = get_last_insn ();
5592 emit_stack_restore (SAVE_BLOCK, sa);
5594 record_new_stack_level ();
5596 fixup_args_size_notes (prev, get_last_insn (), 0);
5599 /* Emit code to save the current value of stack. */
5602 expand_stack_save (void)
5606 emit_stack_save (SAVE_BLOCK, &ret);
5611 /* Expand an expression EXP that calls a built-in function,
5612 with result going to TARGET if that's convenient
5613 (and in mode MODE if that's convenient).
5614 SUBTARGET may be used as the target for computing one of EXP's operands.
5615 IGNORE is nonzero if the value is to be ignored. */
5618 expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode,
5621 tree fndecl = get_callee_fndecl (exp);
5622 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5623 machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5626 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5627 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5629 /* When ASan is enabled, we don't want to expand some memory/string
5630 builtins and rely on libsanitizer's hooks. This allows us to avoid
5631 redundant checks and be sure, that possible overflow will be detected
5634 if ((flag_sanitize & SANITIZE_ADDRESS) && asan_intercepted_p (fcode))
5635 return expand_call (exp, target, ignore);
5637 /* When not optimizing, generate calls to library functions for a certain
5640 && !called_as_built_in (fndecl)
5641 && fcode != BUILT_IN_FORK
5642 && fcode != BUILT_IN_EXECL
5643 && fcode != BUILT_IN_EXECV
5644 && fcode != BUILT_IN_EXECLP
5645 && fcode != BUILT_IN_EXECLE
5646 && fcode != BUILT_IN_EXECVP
5647 && fcode != BUILT_IN_EXECVE
5648 && fcode != BUILT_IN_ALLOCA
5649 && fcode != BUILT_IN_ALLOCA_WITH_ALIGN
5650 && fcode != BUILT_IN_FREE
5651 && fcode != BUILT_IN_CHKP_SET_PTR_BOUNDS
5652 && fcode != BUILT_IN_CHKP_INIT_PTR_BOUNDS
5653 && fcode != BUILT_IN_CHKP_NULL_PTR_BOUNDS
5654 && fcode != BUILT_IN_CHKP_COPY_PTR_BOUNDS
5655 && fcode != BUILT_IN_CHKP_NARROW_PTR_BOUNDS
5656 && fcode != BUILT_IN_CHKP_STORE_PTR_BOUNDS
5657 && fcode != BUILT_IN_CHKP_CHECK_PTR_LBOUNDS
5658 && fcode != BUILT_IN_CHKP_CHECK_PTR_UBOUNDS
5659 && fcode != BUILT_IN_CHKP_CHECK_PTR_BOUNDS
5660 && fcode != BUILT_IN_CHKP_GET_PTR_LBOUND
5661 && fcode != BUILT_IN_CHKP_GET_PTR_UBOUND
5662 && fcode != BUILT_IN_CHKP_BNDRET)
5663 return expand_call (exp, target, ignore);
5665 /* The built-in function expanders test for target == const0_rtx
5666 to determine whether the function's result will be ignored. */
5668 target = const0_rtx;
5670 /* If the result of a pure or const built-in function is ignored, and
5671 none of its arguments are volatile, we can avoid expanding the
5672 built-in call and just evaluate the arguments for side-effects. */
5673 if (target == const0_rtx
5674 && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5675 && !(flags & ECF_LOOPING_CONST_OR_PURE))
5677 bool volatilep = false;
5679 call_expr_arg_iterator iter;
5681 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5682 if (TREE_THIS_VOLATILE (arg))
5690 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5691 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5696 /* expand_builtin_with_bounds is supposed to be used for
5697 instrumented builtin calls. */
5698 gcc_assert (!CALL_WITH_BOUNDS_P (exp));
5702 CASE_FLT_FN (BUILT_IN_FABS):
5703 case BUILT_IN_FABSD32:
5704 case BUILT_IN_FABSD64:
5705 case BUILT_IN_FABSD128:
5706 target = expand_builtin_fabs (exp, target, subtarget);
5711 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5712 target = expand_builtin_copysign (exp, target, subtarget);
5717 /* Just do a normal library call if we were unable to fold
5719 CASE_FLT_FN (BUILT_IN_CABS):
5722 CASE_FLT_FN (BUILT_IN_FMA):
5723 target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5728 CASE_FLT_FN (BUILT_IN_ILOGB):
5729 if (! flag_unsafe_math_optimizations)
5731 CASE_FLT_FN (BUILT_IN_ISINF):
5732 CASE_FLT_FN (BUILT_IN_FINITE):
5733 case BUILT_IN_ISFINITE:
5734 case BUILT_IN_ISNORMAL:
5735 target = expand_builtin_interclass_mathfn (exp, target);
5740 CASE_FLT_FN (BUILT_IN_ICEIL):
5741 CASE_FLT_FN (BUILT_IN_LCEIL):
5742 CASE_FLT_FN (BUILT_IN_LLCEIL):
5743 CASE_FLT_FN (BUILT_IN_LFLOOR):
5744 CASE_FLT_FN (BUILT_IN_IFLOOR):
5745 CASE_FLT_FN (BUILT_IN_LLFLOOR):
5746 target = expand_builtin_int_roundingfn (exp, target);
5751 CASE_FLT_FN (BUILT_IN_IRINT):
5752 CASE_FLT_FN (BUILT_IN_LRINT):
5753 CASE_FLT_FN (BUILT_IN_LLRINT):
5754 CASE_FLT_FN (BUILT_IN_IROUND):
5755 CASE_FLT_FN (BUILT_IN_LROUND):
5756 CASE_FLT_FN (BUILT_IN_LLROUND):
5757 target = expand_builtin_int_roundingfn_2 (exp, target);
5762 CASE_FLT_FN (BUILT_IN_POWI):
5763 target = expand_builtin_powi (exp, target);
5768 CASE_FLT_FN (BUILT_IN_CEXPI):
5769 target = expand_builtin_cexpi (exp, target);
5770 gcc_assert (target);
5773 CASE_FLT_FN (BUILT_IN_SIN):
5774 CASE_FLT_FN (BUILT_IN_COS):
5775 if (! flag_unsafe_math_optimizations)
5777 target = expand_builtin_mathfn_3 (exp, target, subtarget);
5782 CASE_FLT_FN (BUILT_IN_SINCOS):
5783 if (! flag_unsafe_math_optimizations)
5785 target = expand_builtin_sincos (exp);
5790 case BUILT_IN_APPLY_ARGS:
5791 return expand_builtin_apply_args ();
5793 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5794 FUNCTION with a copy of the parameters described by
5795 ARGUMENTS, and ARGSIZE. It returns a block of memory
5796 allocated on the stack into which is stored all the registers
5797 that might possibly be used for returning the result of a
5798 function. ARGUMENTS is the value returned by
5799 __builtin_apply_args. ARGSIZE is the number of bytes of
5800 arguments that must be copied. ??? How should this value be
5801 computed? We'll also need a safe worst case value for varargs
5803 case BUILT_IN_APPLY:
5804 if (!validate_arglist (exp, POINTER_TYPE,
5805 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5806 && !validate_arglist (exp, REFERENCE_TYPE,
5807 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5813 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5814 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5815 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5817 return expand_builtin_apply (ops[0], ops[1], ops[2]);
5820 /* __builtin_return (RESULT) causes the function to return the
5821 value described by RESULT. RESULT is address of the block of
5822 memory returned by __builtin_apply. */
5823 case BUILT_IN_RETURN:
5824 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5825 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5828 case BUILT_IN_SAVEREGS:
5829 return expand_builtin_saveregs ();
5831 case BUILT_IN_VA_ARG_PACK:
5832 /* All valid uses of __builtin_va_arg_pack () are removed during
5834 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5837 case BUILT_IN_VA_ARG_PACK_LEN:
5838 /* All valid uses of __builtin_va_arg_pack_len () are removed during
5840 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5843 /* Return the address of the first anonymous stack arg. */
5844 case BUILT_IN_NEXT_ARG:
5845 if (fold_builtin_next_arg (exp, false))
5847 return expand_builtin_next_arg ();
5849 case BUILT_IN_CLEAR_CACHE:
5850 target = expand_builtin___clear_cache (exp);
5855 case BUILT_IN_CLASSIFY_TYPE:
5856 return expand_builtin_classify_type (exp);
5858 case BUILT_IN_CONSTANT_P:
5861 case BUILT_IN_FRAME_ADDRESS:
5862 case BUILT_IN_RETURN_ADDRESS:
5863 return expand_builtin_frame_address (fndecl, exp);
5865 /* Returns the address of the area where the structure is returned.
5867 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5868 if (call_expr_nargs (exp) != 0
5869 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5870 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5873 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5875 case BUILT_IN_ALLOCA:
5876 case BUILT_IN_ALLOCA_WITH_ALIGN:
5877 /* If the allocation stems from the declaration of a variable-sized
5878 object, it cannot accumulate. */
5879 target = expand_builtin_alloca (exp, CALL_ALLOCA_FOR_VAR_P (exp));
5884 case BUILT_IN_STACK_SAVE:
5885 return expand_stack_save ();
5887 case BUILT_IN_STACK_RESTORE:
5888 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
5891 case BUILT_IN_BSWAP16:
5892 case BUILT_IN_BSWAP32:
5893 case BUILT_IN_BSWAP64:
5894 target = expand_builtin_bswap (target_mode, exp, target, subtarget);
5899 CASE_INT_FN (BUILT_IN_FFS):
5900 target = expand_builtin_unop (target_mode, exp, target,
5901 subtarget, ffs_optab);
5906 CASE_INT_FN (BUILT_IN_CLZ):
5907 target = expand_builtin_unop (target_mode, exp, target,
5908 subtarget, clz_optab);
5913 CASE_INT_FN (BUILT_IN_CTZ):
5914 target = expand_builtin_unop (target_mode, exp, target,
5915 subtarget, ctz_optab);
5920 CASE_INT_FN (BUILT_IN_CLRSB):
5921 target = expand_builtin_unop (target_mode, exp, target,
5922 subtarget, clrsb_optab);
5927 CASE_INT_FN (BUILT_IN_POPCOUNT):
5928 target = expand_builtin_unop (target_mode, exp, target,
5929 subtarget, popcount_optab);
5934 CASE_INT_FN (BUILT_IN_PARITY):
5935 target = expand_builtin_unop (target_mode, exp, target,
5936 subtarget, parity_optab);
5941 case BUILT_IN_STRLEN:
5942 target = expand_builtin_strlen (exp, target, target_mode);
5947 case BUILT_IN_STRCPY:
5948 target = expand_builtin_strcpy (exp, target);
5953 case BUILT_IN_STRNCPY:
5954 target = expand_builtin_strncpy (exp, target);
5959 case BUILT_IN_STPCPY:
5960 target = expand_builtin_stpcpy (exp, target, mode);
5965 case BUILT_IN_MEMCPY:
5966 target = expand_builtin_memcpy (exp, target);
5971 case BUILT_IN_MEMPCPY:
5972 target = expand_builtin_mempcpy (exp, target, mode);
5977 case BUILT_IN_MEMSET:
5978 target = expand_builtin_memset (exp, target, mode);
5983 case BUILT_IN_BZERO:
5984 target = expand_builtin_bzero (exp);
5989 case BUILT_IN_STRCMP:
5990 target = expand_builtin_strcmp (exp, target);
5995 case BUILT_IN_STRNCMP:
5996 target = expand_builtin_strncmp (exp, target, mode);
6002 case BUILT_IN_MEMCMP:
6003 target = expand_builtin_memcmp (exp, target);
6008 case BUILT_IN_SETJMP:
6009 /* This should have been lowered to the builtins below. */
6012 case BUILT_IN_SETJMP_SETUP:
6013 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6014 and the receiver label. */
6015 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6017 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6018 VOIDmode, EXPAND_NORMAL);
6019 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6020 rtx_insn *label_r = label_rtx (label);
6022 /* This is copied from the handling of non-local gotos. */
6023 expand_builtin_setjmp_setup (buf_addr, label_r);
6024 nonlocal_goto_handler_labels
6025 = gen_rtx_INSN_LIST (VOIDmode, label_r,
6026 nonlocal_goto_handler_labels);
6027 /* ??? Do not let expand_label treat us as such since we would
6028 not want to be both on the list of non-local labels and on
6029 the list of forced labels. */
6030 FORCED_LABEL (label) = 0;
6035 case BUILT_IN_SETJMP_RECEIVER:
6036 /* __builtin_setjmp_receiver is passed the receiver label. */
6037 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6039 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6040 rtx_insn *label_r = label_rtx (label);
6042 expand_builtin_setjmp_receiver (label_r);
6047 /* __builtin_longjmp is passed a pointer to an array of five words.
6048 It's similar to the C library longjmp function but works with
6049 __builtin_setjmp above. */
6050 case BUILT_IN_LONGJMP:
6051 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6053 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6054 VOIDmode, EXPAND_NORMAL);
6055 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6057 if (value != const1_rtx)
6059 error ("%<__builtin_longjmp%> second argument must be 1");
6063 expand_builtin_longjmp (buf_addr, value);
6068 case BUILT_IN_NONLOCAL_GOTO:
6069 target = expand_builtin_nonlocal_goto (exp);
6074 /* This updates the setjmp buffer that is its argument with the value
6075 of the current stack pointer. */
6076 case BUILT_IN_UPDATE_SETJMP_BUF:
6077 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6080 = expand_normal (CALL_EXPR_ARG (exp, 0));
6082 expand_builtin_update_setjmp_buf (buf_addr);
6088 expand_builtin_trap ();
6091 case BUILT_IN_UNREACHABLE:
6092 expand_builtin_unreachable ();
6095 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6096 case BUILT_IN_SIGNBITD32:
6097 case BUILT_IN_SIGNBITD64:
6098 case BUILT_IN_SIGNBITD128:
6099 target = expand_builtin_signbit (exp, target);
6104 /* Various hooks for the DWARF 2 __throw routine. */
6105 case BUILT_IN_UNWIND_INIT:
6106 expand_builtin_unwind_init ();
6108 case BUILT_IN_DWARF_CFA:
6109 return virtual_cfa_rtx;
6110 #ifdef DWARF2_UNWIND_INFO
6111 case BUILT_IN_DWARF_SP_COLUMN:
6112 return expand_builtin_dwarf_sp_column ();
6113 case BUILT_IN_INIT_DWARF_REG_SIZES:
6114 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6117 case BUILT_IN_FROB_RETURN_ADDR:
6118 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6119 case BUILT_IN_EXTRACT_RETURN_ADDR:
6120 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6121 case BUILT_IN_EH_RETURN:
6122 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6123 CALL_EXPR_ARG (exp, 1));
6125 case BUILT_IN_EH_RETURN_DATA_REGNO:
6126 return expand_builtin_eh_return_data_regno (exp);
6127 case BUILT_IN_EXTEND_POINTER:
6128 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6129 case BUILT_IN_EH_POINTER:
6130 return expand_builtin_eh_pointer (exp);
6131 case BUILT_IN_EH_FILTER:
6132 return expand_builtin_eh_filter (exp);
6133 case BUILT_IN_EH_COPY_VALUES:
6134 return expand_builtin_eh_copy_values (exp);
6136 case BUILT_IN_VA_START:
6137 return expand_builtin_va_start (exp);
6138 case BUILT_IN_VA_END:
6139 return expand_builtin_va_end (exp);
6140 case BUILT_IN_VA_COPY:
6141 return expand_builtin_va_copy (exp);
6142 case BUILT_IN_EXPECT:
6143 return expand_builtin_expect (exp, target);
6144 case BUILT_IN_ASSUME_ALIGNED:
6145 return expand_builtin_assume_aligned (exp, target);
6146 case BUILT_IN_PREFETCH:
6147 expand_builtin_prefetch (exp);
6150 case BUILT_IN_INIT_TRAMPOLINE:
6151 return expand_builtin_init_trampoline (exp, true);
6152 case BUILT_IN_INIT_HEAP_TRAMPOLINE:
6153 return expand_builtin_init_trampoline (exp, false);
6154 case BUILT_IN_ADJUST_TRAMPOLINE:
6155 return expand_builtin_adjust_trampoline (exp);
6158 case BUILT_IN_EXECL:
6159 case BUILT_IN_EXECV:
6160 case BUILT_IN_EXECLP:
6161 case BUILT_IN_EXECLE:
6162 case BUILT_IN_EXECVP:
6163 case BUILT_IN_EXECVE:
6164 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6169 case BUILT_IN_SYNC_FETCH_AND_ADD_1:
6170 case BUILT_IN_SYNC_FETCH_AND_ADD_2:
6171 case BUILT_IN_SYNC_FETCH_AND_ADD_4:
6172 case BUILT_IN_SYNC_FETCH_AND_ADD_8:
6173 case BUILT_IN_SYNC_FETCH_AND_ADD_16:
6174 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_ADD_1);
6175 target = expand_builtin_sync_operation (mode, exp, PLUS, false, target);
6180 case BUILT_IN_SYNC_FETCH_AND_SUB_1:
6181 case BUILT_IN_SYNC_FETCH_AND_SUB_2:
6182 case BUILT_IN_SYNC_FETCH_AND_SUB_4:
6183 case BUILT_IN_SYNC_FETCH_AND_SUB_8:
6184 case BUILT_IN_SYNC_FETCH_AND_SUB_16:
6185 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_SUB_1);
6186 target = expand_builtin_sync_operation (mode, exp, MINUS, false, target);
6191 case BUILT_IN_SYNC_FETCH_AND_OR_1:
6192 case BUILT_IN_SYNC_FETCH_AND_OR_2:
6193 case BUILT_IN_SYNC_FETCH_AND_OR_4:
6194 case BUILT_IN_SYNC_FETCH_AND_OR_8:
6195 case BUILT_IN_SYNC_FETCH_AND_OR_16:
6196 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_OR_1);
6197 target = expand_builtin_sync_operation (mode, exp, IOR, false, target);
6202 case BUILT_IN_SYNC_FETCH_AND_AND_1:
6203 case BUILT_IN_SYNC_FETCH_AND_AND_2:
6204 case BUILT_IN_SYNC_FETCH_AND_AND_4:
6205 case BUILT_IN_SYNC_FETCH_AND_AND_8:
6206 case BUILT_IN_SYNC_FETCH_AND_AND_16:
6207 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_AND_1);
6208 target = expand_builtin_sync_operation (mode, exp, AND, false, target);
6213 case BUILT_IN_SYNC_FETCH_AND_XOR_1:
6214 case BUILT_IN_SYNC_FETCH_AND_XOR_2:
6215 case BUILT_IN_SYNC_FETCH_AND_XOR_4:
6216 case BUILT_IN_SYNC_FETCH_AND_XOR_8:
6217 case BUILT_IN_SYNC_FETCH_AND_XOR_16:
6218 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_XOR_1);
6219 target = expand_builtin_sync_operation (mode, exp, XOR, false, target);
6224 case BUILT_IN_SYNC_FETCH_AND_NAND_1:
6225 case BUILT_IN_SYNC_FETCH_AND_NAND_2:
6226 case BUILT_IN_SYNC_FETCH_AND_NAND_4:
6227 case BUILT_IN_SYNC_FETCH_AND_NAND_8:
6228 case BUILT_IN_SYNC_FETCH_AND_NAND_16:
6229 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_NAND_1);
6230 target = expand_builtin_sync_operation (mode, exp, NOT, false, target);
6235 case BUILT_IN_SYNC_ADD_AND_FETCH_1:
6236 case BUILT_IN_SYNC_ADD_AND_FETCH_2:
6237 case BUILT_IN_SYNC_ADD_AND_FETCH_4:
6238 case BUILT_IN_SYNC_ADD_AND_FETCH_8:
6239 case BUILT_IN_SYNC_ADD_AND_FETCH_16:
6240 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_ADD_AND_FETCH_1);
6241 target = expand_builtin_sync_operation (mode, exp, PLUS, true, target);
6246 case BUILT_IN_SYNC_SUB_AND_FETCH_1:
6247 case BUILT_IN_SYNC_SUB_AND_FETCH_2:
6248 case BUILT_IN_SYNC_SUB_AND_FETCH_4:
6249 case BUILT_IN_SYNC_SUB_AND_FETCH_8:
6250 case BUILT_IN_SYNC_SUB_AND_FETCH_16:
6251 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_SUB_AND_FETCH_1);
6252 target = expand_builtin_sync_operation (mode, exp, MINUS, true, target);
6257 case BUILT_IN_SYNC_OR_AND_FETCH_1:
6258 case BUILT_IN_SYNC_OR_AND_FETCH_2:
6259 case BUILT_IN_SYNC_OR_AND_FETCH_4:
6260 case BUILT_IN_SYNC_OR_AND_FETCH_8:
6261 case BUILT_IN_SYNC_OR_AND_FETCH_16:
6262 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_OR_AND_FETCH_1);
6263 target = expand_builtin_sync_operation (mode, exp, IOR, true, target);
6268 case BUILT_IN_SYNC_AND_AND_FETCH_1:
6269 case BUILT_IN_SYNC_AND_AND_FETCH_2:
6270 case BUILT_IN_SYNC_AND_AND_FETCH_4:
6271 case BUILT_IN_SYNC_AND_AND_FETCH_8:
6272 case BUILT_IN_SYNC_AND_AND_FETCH_16:
6273 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_AND_AND_FETCH_1);
6274 target = expand_builtin_sync_operation (mode, exp, AND, true, target);
6279 case BUILT_IN_SYNC_XOR_AND_FETCH_1:
6280 case BUILT_IN_SYNC_XOR_AND_FETCH_2:
6281 case BUILT_IN_SYNC_XOR_AND_FETCH_4:
6282 case BUILT_IN_SYNC_XOR_AND_FETCH_8:
6283 case BUILT_IN_SYNC_XOR_AND_FETCH_16:
6284 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_XOR_AND_FETCH_1);
6285 target = expand_builtin_sync_operation (mode, exp, XOR, true, target);
6290 case BUILT_IN_SYNC_NAND_AND_FETCH_1:
6291 case BUILT_IN_SYNC_NAND_AND_FETCH_2:
6292 case BUILT_IN_SYNC_NAND_AND_FETCH_4:
6293 case BUILT_IN_SYNC_NAND_AND_FETCH_8:
6294 case BUILT_IN_SYNC_NAND_AND_FETCH_16:
6295 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_NAND_AND_FETCH_1);
6296 target = expand_builtin_sync_operation (mode, exp, NOT, true, target);
6301 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1:
6302 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2:
6303 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4:
6304 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8:
6305 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16:
6306 if (mode == VOIDmode)
6307 mode = TYPE_MODE (boolean_type_node);
6308 if (!target || !register_operand (target, mode))
6309 target = gen_reg_rtx (mode);
6311 mode = get_builtin_sync_mode
6312 (fcode - BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1);
6313 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6318 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1:
6319 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2:
6320 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4:
6321 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8:
6322 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16:
6323 mode = get_builtin_sync_mode
6324 (fcode - BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1);
6325 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6330 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1:
6331 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2:
6332 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4:
6333 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8:
6334 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16:
6335 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_TEST_AND_SET_1);
6336 target = expand_builtin_sync_lock_test_and_set (mode, exp, target);
6341 case BUILT_IN_SYNC_LOCK_RELEASE_1:
6342 case BUILT_IN_SYNC_LOCK_RELEASE_2:
6343 case BUILT_IN_SYNC_LOCK_RELEASE_4:
6344 case BUILT_IN_SYNC_LOCK_RELEASE_8:
6345 case BUILT_IN_SYNC_LOCK_RELEASE_16:
6346 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_RELEASE_1);
6347 expand_builtin_sync_lock_release (mode, exp);
6350 case BUILT_IN_SYNC_SYNCHRONIZE:
6351 expand_builtin_sync_synchronize ();
6354 case BUILT_IN_ATOMIC_EXCHANGE_1:
6355 case BUILT_IN_ATOMIC_EXCHANGE_2:
6356 case BUILT_IN_ATOMIC_EXCHANGE_4:
6357 case BUILT_IN_ATOMIC_EXCHANGE_8:
6358 case BUILT_IN_ATOMIC_EXCHANGE_16:
6359 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_EXCHANGE_1);
6360 target = expand_builtin_atomic_exchange (mode, exp, target);
6365 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
6366 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
6367 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
6368 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
6369 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
6371 unsigned int nargs, z;
6372 vec<tree, va_gc> *vec;
6375 get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1);
6376 target = expand_builtin_atomic_compare_exchange (mode, exp, target);
6380 /* If this is turned into an external library call, the weak parameter
6381 must be dropped to match the expected parameter list. */
6382 nargs = call_expr_nargs (exp);
6383 vec_alloc (vec, nargs - 1);
6384 for (z = 0; z < 3; z++)
6385 vec->quick_push (CALL_EXPR_ARG (exp, z));
6386 /* Skip the boolean weak parameter. */
6387 for (z = 4; z < 6; z++)
6388 vec->quick_push (CALL_EXPR_ARG (exp, z));
6389 exp = build_call_vec (TREE_TYPE (exp), CALL_EXPR_FN (exp), vec);
6393 case BUILT_IN_ATOMIC_LOAD_1:
6394 case BUILT_IN_ATOMIC_LOAD_2:
6395 case BUILT_IN_ATOMIC_LOAD_4:
6396 case BUILT_IN_ATOMIC_LOAD_8:
6397 case BUILT_IN_ATOMIC_LOAD_16:
6398 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_LOAD_1);
6399 target = expand_builtin_atomic_load (mode, exp, target);
6404 case BUILT_IN_ATOMIC_STORE_1:
6405 case BUILT_IN_ATOMIC_STORE_2:
6406 case BUILT_IN_ATOMIC_STORE_4:
6407 case BUILT_IN_ATOMIC_STORE_8:
6408 case BUILT_IN_ATOMIC_STORE_16:
6409 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_STORE_1);
6410 target = expand_builtin_atomic_store (mode, exp);
6415 case BUILT_IN_ATOMIC_ADD_FETCH_1:
6416 case BUILT_IN_ATOMIC_ADD_FETCH_2:
6417 case BUILT_IN_ATOMIC_ADD_FETCH_4:
6418 case BUILT_IN_ATOMIC_ADD_FETCH_8:
6419 case BUILT_IN_ATOMIC_ADD_FETCH_16:
6421 enum built_in_function lib;
6422 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1);
6423 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_ADD_1 +
6424 (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1));
6425 target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, true,
6431 case BUILT_IN_ATOMIC_SUB_FETCH_1:
6432 case BUILT_IN_ATOMIC_SUB_FETCH_2:
6433 case BUILT_IN_ATOMIC_SUB_FETCH_4:
6434 case BUILT_IN_ATOMIC_SUB_FETCH_8:
6435 case BUILT_IN_ATOMIC_SUB_FETCH_16:
6437 enum built_in_function lib;
6438 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1);
6439 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_SUB_1 +
6440 (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1));
6441 target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, true,
6447 case BUILT_IN_ATOMIC_AND_FETCH_1:
6448 case BUILT_IN_ATOMIC_AND_FETCH_2:
6449 case BUILT_IN_ATOMIC_AND_FETCH_4:
6450 case BUILT_IN_ATOMIC_AND_FETCH_8:
6451 case BUILT_IN_ATOMIC_AND_FETCH_16:
6453 enum built_in_function lib;
6454 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_AND_FETCH_1);
6455 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_AND_1 +
6456 (fcode - BUILT_IN_ATOMIC_AND_FETCH_1));
6457 target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, true,
6463 case BUILT_IN_ATOMIC_NAND_FETCH_1:
6464 case BUILT_IN_ATOMIC_NAND_FETCH_2:
6465 case BUILT_IN_ATOMIC_NAND_FETCH_4:
6466 case BUILT_IN_ATOMIC_NAND_FETCH_8:
6467 case BUILT_IN_ATOMIC_NAND_FETCH_16:
6469 enum built_in_function lib;
6470 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1);
6471 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_NAND_1 +
6472 (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1));
6473 target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, true,
6479 case BUILT_IN_ATOMIC_XOR_FETCH_1:
6480 case BUILT_IN_ATOMIC_XOR_FETCH_2:
6481 case BUILT_IN_ATOMIC_XOR_FETCH_4:
6482 case BUILT_IN_ATOMIC_XOR_FETCH_8:
6483 case BUILT_IN_ATOMIC_XOR_FETCH_16:
6485 enum built_in_function lib;
6486 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1);
6487 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_XOR_1 +
6488 (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1));
6489 target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, true,
6495 case BUILT_IN_ATOMIC_OR_FETCH_1:
6496 case BUILT_IN_ATOMIC_OR_FETCH_2:
6497 case BUILT_IN_ATOMIC_OR_FETCH_4:
6498 case BUILT_IN_ATOMIC_OR_FETCH_8:
6499 case BUILT_IN_ATOMIC_OR_FETCH_16:
6501 enum built_in_function lib;
6502 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_OR_FETCH_1);
6503 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_OR_1 +
6504 (fcode - BUILT_IN_ATOMIC_OR_FETCH_1));
6505 target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, true,
6511 case BUILT_IN_ATOMIC_FETCH_ADD_1:
6512 case BUILT_IN_ATOMIC_FETCH_ADD_2:
6513 case BUILT_IN_ATOMIC_FETCH_ADD_4:
6514 case BUILT_IN_ATOMIC_FETCH_ADD_8:
6515 case BUILT_IN_ATOMIC_FETCH_ADD_16:
6516 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_ADD_1);
6517 target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, false,
6518 ignore, BUILT_IN_NONE);
6523 case BUILT_IN_ATOMIC_FETCH_SUB_1:
6524 case BUILT_IN_ATOMIC_FETCH_SUB_2:
6525 case BUILT_IN_ATOMIC_FETCH_SUB_4:
6526 case BUILT_IN_ATOMIC_FETCH_SUB_8:
6527 case BUILT_IN_ATOMIC_FETCH_SUB_16:
6528 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_SUB_1);
6529 target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, false,
6530 ignore, BUILT_IN_NONE);
6535 case BUILT_IN_ATOMIC_FETCH_AND_1:
6536 case BUILT_IN_ATOMIC_FETCH_AND_2:
6537 case BUILT_IN_ATOMIC_FETCH_AND_4:
6538 case BUILT_IN_ATOMIC_FETCH_AND_8:
6539 case BUILT_IN_ATOMIC_FETCH_AND_16:
6540 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_AND_1);
6541 target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, false,
6542 ignore, BUILT_IN_NONE);
6547 case BUILT_IN_ATOMIC_FETCH_NAND_1:
6548 case BUILT_IN_ATOMIC_FETCH_NAND_2:
6549 case BUILT_IN_ATOMIC_FETCH_NAND_4:
6550 case BUILT_IN_ATOMIC_FETCH_NAND_8:
6551 case BUILT_IN_ATOMIC_FETCH_NAND_16:
6552 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_NAND_1);
6553 target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, false,
6554 ignore, BUILT_IN_NONE);
6559 case BUILT_IN_ATOMIC_FETCH_XOR_1:
6560 case BUILT_IN_ATOMIC_FETCH_XOR_2:
6561 case BUILT_IN_ATOMIC_FETCH_XOR_4:
6562 case BUILT_IN_ATOMIC_FETCH_XOR_8:
6563 case BUILT_IN_ATOMIC_FETCH_XOR_16:
6564 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_XOR_1);
6565 target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, false,
6566 ignore, BUILT_IN_NONE);
6571 case BUILT_IN_ATOMIC_FETCH_OR_1:
6572 case BUILT_IN_ATOMIC_FETCH_OR_2:
6573 case BUILT_IN_ATOMIC_FETCH_OR_4:
6574 case BUILT_IN_ATOMIC_FETCH_OR_8:
6575 case BUILT_IN_ATOMIC_FETCH_OR_16:
6576 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_OR_1);
6577 target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, false,
6578 ignore, BUILT_IN_NONE);
6583 case BUILT_IN_ATOMIC_TEST_AND_SET:
6584 return expand_builtin_atomic_test_and_set (exp, target);
6586 case BUILT_IN_ATOMIC_CLEAR:
6587 return expand_builtin_atomic_clear (exp);
6589 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
6590 return expand_builtin_atomic_always_lock_free (exp);
6592 case BUILT_IN_ATOMIC_IS_LOCK_FREE:
6593 target = expand_builtin_atomic_is_lock_free (exp);
6598 case BUILT_IN_ATOMIC_THREAD_FENCE:
6599 expand_builtin_atomic_thread_fence (exp);
6602 case BUILT_IN_ATOMIC_SIGNAL_FENCE:
6603 expand_builtin_atomic_signal_fence (exp);
6606 case BUILT_IN_OBJECT_SIZE:
6607 return expand_builtin_object_size (exp);
6609 case BUILT_IN_MEMCPY_CHK:
6610 case BUILT_IN_MEMPCPY_CHK:
6611 case BUILT_IN_MEMMOVE_CHK:
6612 case BUILT_IN_MEMSET_CHK:
6613 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6618 case BUILT_IN_STRCPY_CHK:
6619 case BUILT_IN_STPCPY_CHK:
6620 case BUILT_IN_STRNCPY_CHK:
6621 case BUILT_IN_STPNCPY_CHK:
6622 case BUILT_IN_STRCAT_CHK:
6623 case BUILT_IN_STRNCAT_CHK:
6624 case BUILT_IN_SNPRINTF_CHK:
6625 case BUILT_IN_VSNPRINTF_CHK:
6626 maybe_emit_chk_warning (exp, fcode);
6629 case BUILT_IN_SPRINTF_CHK:
6630 case BUILT_IN_VSPRINTF_CHK:
6631 maybe_emit_sprintf_chk_warning (exp, fcode);
6635 if (warn_free_nonheap_object)
6636 maybe_emit_free_warning (exp);
6639 case BUILT_IN_THREAD_POINTER:
6640 return expand_builtin_thread_pointer (exp, target);
6642 case BUILT_IN_SET_THREAD_POINTER:
6643 expand_builtin_set_thread_pointer (exp);
6646 case BUILT_IN_CILK_DETACH:
6647 expand_builtin_cilk_detach (exp);
6650 case BUILT_IN_CILK_POP_FRAME:
6651 expand_builtin_cilk_pop_frame (exp);
6654 case BUILT_IN_CHKP_INIT_PTR_BOUNDS:
6655 case BUILT_IN_CHKP_NULL_PTR_BOUNDS:
6656 case BUILT_IN_CHKP_COPY_PTR_BOUNDS:
6657 case BUILT_IN_CHKP_CHECK_PTR_LBOUNDS:
6658 case BUILT_IN_CHKP_CHECK_PTR_UBOUNDS:
6659 case BUILT_IN_CHKP_CHECK_PTR_BOUNDS:
6660 case BUILT_IN_CHKP_SET_PTR_BOUNDS:
6661 case BUILT_IN_CHKP_NARROW_PTR_BOUNDS:
6662 case BUILT_IN_CHKP_STORE_PTR_BOUNDS:
6663 case BUILT_IN_CHKP_GET_PTR_LBOUND:
6664 case BUILT_IN_CHKP_GET_PTR_UBOUND:
6665 /* We allow user CHKP builtins if Pointer Bounds
6667 if (!chkp_function_instrumented_p (current_function_decl))
6669 if (fcode == BUILT_IN_CHKP_SET_PTR_BOUNDS
6670 || fcode == BUILT_IN_CHKP_NARROW_PTR_BOUNDS
6671 || fcode == BUILT_IN_CHKP_INIT_PTR_BOUNDS
6672 || fcode == BUILT_IN_CHKP_NULL_PTR_BOUNDS
6673 || fcode == BUILT_IN_CHKP_COPY_PTR_BOUNDS)
6674 return expand_normal (CALL_EXPR_ARG (exp, 0));
6675 else if (fcode == BUILT_IN_CHKP_GET_PTR_LBOUND)
6676 return expand_normal (size_zero_node);
6677 else if (fcode == BUILT_IN_CHKP_GET_PTR_UBOUND)
6678 return expand_normal (size_int (-1));
6684 case BUILT_IN_CHKP_BNDMK:
6685 case BUILT_IN_CHKP_BNDSTX:
6686 case BUILT_IN_CHKP_BNDCL:
6687 case BUILT_IN_CHKP_BNDCU:
6688 case BUILT_IN_CHKP_BNDLDX:
6689 case BUILT_IN_CHKP_BNDRET:
6690 case BUILT_IN_CHKP_INTERSECT:
6691 case BUILT_IN_CHKP_NARROW:
6692 case BUILT_IN_CHKP_EXTRACT_LOWER:
6693 case BUILT_IN_CHKP_EXTRACT_UPPER:
6694 /* Software implementation of Pointer Bounds Checker is NYI.
6695 Target support is required. */
6696 error ("Your target platform does not support -fcheck-pointer-bounds");
6699 case BUILT_IN_ACC_ON_DEVICE:
6700 /* Do library call, if we failed to expand the builtin when
6704 default: /* just do library call, if unknown builtin */
6708 /* The switch statement above can drop through to cause the function
6709 to be called normally. */
6710 return expand_call (exp, target, ignore);
6713 /* Similar to expand_builtin but is used for instrumented calls. */
6716 expand_builtin_with_bounds (tree exp, rtx target,
6717 rtx subtarget ATTRIBUTE_UNUSED,
6718 machine_mode mode, int ignore)
6720 tree fndecl = get_callee_fndecl (exp);
6721 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6723 gcc_assert (CALL_WITH_BOUNDS_P (exp));
6725 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6726 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
6728 gcc_assert (fcode > BEGIN_CHKP_BUILTINS
6729 && fcode < END_CHKP_BUILTINS);
6733 case BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP:
6734 target = expand_builtin_memcpy_with_bounds (exp, target);
6739 case BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP:
6740 target = expand_builtin_mempcpy_with_bounds (exp, target, mode);
6745 case BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP:
6746 target = expand_builtin_memset_with_bounds (exp, target, mode);
6755 /* The switch statement above can drop through to cause the function
6756 to be called normally. */
6757 return expand_call (exp, target, ignore);
6760 /* Determine whether a tree node represents a call to a built-in
6761 function. If the tree T is a call to a built-in function with
6762 the right number of arguments of the appropriate types, return
6763 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6764 Otherwise the return value is END_BUILTINS. */
6766 enum built_in_function
6767 builtin_mathfn_code (const_tree t)
6769 const_tree fndecl, arg, parmlist;
6770 const_tree argtype, parmtype;
6771 const_call_expr_arg_iterator iter;
6773 if (TREE_CODE (t) != CALL_EXPR
6774 || !CALL_EXPR_FN (t)
6775 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6776 return END_BUILTINS;
6778 fndecl = get_callee_fndecl (t);
6779 if (fndecl == NULL_TREE
6780 || TREE_CODE (fndecl) != FUNCTION_DECL
6781 || ! DECL_BUILT_IN (fndecl)
6782 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6783 return END_BUILTINS;
6785 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6786 init_const_call_expr_arg_iterator (t, &iter);
6787 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6789 /* If a function doesn't take a variable number of arguments,
6790 the last element in the list will have type `void'. */
6791 parmtype = TREE_VALUE (parmlist);
6792 if (VOID_TYPE_P (parmtype))
6794 if (more_const_call_expr_args_p (&iter))
6795 return END_BUILTINS;
6796 return DECL_FUNCTION_CODE (fndecl);
6799 if (! more_const_call_expr_args_p (&iter))
6800 return END_BUILTINS;
6802 arg = next_const_call_expr_arg (&iter);
6803 argtype = TREE_TYPE (arg);
6805 if (SCALAR_FLOAT_TYPE_P (parmtype))
6807 if (! SCALAR_FLOAT_TYPE_P (argtype))
6808 return END_BUILTINS;
6810 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6812 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6813 return END_BUILTINS;
6815 else if (POINTER_TYPE_P (parmtype))
6817 if (! POINTER_TYPE_P (argtype))
6818 return END_BUILTINS;
6820 else if (INTEGRAL_TYPE_P (parmtype))
6822 if (! INTEGRAL_TYPE_P (argtype))
6823 return END_BUILTINS;
6826 return END_BUILTINS;
6829 /* Variable-length argument list. */
6830 return DECL_FUNCTION_CODE (fndecl);
6833 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6834 evaluate to a constant. */
6837 fold_builtin_constant_p (tree arg)
6839 /* We return 1 for a numeric type that's known to be a constant
6840 value at compile-time or for an aggregate type that's a
6841 literal constant. */
6844 /* If we know this is a constant, emit the constant of one. */
6845 if (CONSTANT_CLASS_P (arg)
6846 || (TREE_CODE (arg) == CONSTRUCTOR
6847 && TREE_CONSTANT (arg)))
6848 return integer_one_node;
6849 if (TREE_CODE (arg) == ADDR_EXPR)
6851 tree op = TREE_OPERAND (arg, 0);
6852 if (TREE_CODE (op) == STRING_CST
6853 || (TREE_CODE (op) == ARRAY_REF
6854 && integer_zerop (TREE_OPERAND (op, 1))
6855 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6856 return integer_one_node;
6859 /* If this expression has side effects, show we don't know it to be a
6860 constant. Likewise if it's a pointer or aggregate type since in
6861 those case we only want literals, since those are only optimized
6862 when generating RTL, not later.
6863 And finally, if we are compiling an initializer, not code, we
6864 need to return a definite result now; there's not going to be any
6865 more optimization done. */
6866 if (TREE_SIDE_EFFECTS (arg)
6867 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6868 || POINTER_TYPE_P (TREE_TYPE (arg))
6870 || folding_initializer
6871 || force_folding_builtin_constant_p)
6872 return integer_zero_node;
6877 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6878 return it as a truthvalue. */
6881 build_builtin_expect_predicate (location_t loc, tree pred, tree expected,
6884 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6886 fn = builtin_decl_explicit (BUILT_IN_EXPECT);
6887 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6888 ret_type = TREE_TYPE (TREE_TYPE (fn));
6889 pred_type = TREE_VALUE (arg_types);
6890 expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6892 pred = fold_convert_loc (loc, pred_type, pred);
6893 expected = fold_convert_loc (loc, expected_type, expected);
6894 call_expr = build_call_expr_loc (loc, fn, predictor ? 3 : 2, pred, expected,
6897 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6898 build_int_cst (ret_type, 0));
6901 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
6902 NULL_TREE if no simplification is possible. */
6905 fold_builtin_expect (location_t loc, tree arg0, tree arg1, tree arg2)
6907 tree inner, fndecl, inner_arg0;
6908 enum tree_code code;
6910 /* Distribute the expected value over short-circuiting operators.
6911 See through the cast from truthvalue_type_node to long. */
6913 while (CONVERT_EXPR_P (inner_arg0)
6914 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0))
6915 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0))))
6916 inner_arg0 = TREE_OPERAND (inner_arg0, 0);
6918 /* If this is a builtin_expect within a builtin_expect keep the
6919 inner one. See through a comparison against a constant. It
6920 might have been added to create a thruthvalue. */
6923 if (COMPARISON_CLASS_P (inner)
6924 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6925 inner = TREE_OPERAND (inner, 0);
6927 if (TREE_CODE (inner) == CALL_EXPR
6928 && (fndecl = get_callee_fndecl (inner))
6929 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6930 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6934 code = TREE_CODE (inner);
6935 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6937 tree op0 = TREE_OPERAND (inner, 0);
6938 tree op1 = TREE_OPERAND (inner, 1);
6940 op0 = build_builtin_expect_predicate (loc, op0, arg1, arg2);
6941 op1 = build_builtin_expect_predicate (loc, op1, arg1, arg2);
6942 inner = build2 (code, TREE_TYPE (inner), op0, op1);
6944 return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6947 /* If the argument isn't invariant then there's nothing else we can do. */
6948 if (!TREE_CONSTANT (inner_arg0))
6951 /* If we expect that a comparison against the argument will fold to
6952 a constant return the constant. In practice, this means a true
6953 constant or the address of a non-weak symbol. */
6956 if (TREE_CODE (inner) == ADDR_EXPR)
6960 inner = TREE_OPERAND (inner, 0);
6962 while (TREE_CODE (inner) == COMPONENT_REF
6963 || TREE_CODE (inner) == ARRAY_REF);
6964 if ((TREE_CODE (inner) == VAR_DECL
6965 || TREE_CODE (inner) == FUNCTION_DECL)
6966 && DECL_WEAK (inner))
6970 /* Otherwise, ARG0 already has the proper type for the return value. */
6974 /* Fold a call to __builtin_classify_type with argument ARG. */
6977 fold_builtin_classify_type (tree arg)
6980 return build_int_cst (integer_type_node, no_type_class);
6982 return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg)));
6985 /* Fold a call to __builtin_strlen with argument ARG. */
6988 fold_builtin_strlen (location_t loc, tree type, tree arg)
6990 if (!validate_arg (arg, POINTER_TYPE))
6994 tree len = c_strlen (arg, 0);
6997 return fold_convert_loc (loc, type, len);
7003 /* Fold a call to __builtin_inf or __builtin_huge_val. */
7006 fold_builtin_inf (location_t loc, tree type, int warn)
7008 REAL_VALUE_TYPE real;
7010 /* __builtin_inff is intended to be usable to define INFINITY on all
7011 targets. If an infinity is not available, INFINITY expands "to a
7012 positive constant of type float that overflows at translation
7013 time", footnote "In this case, using INFINITY will violate the
7014 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7015 Thus we pedwarn to ensure this constraint violation is
7017 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7018 pedwarn (loc, 0, "target format does not support infinity");
7021 return build_real (type, real);
7024 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7025 NULL_TREE if no simplification can be made. */
7028 fold_builtin_sincos (location_t loc,
7029 tree arg0, tree arg1, tree arg2)
7032 tree fndecl, call = NULL_TREE;
7034 if (!validate_arg (arg0, REAL_TYPE)
7035 || !validate_arg (arg1, POINTER_TYPE)
7036 || !validate_arg (arg2, POINTER_TYPE))
7039 type = TREE_TYPE (arg0);
7041 /* Calculate the result when the argument is a constant. */
7042 built_in_function fn = mathfn_built_in_2 (type, CFN_BUILT_IN_CEXPI);
7043 if (fn == END_BUILTINS)
7046 /* Canonicalize sincos to cexpi. */
7047 if (TREE_CODE (arg0) == REAL_CST)
7049 tree complex_type = build_complex_type (type);
7050 call = fold_const_call (as_combined_fn (fn), complex_type, arg0);
7054 if (!targetm.libc_has_function (function_c99_math_complex)
7055 || !builtin_decl_implicit_p (fn))
7057 fndecl = builtin_decl_explicit (fn);
7058 call = build_call_expr_loc (loc, fndecl, 1, arg0);
7059 call = builtin_save_expr (call);
7062 return build2 (COMPOUND_EXPR, void_type_node,
7063 build2 (MODIFY_EXPR, void_type_node,
7064 build_fold_indirect_ref_loc (loc, arg1),
7065 fold_build1_loc (loc, IMAGPART_EXPR, type, call)),
7066 build2 (MODIFY_EXPR, void_type_node,
7067 build_fold_indirect_ref_loc (loc, arg2),
7068 fold_build1_loc (loc, REALPART_EXPR, type, call)));
7071 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
7072 arguments to the call, and TYPE is its return type.
7073 Return NULL_TREE if no simplification can be made. */
7076 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
7078 if (!validate_arg (arg1, POINTER_TYPE)
7079 || !validate_arg (arg2, INTEGER_TYPE)
7080 || !validate_arg (len, INTEGER_TYPE))
7086 if (TREE_CODE (arg2) != INTEGER_CST
7087 || !tree_fits_uhwi_p (len))
7090 p1 = c_getstr (arg1);
7091 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
7097 if (target_char_cast (arg2, &c))
7100 r = (const char *) memchr (p1, c, tree_to_uhwi (len));
7103 return build_int_cst (TREE_TYPE (arg1), 0);
7105 tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
7106 return fold_convert_loc (loc, type, tem);
7112 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
7113 Return NULL_TREE if no simplification can be made. */
7116 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
7118 if (!validate_arg (arg1, POINTER_TYPE)
7119 || !validate_arg (arg2, POINTER_TYPE)
7120 || !validate_arg (len, INTEGER_TYPE))
7123 /* If the LEN parameter is zero, return zero. */
7124 if (integer_zerop (len))
7125 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
7128 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7129 if (operand_equal_p (arg1, arg2, 0))
7130 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
7132 /* If len parameter is one, return an expression corresponding to
7133 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7134 if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1)
7136 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7137 tree cst_uchar_ptr_node
7138 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7141 = fold_convert_loc (loc, integer_type_node,
7142 build1 (INDIRECT_REF, cst_uchar_node,
7143 fold_convert_loc (loc,
7147 = fold_convert_loc (loc, integer_type_node,
7148 build1 (INDIRECT_REF, cst_uchar_node,
7149 fold_convert_loc (loc,
7152 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
7158 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
7159 Return NULL_TREE if no simplification can be made. */
7162 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
7164 if (!validate_arg (arg1, POINTER_TYPE)
7165 || !validate_arg (arg2, POINTER_TYPE))
7168 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7169 if (operand_equal_p (arg1, arg2, 0))
7170 return integer_zero_node;
7172 /* If the second arg is "", return *(const unsigned char*)arg1. */
7173 const char *p2 = c_getstr (arg2);
7174 if (p2 && *p2 == '\0')
7176 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7177 tree cst_uchar_ptr_node
7178 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7180 return fold_convert_loc (loc, integer_type_node,
7181 build1 (INDIRECT_REF, cst_uchar_node,
7182 fold_convert_loc (loc,
7187 /* If the first arg is "", return -*(const unsigned char*)arg2. */
7188 const char *p1 = c_getstr (arg1);
7189 if (p1 && *p1 == '\0')
7191 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7192 tree cst_uchar_ptr_node
7193 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7196 = fold_convert_loc (loc, integer_type_node,
7197 build1 (INDIRECT_REF, cst_uchar_node,
7198 fold_convert_loc (loc,
7201 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
7207 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
7208 Return NULL_TREE if no simplification can be made. */
7211 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
7213 if (!validate_arg (arg1, POINTER_TYPE)
7214 || !validate_arg (arg2, POINTER_TYPE)
7215 || !validate_arg (len, INTEGER_TYPE))
7218 /* If the LEN parameter is zero, return zero. */
7219 if (integer_zerop (len))
7220 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
7223 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7224 if (operand_equal_p (arg1, arg2, 0))
7225 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
7227 /* If the second arg is "", and the length is greater than zero,
7228 return *(const unsigned char*)arg1. */
7229 const char *p2 = c_getstr (arg2);
7230 if (p2 && *p2 == '\0'
7231 && TREE_CODE (len) == INTEGER_CST
7232 && tree_int_cst_sgn (len) == 1)
7234 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7235 tree cst_uchar_ptr_node
7236 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7238 return fold_convert_loc (loc, integer_type_node,
7239 build1 (INDIRECT_REF, cst_uchar_node,
7240 fold_convert_loc (loc,
7245 /* If the first arg is "", and the length is greater than zero,
7246 return -*(const unsigned char*)arg2. */
7247 const char *p1 = c_getstr (arg1);
7248 if (p1 && *p1 == '\0'
7249 && TREE_CODE (len) == INTEGER_CST
7250 && tree_int_cst_sgn (len) == 1)
7252 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7253 tree cst_uchar_ptr_node
7254 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7256 tree temp = fold_convert_loc (loc, integer_type_node,
7257 build1 (INDIRECT_REF, cst_uchar_node,
7258 fold_convert_loc (loc,
7261 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
7264 /* If len parameter is one, return an expression corresponding to
7265 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7266 if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1)
7268 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7269 tree cst_uchar_ptr_node
7270 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7272 tree ind1 = fold_convert_loc (loc, integer_type_node,
7273 build1 (INDIRECT_REF, cst_uchar_node,
7274 fold_convert_loc (loc,
7277 tree ind2 = fold_convert_loc (loc, integer_type_node,
7278 build1 (INDIRECT_REF, cst_uchar_node,
7279 fold_convert_loc (loc,
7282 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
7288 /* Fold a call to builtin isascii with argument ARG. */
7291 fold_builtin_isascii (location_t loc, tree arg)
7293 if (!validate_arg (arg, INTEGER_TYPE))
7297 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
7298 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
7299 build_int_cst (integer_type_node,
7300 ~ (unsigned HOST_WIDE_INT) 0x7f));
7301 return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
7302 arg, integer_zero_node);
7306 /* Fold a call to builtin toascii with argument ARG. */
7309 fold_builtin_toascii (location_t loc, tree arg)
7311 if (!validate_arg (arg, INTEGER_TYPE))
7314 /* Transform toascii(c) -> (c & 0x7f). */
7315 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
7316 build_int_cst (integer_type_node, 0x7f));
7319 /* Fold a call to builtin isdigit with argument ARG. */
7322 fold_builtin_isdigit (location_t loc, tree arg)
7324 if (!validate_arg (arg, INTEGER_TYPE))
7328 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
7329 /* According to the C standard, isdigit is unaffected by locale.
7330 However, it definitely is affected by the target character set. */
7331 unsigned HOST_WIDE_INT target_digit0
7332 = lang_hooks.to_target_charset ('0');
7334 if (target_digit0 == 0)
7337 arg = fold_convert_loc (loc, unsigned_type_node, arg);
7338 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
7339 build_int_cst (unsigned_type_node, target_digit0));
7340 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
7341 build_int_cst (unsigned_type_node, 9));
7345 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
7348 fold_builtin_fabs (location_t loc, tree arg, tree type)
7350 if (!validate_arg (arg, REAL_TYPE))
7353 arg = fold_convert_loc (loc, type, arg);
7354 return fold_build1_loc (loc, ABS_EXPR, type, arg);
7357 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
7360 fold_builtin_abs (location_t loc, tree arg, tree type)
7362 if (!validate_arg (arg, INTEGER_TYPE))
7365 arg = fold_convert_loc (loc, type, arg);
7366 return fold_build1_loc (loc, ABS_EXPR, type, arg);
7369 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
7372 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
7374 /* ??? Only expand to FMA_EXPR if it's directly supported. */
7375 if (validate_arg (arg0, REAL_TYPE)
7376 && validate_arg (arg1, REAL_TYPE)
7377 && validate_arg (arg2, REAL_TYPE)
7378 && optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
7379 return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
7384 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
7387 fold_builtin_carg (location_t loc, tree arg, tree type)
7389 if (validate_arg (arg, COMPLEX_TYPE)
7390 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7392 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
7396 tree new_arg = builtin_save_expr (arg);
7397 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
7398 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
7399 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
7406 /* Fold a call to builtin frexp, we can assume the base is 2. */
7409 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
7411 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
7416 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
7419 arg1 = build_fold_indirect_ref_loc (loc, arg1);
7421 /* Proceed if a valid pointer type was passed in. */
7422 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
7424 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
7430 /* For +-0, return (*exp = 0, +-0). */
7431 exp = integer_zero_node;
7436 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
7437 return omit_one_operand_loc (loc, rettype, arg0, arg1);
7440 /* Since the frexp function always expects base 2, and in
7441 GCC normalized significands are already in the range
7442 [0.5, 1.0), we have exactly what frexp wants. */
7443 REAL_VALUE_TYPE frac_rvt = *value;
7444 SET_REAL_EXP (&frac_rvt, 0);
7445 frac = build_real (rettype, frac_rvt);
7446 exp = build_int_cst (integer_type_node, REAL_EXP (value));
7453 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
7454 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
7455 TREE_SIDE_EFFECTS (arg1) = 1;
7456 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
7462 /* Fold a call to builtin modf. */
7465 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
7467 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
7472 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
7475 arg1 = build_fold_indirect_ref_loc (loc, arg1);
7477 /* Proceed if a valid pointer type was passed in. */
7478 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
7480 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
7481 REAL_VALUE_TYPE trunc, frac;
7487 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
7488 trunc = frac = *value;
7491 /* For +-Inf, return (*arg1 = arg0, +-0). */
7493 frac.sign = value->sign;
7497 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
7498 real_trunc (&trunc, VOIDmode, value);
7499 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
7500 /* If the original number was negative and already
7501 integral, then the fractional part is -0.0. */
7502 if (value->sign && frac.cl == rvc_zero)
7503 frac.sign = value->sign;
7507 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
7508 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
7509 build_real (rettype, trunc));
7510 TREE_SIDE_EFFECTS (arg1) = 1;
7511 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
7512 build_real (rettype, frac));
7518 /* Given a location LOC, an interclass builtin function decl FNDECL
7519 and its single argument ARG, return an folded expression computing
7520 the same, or NULL_TREE if we either couldn't or didn't want to fold
7521 (the latter happen if there's an RTL instruction available). */
7524 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
7528 if (!validate_arg (arg, REAL_TYPE))
7531 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
7534 mode = TYPE_MODE (TREE_TYPE (arg));
7536 bool is_ibm_extended = MODE_COMPOSITE_P (mode);
7538 /* If there is no optab, try generic code. */
7539 switch (DECL_FUNCTION_CODE (fndecl))
7543 CASE_FLT_FN (BUILT_IN_ISINF):
7545 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
7546 tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
7547 tree type = TREE_TYPE (arg);
7551 if (is_ibm_extended)
7553 /* NaN and Inf are encoded in the high-order double value
7554 only. The low-order value is not significant. */
7555 type = double_type_node;
7557 arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
7559 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7560 real_from_string (&r, buf);
7561 result = build_call_expr (isgr_fn, 2,
7562 fold_build1_loc (loc, ABS_EXPR, type, arg),
7563 build_real (type, r));
7566 CASE_FLT_FN (BUILT_IN_FINITE):
7567 case BUILT_IN_ISFINITE:
7569 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
7570 tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
7571 tree type = TREE_TYPE (arg);
7575 if (is_ibm_extended)
7577 /* NaN and Inf are encoded in the high-order double value
7578 only. The low-order value is not significant. */
7579 type = double_type_node;
7581 arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
7583 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7584 real_from_string (&r, buf);
7585 result = build_call_expr (isle_fn, 2,
7586 fold_build1_loc (loc, ABS_EXPR, type, arg),
7587 build_real (type, r));
7588 /*result = fold_build2_loc (loc, UNGT_EXPR,
7589 TREE_TYPE (TREE_TYPE (fndecl)),
7590 fold_build1_loc (loc, ABS_EXPR, type, arg),
7591 build_real (type, r));
7592 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
7593 TREE_TYPE (TREE_TYPE (fndecl)),
7597 case BUILT_IN_ISNORMAL:
7599 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
7600 islessequal(fabs(x),DBL_MAX). */
7601 tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
7602 tree type = TREE_TYPE (arg);
7603 tree orig_arg, max_exp, min_exp;
7604 machine_mode orig_mode = mode;
7605 REAL_VALUE_TYPE rmax, rmin;
7608 orig_arg = arg = builtin_save_expr (arg);
7609 if (is_ibm_extended)
7611 /* Use double to test the normal range of IBM extended
7612 precision. Emin for IBM extended precision is
7613 different to emin for IEEE double, being 53 higher
7614 since the low double exponent is at least 53 lower
7615 than the high double exponent. */
7616 type = double_type_node;
7618 arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
7620 arg = fold_build1_loc (loc, ABS_EXPR, type, arg);
7622 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7623 real_from_string (&rmax, buf);
7624 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (orig_mode)->emin - 1);
7625 real_from_string (&rmin, buf);
7626 max_exp = build_real (type, rmax);
7627 min_exp = build_real (type, rmin);
7629 max_exp = build_call_expr (isle_fn, 2, arg, max_exp);
7630 if (is_ibm_extended)
7632 /* Testing the high end of the range is done just using
7633 the high double, using the same test as isfinite().
7634 For the subnormal end of the range we first test the
7635 high double, then if its magnitude is equal to the
7636 limit of 0x1p-969, we test whether the low double is
7637 non-zero and opposite sign to the high double. */
7638 tree const islt_fn = builtin_decl_explicit (BUILT_IN_ISLESS);
7639 tree const isgt_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
7640 tree gt_min = build_call_expr (isgt_fn, 2, arg, min_exp);
7641 tree eq_min = fold_build2 (EQ_EXPR, integer_type_node,
7643 tree as_complex = build1 (VIEW_CONVERT_EXPR,
7644 complex_double_type_node, orig_arg);
7645 tree hi_dbl = build1 (REALPART_EXPR, type, as_complex);
7646 tree lo_dbl = build1 (IMAGPART_EXPR, type, as_complex);
7647 tree zero = build_real (type, dconst0);
7648 tree hilt = build_call_expr (islt_fn, 2, hi_dbl, zero);
7649 tree lolt = build_call_expr (islt_fn, 2, lo_dbl, zero);
7650 tree logt = build_call_expr (isgt_fn, 2, lo_dbl, zero);
7651 tree ok_lo = fold_build1 (TRUTH_NOT_EXPR, integer_type_node,
7652 fold_build3 (COND_EXPR,
7655 eq_min = fold_build2 (TRUTH_ANDIF_EXPR, integer_type_node,
7657 min_exp = fold_build2 (TRUTH_ORIF_EXPR, integer_type_node,
7663 = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL);
7664 min_exp = build_call_expr (isge_fn, 2, arg, min_exp);
7666 result = fold_build2 (BIT_AND_EXPR, integer_type_node,
7677 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
7678 ARG is the argument for the call. */
7681 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
7683 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7685 if (!validate_arg (arg, REAL_TYPE))
7688 switch (builtin_index)
7690 case BUILT_IN_ISINF:
7691 if (!HONOR_INFINITIES (arg))
7692 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
7696 case BUILT_IN_ISINF_SIGN:
7698 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
7699 /* In a boolean context, GCC will fold the inner COND_EXPR to
7700 1. So e.g. "if (isinf_sign(x))" would be folded to just
7701 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
7702 tree signbit_fn = mathfn_built_in_1
7703 (TREE_TYPE (arg), CFN_BUILT_IN_SIGNBIT, 0);
7704 tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF);
7705 tree tmp = NULL_TREE;
7707 arg = builtin_save_expr (arg);
7709 if (signbit_fn && isinf_fn)
7711 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
7712 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
7714 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
7715 signbit_call, integer_zero_node);
7716 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
7717 isinf_call, integer_zero_node);
7719 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
7720 integer_minus_one_node, integer_one_node);
7721 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
7729 case BUILT_IN_ISFINITE:
7730 if (!HONOR_NANS (arg)
7731 && !HONOR_INFINITIES (arg))
7732 return omit_one_operand_loc (loc, type, integer_one_node, arg);
7736 case BUILT_IN_ISNAN:
7737 if (!HONOR_NANS (arg))
7738 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
7741 bool is_ibm_extended = MODE_COMPOSITE_P (TYPE_MODE (TREE_TYPE (arg)));
7742 if (is_ibm_extended)
7744 /* NaN and Inf are encoded in the high-order double value
7745 only. The low-order value is not significant. */
7746 arg = fold_build1_loc (loc, NOP_EXPR, double_type_node, arg);
7749 arg = builtin_save_expr (arg);
7750 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
7757 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
7758 This builtin will generate code to return the appropriate floating
7759 point classification depending on the value of the floating point
7760 number passed in. The possible return values must be supplied as
7761 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
7762 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
7763 one floating point argument which is "type generic". */
7766 fold_builtin_fpclassify (location_t loc, tree *args, int nargs)
7768 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
7769 arg, type, res, tmp;
7774 /* Verify the required arguments in the original call. */
7776 || !validate_arg (args[0], INTEGER_TYPE)
7777 || !validate_arg (args[1], INTEGER_TYPE)
7778 || !validate_arg (args[2], INTEGER_TYPE)
7779 || !validate_arg (args[3], INTEGER_TYPE)
7780 || !validate_arg (args[4], INTEGER_TYPE)
7781 || !validate_arg (args[5], REAL_TYPE))
7785 fp_infinite = args[1];
7786 fp_normal = args[2];
7787 fp_subnormal = args[3];
7790 type = TREE_TYPE (arg);
7791 mode = TYPE_MODE (type);
7792 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
7796 (fabs(x) == Inf ? FP_INFINITE :
7797 (fabs(x) >= DBL_MIN ? FP_NORMAL :
7798 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
7800 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
7801 build_real (type, dconst0));
7802 res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
7803 tmp, fp_zero, fp_subnormal);
7805 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
7806 real_from_string (&r, buf);
7807 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
7808 arg, build_real (type, r));
7809 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
7811 if (HONOR_INFINITIES (mode))
7814 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
7815 build_real (type, r));
7816 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
7820 if (HONOR_NANS (mode))
7822 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
7823 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
7829 /* Fold a call to an unordered comparison function such as
7830 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
7831 being called and ARG0 and ARG1 are the arguments for the call.
7832 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
7833 the opposite of the desired result. UNORDERED_CODE is used
7834 for modes that can hold NaNs and ORDERED_CODE is used for
7838 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
7839 enum tree_code unordered_code,
7840 enum tree_code ordered_code)
7842 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7843 enum tree_code code;
7845 enum tree_code code0, code1;
7846 tree cmp_type = NULL_TREE;
7848 type0 = TREE_TYPE (arg0);
7849 type1 = TREE_TYPE (arg1);
7851 code0 = TREE_CODE (type0);
7852 code1 = TREE_CODE (type1);
7854 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
7855 /* Choose the wider of two real types. */
7856 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
7858 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7860 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
7863 arg0 = fold_convert_loc (loc, cmp_type, arg0);
7864 arg1 = fold_convert_loc (loc, cmp_type, arg1);
7866 if (unordered_code == UNORDERED_EXPR)
7868 if (!HONOR_NANS (arg0))
7869 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
7870 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
7873 code = HONOR_NANS (arg0) ? unordered_code : ordered_code;
7874 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
7875 fold_build2_loc (loc, code, type, arg0, arg1));
7878 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
7879 arithmetics if it can never overflow, or into internal functions that
7880 return both result of arithmetics and overflowed boolean flag in
7881 a complex integer result, or some other check for overflow. */
7884 fold_builtin_arith_overflow (location_t loc, enum built_in_function fcode,
7885 tree arg0, tree arg1, tree arg2)
7887 enum internal_fn ifn = IFN_LAST;
7888 tree type = TREE_TYPE (TREE_TYPE (arg2));
7889 tree mem_arg2 = build_fold_indirect_ref_loc (loc, arg2);
7892 case BUILT_IN_ADD_OVERFLOW:
7893 case BUILT_IN_SADD_OVERFLOW:
7894 case BUILT_IN_SADDL_OVERFLOW:
7895 case BUILT_IN_SADDLL_OVERFLOW:
7896 case BUILT_IN_UADD_OVERFLOW:
7897 case BUILT_IN_UADDL_OVERFLOW:
7898 case BUILT_IN_UADDLL_OVERFLOW:
7899 ifn = IFN_ADD_OVERFLOW;
7901 case BUILT_IN_SUB_OVERFLOW:
7902 case BUILT_IN_SSUB_OVERFLOW:
7903 case BUILT_IN_SSUBL_OVERFLOW:
7904 case BUILT_IN_SSUBLL_OVERFLOW:
7905 case BUILT_IN_USUB_OVERFLOW:
7906 case BUILT_IN_USUBL_OVERFLOW:
7907 case BUILT_IN_USUBLL_OVERFLOW:
7908 ifn = IFN_SUB_OVERFLOW;
7910 case BUILT_IN_MUL_OVERFLOW:
7911 case BUILT_IN_SMUL_OVERFLOW:
7912 case BUILT_IN_SMULL_OVERFLOW:
7913 case BUILT_IN_SMULLL_OVERFLOW:
7914 case BUILT_IN_UMUL_OVERFLOW:
7915 case BUILT_IN_UMULL_OVERFLOW:
7916 case BUILT_IN_UMULLL_OVERFLOW:
7917 ifn = IFN_MUL_OVERFLOW;
7922 tree ctype = build_complex_type (type);
7923 tree call = build_call_expr_internal_loc (loc, ifn, ctype,
7925 tree tgt = save_expr (call);
7926 tree intres = build1_loc (loc, REALPART_EXPR, type, tgt);
7927 tree ovfres = build1_loc (loc, IMAGPART_EXPR, type, tgt);
7928 ovfres = fold_convert_loc (loc, boolean_type_node, ovfres);
7930 = fold_build2_loc (loc, MODIFY_EXPR, void_type_node, mem_arg2, intres);
7931 return build2_loc (loc, COMPOUND_EXPR, boolean_type_node, store, ovfres);
7934 /* Fold a call to built-in function FNDECL with 0 arguments.
7935 This function returns NULL_TREE if no simplification was possible. */
7938 fold_builtin_0 (location_t loc, tree fndecl)
7940 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7941 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7944 CASE_FLT_FN (BUILT_IN_INF):
7945 case BUILT_IN_INFD32:
7946 case BUILT_IN_INFD64:
7947 case BUILT_IN_INFD128:
7948 return fold_builtin_inf (loc, type, true);
7950 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
7951 return fold_builtin_inf (loc, type, false);
7953 case BUILT_IN_CLASSIFY_TYPE:
7954 return fold_builtin_classify_type (NULL_TREE);
7962 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
7963 This function returns NULL_TREE if no simplification was possible. */
7966 fold_builtin_1 (location_t loc, tree fndecl, tree arg0)
7968 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7969 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7971 if (TREE_CODE (arg0) == ERROR_MARK)
7974 if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0))
7979 case BUILT_IN_CONSTANT_P:
7981 tree val = fold_builtin_constant_p (arg0);
7983 /* Gimplification will pull the CALL_EXPR for the builtin out of
7984 an if condition. When not optimizing, we'll not CSE it back.
7985 To avoid link error types of regressions, return false now. */
7986 if (!val && !optimize)
7987 val = integer_zero_node;
7992 case BUILT_IN_CLASSIFY_TYPE:
7993 return fold_builtin_classify_type (arg0);
7995 case BUILT_IN_STRLEN:
7996 return fold_builtin_strlen (loc, type, arg0);
7998 CASE_FLT_FN (BUILT_IN_FABS):
7999 case BUILT_IN_FABSD32:
8000 case BUILT_IN_FABSD64:
8001 case BUILT_IN_FABSD128:
8002 return fold_builtin_fabs (loc, arg0, type);
8006 case BUILT_IN_LLABS:
8007 case BUILT_IN_IMAXABS:
8008 return fold_builtin_abs (loc, arg0, type);
8010 CASE_FLT_FN (BUILT_IN_CONJ):
8011 if (validate_arg (arg0, COMPLEX_TYPE)
8012 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8013 return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
8016 CASE_FLT_FN (BUILT_IN_CREAL):
8017 if (validate_arg (arg0, COMPLEX_TYPE)
8018 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8019 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));
8022 CASE_FLT_FN (BUILT_IN_CIMAG):
8023 if (validate_arg (arg0, COMPLEX_TYPE)
8024 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8025 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
8028 CASE_FLT_FN (BUILT_IN_CARG):
8029 return fold_builtin_carg (loc, arg0, type);
8031 case BUILT_IN_ISASCII:
8032 return fold_builtin_isascii (loc, arg0);
8034 case BUILT_IN_TOASCII:
8035 return fold_builtin_toascii (loc, arg0);
8037 case BUILT_IN_ISDIGIT:
8038 return fold_builtin_isdigit (loc, arg0);
8040 CASE_FLT_FN (BUILT_IN_FINITE):
8041 case BUILT_IN_FINITED32:
8042 case BUILT_IN_FINITED64:
8043 case BUILT_IN_FINITED128:
8044 case BUILT_IN_ISFINITE:
8046 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
8049 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
8052 CASE_FLT_FN (BUILT_IN_ISINF):
8053 case BUILT_IN_ISINFD32:
8054 case BUILT_IN_ISINFD64:
8055 case BUILT_IN_ISINFD128:
8057 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
8060 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
8063 case BUILT_IN_ISNORMAL:
8064 return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
8066 case BUILT_IN_ISINF_SIGN:
8067 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
8069 CASE_FLT_FN (BUILT_IN_ISNAN):
8070 case BUILT_IN_ISNAND32:
8071 case BUILT_IN_ISNAND64:
8072 case BUILT_IN_ISNAND128:
8073 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
8076 if (integer_zerop (arg0))
8077 return build_empty_stmt (loc);
8088 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
8089 This function returns NULL_TREE if no simplification was possible. */
8092 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1)
8094 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8095 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
8097 if (TREE_CODE (arg0) == ERROR_MARK
8098 || TREE_CODE (arg1) == ERROR_MARK)
8101 if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0, arg1))
8106 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
8107 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
8108 if (validate_arg (arg0, REAL_TYPE)
8109 && validate_arg (arg1, POINTER_TYPE))
8110 return do_mpfr_lgamma_r (arg0, arg1, type);
8113 CASE_FLT_FN (BUILT_IN_FREXP):
8114 return fold_builtin_frexp (loc, arg0, arg1, type);
8116 CASE_FLT_FN (BUILT_IN_MODF):
8117 return fold_builtin_modf (loc, arg0, arg1, type);
8119 case BUILT_IN_STRSTR:
8120 return fold_builtin_strstr (loc, arg0, arg1, type);
8122 case BUILT_IN_STRSPN:
8123 return fold_builtin_strspn (loc, arg0, arg1);
8125 case BUILT_IN_STRCSPN:
8126 return fold_builtin_strcspn (loc, arg0, arg1);
8128 case BUILT_IN_STRCHR:
8129 case BUILT_IN_INDEX:
8130 return fold_builtin_strchr (loc, arg0, arg1, type);
8132 case BUILT_IN_STRRCHR:
8133 case BUILT_IN_RINDEX:
8134 return fold_builtin_strrchr (loc, arg0, arg1, type);
8136 case BUILT_IN_STRCMP:
8137 return fold_builtin_strcmp (loc, arg0, arg1);
8139 case BUILT_IN_STRPBRK:
8140 return fold_builtin_strpbrk (loc, arg0, arg1, type);
8142 case BUILT_IN_EXPECT:
8143 return fold_builtin_expect (loc, arg0, arg1, NULL_TREE);
8145 case BUILT_IN_ISGREATER:
8146 return fold_builtin_unordered_cmp (loc, fndecl,
8147 arg0, arg1, UNLE_EXPR, LE_EXPR);
8148 case BUILT_IN_ISGREATEREQUAL:
8149 return fold_builtin_unordered_cmp (loc, fndecl,
8150 arg0, arg1, UNLT_EXPR, LT_EXPR);
8151 case BUILT_IN_ISLESS:
8152 return fold_builtin_unordered_cmp (loc, fndecl,
8153 arg0, arg1, UNGE_EXPR, GE_EXPR);
8154 case BUILT_IN_ISLESSEQUAL:
8155 return fold_builtin_unordered_cmp (loc, fndecl,
8156 arg0, arg1, UNGT_EXPR, GT_EXPR);
8157 case BUILT_IN_ISLESSGREATER:
8158 return fold_builtin_unordered_cmp (loc, fndecl,
8159 arg0, arg1, UNEQ_EXPR, EQ_EXPR);
8160 case BUILT_IN_ISUNORDERED:
8161 return fold_builtin_unordered_cmp (loc, fndecl,
8162 arg0, arg1, UNORDERED_EXPR,
8165 /* We do the folding for va_start in the expander. */
8166 case BUILT_IN_VA_START:
8169 case BUILT_IN_OBJECT_SIZE:
8170 return fold_builtin_object_size (arg0, arg1);
8172 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
8173 return fold_builtin_atomic_always_lock_free (arg0, arg1);
8175 case BUILT_IN_ATOMIC_IS_LOCK_FREE:
8176 return fold_builtin_atomic_is_lock_free (arg0, arg1);
8184 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
8186 This function returns NULL_TREE if no simplification was possible. */
8189 fold_builtin_3 (location_t loc, tree fndecl,
8190 tree arg0, tree arg1, tree arg2)
8192 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8193 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
8195 if (TREE_CODE (arg0) == ERROR_MARK
8196 || TREE_CODE (arg1) == ERROR_MARK
8197 || TREE_CODE (arg2) == ERROR_MARK)
8200 if (tree ret = fold_const_call (as_combined_fn (fcode), type,
8207 CASE_FLT_FN (BUILT_IN_SINCOS):
8208 return fold_builtin_sincos (loc, arg0, arg1, arg2);
8210 CASE_FLT_FN (BUILT_IN_FMA):
8211 return fold_builtin_fma (loc, arg0, arg1, arg2, type);
8213 CASE_FLT_FN (BUILT_IN_REMQUO):
8214 if (validate_arg (arg0, REAL_TYPE)
8215 && validate_arg (arg1, REAL_TYPE)
8216 && validate_arg (arg2, POINTER_TYPE))
8217 return do_mpfr_remquo (arg0, arg1, arg2);
8220 case BUILT_IN_STRNCMP:
8221 return fold_builtin_strncmp (loc, arg0, arg1, arg2);
8223 case BUILT_IN_MEMCHR:
8224 return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
8227 case BUILT_IN_MEMCMP:
8228 return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
8230 case BUILT_IN_EXPECT:
8231 return fold_builtin_expect (loc, arg0, arg1, arg2);
8233 case BUILT_IN_ADD_OVERFLOW:
8234 case BUILT_IN_SUB_OVERFLOW:
8235 case BUILT_IN_MUL_OVERFLOW:
8236 case BUILT_IN_SADD_OVERFLOW:
8237 case BUILT_IN_SADDL_OVERFLOW:
8238 case BUILT_IN_SADDLL_OVERFLOW:
8239 case BUILT_IN_SSUB_OVERFLOW:
8240 case BUILT_IN_SSUBL_OVERFLOW:
8241 case BUILT_IN_SSUBLL_OVERFLOW:
8242 case BUILT_IN_SMUL_OVERFLOW:
8243 case BUILT_IN_SMULL_OVERFLOW:
8244 case BUILT_IN_SMULLL_OVERFLOW:
8245 case BUILT_IN_UADD_OVERFLOW:
8246 case BUILT_IN_UADDL_OVERFLOW:
8247 case BUILT_IN_UADDLL_OVERFLOW:
8248 case BUILT_IN_USUB_OVERFLOW:
8249 case BUILT_IN_USUBL_OVERFLOW:
8250 case BUILT_IN_USUBLL_OVERFLOW:
8251 case BUILT_IN_UMUL_OVERFLOW:
8252 case BUILT_IN_UMULL_OVERFLOW:
8253 case BUILT_IN_UMULLL_OVERFLOW:
8254 return fold_builtin_arith_overflow (loc, fcode, arg0, arg1, arg2);
8262 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
8263 arguments. IGNORE is true if the result of the
8264 function call is ignored. This function returns NULL_TREE if no
8265 simplification was possible. */
8268 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool)
8270 tree ret = NULL_TREE;
8275 ret = fold_builtin_0 (loc, fndecl);
8278 ret = fold_builtin_1 (loc, fndecl, args[0]);
8281 ret = fold_builtin_2 (loc, fndecl, args[0], args[1]);
8284 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2]);
8287 ret = fold_builtin_varargs (loc, fndecl, args, nargs);
8292 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
8293 SET_EXPR_LOCATION (ret, loc);
8294 TREE_NO_WARNING (ret) = 1;
8300 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
8301 list ARGS along with N new arguments in NEWARGS. SKIP is the number
8302 of arguments in ARGS to be omitted. OLDNARGS is the number of
8303 elements in ARGS. */
8306 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
8307 int skip, tree fndecl, int n, va_list newargs)
8309 int nargs = oldnargs - skip + n;
8316 buffer = XALLOCAVEC (tree, nargs);
8317 for (i = 0; i < n; i++)
8318 buffer[i] = va_arg (newargs, tree);
8319 for (j = skip; j < oldnargs; j++, i++)
8320 buffer[i] = args[j];
8323 buffer = args + skip;
8325 return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
8328 /* Return true if FNDECL shouldn't be folded right now.
8329 If a built-in function has an inline attribute always_inline
8330 wrapper, defer folding it after always_inline functions have
8331 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
8332 might not be performed. */
8335 avoid_folding_inline_builtin (tree fndecl)
8337 return (DECL_DECLARED_INLINE_P (fndecl)
8338 && DECL_DISREGARD_INLINE_LIMITS (fndecl)
8340 && !cfun->always_inline_functions_inlined
8341 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
8344 /* A wrapper function for builtin folding that prevents warnings for
8345 "statement without effect" and the like, caused by removing the
8346 call node earlier than the warning is generated. */
8349 fold_call_expr (location_t loc, tree exp, bool ignore)
8351 tree ret = NULL_TREE;
8352 tree fndecl = get_callee_fndecl (exp);
8354 && TREE_CODE (fndecl) == FUNCTION_DECL
8355 && DECL_BUILT_IN (fndecl)
8356 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
8357 yet. Defer folding until we see all the arguments
8358 (after inlining). */
8359 && !CALL_EXPR_VA_ARG_PACK (exp))
8361 int nargs = call_expr_nargs (exp);
8363 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
8364 instead last argument is __builtin_va_arg_pack (). Defer folding
8365 even in that case, until arguments are finalized. */
8366 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
8368 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
8370 && TREE_CODE (fndecl2) == FUNCTION_DECL
8371 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
8372 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
8376 if (avoid_folding_inline_builtin (fndecl))
8379 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8380 return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
8381 CALL_EXPR_ARGP (exp), ignore);
8384 tree *args = CALL_EXPR_ARGP (exp);
8385 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
8393 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
8394 N arguments are passed in the array ARGARRAY. Return a folded
8395 expression or NULL_TREE if no simplification was possible. */
8398 fold_builtin_call_array (location_t loc, tree,
8403 if (TREE_CODE (fn) != ADDR_EXPR)
8406 tree fndecl = TREE_OPERAND (fn, 0);
8407 if (TREE_CODE (fndecl) == FUNCTION_DECL
8408 && DECL_BUILT_IN (fndecl))
8410 /* If last argument is __builtin_va_arg_pack (), arguments to this
8411 function are not finalized yet. Defer folding until they are. */
8412 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
8414 tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
8416 && TREE_CODE (fndecl2) == FUNCTION_DECL
8417 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
8418 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
8421 if (avoid_folding_inline_builtin (fndecl))
8423 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8424 return targetm.fold_builtin (fndecl, n, argarray, false);
8426 return fold_builtin_n (loc, fndecl, argarray, n, false);
8432 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
8433 along with N new arguments specified as the "..." parameters. SKIP
8434 is the number of arguments in EXP to be omitted. This function is used
8435 to do varargs-to-varargs transformations. */
8438 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
8444 t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
8445 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
8451 /* Validate a single argument ARG against a tree code CODE representing
8455 validate_arg (const_tree arg, enum tree_code code)
8459 else if (code == POINTER_TYPE)
8460 return POINTER_TYPE_P (TREE_TYPE (arg));
8461 else if (code == INTEGER_TYPE)
8462 return INTEGRAL_TYPE_P (TREE_TYPE (arg));
8463 return code == TREE_CODE (TREE_TYPE (arg));
8466 /* This function validates the types of a function call argument list
8467 against a specified list of tree_codes. If the last specifier is a 0,
8468 that represents an ellipses, otherwise the last specifier must be a
8471 This is the GIMPLE version of validate_arglist. Eventually we want to
8472 completely convert builtins.c to work from GIMPLEs and the tree based
8473 validate_arglist will then be removed. */
8476 validate_gimple_arglist (const gcall *call, ...)
8478 enum tree_code code;
8484 va_start (ap, call);
8489 code = (enum tree_code) va_arg (ap, int);
8493 /* This signifies an ellipses, any further arguments are all ok. */
8497 /* This signifies an endlink, if no arguments remain, return
8498 true, otherwise return false. */
8499 res = (i == gimple_call_num_args (call));
8502 /* If no parameters remain or the parameter's code does not
8503 match the specified code, return false. Otherwise continue
8504 checking any remaining arguments. */
8505 arg = gimple_call_arg (call, i++);
8506 if (!validate_arg (arg, code))
8513 /* We need gotos here since we can only have one VA_CLOSE in a
8521 /* Default target-specific builtin expander that does nothing. */
8524 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
8525 rtx target ATTRIBUTE_UNUSED,
8526 rtx subtarget ATTRIBUTE_UNUSED,
8527 machine_mode mode ATTRIBUTE_UNUSED,
8528 int ignore ATTRIBUTE_UNUSED)
8533 /* Returns true is EXP represents data that would potentially reside
8534 in a readonly section. */
8537 readonly_data_expr (tree exp)
8541 if (TREE_CODE (exp) != ADDR_EXPR)
8544 exp = get_base_address (TREE_OPERAND (exp, 0));
8548 /* Make sure we call decl_readonly_section only for trees it
8549 can handle (since it returns true for everything it doesn't
8551 if (TREE_CODE (exp) == STRING_CST
8552 || TREE_CODE (exp) == CONSTRUCTOR
8553 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
8554 return decl_readonly_section (exp, 0);
8559 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
8560 to the call, and TYPE is its return type.
8562 Return NULL_TREE if no simplification was possible, otherwise return the
8563 simplified form of the call as a tree.
8565 The simplified form may be a constant or other expression which
8566 computes the same value, but in a more efficient manner (including
8567 calls to other builtin functions).
8569 The call may contain arguments which need to be evaluated, but
8570 which are not useful to determine the result of the call. In
8571 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8572 COMPOUND_EXPR will be an argument which must be evaluated.
8573 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8574 COMPOUND_EXPR in the chain will contain the tree for the simplified
8575 form of the builtin function call. */
8578 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
8580 if (!validate_arg (s1, POINTER_TYPE)
8581 || !validate_arg (s2, POINTER_TYPE))
8586 const char *p1, *p2;
8595 const char *r = strstr (p1, p2);
8599 return build_int_cst (TREE_TYPE (s1), 0);
8601 /* Return an offset into the constant string argument. */
8602 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8603 return fold_convert_loc (loc, type, tem);
8606 /* The argument is const char *, and the result is char *, so we need
8607 a type conversion here to avoid a warning. */
8609 return fold_convert_loc (loc, type, s1);
8614 fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8618 /* New argument list transforming strstr(s1, s2) to
8619 strchr(s1, s2[0]). */
8620 return build_call_expr_loc (loc, fn, 2, s1,
8621 build_int_cst (integer_type_node, p2[0]));
8625 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
8626 the call, and TYPE is its return type.
8628 Return NULL_TREE if no simplification was possible, otherwise return the
8629 simplified form of the call as a tree.
8631 The simplified form may be a constant or other expression which
8632 computes the same value, but in a more efficient manner (including
8633 calls to other builtin functions).
8635 The call may contain arguments which need to be evaluated, but
8636 which are not useful to determine the result of the call. In
8637 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8638 COMPOUND_EXPR will be an argument which must be evaluated.
8639 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8640 COMPOUND_EXPR in the chain will contain the tree for the simplified
8641 form of the builtin function call. */
8644 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
8646 if (!validate_arg (s1, POINTER_TYPE)
8647 || !validate_arg (s2, INTEGER_TYPE))
8653 if (TREE_CODE (s2) != INTEGER_CST)
8663 if (target_char_cast (s2, &c))
8669 return build_int_cst (TREE_TYPE (s1), 0);
8671 /* Return an offset into the constant string argument. */
8672 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8673 return fold_convert_loc (loc, type, tem);
8679 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
8680 the call, and TYPE is its return type.
8682 Return NULL_TREE if no simplification was possible, otherwise return the
8683 simplified form of the call as a tree.
8685 The simplified form may be a constant or other expression which
8686 computes the same value, but in a more efficient manner (including
8687 calls to other builtin functions).
8689 The call may contain arguments which need to be evaluated, but
8690 which are not useful to determine the result of the call. In
8691 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8692 COMPOUND_EXPR will be an argument which must be evaluated.
8693 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8694 COMPOUND_EXPR in the chain will contain the tree for the simplified
8695 form of the builtin function call. */
8698 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
8700 if (!validate_arg (s1, POINTER_TYPE)
8701 || !validate_arg (s2, INTEGER_TYPE))
8708 if (TREE_CODE (s2) != INTEGER_CST)
8718 if (target_char_cast (s2, &c))
8721 r = strrchr (p1, c);
8724 return build_int_cst (TREE_TYPE (s1), 0);
8726 /* Return an offset into the constant string argument. */
8727 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8728 return fold_convert_loc (loc, type, tem);
8731 if (! integer_zerop (s2))
8734 fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8738 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
8739 return build_call_expr_loc (loc, fn, 2, s1, s2);
8743 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
8744 to the call, and TYPE is its return type.
8746 Return NULL_TREE if no simplification was possible, otherwise return the
8747 simplified form of the call as a tree.
8749 The simplified form may be a constant or other expression which
8750 computes the same value, but in a more efficient manner (including
8751 calls to other builtin functions).
8753 The call may contain arguments which need to be evaluated, but
8754 which are not useful to determine the result of the call. In
8755 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8756 COMPOUND_EXPR will be an argument which must be evaluated.
8757 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8758 COMPOUND_EXPR in the chain will contain the tree for the simplified
8759 form of the builtin function call. */
8762 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
8764 if (!validate_arg (s1, POINTER_TYPE)
8765 || !validate_arg (s2, POINTER_TYPE))
8770 const char *p1, *p2;
8779 const char *r = strpbrk (p1, p2);
8783 return build_int_cst (TREE_TYPE (s1), 0);
8785 /* Return an offset into the constant string argument. */
8786 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8787 return fold_convert_loc (loc, type, tem);
8791 /* strpbrk(x, "") == NULL.
8792 Evaluate and ignore s1 in case it had side-effects. */
8793 return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
8796 return NULL_TREE; /* Really call strpbrk. */
8798 fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8802 /* New argument list transforming strpbrk(s1, s2) to
8803 strchr(s1, s2[0]). */
8804 return build_call_expr_loc (loc, fn, 2, s1,
8805 build_int_cst (integer_type_node, p2[0]));
8809 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
8812 Return NULL_TREE if no simplification was possible, otherwise return the
8813 simplified form of the call as a tree.
8815 The simplified form may be a constant or other expression which
8816 computes the same value, but in a more efficient manner (including
8817 calls to other builtin functions).
8819 The call may contain arguments which need to be evaluated, but
8820 which are not useful to determine the result of the call. In
8821 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8822 COMPOUND_EXPR will be an argument which must be evaluated.
8823 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8824 COMPOUND_EXPR in the chain will contain the tree for the simplified
8825 form of the builtin function call. */
8828 fold_builtin_strspn (location_t loc, tree s1, tree s2)
8830 if (!validate_arg (s1, POINTER_TYPE)
8831 || !validate_arg (s2, POINTER_TYPE))
8835 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
8837 /* If either argument is "", return NULL_TREE. */
8838 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
8839 /* Evaluate and ignore both arguments in case either one has
8841 return omit_two_operands_loc (loc, size_type_node, size_zero_node,
8847 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
8850 Return NULL_TREE if no simplification was possible, otherwise return the
8851 simplified form of the call as a tree.
8853 The simplified form may be a constant or other expression which
8854 computes the same value, but in a more efficient manner (including
8855 calls to other builtin functions).
8857 The call may contain arguments which need to be evaluated, but
8858 which are not useful to determine the result of the call. In
8859 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8860 COMPOUND_EXPR will be an argument which must be evaluated.
8861 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8862 COMPOUND_EXPR in the chain will contain the tree for the simplified
8863 form of the builtin function call. */
8866 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
8868 if (!validate_arg (s1, POINTER_TYPE)
8869 || !validate_arg (s2, POINTER_TYPE))
8873 /* If the first argument is "", return NULL_TREE. */
8874 const char *p1 = c_getstr (s1);
8875 if (p1 && *p1 == '\0')
8877 /* Evaluate and ignore argument s2 in case it has
8879 return omit_one_operand_loc (loc, size_type_node,
8880 size_zero_node, s2);
8883 /* If the second argument is "", return __builtin_strlen(s1). */
8884 const char *p2 = c_getstr (s2);
8885 if (p2 && *p2 == '\0')
8887 tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
8889 /* If the replacement _DECL isn't initialized, don't do the
8894 return build_call_expr_loc (loc, fn, 1, s1);
8900 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
8901 produced. False otherwise. This is done so that we don't output the error
8902 or warning twice or three times. */
8905 fold_builtin_next_arg (tree exp, bool va_start_p)
8907 tree fntype = TREE_TYPE (current_function_decl);
8908 int nargs = call_expr_nargs (exp);
8910 /* There is good chance the current input_location points inside the
8911 definition of the va_start macro (perhaps on the token for
8912 builtin) in a system header, so warnings will not be emitted.
8913 Use the location in real source code. */
8914 source_location current_location =
8915 linemap_unwind_to_first_non_reserved_loc (line_table, input_location,
8918 if (!stdarg_p (fntype))
8920 error ("%<va_start%> used in function with fixed args");
8926 if (va_start_p && (nargs != 2))
8928 error ("wrong number of arguments to function %<va_start%>");
8931 arg = CALL_EXPR_ARG (exp, 1);
8933 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
8934 when we checked the arguments and if needed issued a warning. */
8939 /* Evidently an out of date version of <stdarg.h>; can't validate
8940 va_start's second argument, but can still work as intended. */
8941 warning_at (current_location,
8943 "%<__builtin_next_arg%> called without an argument");
8948 error ("wrong number of arguments to function %<__builtin_next_arg%>");
8951 arg = CALL_EXPR_ARG (exp, 0);
8954 if (TREE_CODE (arg) == SSA_NAME)
8955 arg = SSA_NAME_VAR (arg);
8957 /* We destructively modify the call to be __builtin_va_start (ap, 0)
8958 or __builtin_next_arg (0) the first time we see it, after checking
8959 the arguments and if needed issuing a warning. */
8960 if (!integer_zerop (arg))
8962 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
8964 /* Strip off all nops for the sake of the comparison. This
8965 is not quite the same as STRIP_NOPS. It does more.
8966 We must also strip off INDIRECT_EXPR for C++ reference
8968 while (CONVERT_EXPR_P (arg)
8969 || TREE_CODE (arg) == INDIRECT_REF)
8970 arg = TREE_OPERAND (arg, 0);
8971 if (arg != last_parm)
8973 /* FIXME: Sometimes with the tree optimizers we can get the
8974 not the last argument even though the user used the last
8975 argument. We just warn and set the arg to be the last
8976 argument so that we will get wrong-code because of
8978 warning_at (current_location,
8980 "second parameter of %<va_start%> not last named argument");
8983 /* Undefined by C99 7.15.1.4p4 (va_start):
8984 "If the parameter parmN is declared with the register storage
8985 class, with a function or array type, or with a type that is
8986 not compatible with the type that results after application of
8987 the default argument promotions, the behavior is undefined."
8989 else if (DECL_REGISTER (arg))
8991 warning_at (current_location,
8993 "undefined behavior when second parameter of "
8994 "%<va_start%> is declared with %<register%> storage");
8997 /* We want to verify the second parameter just once before the tree
8998 optimizers are run and then avoid keeping it in the tree,
8999 as otherwise we could warn even for correct code like:
9000 void foo (int i, ...)
9001 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
9003 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
9005 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
9011 /* Expand a call EXP to __builtin_object_size. */
9014 expand_builtin_object_size (tree exp)
9017 int object_size_type;
9018 tree fndecl = get_callee_fndecl (exp);
9020 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9022 error ("%Kfirst argument of %D must be a pointer, second integer constant",
9024 expand_builtin_trap ();
9028 ost = CALL_EXPR_ARG (exp, 1);
9031 if (TREE_CODE (ost) != INTEGER_CST
9032 || tree_int_cst_sgn (ost) < 0
9033 || compare_tree_int (ost, 3) > 0)
9035 error ("%Klast argument of %D is not integer constant between 0 and 3",
9037 expand_builtin_trap ();
9041 object_size_type = tree_to_shwi (ost);
9043 return object_size_type < 2 ? constm1_rtx : const0_rtx;
9046 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9047 FCODE is the BUILT_IN_* to use.
9048 Return NULL_RTX if we failed; the caller should emit a normal call,
9049 otherwise try to get the result in TARGET, if convenient (and in
9050 mode MODE if that's convenient). */
9053 expand_builtin_memory_chk (tree exp, rtx target, machine_mode mode,
9054 enum built_in_function fcode)
9056 tree dest, src, len, size;
9058 if (!validate_arglist (exp,
9060 fcode == BUILT_IN_MEMSET_CHK
9061 ? INTEGER_TYPE : POINTER_TYPE,
9062 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
9065 dest = CALL_EXPR_ARG (exp, 0);
9066 src = CALL_EXPR_ARG (exp, 1);
9067 len = CALL_EXPR_ARG (exp, 2);
9068 size = CALL_EXPR_ARG (exp, 3);
9070 if (! tree_fits_uhwi_p (size))
9073 if (tree_fits_uhwi_p (len) || integer_all_onesp (size))
9077 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
9079 warning_at (tree_nonartificial_location (exp),
9080 0, "%Kcall to %D will always overflow destination buffer",
9081 exp, get_callee_fndecl (exp));
9086 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9087 mem{cpy,pcpy,move,set} is available. */
9090 case BUILT_IN_MEMCPY_CHK:
9091 fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
9093 case BUILT_IN_MEMPCPY_CHK:
9094 fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
9096 case BUILT_IN_MEMMOVE_CHK:
9097 fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
9099 case BUILT_IN_MEMSET_CHK:
9100 fn = builtin_decl_explicit (BUILT_IN_MEMSET);
9109 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
9110 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
9111 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9112 return expand_expr (fn, target, mode, EXPAND_NORMAL);
9114 else if (fcode == BUILT_IN_MEMSET_CHK)
9118 unsigned int dest_align = get_pointer_alignment (dest);
9120 /* If DEST is not a pointer type, call the normal function. */
9121 if (dest_align == 0)
9124 /* If SRC and DEST are the same (and not volatile), do nothing. */
9125 if (operand_equal_p (src, dest, 0))
9129 if (fcode != BUILT_IN_MEMPCPY_CHK)
9131 /* Evaluate and ignore LEN in case it has side-effects. */
9132 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
9133 return expand_expr (dest, target, mode, EXPAND_NORMAL);
9136 expr = fold_build_pointer_plus (dest, len);
9137 return expand_expr (expr, target, mode, EXPAND_NORMAL);
9140 /* __memmove_chk special case. */
9141 if (fcode == BUILT_IN_MEMMOVE_CHK)
9143 unsigned int src_align = get_pointer_alignment (src);
9148 /* If src is categorized for a readonly section we can use
9149 normal __memcpy_chk. */
9150 if (readonly_data_expr (src))
9152 tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
9155 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
9156 dest, src, len, size);
9157 gcc_assert (TREE_CODE (fn) == CALL_EXPR);
9158 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9159 return expand_expr (fn, target, mode, EXPAND_NORMAL);
9166 /* Emit warning if a buffer overflow is detected at compile time. */
9169 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
9173 location_t loc = tree_nonartificial_location (exp);
9177 case BUILT_IN_STRCPY_CHK:
9178 case BUILT_IN_STPCPY_CHK:
9179 /* For __strcat_chk the warning will be emitted only if overflowing
9180 by at least strlen (dest) + 1 bytes. */
9181 case BUILT_IN_STRCAT_CHK:
9182 len = CALL_EXPR_ARG (exp, 1);
9183 size = CALL_EXPR_ARG (exp, 2);
9186 case BUILT_IN_STRNCAT_CHK:
9187 case BUILT_IN_STRNCPY_CHK:
9188 case BUILT_IN_STPNCPY_CHK:
9189 len = CALL_EXPR_ARG (exp, 2);
9190 size = CALL_EXPR_ARG (exp, 3);
9192 case BUILT_IN_SNPRINTF_CHK:
9193 case BUILT_IN_VSNPRINTF_CHK:
9194 len = CALL_EXPR_ARG (exp, 1);
9195 size = CALL_EXPR_ARG (exp, 3);
9204 if (! tree_fits_uhwi_p (size) || integer_all_onesp (size))
9209 len = c_strlen (len, 1);
9210 if (! len || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size))
9213 else if (fcode == BUILT_IN_STRNCAT_CHK)
9215 tree src = CALL_EXPR_ARG (exp, 1);
9216 if (! src || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size))
9218 src = c_strlen (src, 1);
9219 if (! src || ! tree_fits_uhwi_p (src))
9221 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
9222 exp, get_callee_fndecl (exp));
9225 else if (tree_int_cst_lt (src, size))
9228 else if (! tree_fits_uhwi_p (len) || ! tree_int_cst_lt (size, len))
9231 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
9232 exp, get_callee_fndecl (exp));
9235 /* Emit warning if a buffer overflow is detected at compile time
9236 in __sprintf_chk/__vsprintf_chk calls. */
9239 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
9241 tree size, len, fmt;
9242 const char *fmt_str;
9243 int nargs = call_expr_nargs (exp);
9245 /* Verify the required arguments in the original call. */
9249 size = CALL_EXPR_ARG (exp, 2);
9250 fmt = CALL_EXPR_ARG (exp, 3);
9252 if (! tree_fits_uhwi_p (size) || integer_all_onesp (size))
9255 /* Check whether the format is a literal string constant. */
9256 fmt_str = c_getstr (fmt);
9257 if (fmt_str == NULL)
9260 if (!init_target_chars ())
9263 /* If the format doesn't contain % args or %%, we know its size. */
9264 if (strchr (fmt_str, target_percent) == 0)
9265 len = build_int_cstu (size_type_node, strlen (fmt_str));
9266 /* If the format is "%s" and first ... argument is a string literal,
9268 else if (fcode == BUILT_IN_SPRINTF_CHK
9269 && strcmp (fmt_str, target_percent_s) == 0)
9275 arg = CALL_EXPR_ARG (exp, 4);
9276 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
9279 len = c_strlen (arg, 1);
9280 if (!len || ! tree_fits_uhwi_p (len))
9286 if (! tree_int_cst_lt (len, size))
9287 warning_at (tree_nonartificial_location (exp),
9288 0, "%Kcall to %D will always overflow destination buffer",
9289 exp, get_callee_fndecl (exp));
9292 /* Emit warning if a free is called with address of a variable. */
9295 maybe_emit_free_warning (tree exp)
9297 tree arg = CALL_EXPR_ARG (exp, 0);
9300 if (TREE_CODE (arg) != ADDR_EXPR)
9303 arg = get_base_address (TREE_OPERAND (arg, 0));
9304 if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
9307 if (SSA_VAR_P (arg))
9308 warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
9309 "%Kattempt to free a non-heap object %qD", exp, arg);
9311 warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
9312 "%Kattempt to free a non-heap object", exp);
9315 /* Fold a call to __builtin_object_size with arguments PTR and OST,
9319 fold_builtin_object_size (tree ptr, tree ost)
9321 unsigned HOST_WIDE_INT bytes;
9322 int object_size_type;
9324 if (!validate_arg (ptr, POINTER_TYPE)
9325 || !validate_arg (ost, INTEGER_TYPE))
9330 if (TREE_CODE (ost) != INTEGER_CST
9331 || tree_int_cst_sgn (ost) < 0
9332 || compare_tree_int (ost, 3) > 0)
9335 object_size_type = tree_to_shwi (ost);
9337 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
9338 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
9339 and (size_t) 0 for types 2 and 3. */
9340 if (TREE_SIDE_EFFECTS (ptr))
9341 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
9343 if (TREE_CODE (ptr) == ADDR_EXPR)
9345 bytes = compute_builtin_object_size (ptr, object_size_type);
9346 if (wi::fits_to_tree_p (bytes, size_type_node))
9347 return build_int_cstu (size_type_node, bytes);
9349 else if (TREE_CODE (ptr) == SSA_NAME)
9351 /* If object size is not known yet, delay folding until
9352 later. Maybe subsequent passes will help determining
9354 bytes = compute_builtin_object_size (ptr, object_size_type);
9355 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
9356 && wi::fits_to_tree_p (bytes, size_type_node))
9357 return build_int_cstu (size_type_node, bytes);
9363 /* Builtins with folding operations that operate on "..." arguments
9364 need special handling; we need to store the arguments in a convenient
9365 data structure before attempting any folding. Fortunately there are
9366 only a few builtins that fall into this category. FNDECL is the
9367 function, EXP is the CALL_EXPR for the call. */
9370 fold_builtin_varargs (location_t loc, tree fndecl, tree *args, int nargs)
9372 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9373 tree ret = NULL_TREE;
9377 case BUILT_IN_FPCLASSIFY:
9378 ret = fold_builtin_fpclassify (loc, args, nargs);
9386 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
9387 SET_EXPR_LOCATION (ret, loc);
9388 TREE_NO_WARNING (ret) = 1;
9394 /* Initialize format string characters in the target charset. */
9397 init_target_chars (void)
9402 target_newline = lang_hooks.to_target_charset ('\n');
9403 target_percent = lang_hooks.to_target_charset ('%');
9404 target_c = lang_hooks.to_target_charset ('c');
9405 target_s = lang_hooks.to_target_charset ('s');
9406 if (target_newline == 0 || target_percent == 0 || target_c == 0
9410 target_percent_c[0] = target_percent;
9411 target_percent_c[1] = target_c;
9412 target_percent_c[2] = '\0';
9414 target_percent_s[0] = target_percent;
9415 target_percent_s[1] = target_s;
9416 target_percent_s[2] = '\0';
9418 target_percent_s_newline[0] = target_percent;
9419 target_percent_s_newline[1] = target_s;
9420 target_percent_s_newline[2] = target_newline;
9421 target_percent_s_newline[3] = '\0';
9428 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
9429 and no overflow/underflow occurred. INEXACT is true if M was not
9430 exactly calculated. TYPE is the tree type for the result. This
9431 function assumes that you cleared the MPFR flags and then
9432 calculated M to see if anything subsequently set a flag prior to
9433 entering this function. Return NULL_TREE if any checks fail. */
9436 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
9438 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
9439 overflow/underflow occurred. If -frounding-math, proceed iff the
9440 result of calling FUNC was exact. */
9441 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
9442 && (!flag_rounding_math || !inexact))
9446 real_from_mpfr (&rr, m, type, GMP_RNDN);
9447 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
9448 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
9449 but the mpft_t is not, then we underflowed in the
9451 if (real_isfinite (&rr)
9452 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
9454 REAL_VALUE_TYPE rmode;
9456 real_convert (&rmode, TYPE_MODE (type), &rr);
9457 /* Proceed iff the specified mode can hold the value. */
9458 if (real_identical (&rmode, &rr))
9459 return build_real (type, rmode);
9465 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
9466 number and no overflow/underflow occurred. INEXACT is true if M
9467 was not exactly calculated. TYPE is the tree type for the result.
9468 This function assumes that you cleared the MPFR flags and then
9469 calculated M to see if anything subsequently set a flag prior to
9470 entering this function. Return NULL_TREE if any checks fail, if
9471 FORCE_CONVERT is true, then bypass the checks. */
9474 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
9476 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
9477 overflow/underflow occurred. If -frounding-math, proceed iff the
9478 result of calling FUNC was exact. */
9480 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
9481 && !mpfr_overflow_p () && !mpfr_underflow_p ()
9482 && (!flag_rounding_math || !inexact)))
9484 REAL_VALUE_TYPE re, im;
9486 real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
9487 real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
9488 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
9489 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
9490 but the mpft_t is not, then we underflowed in the
9493 || (real_isfinite (&re) && real_isfinite (&im)
9494 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
9495 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
9497 REAL_VALUE_TYPE re_mode, im_mode;
9499 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
9500 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
9501 /* Proceed iff the specified mode can hold the value. */
9503 || (real_identical (&re_mode, &re)
9504 && real_identical (&im_mode, &im)))
9505 return build_complex (type, build_real (TREE_TYPE (type), re_mode),
9506 build_real (TREE_TYPE (type), im_mode));
9512 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
9513 the pointer *(ARG_QUO) and return the result. The type is taken
9514 from the type of ARG0 and is used for setting the precision of the
9515 calculation and results. */
9518 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
9520 tree const type = TREE_TYPE (arg0);
9521 tree result = NULL_TREE;
9526 /* To proceed, MPFR must exactly represent the target floating point
9527 format, which only happens when the target base equals two. */
9528 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
9529 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9530 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
9532 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
9533 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
9535 if (real_isfinite (ra0) && real_isfinite (ra1))
9537 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
9538 const int prec = fmt->p;
9539 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
9544 mpfr_inits2 (prec, m0, m1, NULL);
9545 mpfr_from_real (m0, ra0, GMP_RNDN);
9546 mpfr_from_real (m1, ra1, GMP_RNDN);
9547 mpfr_clear_flags ();
9548 mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
9549 /* Remquo is independent of the rounding mode, so pass
9550 inexact=0 to do_mpfr_ckconv(). */
9551 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
9552 mpfr_clears (m0, m1, NULL);
9555 /* MPFR calculates quo in the host's long so it may
9556 return more bits in quo than the target int can hold
9557 if sizeof(host long) > sizeof(target int). This can
9558 happen even for native compilers in LP64 mode. In
9559 these cases, modulo the quo value with the largest
9560 number that the target int can hold while leaving one
9561 bit for the sign. */
9562 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
9563 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
9565 /* Dereference the quo pointer argument. */
9566 arg_quo = build_fold_indirect_ref (arg_quo);
9567 /* Proceed iff a valid pointer type was passed in. */
9568 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
9570 /* Set the value. */
9572 = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo,
9573 build_int_cst (TREE_TYPE (arg_quo),
9575 TREE_SIDE_EFFECTS (result_quo) = 1;
9576 /* Combine the quo assignment with the rem. */
9577 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
9578 result_quo, result_rem));
9586 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
9587 resulting value as a tree with type TYPE. The mpfr precision is
9588 set to the precision of TYPE. We assume that this mpfr function
9589 returns zero if the result could be calculated exactly within the
9590 requested precision. In addition, the integer pointer represented
9591 by ARG_SG will be dereferenced and set to the appropriate signgam
9595 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
9597 tree result = NULL_TREE;
9601 /* To proceed, MPFR must exactly represent the target floating point
9602 format, which only happens when the target base equals two. Also
9603 verify ARG is a constant and that ARG_SG is an int pointer. */
9604 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
9605 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
9606 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
9607 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
9609 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
9611 /* In addition to NaN and Inf, the argument cannot be zero or a
9612 negative integer. */
9613 if (real_isfinite (ra)
9614 && ra->cl != rvc_zero
9615 && !(real_isneg (ra) && real_isinteger (ra, TYPE_MODE (type))))
9617 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
9618 const int prec = fmt->p;
9619 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
9624 mpfr_init2 (m, prec);
9625 mpfr_from_real (m, ra, GMP_RNDN);
9626 mpfr_clear_flags ();
9627 inexact = mpfr_lgamma (m, &sg, m, rnd);
9628 result_lg = do_mpfr_ckconv (m, type, inexact);
9634 /* Dereference the arg_sg pointer argument. */
9635 arg_sg = build_fold_indirect_ref (arg_sg);
9636 /* Assign the signgam value into *arg_sg. */
9637 result_sg = fold_build2 (MODIFY_EXPR,
9638 TREE_TYPE (arg_sg), arg_sg,
9639 build_int_cst (TREE_TYPE (arg_sg), sg));
9640 TREE_SIDE_EFFECTS (result_sg) = 1;
9641 /* Combine the signgam assignment with the lgamma result. */
9642 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
9643 result_sg, result_lg));
9651 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
9652 mpc function FUNC on it and return the resulting value as a tree
9653 with type TYPE. The mpfr precision is set to the precision of
9654 TYPE. We assume that function FUNC returns zero if the result
9655 could be calculated exactly within the requested precision. If
9656 DO_NONFINITE is true, then fold expressions containing Inf or NaN
9657 in the arguments and/or results. */
9660 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
9661 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
9663 tree result = NULL_TREE;
9668 /* To proceed, MPFR must exactly represent the target floating point
9669 format, which only happens when the target base equals two. */
9670 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
9671 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
9672 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
9673 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
9674 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
9676 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
9677 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
9678 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
9679 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
9682 || (real_isfinite (re0) && real_isfinite (im0)
9683 && real_isfinite (re1) && real_isfinite (im1)))
9685 const struct real_format *const fmt =
9686 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
9687 const int prec = fmt->p;
9688 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
9689 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
9693 mpc_init2 (m0, prec);
9694 mpc_init2 (m1, prec);
9695 mpfr_from_real (mpc_realref (m0), re0, rnd);
9696 mpfr_from_real (mpc_imagref (m0), im0, rnd);
9697 mpfr_from_real (mpc_realref (m1), re1, rnd);
9698 mpfr_from_real (mpc_imagref (m1), im1, rnd);
9699 mpfr_clear_flags ();
9700 inexact = func (m0, m0, m1, crnd);
9701 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
9710 /* A wrapper function for builtin folding that prevents warnings for
9711 "statement without effect" and the like, caused by removing the
9712 call node earlier than the warning is generated. */
9715 fold_call_stmt (gcall *stmt, bool ignore)
9717 tree ret = NULL_TREE;
9718 tree fndecl = gimple_call_fndecl (stmt);
9719 location_t loc = gimple_location (stmt);
9721 && TREE_CODE (fndecl) == FUNCTION_DECL
9722 && DECL_BUILT_IN (fndecl)
9723 && !gimple_call_va_arg_pack_p (stmt))
9725 int nargs = gimple_call_num_args (stmt);
9726 tree *args = (nargs > 0
9727 ? gimple_call_arg_ptr (stmt, 0)
9728 : &error_mark_node);
9730 if (avoid_folding_inline_builtin (fndecl))
9732 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
9734 return targetm.fold_builtin (fndecl, nargs, args, ignore);
9738 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
9741 /* Propagate location information from original call to
9742 expansion of builtin. Otherwise things like
9743 maybe_emit_chk_warning, that operate on the expansion
9744 of a builtin, will use the wrong location information. */
9745 if (gimple_has_location (stmt))
9748 if (TREE_CODE (ret) == NOP_EXPR)
9749 realret = TREE_OPERAND (ret, 0);
9750 if (CAN_HAVE_LOCATION_P (realret)
9751 && !EXPR_HAS_LOCATION (realret))
9752 SET_EXPR_LOCATION (realret, loc);
9762 /* Look up the function in builtin_decl that corresponds to DECL
9763 and set ASMSPEC as its user assembler name. DECL must be a
9764 function decl that declares a builtin. */
9767 set_builtin_user_assembler_name (tree decl, const char *asmspec)
9770 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
9771 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
9774 builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
9775 set_user_assembler_name (builtin, asmspec);
9776 switch (DECL_FUNCTION_CODE (decl))
9778 case BUILT_IN_MEMCPY:
9779 init_block_move_fn (asmspec);
9780 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
9782 case BUILT_IN_MEMSET:
9783 init_block_clear_fn (asmspec);
9784 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
9786 case BUILT_IN_MEMMOVE:
9787 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
9789 case BUILT_IN_MEMCMP:
9790 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
9792 case BUILT_IN_ABORT:
9793 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
9796 if (INT_TYPE_SIZE < BITS_PER_WORD)
9798 set_user_assembler_libfunc ("ffs", asmspec);
9799 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
9800 MODE_INT, 0), "ffs");
9808 /* Return true if DECL is a builtin that expands to a constant or similarly
9811 is_simple_builtin (tree decl)
9813 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
9814 switch (DECL_FUNCTION_CODE (decl))
9816 /* Builtins that expand to constants. */
9817 case BUILT_IN_CONSTANT_P:
9818 case BUILT_IN_EXPECT:
9819 case BUILT_IN_OBJECT_SIZE:
9820 case BUILT_IN_UNREACHABLE:
9821 /* Simple register moves or loads from stack. */
9822 case BUILT_IN_ASSUME_ALIGNED:
9823 case BUILT_IN_RETURN_ADDRESS:
9824 case BUILT_IN_EXTRACT_RETURN_ADDR:
9825 case BUILT_IN_FROB_RETURN_ADDR:
9826 case BUILT_IN_RETURN:
9827 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
9828 case BUILT_IN_FRAME_ADDRESS:
9829 case BUILT_IN_VA_END:
9830 case BUILT_IN_STACK_SAVE:
9831 case BUILT_IN_STACK_RESTORE:
9832 /* Exception state returns or moves registers around. */
9833 case BUILT_IN_EH_FILTER:
9834 case BUILT_IN_EH_POINTER:
9835 case BUILT_IN_EH_COPY_VALUES:
9845 /* Return true if DECL is a builtin that is not expensive, i.e., they are
9846 most probably expanded inline into reasonably simple code. This is a
9847 superset of is_simple_builtin. */
9849 is_inexpensive_builtin (tree decl)
9853 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
9855 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
9856 switch (DECL_FUNCTION_CODE (decl))
9859 case BUILT_IN_ALLOCA:
9860 case BUILT_IN_ALLOCA_WITH_ALIGN:
9861 case BUILT_IN_BSWAP16:
9862 case BUILT_IN_BSWAP32:
9863 case BUILT_IN_BSWAP64:
9865 case BUILT_IN_CLZIMAX:
9867 case BUILT_IN_CLZLL:
9869 case BUILT_IN_CTZIMAX:
9871 case BUILT_IN_CTZLL:
9873 case BUILT_IN_FFSIMAX:
9875 case BUILT_IN_FFSLL:
9876 case BUILT_IN_IMAXABS:
9877 case BUILT_IN_FINITE:
9878 case BUILT_IN_FINITEF:
9879 case BUILT_IN_FINITEL:
9880 case BUILT_IN_FINITED32:
9881 case BUILT_IN_FINITED64:
9882 case BUILT_IN_FINITED128:
9883 case BUILT_IN_FPCLASSIFY:
9884 case BUILT_IN_ISFINITE:
9885 case BUILT_IN_ISINF_SIGN:
9886 case BUILT_IN_ISINF:
9887 case BUILT_IN_ISINFF:
9888 case BUILT_IN_ISINFL:
9889 case BUILT_IN_ISINFD32:
9890 case BUILT_IN_ISINFD64:
9891 case BUILT_IN_ISINFD128:
9892 case BUILT_IN_ISNAN:
9893 case BUILT_IN_ISNANF:
9894 case BUILT_IN_ISNANL:
9895 case BUILT_IN_ISNAND32:
9896 case BUILT_IN_ISNAND64:
9897 case BUILT_IN_ISNAND128:
9898 case BUILT_IN_ISNORMAL:
9899 case BUILT_IN_ISGREATER:
9900 case BUILT_IN_ISGREATEREQUAL:
9901 case BUILT_IN_ISLESS:
9902 case BUILT_IN_ISLESSEQUAL:
9903 case BUILT_IN_ISLESSGREATER:
9904 case BUILT_IN_ISUNORDERED:
9905 case BUILT_IN_VA_ARG_PACK:
9906 case BUILT_IN_VA_ARG_PACK_LEN:
9907 case BUILT_IN_VA_COPY:
9909 case BUILT_IN_SAVEREGS:
9910 case BUILT_IN_POPCOUNTL:
9911 case BUILT_IN_POPCOUNTLL:
9912 case BUILT_IN_POPCOUNTIMAX:
9913 case BUILT_IN_POPCOUNT:
9914 case BUILT_IN_PARITYL:
9915 case BUILT_IN_PARITYLL:
9916 case BUILT_IN_PARITYIMAX:
9917 case BUILT_IN_PARITY:
9919 case BUILT_IN_LLABS:
9920 case BUILT_IN_PREFETCH:
9921 case BUILT_IN_ACC_ON_DEVICE:
9925 return is_simple_builtin (decl);