1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
31 #include "tree-gimple.h"
34 #include "hard-reg-set.h"
37 #include "insn-config.h"
43 #include "typeclass.h"
48 #include "langhooks.h"
49 #include "basic-block.h"
50 #include "tree-mudflap.h"
51 #include "tree-flow.h"
52 #include "value-prof.h"
54 #ifndef PAD_VARARGS_DOWN
55 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
58 /* Define the names of the builtin function types and codes. */
59 const char *const built_in_class_names[4]
60 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
62 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
63 const char * built_in_names[(int) END_BUILTINS] =
65 #include "builtins.def"
69 /* Setup an array of _DECL trees, make sure each element is
70 initialized to NULL_TREE. */
71 tree built_in_decls[(int) END_BUILTINS];
72 /* Declarations used when constructing the builtin implicitly in the compiler.
73 It may be NULL_TREE when this is invalid (for instance runtime is not
74 required to implement the function call in all cases). */
75 tree implicit_built_in_decls[(int) END_BUILTINS];
77 static const char *c_getstr (tree);
78 static rtx c_readstr (const char *, enum machine_mode);
79 static int target_char_cast (tree, char *);
80 static rtx get_memory_rtx (tree, tree);
81 static int apply_args_size (void);
82 static int apply_result_size (void);
83 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
84 static rtx result_vector (int, rtx);
86 static void expand_builtin_update_setjmp_buf (rtx);
87 static void expand_builtin_prefetch (tree);
88 static rtx expand_builtin_apply_args (void);
89 static rtx expand_builtin_apply_args_1 (void);
90 static rtx expand_builtin_apply (rtx, rtx, rtx);
91 static void expand_builtin_return (rtx);
92 static enum type_class type_to_class (tree);
93 static rtx expand_builtin_classify_type (tree);
94 static void expand_errno_check (tree, rtx);
95 static rtx expand_builtin_mathfn (tree, rtx, rtx);
96 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
97 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
98 static rtx expand_builtin_interclass_mathfn (tree, rtx, rtx);
99 static rtx expand_builtin_sincos (tree);
100 static rtx expand_builtin_cexpi (tree, rtx, rtx);
101 static rtx expand_builtin_int_roundingfn (tree, rtx, rtx);
102 static rtx expand_builtin_int_roundingfn_2 (tree, rtx, rtx);
103 static rtx expand_builtin_args_info (tree);
104 static rtx expand_builtin_next_arg (void);
105 static rtx expand_builtin_va_start (tree);
106 static rtx expand_builtin_va_end (tree);
107 static rtx expand_builtin_va_copy (tree);
108 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
109 static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
110 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
111 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
112 static rtx expand_builtin_strcat (tree, tree, rtx, enum machine_mode);
113 static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
114 static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
115 static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
116 static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
117 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
118 static rtx expand_builtin_mempcpy_args (tree, tree, tree, tree, rtx,
119 enum machine_mode, int);
120 static rtx expand_builtin_memmove (tree, rtx, enum machine_mode, int);
121 static rtx expand_builtin_memmove_args (tree, tree, tree, tree, rtx,
122 enum machine_mode, int);
123 static rtx expand_builtin_bcopy (tree, int);
124 static rtx expand_builtin_strcpy (tree, tree, rtx, enum machine_mode);
125 static rtx expand_builtin_strcpy_args (tree, tree, tree, rtx, enum machine_mode);
126 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
127 static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
128 static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
129 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
130 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
131 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
132 static rtx expand_builtin_bzero (tree);
133 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
134 static rtx expand_builtin_strstr (tree, rtx, enum machine_mode);
135 static rtx expand_builtin_strpbrk (tree, rtx, enum machine_mode);
136 static rtx expand_builtin_strchr (tree, rtx, enum machine_mode);
137 static rtx expand_builtin_strrchr (tree, rtx, enum machine_mode);
138 static rtx expand_builtin_alloca (tree, rtx);
139 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
140 static rtx expand_builtin_frame_address (tree, tree);
141 static rtx expand_builtin_fputs (tree, rtx, bool);
142 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
143 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
144 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
145 static tree stabilize_va_list (tree, int);
146 static rtx expand_builtin_expect (tree, rtx);
147 static tree fold_builtin_constant_p (tree);
148 static tree fold_builtin_expect (tree);
149 static tree fold_builtin_classify_type (tree);
150 static tree fold_builtin_strlen (tree);
151 static tree fold_builtin_inf (tree, int);
152 static tree fold_builtin_nan (tree, tree, int);
153 static tree rewrite_call_expr (tree, int, tree, int, ...);
154 static bool validate_arg (tree, enum tree_code code);
155 static bool integer_valued_real_p (tree);
156 static tree fold_trunc_transparent_mathfn (tree, tree);
157 static bool readonly_data_expr (tree);
158 static rtx expand_builtin_fabs (tree, rtx, rtx);
159 static rtx expand_builtin_signbit (tree, rtx);
160 static tree fold_builtin_sqrt (tree, tree);
161 static tree fold_builtin_cbrt (tree, tree);
162 static tree fold_builtin_pow (tree, tree, tree, tree);
163 static tree fold_builtin_powi (tree, tree, tree, tree);
164 static tree fold_builtin_cos (tree, tree, tree);
165 static tree fold_builtin_cosh (tree, tree, tree);
166 static tree fold_builtin_tan (tree, tree);
167 static tree fold_builtin_trunc (tree, tree);
168 static tree fold_builtin_floor (tree, tree);
169 static tree fold_builtin_ceil (tree, tree);
170 static tree fold_builtin_round (tree, tree);
171 static tree fold_builtin_int_roundingfn (tree, tree);
172 static tree fold_builtin_bitop (tree, tree);
173 static tree fold_builtin_memory_op (tree, tree, tree, tree, bool, int);
174 static tree fold_builtin_strchr (tree, tree, tree);
175 static tree fold_builtin_memcmp (tree, tree, tree);
176 static tree fold_builtin_strcmp (tree, tree);
177 static tree fold_builtin_strncmp (tree, tree, tree);
178 static tree fold_builtin_signbit (tree, tree);
179 static tree fold_builtin_copysign (tree, tree, tree, tree);
180 static tree fold_builtin_isascii (tree);
181 static tree fold_builtin_toascii (tree);
182 static tree fold_builtin_isdigit (tree);
183 static tree fold_builtin_fabs (tree, tree);
184 static tree fold_builtin_abs (tree, tree);
185 static tree fold_builtin_unordered_cmp (tree, tree, tree, enum tree_code,
187 static tree fold_builtin_n (tree, tree *, int, bool);
188 static tree fold_builtin_0 (tree, bool);
189 static tree fold_builtin_1 (tree, tree, bool);
190 static tree fold_builtin_2 (tree, tree, tree, bool);
191 static tree fold_builtin_3 (tree, tree, tree, tree, bool);
192 static tree fold_builtin_4 (tree, tree, tree, tree, tree, bool);
193 static tree fold_builtin_varargs (tree, tree, bool);
195 static tree fold_builtin_strpbrk (tree, tree, tree);
196 static tree fold_builtin_strstr (tree, tree, tree);
197 static tree fold_builtin_strrchr (tree, tree, tree);
198 static tree fold_builtin_strcat (tree, tree);
199 static tree fold_builtin_strncat (tree, tree, tree);
200 static tree fold_builtin_strspn (tree, tree);
201 static tree fold_builtin_strcspn (tree, tree);
202 static tree fold_builtin_sprintf (tree, tree, tree, int);
204 static rtx expand_builtin_object_size (tree);
205 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
206 enum built_in_function);
207 static void maybe_emit_chk_warning (tree, enum built_in_function);
208 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
209 static tree fold_builtin_object_size (tree, tree);
210 static tree fold_builtin_strcat_chk (tree, tree, tree, tree);
211 static tree fold_builtin_strncat_chk (tree, tree, tree, tree, tree);
212 static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
213 static tree fold_builtin_printf (tree, tree, tree, bool, enum built_in_function);
214 static tree fold_builtin_fprintf (tree, tree, tree, tree, bool,
215 enum built_in_function);
216 static bool init_target_chars (void);
218 static unsigned HOST_WIDE_INT target_newline;
219 static unsigned HOST_WIDE_INT target_percent;
220 static unsigned HOST_WIDE_INT target_c;
221 static unsigned HOST_WIDE_INT target_s;
222 static char target_percent_c[3];
223 static char target_percent_s[3];
224 static char target_percent_s_newline[4];
225 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
226 const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
227 static tree do_mpfr_arg2 (tree, tree, tree,
228 int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
229 static tree do_mpfr_arg3 (tree, tree, tree, tree,
230 int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
231 static tree do_mpfr_sincos (tree, tree, tree);
233 /* Return true if NODE should be considered for inline expansion regardless
234 of the optimization level. This means whenever a function is invoked with
235 its "internal" name, which normally contains the prefix "__builtin". */
237 static bool called_as_built_in (tree node)
239 const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
240 if (strncmp (name, "__builtin_", 10) == 0)
242 if (strncmp (name, "__sync_", 7) == 0)
247 /* Return the alignment in bits of EXP, a pointer valued expression.
248 But don't return more than MAX_ALIGN no matter what.
249 The alignment returned is, by default, the alignment of the thing that
250 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
252 Otherwise, look at the expression to see if we can do better, i.e., if the
253 expression is actually pointing at an object whose alignment is tighter. */
256 get_pointer_alignment (tree exp, unsigned int max_align)
258 unsigned int align, inner;
260 /* We rely on TER to compute accurate alignment information. */
261 if (!(optimize && flag_tree_ter))
264 if (!POINTER_TYPE_P (TREE_TYPE (exp)))
267 align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
268 align = MIN (align, max_align);
272 switch (TREE_CODE (exp))
276 case NON_LVALUE_EXPR:
277 exp = TREE_OPERAND (exp, 0);
278 if (! POINTER_TYPE_P (TREE_TYPE (exp)))
281 inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
282 align = MIN (inner, max_align);
286 /* If sum of pointer + int, restrict our maximum alignment to that
287 imposed by the integer. If not, we can't do any better than
289 if (! host_integerp (TREE_OPERAND (exp, 1), 1))
292 while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
293 & (max_align / BITS_PER_UNIT - 1))
297 exp = TREE_OPERAND (exp, 0);
301 /* See what we are pointing at and look at its alignment. */
302 exp = TREE_OPERAND (exp, 0);
304 if (handled_component_p (exp))
306 HOST_WIDE_INT bitsize, bitpos;
308 enum machine_mode mode;
309 int unsignedp, volatilep;
311 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
312 &mode, &unsignedp, &volatilep, true);
314 inner = MIN (inner, (unsigned) (bitpos & -bitpos));
315 if (offset && TREE_CODE (offset) == PLUS_EXPR
316 && host_integerp (TREE_OPERAND (offset, 1), 1))
318 /* Any overflow in calculating offset_bits won't change
321 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
325 inner = MIN (inner, (offset_bits & -offset_bits));
326 offset = TREE_OPERAND (offset, 0);
328 if (offset && TREE_CODE (offset) == MULT_EXPR
329 && host_integerp (TREE_OPERAND (offset, 1), 1))
331 /* Any overflow in calculating offset_factor won't change
333 unsigned offset_factor
334 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
338 inner = MIN (inner, (offset_factor & -offset_factor));
341 inner = MIN (inner, BITS_PER_UNIT);
343 if (TREE_CODE (exp) == FUNCTION_DECL)
344 align = FUNCTION_BOUNDARY;
345 else if (DECL_P (exp))
346 align = MIN (inner, DECL_ALIGN (exp));
347 #ifdef CONSTANT_ALIGNMENT
348 else if (CONSTANT_CLASS_P (exp))
349 align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
351 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
352 || TREE_CODE (exp) == INDIRECT_REF)
353 align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
355 align = MIN (align, inner);
356 return MIN (align, max_align);
364 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
365 way, because it could contain a zero byte in the middle.
366 TREE_STRING_LENGTH is the size of the character array, not the string.
368 ONLY_VALUE should be nonzero if the result is not going to be emitted
369 into the instruction stream and zero if it is going to be expanded.
370 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
371 is returned, otherwise NULL, since
372 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
373 evaluate the side-effects.
375 The value returned is of type `ssizetype'.
377 Unfortunately, string_constant can't access the values of const char
378 arrays with initializers, so neither can we do so here. */
381 c_strlen (tree src, int only_value)
384 HOST_WIDE_INT offset;
389 if (TREE_CODE (src) == COND_EXPR
390 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
394 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
395 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
396 if (tree_int_cst_equal (len1, len2))
400 if (TREE_CODE (src) == COMPOUND_EXPR
401 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
402 return c_strlen (TREE_OPERAND (src, 1), only_value);
404 src = string_constant (src, &offset_node);
408 max = TREE_STRING_LENGTH (src) - 1;
409 ptr = TREE_STRING_POINTER (src);
411 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
413 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
414 compute the offset to the following null if we don't know where to
415 start searching for it. */
418 for (i = 0; i < max; i++)
422 /* We don't know the starting offset, but we do know that the string
423 has no internal zero bytes. We can assume that the offset falls
424 within the bounds of the string; otherwise, the programmer deserves
425 what he gets. Subtract the offset from the length of the string,
426 and return that. This would perhaps not be valid if we were dealing
427 with named arrays in addition to literal string constants. */
429 return size_diffop (size_int (max), offset_node);
432 /* We have a known offset into the string. Start searching there for
433 a null character if we can represent it as a single HOST_WIDE_INT. */
434 if (offset_node == 0)
436 else if (! host_integerp (offset_node, 0))
439 offset = tree_low_cst (offset_node, 0);
441 /* If the offset is known to be out of bounds, warn, and call strlen at
443 if (offset < 0 || offset > max)
445 warning (0, "offset outside bounds of constant string");
449 /* Use strlen to search for the first zero byte. Since any strings
450 constructed with build_string will have nulls appended, we win even
451 if we get handed something like (char[4])"abcd".
453 Since OFFSET is our starting index into the string, no further
454 calculation is needed. */
455 return ssize_int (strlen (ptr + offset));
458 /* Return a char pointer for a C string if it is a string constant
459 or sum of string constant and integer constant. */
466 src = string_constant (src, &offset_node);
470 if (offset_node == 0)
471 return TREE_STRING_POINTER (src);
472 else if (!host_integerp (offset_node, 1)
473 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
476 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
479 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
480 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
483 c_readstr (const char *str, enum machine_mode mode)
489 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
494 for (i = 0; i < GET_MODE_SIZE (mode); i++)
497 if (WORDS_BIG_ENDIAN)
498 j = GET_MODE_SIZE (mode) - i - 1;
499 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
500 && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
501 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
503 gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
506 ch = (unsigned char) str[i];
507 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
509 return immed_double_const (c[0], c[1], mode);
512 /* Cast a target constant CST to target CHAR and if that value fits into
513 host char type, return zero and put that value into variable pointed to by
517 target_char_cast (tree cst, char *p)
519 unsigned HOST_WIDE_INT val, hostval;
521 if (!host_integerp (cst, 1)
522 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
525 val = tree_low_cst (cst, 1);
526 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
527 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
530 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
531 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
540 /* Similar to save_expr, but assumes that arbitrary code is not executed
541 in between the multiple evaluations. In particular, we assume that a
542 non-addressable local variable will not be modified. */
545 builtin_save_expr (tree exp)
547 if (TREE_ADDRESSABLE (exp) == 0
548 && (TREE_CODE (exp) == PARM_DECL
549 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
552 return save_expr (exp);
555 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
556 times to get the address of either a higher stack frame, or a return
557 address located within it (depending on FNDECL_CODE). */
560 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
564 #ifdef INITIAL_FRAME_ADDRESS_RTX
565 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
569 /* For a zero count with __builtin_return_address, we don't care what
570 frame address we return, because target-specific definitions will
571 override us. Therefore frame pointer elimination is OK, and using
572 the soft frame pointer is OK.
574 For a nonzero count, or a zero count with __builtin_frame_address,
575 we require a stable offset from the current frame pointer to the
576 previous one, so we must use the hard frame pointer, and
577 we must disable frame pointer elimination. */
578 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
579 tem = frame_pointer_rtx;
582 tem = hard_frame_pointer_rtx;
584 /* Tell reload not to eliminate the frame pointer. */
585 current_function_accesses_prior_frames = 1;
589 /* Some machines need special handling before we can access
590 arbitrary frames. For example, on the SPARC, we must first flush
591 all register windows to the stack. */
592 #ifdef SETUP_FRAME_ADDRESSES
594 SETUP_FRAME_ADDRESSES ();
597 /* On the SPARC, the return address is not in the frame, it is in a
598 register. There is no way to access it off of the current frame
599 pointer, but it can be accessed off the previous frame pointer by
600 reading the value from the register window save area. */
601 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
602 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
606 /* Scan back COUNT frames to the specified frame. */
607 for (i = 0; i < count; i++)
609 /* Assume the dynamic chain pointer is in the word that the
610 frame address points to, unless otherwise specified. */
611 #ifdef DYNAMIC_CHAIN_ADDRESS
612 tem = DYNAMIC_CHAIN_ADDRESS (tem);
614 tem = memory_address (Pmode, tem);
615 tem = gen_frame_mem (Pmode, tem);
616 tem = copy_to_reg (tem);
619 /* For __builtin_frame_address, return what we've got. But, on
620 the SPARC for example, we may have to add a bias. */
621 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
622 #ifdef FRAME_ADDR_RTX
623 return FRAME_ADDR_RTX (tem);
628 /* For __builtin_return_address, get the return address from that frame. */
629 #ifdef RETURN_ADDR_RTX
630 tem = RETURN_ADDR_RTX (count, tem);
632 tem = memory_address (Pmode,
633 plus_constant (tem, GET_MODE_SIZE (Pmode)));
634 tem = gen_frame_mem (Pmode, tem);
639 /* Alias set used for setjmp buffer. */
640 static HOST_WIDE_INT setjmp_alias_set = -1;
642 /* Construct the leading half of a __builtin_setjmp call. Control will
643 return to RECEIVER_LABEL. This is also called directly by the SJLJ
644 exception handling code. */
647 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
649 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
653 if (setjmp_alias_set == -1)
654 setjmp_alias_set = new_alias_set ();
656 buf_addr = convert_memory_address (Pmode, buf_addr);
658 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
660 /* We store the frame pointer and the address of receiver_label in
661 the buffer and use the rest of it for the stack save area, which
662 is machine-dependent. */
664 mem = gen_rtx_MEM (Pmode, buf_addr);
665 set_mem_alias_set (mem, setjmp_alias_set);
666 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
668 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
669 set_mem_alias_set (mem, setjmp_alias_set);
671 emit_move_insn (validize_mem (mem),
672 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
674 stack_save = gen_rtx_MEM (sa_mode,
675 plus_constant (buf_addr,
676 2 * GET_MODE_SIZE (Pmode)));
677 set_mem_alias_set (stack_save, setjmp_alias_set);
678 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
680 /* If there is further processing to do, do it. */
681 #ifdef HAVE_builtin_setjmp_setup
682 if (HAVE_builtin_setjmp_setup)
683 emit_insn (gen_builtin_setjmp_setup (buf_addr));
686 /* Tell optimize_save_area_alloca that extra work is going to
687 need to go on during alloca. */
688 current_function_calls_setjmp = 1;
690 /* Set this so all the registers get saved in our frame; we need to be
691 able to copy the saved values for any registers from frames we unwind. */
692 current_function_has_nonlocal_label = 1;
695 /* Construct the trailing part of a __builtin_setjmp call. This is
696 also called directly by the SJLJ exception handling code. */
699 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
701 /* Clobber the FP when we get here, so we have to make sure it's
702 marked as used by this function. */
703 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
705 /* Mark the static chain as clobbered here so life information
706 doesn't get messed up for it. */
707 emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
709 /* Now put in the code to restore the frame pointer, and argument
710 pointer, if needed. */
711 #ifdef HAVE_nonlocal_goto
712 if (! HAVE_nonlocal_goto)
715 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
716 /* This might change the hard frame pointer in ways that aren't
717 apparent to early optimization passes, so force a clobber. */
718 emit_insn (gen_rtx_CLOBBER (VOIDmode, hard_frame_pointer_rtx));
721 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
722 if (fixed_regs[ARG_POINTER_REGNUM])
724 #ifdef ELIMINABLE_REGS
726 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
728 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
729 if (elim_regs[i].from == ARG_POINTER_REGNUM
730 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
733 if (i == ARRAY_SIZE (elim_regs))
736 /* Now restore our arg pointer from the address at which it
737 was saved in our stack frame. */
738 emit_move_insn (virtual_incoming_args_rtx,
739 copy_to_reg (get_arg_pointer_save_area (cfun)));
744 #ifdef HAVE_builtin_setjmp_receiver
745 if (HAVE_builtin_setjmp_receiver)
746 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
749 #ifdef HAVE_nonlocal_goto_receiver
750 if (HAVE_nonlocal_goto_receiver)
751 emit_insn (gen_nonlocal_goto_receiver ());
756 /* @@@ This is a kludge. Not all machine descriptions define a blockage
757 insn, but we must not allow the code we just generated to be reordered
758 by scheduling. Specifically, the update of the frame pointer must
759 happen immediately, not later. So emit an ASM_INPUT to act as blockage
761 emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
764 /* __builtin_longjmp is passed a pointer to an array of five words (not
765 all will be used on all machines). It operates similarly to the C
766 library function of the same name, but is more efficient. Much of
767 the code below is copied from the handling of non-local gotos. */
770 expand_builtin_longjmp (rtx buf_addr, rtx value)
772 rtx fp, lab, stack, insn, last;
773 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
775 if (setjmp_alias_set == -1)
776 setjmp_alias_set = new_alias_set ();
778 buf_addr = convert_memory_address (Pmode, buf_addr);
780 buf_addr = force_reg (Pmode, buf_addr);
782 /* We used to store value in static_chain_rtx, but that fails if pointers
783 are smaller than integers. We instead require that the user must pass
784 a second argument of 1, because that is what builtin_setjmp will
785 return. This also makes EH slightly more efficient, since we are no
786 longer copying around a value that we don't care about. */
787 gcc_assert (value == const1_rtx);
789 last = get_last_insn ();
790 #ifdef HAVE_builtin_longjmp
791 if (HAVE_builtin_longjmp)
792 emit_insn (gen_builtin_longjmp (buf_addr));
796 fp = gen_rtx_MEM (Pmode, buf_addr);
797 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
798 GET_MODE_SIZE (Pmode)));
800 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
801 2 * GET_MODE_SIZE (Pmode)));
802 set_mem_alias_set (fp, setjmp_alias_set);
803 set_mem_alias_set (lab, setjmp_alias_set);
804 set_mem_alias_set (stack, setjmp_alias_set);
806 /* Pick up FP, label, and SP from the block and jump. This code is
807 from expand_goto in stmt.c; see there for detailed comments. */
808 #ifdef HAVE_nonlocal_goto
809 if (HAVE_nonlocal_goto)
810 /* We have to pass a value to the nonlocal_goto pattern that will
811 get copied into the static_chain pointer, but it does not matter
812 what that value is, because builtin_setjmp does not use it. */
813 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
817 lab = copy_to_reg (lab);
819 emit_insn (gen_rtx_CLOBBER (VOIDmode,
820 gen_rtx_MEM (BLKmode,
821 gen_rtx_SCRATCH (VOIDmode))));
822 emit_insn (gen_rtx_CLOBBER (VOIDmode,
823 gen_rtx_MEM (BLKmode,
824 hard_frame_pointer_rtx)));
826 emit_move_insn (hard_frame_pointer_rtx, fp);
827 emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
829 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
830 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
831 emit_indirect_jump (lab);
835 /* Search backwards and mark the jump insn as a non-local goto.
836 Note that this precludes the use of __builtin_longjmp to a
837 __builtin_setjmp target in the same function. However, we've
838 already cautioned the user that these functions are for
839 internal exception handling use only. */
840 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
842 gcc_assert (insn != last);
846 REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
850 else if (CALL_P (insn))
855 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
856 and the address of the save area. */
859 expand_builtin_nonlocal_goto (tree exp)
861 tree t_label, t_save_area;
862 rtx r_label, r_save_area, r_fp, r_sp, insn;
864 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
867 t_label = CALL_EXPR_ARG (exp, 0);
868 t_save_area = CALL_EXPR_ARG (exp, 1);
870 r_label = expand_normal (t_label);
871 r_label = convert_memory_address (Pmode, r_label);
872 r_save_area = expand_normal (t_save_area);
873 r_save_area = convert_memory_address (Pmode, r_save_area);
874 r_fp = gen_rtx_MEM (Pmode, r_save_area);
875 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
876 plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
878 current_function_has_nonlocal_goto = 1;
880 #ifdef HAVE_nonlocal_goto
881 /* ??? We no longer need to pass the static chain value, afaik. */
882 if (HAVE_nonlocal_goto)
883 emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
887 r_label = copy_to_reg (r_label);
889 emit_insn (gen_rtx_CLOBBER (VOIDmode,
890 gen_rtx_MEM (BLKmode,
891 gen_rtx_SCRATCH (VOIDmode))));
893 emit_insn (gen_rtx_CLOBBER (VOIDmode,
894 gen_rtx_MEM (BLKmode,
895 hard_frame_pointer_rtx)));
897 /* Restore frame pointer for containing function.
898 This sets the actual hard register used for the frame pointer
899 to the location of the function's incoming static chain info.
900 The non-local goto handler will then adjust it to contain the
901 proper value and reload the argument pointer, if needed. */
902 emit_move_insn (hard_frame_pointer_rtx, r_fp);
903 emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
905 /* USE of hard_frame_pointer_rtx added for consistency;
906 not clear if really needed. */
907 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
908 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
909 emit_indirect_jump (r_label);
912 /* Search backwards to the jump insn and mark it as a
914 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
918 REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO,
919 const0_rtx, REG_NOTES (insn));
922 else if (CALL_P (insn))
929 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
930 (not all will be used on all machines) that was passed to __builtin_setjmp.
931 It updates the stack pointer in that block to correspond to the current
935 expand_builtin_update_setjmp_buf (rtx buf_addr)
937 enum machine_mode sa_mode = Pmode;
941 #ifdef HAVE_save_stack_nonlocal
942 if (HAVE_save_stack_nonlocal)
943 sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
945 #ifdef STACK_SAVEAREA_MODE
946 sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
950 = gen_rtx_MEM (sa_mode,
953 plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
957 emit_insn (gen_setjmp ());
960 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
963 /* Expand a call to __builtin_prefetch. For a target that does not support
964 data prefetch, evaluate the memory address argument in case it has side
968 expand_builtin_prefetch (tree exp)
970 tree arg0, arg1, arg2;
974 if (!validate_arglist (exp, POINTER_TYPE, 0))
977 arg0 = CALL_EXPR_ARG (exp, 0);
979 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
980 zero (read) and argument 2 (locality) defaults to 3 (high degree of
982 nargs = call_expr_nargs (exp);
984 arg1 = CALL_EXPR_ARG (exp, 1);
986 arg1 = integer_zero_node;
988 arg2 = CALL_EXPR_ARG (exp, 2);
990 arg2 = build_int_cst (NULL_TREE, 3);
992 /* Argument 0 is an address. */
993 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
995 /* Argument 1 (read/write flag) must be a compile-time constant int. */
996 if (TREE_CODE (arg1) != INTEGER_CST)
998 error ("second argument to %<__builtin_prefetch%> must be a constant");
999 arg1 = integer_zero_node;
1001 op1 = expand_normal (arg1);
1002 /* Argument 1 must be either zero or one. */
1003 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1005 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1010 /* Argument 2 (locality) must be a compile-time constant int. */
1011 if (TREE_CODE (arg2) != INTEGER_CST)
1013 error ("third argument to %<__builtin_prefetch%> must be a constant");
1014 arg2 = integer_zero_node;
1016 op2 = expand_normal (arg2);
1017 /* Argument 2 must be 0, 1, 2, or 3. */
1018 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1020 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1024 #ifdef HAVE_prefetch
1027 if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1029 insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1030 || (GET_MODE (op0) != Pmode))
1032 op0 = convert_memory_address (Pmode, op0);
1033 op0 = force_reg (Pmode, op0);
1035 emit_insn (gen_prefetch (op0, op1, op2));
1039 /* Don't do anything with direct references to volatile memory, but
1040 generate code to handle other side effects. */
1041 if (!MEM_P (op0) && side_effects_p (op0))
1045 /* Get a MEM rtx for expression EXP which is the address of an operand
1046 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1047 the maximum length of the block of memory that might be accessed or
1051 get_memory_rtx (tree exp, tree len)
1053 rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1054 rtx mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1056 /* Get an expression we can use to find the attributes to assign to MEM.
1057 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1058 we can. First remove any nops. */
1059 while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
1060 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1061 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1062 exp = TREE_OPERAND (exp, 0);
1064 if (TREE_CODE (exp) == ADDR_EXPR)
1065 exp = TREE_OPERAND (exp, 0);
1066 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1067 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1071 /* Honor attributes derived from exp, except for the alias set
1072 (as builtin stringops may alias with anything) and the size
1073 (as stringops may access multiple array elements). */
1076 set_mem_attributes (mem, exp, 0);
1078 /* Allow the string and memory builtins to overflow from one
1079 field into another, see http://gcc.gnu.org/PR23561.
1080 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1081 memory accessed by the string or memory builtin will fit
1082 within the field. */
1083 if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1085 tree mem_expr = MEM_EXPR (mem);
1086 HOST_WIDE_INT offset = -1, length = -1;
1089 while (TREE_CODE (inner) == ARRAY_REF
1090 || TREE_CODE (inner) == NOP_EXPR
1091 || TREE_CODE (inner) == CONVERT_EXPR
1092 || TREE_CODE (inner) == NON_LVALUE_EXPR
1093 || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1094 || TREE_CODE (inner) == SAVE_EXPR)
1095 inner = TREE_OPERAND (inner, 0);
1097 gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1099 if (MEM_OFFSET (mem)
1100 && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
1101 offset = INTVAL (MEM_OFFSET (mem));
1103 if (offset >= 0 && len && host_integerp (len, 0))
1104 length = tree_low_cst (len, 0);
1106 while (TREE_CODE (inner) == COMPONENT_REF)
1108 tree field = TREE_OPERAND (inner, 1);
1109 gcc_assert (! DECL_BIT_FIELD (field));
1110 gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1111 gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1114 && TYPE_SIZE_UNIT (TREE_TYPE (inner))
1115 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0))
1118 = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0);
1119 /* If we can prove the memory starting at XEXP (mem, 0)
1120 and ending at XEXP (mem, 0) + LENGTH will fit into
1121 this field, we can keep that COMPONENT_REF in MEM_EXPR. */
1124 && offset + length <= size)
1129 && host_integerp (DECL_FIELD_OFFSET (field), 0))
1130 offset += tree_low_cst (DECL_FIELD_OFFSET (field), 0)
1131 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1139 mem_expr = TREE_OPERAND (mem_expr, 0);
1140 inner = TREE_OPERAND (inner, 0);
1143 if (mem_expr == NULL)
1145 if (mem_expr != MEM_EXPR (mem))
1147 set_mem_expr (mem, mem_expr);
1148 set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1151 set_mem_alias_set (mem, 0);
1152 set_mem_size (mem, NULL_RTX);
1158 /* Built-in functions to perform an untyped call and return. */
1160 /* For each register that may be used for calling a function, this
1161 gives a mode used to copy the register's value. VOIDmode indicates
1162 the register is not used for calling a function. If the machine
1163 has register windows, this gives only the outbound registers.
1164 INCOMING_REGNO gives the corresponding inbound register. */
1165 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1167 /* For each register that may be used for returning values, this gives
1168 a mode used to copy the register's value. VOIDmode indicates the
1169 register is not used for returning values. If the machine has
1170 register windows, this gives only the outbound registers.
1171 INCOMING_REGNO gives the corresponding inbound register. */
1172 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1174 /* For each register that may be used for calling a function, this
1175 gives the offset of that register into the block returned by
1176 __builtin_apply_args. 0 indicates that the register is not
1177 used for calling a function. */
1178 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1180 /* Return the size required for the block returned by __builtin_apply_args,
1181 and initialize apply_args_mode. */
1184 apply_args_size (void)
1186 static int size = -1;
1189 enum machine_mode mode;
1191 /* The values computed by this function never change. */
1194 /* The first value is the incoming arg-pointer. */
1195 size = GET_MODE_SIZE (Pmode);
1197 /* The second value is the structure value address unless this is
1198 passed as an "invisible" first argument. */
1199 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1200 size += GET_MODE_SIZE (Pmode);
1202 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1203 if (FUNCTION_ARG_REGNO_P (regno))
1205 mode = reg_raw_mode[regno];
1207 gcc_assert (mode != VOIDmode);
1209 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1210 if (size % align != 0)
1211 size = CEIL (size, align) * align;
1212 apply_args_reg_offset[regno] = size;
1213 size += GET_MODE_SIZE (mode);
1214 apply_args_mode[regno] = mode;
1218 apply_args_mode[regno] = VOIDmode;
1219 apply_args_reg_offset[regno] = 0;
1225 /* Return the size required for the block returned by __builtin_apply,
1226 and initialize apply_result_mode. */
1229 apply_result_size (void)
1231 static int size = -1;
1233 enum machine_mode mode;
1235 /* The values computed by this function never change. */
1240 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1241 if (FUNCTION_VALUE_REGNO_P (regno))
1243 mode = reg_raw_mode[regno];
1245 gcc_assert (mode != VOIDmode);
1247 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1248 if (size % align != 0)
1249 size = CEIL (size, align) * align;
1250 size += GET_MODE_SIZE (mode);
1251 apply_result_mode[regno] = mode;
1254 apply_result_mode[regno] = VOIDmode;
1256 /* Allow targets that use untyped_call and untyped_return to override
1257 the size so that machine-specific information can be stored here. */
1258 #ifdef APPLY_RESULT_SIZE
1259 size = APPLY_RESULT_SIZE;
1265 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1266 /* Create a vector describing the result block RESULT. If SAVEP is true,
1267 the result block is used to save the values; otherwise it is used to
1268 restore the values. */
1271 result_vector (int savep, rtx result)
1273 int regno, size, align, nelts;
1274 enum machine_mode mode;
1276 rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
1279 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1280 if ((mode = apply_result_mode[regno]) != VOIDmode)
1282 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1283 if (size % align != 0)
1284 size = CEIL (size, align) * align;
1285 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1286 mem = adjust_address (result, mode, size);
1287 savevec[nelts++] = (savep
1288 ? gen_rtx_SET (VOIDmode, mem, reg)
1289 : gen_rtx_SET (VOIDmode, reg, mem));
1290 size += GET_MODE_SIZE (mode);
1292 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1294 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1296 /* Save the state required to perform an untyped call with the same
1297 arguments as were passed to the current function. */
1300 expand_builtin_apply_args_1 (void)
1303 int size, align, regno;
1304 enum machine_mode mode;
1305 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1307 /* Create a block where the arg-pointer, structure value address,
1308 and argument registers can be saved. */
1309 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1311 /* Walk past the arg-pointer and structure value address. */
1312 size = GET_MODE_SIZE (Pmode);
1313 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1314 size += GET_MODE_SIZE (Pmode);
1316 /* Save each register used in calling a function to the block. */
1317 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1318 if ((mode = apply_args_mode[regno]) != VOIDmode)
1320 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1321 if (size % align != 0)
1322 size = CEIL (size, align) * align;
1324 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1326 emit_move_insn (adjust_address (registers, mode, size), tem);
1327 size += GET_MODE_SIZE (mode);
1330 /* Save the arg pointer to the block. */
1331 tem = copy_to_reg (virtual_incoming_args_rtx);
1332 #ifdef STACK_GROWS_DOWNWARD
1333 /* We need the pointer as the caller actually passed them to us, not
1334 as we might have pretended they were passed. Make sure it's a valid
1335 operand, as emit_move_insn isn't expected to handle a PLUS. */
1337 = force_operand (plus_constant (tem, current_function_pretend_args_size),
1340 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1342 size = GET_MODE_SIZE (Pmode);
1344 /* Save the structure value address unless this is passed as an
1345 "invisible" first argument. */
1346 if (struct_incoming_value)
1348 emit_move_insn (adjust_address (registers, Pmode, size),
1349 copy_to_reg (struct_incoming_value));
1350 size += GET_MODE_SIZE (Pmode);
1353 /* Return the address of the block. */
1354 return copy_addr_to_reg (XEXP (registers, 0));
1357 /* __builtin_apply_args returns block of memory allocated on
1358 the stack into which is stored the arg pointer, structure
1359 value address, static chain, and all the registers that might
1360 possibly be used in performing a function call. The code is
1361 moved to the start of the function so the incoming values are
1365 expand_builtin_apply_args (void)
1367 /* Don't do __builtin_apply_args more than once in a function.
1368 Save the result of the first call and reuse it. */
1369 if (apply_args_value != 0)
1370 return apply_args_value;
1372 /* When this function is called, it means that registers must be
1373 saved on entry to this function. So we migrate the
1374 call to the first insn of this function. */
1379 temp = expand_builtin_apply_args_1 ();
1383 apply_args_value = temp;
1385 /* Put the insns after the NOTE that starts the function.
1386 If this is inside a start_sequence, make the outer-level insn
1387 chain current, so the code is placed at the start of the
1389 push_topmost_sequence ();
1390 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1391 pop_topmost_sequence ();
1396 /* Perform an untyped call and save the state required to perform an
1397 untyped return of whatever value was returned by the given function. */
1400 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1402 int size, align, regno;
1403 enum machine_mode mode;
1404 rtx incoming_args, result, reg, dest, src, call_insn;
1405 rtx old_stack_level = 0;
1406 rtx call_fusage = 0;
1407 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1409 arguments = convert_memory_address (Pmode, arguments);
1411 /* Create a block where the return registers can be saved. */
1412 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1414 /* Fetch the arg pointer from the ARGUMENTS block. */
1415 incoming_args = gen_reg_rtx (Pmode);
1416 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1417 #ifndef STACK_GROWS_DOWNWARD
1418 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1419 incoming_args, 0, OPTAB_LIB_WIDEN);
1422 /* Push a new argument block and copy the arguments. Do not allow
1423 the (potential) memcpy call below to interfere with our stack
1425 do_pending_stack_adjust ();
1428 /* Save the stack with nonlocal if available. */
1429 #ifdef HAVE_save_stack_nonlocal
1430 if (HAVE_save_stack_nonlocal)
1431 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1434 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1436 /* Allocate a block of memory onto the stack and copy the memory
1437 arguments to the outgoing arguments address. */
1438 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1439 dest = virtual_outgoing_args_rtx;
1440 #ifndef STACK_GROWS_DOWNWARD
1441 if (GET_CODE (argsize) == CONST_INT)
1442 dest = plus_constant (dest, -INTVAL (argsize));
1444 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1446 dest = gen_rtx_MEM (BLKmode, dest);
1447 set_mem_align (dest, PARM_BOUNDARY);
1448 src = gen_rtx_MEM (BLKmode, incoming_args);
1449 set_mem_align (src, PARM_BOUNDARY);
1450 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1452 /* Refer to the argument block. */
1454 arguments = gen_rtx_MEM (BLKmode, arguments);
1455 set_mem_align (arguments, PARM_BOUNDARY);
1457 /* Walk past the arg-pointer and structure value address. */
1458 size = GET_MODE_SIZE (Pmode);
1460 size += GET_MODE_SIZE (Pmode);
1462 /* Restore each of the registers previously saved. Make USE insns
1463 for each of these registers for use in making the call. */
1464 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1465 if ((mode = apply_args_mode[regno]) != VOIDmode)
1467 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1468 if (size % align != 0)
1469 size = CEIL (size, align) * align;
1470 reg = gen_rtx_REG (mode, regno);
1471 emit_move_insn (reg, adjust_address (arguments, mode, size));
1472 use_reg (&call_fusage, reg);
1473 size += GET_MODE_SIZE (mode);
1476 /* Restore the structure value address unless this is passed as an
1477 "invisible" first argument. */
1478 size = GET_MODE_SIZE (Pmode);
1481 rtx value = gen_reg_rtx (Pmode);
1482 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1483 emit_move_insn (struct_value, value);
1484 if (REG_P (struct_value))
1485 use_reg (&call_fusage, struct_value);
1486 size += GET_MODE_SIZE (Pmode);
1489 /* All arguments and registers used for the call are set up by now! */
1490 function = prepare_call_address (function, NULL, &call_fusage, 0, 0);
1492 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1493 and we don't want to load it into a register as an optimization,
1494 because prepare_call_address already did it if it should be done. */
1495 if (GET_CODE (function) != SYMBOL_REF)
1496 function = memory_address (FUNCTION_MODE, function);
1498 /* Generate the actual call instruction and save the return value. */
1499 #ifdef HAVE_untyped_call
1500 if (HAVE_untyped_call)
1501 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1502 result, result_vector (1, result)));
1505 #ifdef HAVE_call_value
1506 if (HAVE_call_value)
1510 /* Locate the unique return register. It is not possible to
1511 express a call that sets more than one return register using
1512 call_value; use untyped_call for that. In fact, untyped_call
1513 only needs to save the return registers in the given block. */
1514 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1515 if ((mode = apply_result_mode[regno]) != VOIDmode)
1517 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1519 valreg = gen_rtx_REG (mode, regno);
1522 emit_call_insn (GEN_CALL_VALUE (valreg,
1523 gen_rtx_MEM (FUNCTION_MODE, function),
1524 const0_rtx, NULL_RTX, const0_rtx));
1526 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1532 /* Find the CALL insn we just emitted, and attach the register usage
1534 call_insn = last_call_insn ();
1535 add_function_usage_to (call_insn, call_fusage);
1537 /* Restore the stack. */
1538 #ifdef HAVE_save_stack_nonlocal
1539 if (HAVE_save_stack_nonlocal)
1540 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1543 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1547 /* Return the address of the result block. */
1548 result = copy_addr_to_reg (XEXP (result, 0));
1549 return convert_memory_address (ptr_mode, result);
1552 /* Perform an untyped return. */
1555 expand_builtin_return (rtx result)
1557 int size, align, regno;
1558 enum machine_mode mode;
1560 rtx call_fusage = 0;
1562 result = convert_memory_address (Pmode, result);
1564 apply_result_size ();
1565 result = gen_rtx_MEM (BLKmode, result);
1567 #ifdef HAVE_untyped_return
1568 if (HAVE_untyped_return)
1570 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1576 /* Restore the return value and note that each value is used. */
1578 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1579 if ((mode = apply_result_mode[regno]) != VOIDmode)
1581 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1582 if (size % align != 0)
1583 size = CEIL (size, align) * align;
1584 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1585 emit_move_insn (reg, adjust_address (result, mode, size));
1587 push_to_sequence (call_fusage);
1588 emit_insn (gen_rtx_USE (VOIDmode, reg));
1589 call_fusage = get_insns ();
1591 size += GET_MODE_SIZE (mode);
1594 /* Put the USE insns before the return. */
1595 emit_insn (call_fusage);
1597 /* Return whatever values was restored by jumping directly to the end
1599 expand_naked_return ();
1602 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1604 static enum type_class
1605 type_to_class (tree type)
1607 switch (TREE_CODE (type))
1609 case VOID_TYPE: return void_type_class;
1610 case INTEGER_TYPE: return integer_type_class;
1611 case ENUMERAL_TYPE: return enumeral_type_class;
1612 case BOOLEAN_TYPE: return boolean_type_class;
1613 case POINTER_TYPE: return pointer_type_class;
1614 case REFERENCE_TYPE: return reference_type_class;
1615 case OFFSET_TYPE: return offset_type_class;
1616 case REAL_TYPE: return real_type_class;
1617 case COMPLEX_TYPE: return complex_type_class;
1618 case FUNCTION_TYPE: return function_type_class;
1619 case METHOD_TYPE: return method_type_class;
1620 case RECORD_TYPE: return record_type_class;
1622 case QUAL_UNION_TYPE: return union_type_class;
1623 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1624 ? string_type_class : array_type_class);
1625 case LANG_TYPE: return lang_type_class;
1626 default: return no_type_class;
1630 /* Expand a call EXP to __builtin_classify_type. */
1633 expand_builtin_classify_type (tree exp)
1635 if (call_expr_nargs (exp))
1636 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1637 return GEN_INT (no_type_class);
1640 /* This helper macro, meant to be used in mathfn_built_in below,
1641 determines which among a set of three builtin math functions is
1642 appropriate for a given type mode. The `F' and `L' cases are
1643 automatically generated from the `double' case. */
1644 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1645 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1646 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1647 fcodel = BUILT_IN_MATHFN##L ; break;
1649 /* Return mathematic function equivalent to FN but operating directly
1650 on TYPE, if available. If we can't do the conversion, return zero. */
1652 mathfn_built_in (tree type, enum built_in_function fn)
1654 enum built_in_function fcode, fcodef, fcodel;
1658 CASE_MATHFN (BUILT_IN_ACOS)
1659 CASE_MATHFN (BUILT_IN_ACOSH)
1660 CASE_MATHFN (BUILT_IN_ASIN)
1661 CASE_MATHFN (BUILT_IN_ASINH)
1662 CASE_MATHFN (BUILT_IN_ATAN)
1663 CASE_MATHFN (BUILT_IN_ATAN2)
1664 CASE_MATHFN (BUILT_IN_ATANH)
1665 CASE_MATHFN (BUILT_IN_CBRT)
1666 CASE_MATHFN (BUILT_IN_CEIL)
1667 CASE_MATHFN (BUILT_IN_CEXPI)
1668 CASE_MATHFN (BUILT_IN_COPYSIGN)
1669 CASE_MATHFN (BUILT_IN_COS)
1670 CASE_MATHFN (BUILT_IN_COSH)
1671 CASE_MATHFN (BUILT_IN_DREM)
1672 CASE_MATHFN (BUILT_IN_ERF)
1673 CASE_MATHFN (BUILT_IN_ERFC)
1674 CASE_MATHFN (BUILT_IN_EXP)
1675 CASE_MATHFN (BUILT_IN_EXP10)
1676 CASE_MATHFN (BUILT_IN_EXP2)
1677 CASE_MATHFN (BUILT_IN_EXPM1)
1678 CASE_MATHFN (BUILT_IN_FABS)
1679 CASE_MATHFN (BUILT_IN_FDIM)
1680 CASE_MATHFN (BUILT_IN_FLOOR)
1681 CASE_MATHFN (BUILT_IN_FMA)
1682 CASE_MATHFN (BUILT_IN_FMAX)
1683 CASE_MATHFN (BUILT_IN_FMIN)
1684 CASE_MATHFN (BUILT_IN_FMOD)
1685 CASE_MATHFN (BUILT_IN_FREXP)
1686 CASE_MATHFN (BUILT_IN_GAMMA)
1687 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1688 CASE_MATHFN (BUILT_IN_HYPOT)
1689 CASE_MATHFN (BUILT_IN_ILOGB)
1690 CASE_MATHFN (BUILT_IN_INF)
1691 CASE_MATHFN (BUILT_IN_ISINF)
1692 CASE_MATHFN (BUILT_IN_J0)
1693 CASE_MATHFN (BUILT_IN_J1)
1694 CASE_MATHFN (BUILT_IN_JN)
1695 CASE_MATHFN (BUILT_IN_LCEIL)
1696 CASE_MATHFN (BUILT_IN_LDEXP)
1697 CASE_MATHFN (BUILT_IN_LFLOOR)
1698 CASE_MATHFN (BUILT_IN_LGAMMA)
1699 CASE_MATHFN (BUILT_IN_LLCEIL)
1700 CASE_MATHFN (BUILT_IN_LLFLOOR)
1701 CASE_MATHFN (BUILT_IN_LLRINT)
1702 CASE_MATHFN (BUILT_IN_LLROUND)
1703 CASE_MATHFN (BUILT_IN_LOG)
1704 CASE_MATHFN (BUILT_IN_LOG10)
1705 CASE_MATHFN (BUILT_IN_LOG1P)
1706 CASE_MATHFN (BUILT_IN_LOG2)
1707 CASE_MATHFN (BUILT_IN_LOGB)
1708 CASE_MATHFN (BUILT_IN_LRINT)
1709 CASE_MATHFN (BUILT_IN_LROUND)
1710 CASE_MATHFN (BUILT_IN_MODF)
1711 CASE_MATHFN (BUILT_IN_NAN)
1712 CASE_MATHFN (BUILT_IN_NANS)
1713 CASE_MATHFN (BUILT_IN_NEARBYINT)
1714 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1715 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1716 CASE_MATHFN (BUILT_IN_POW)
1717 CASE_MATHFN (BUILT_IN_POWI)
1718 CASE_MATHFN (BUILT_IN_POW10)
1719 CASE_MATHFN (BUILT_IN_REMAINDER)
1720 CASE_MATHFN (BUILT_IN_REMQUO)
1721 CASE_MATHFN (BUILT_IN_RINT)
1722 CASE_MATHFN (BUILT_IN_ROUND)
1723 CASE_MATHFN (BUILT_IN_SCALB)
1724 CASE_MATHFN (BUILT_IN_SCALBLN)
1725 CASE_MATHFN (BUILT_IN_SCALBN)
1726 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1727 CASE_MATHFN (BUILT_IN_SIN)
1728 CASE_MATHFN (BUILT_IN_SINCOS)
1729 CASE_MATHFN (BUILT_IN_SINH)
1730 CASE_MATHFN (BUILT_IN_SQRT)
1731 CASE_MATHFN (BUILT_IN_TAN)
1732 CASE_MATHFN (BUILT_IN_TANH)
1733 CASE_MATHFN (BUILT_IN_TGAMMA)
1734 CASE_MATHFN (BUILT_IN_TRUNC)
1735 CASE_MATHFN (BUILT_IN_Y0)
1736 CASE_MATHFN (BUILT_IN_Y1)
1737 CASE_MATHFN (BUILT_IN_YN)
1743 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1744 return implicit_built_in_decls[fcode];
1745 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1746 return implicit_built_in_decls[fcodef];
1747 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1748 return implicit_built_in_decls[fcodel];
1753 /* If errno must be maintained, expand the RTL to check if the result,
1754 TARGET, of a built-in function call, EXP, is NaN, and if so set
1758 expand_errno_check (tree exp, rtx target)
1760 rtx lab = gen_label_rtx ();
1762 /* Test the result; if it is NaN, set errno=EDOM because
1763 the argument was not in the domain. */
1764 emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1768 /* If this built-in doesn't throw an exception, set errno directly. */
1769 if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1771 #ifdef GEN_ERRNO_RTX
1772 rtx errno_rtx = GEN_ERRNO_RTX;
1775 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1777 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1783 /* We can't set errno=EDOM directly; let the library call do it.
1784 Pop the arguments right away in case the call gets deleted. */
1786 expand_call (exp, target, 0);
1791 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1792 Return NULL_RTX if a normal call should be emitted rather than expanding
1793 the function in-line. EXP is the expression that is a call to the builtin
1794 function; if convenient, the result should be placed in TARGET.
1795 SUBTARGET may be used as the target for computing one of EXP's operands. */
1798 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1800 optab builtin_optab;
1801 rtx op0, insns, before_call;
1802 tree fndecl = get_callee_fndecl (exp);
1803 enum machine_mode mode;
1804 bool errno_set = false;
1807 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1810 arg = CALL_EXPR_ARG (exp, 0);
1812 switch (DECL_FUNCTION_CODE (fndecl))
1814 CASE_FLT_FN (BUILT_IN_SQRT):
1815 errno_set = ! tree_expr_nonnegative_p (arg);
1816 builtin_optab = sqrt_optab;
1818 CASE_FLT_FN (BUILT_IN_EXP):
1819 errno_set = true; builtin_optab = exp_optab; break;
1820 CASE_FLT_FN (BUILT_IN_EXP10):
1821 CASE_FLT_FN (BUILT_IN_POW10):
1822 errno_set = true; builtin_optab = exp10_optab; break;
1823 CASE_FLT_FN (BUILT_IN_EXP2):
1824 errno_set = true; builtin_optab = exp2_optab; break;
1825 CASE_FLT_FN (BUILT_IN_EXPM1):
1826 errno_set = true; builtin_optab = expm1_optab; break;
1827 CASE_FLT_FN (BUILT_IN_LOGB):
1828 errno_set = true; builtin_optab = logb_optab; break;
1829 CASE_FLT_FN (BUILT_IN_LOG):
1830 errno_set = true; builtin_optab = log_optab; break;
1831 CASE_FLT_FN (BUILT_IN_LOG10):
1832 errno_set = true; builtin_optab = log10_optab; break;
1833 CASE_FLT_FN (BUILT_IN_LOG2):
1834 errno_set = true; builtin_optab = log2_optab; break;
1835 CASE_FLT_FN (BUILT_IN_LOG1P):
1836 errno_set = true; builtin_optab = log1p_optab; break;
1837 CASE_FLT_FN (BUILT_IN_ASIN):
1838 builtin_optab = asin_optab; break;
1839 CASE_FLT_FN (BUILT_IN_ACOS):
1840 builtin_optab = acos_optab; break;
1841 CASE_FLT_FN (BUILT_IN_TAN):
1842 builtin_optab = tan_optab; break;
1843 CASE_FLT_FN (BUILT_IN_ATAN):
1844 builtin_optab = atan_optab; break;
1845 CASE_FLT_FN (BUILT_IN_FLOOR):
1846 builtin_optab = floor_optab; break;
1847 CASE_FLT_FN (BUILT_IN_CEIL):
1848 builtin_optab = ceil_optab; break;
1849 CASE_FLT_FN (BUILT_IN_TRUNC):
1850 builtin_optab = btrunc_optab; break;
1851 CASE_FLT_FN (BUILT_IN_ROUND):
1852 builtin_optab = round_optab; break;
1853 CASE_FLT_FN (BUILT_IN_NEARBYINT):
1854 builtin_optab = nearbyint_optab;
1855 if (flag_trapping_math)
1857 /* Else fallthrough and expand as rint. */
1858 CASE_FLT_FN (BUILT_IN_RINT):
1859 builtin_optab = rint_optab; break;
1864 /* Make a suitable register to place result in. */
1865 mode = TYPE_MODE (TREE_TYPE (exp));
1867 if (! flag_errno_math || ! HONOR_NANS (mode))
1870 /* Before working hard, check whether the instruction is available. */
1871 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1873 target = gen_reg_rtx (mode);
1875 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1876 need to expand the argument again. This way, we will not perform
1877 side-effects more the once. */
1878 narg = builtin_save_expr (arg);
1882 exp = build_call_expr (fndecl, 1, arg);
1885 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
1889 /* Compute into TARGET.
1890 Set TARGET to wherever the result comes back. */
1891 target = expand_unop (mode, builtin_optab, op0, target, 0);
1896 expand_errno_check (exp, target);
1898 /* Output the entire sequence. */
1899 insns = get_insns ();
1905 /* If we were unable to expand via the builtin, stop the sequence
1906 (without outputting the insns) and call to the library function
1907 with the stabilized argument list. */
1911 before_call = get_last_insn ();
1913 target = expand_call (exp, target, target == const0_rtx);
1915 /* If this is a sqrt operation and we don't care about errno, try to
1916 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1917 This allows the semantics of the libcall to be visible to the RTL
1919 if (builtin_optab == sqrt_optab && !errno_set)
1921 /* Search backwards through the insns emitted by expand_call looking
1922 for the instruction with the REG_RETVAL note. */
1923 rtx last = get_last_insn ();
1924 while (last != before_call)
1926 if (find_reg_note (last, REG_RETVAL, NULL))
1928 rtx note = find_reg_note (last, REG_EQUAL, NULL);
1929 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1930 two elements, i.e. symbol_ref(sqrt) and the operand. */
1932 && GET_CODE (note) == EXPR_LIST
1933 && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1934 && XEXP (XEXP (note, 0), 1) != NULL_RTX
1935 && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1937 rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1938 /* Check operand is a register with expected mode. */
1941 && GET_MODE (operand) == mode)
1943 /* Replace the REG_EQUAL note with a SQRT rtx. */
1944 rtx equiv = gen_rtx_SQRT (mode, operand);
1945 set_unique_reg_note (last, REG_EQUAL, equiv);
1950 last = PREV_INSN (last);
1957 /* Expand a call to the builtin binary math functions (pow and atan2).
1958 Return NULL_RTX if a normal call should be emitted rather than expanding the
1959 function in-line. EXP is the expression that is a call to the builtin
1960 function; if convenient, the result should be placed in TARGET.
1961 SUBTARGET may be used as the target for computing one of EXP's
1965 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
1967 optab builtin_optab;
1968 rtx op0, op1, insns;
1969 int op1_type = REAL_TYPE;
1970 tree fndecl = get_callee_fndecl (exp);
1971 tree arg0, arg1, narg;
1972 enum machine_mode mode;
1973 bool errno_set = true;
1976 switch (DECL_FUNCTION_CODE (fndecl))
1978 CASE_FLT_FN (BUILT_IN_SCALBN):
1979 CASE_FLT_FN (BUILT_IN_SCALBLN):
1980 CASE_FLT_FN (BUILT_IN_LDEXP):
1981 op1_type = INTEGER_TYPE;
1986 if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
1989 arg0 = CALL_EXPR_ARG (exp, 0);
1990 arg1 = CALL_EXPR_ARG (exp, 1);
1992 switch (DECL_FUNCTION_CODE (fndecl))
1994 CASE_FLT_FN (BUILT_IN_POW):
1995 builtin_optab = pow_optab; break;
1996 CASE_FLT_FN (BUILT_IN_ATAN2):
1997 builtin_optab = atan2_optab; break;
1998 CASE_FLT_FN (BUILT_IN_SCALB):
1999 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2001 builtin_optab = scalb_optab; break;
2002 CASE_FLT_FN (BUILT_IN_SCALBN):
2003 CASE_FLT_FN (BUILT_IN_SCALBLN):
2004 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2006 /* Fall through... */
2007 CASE_FLT_FN (BUILT_IN_LDEXP):
2008 builtin_optab = ldexp_optab; break;
2009 CASE_FLT_FN (BUILT_IN_FMOD):
2010 builtin_optab = fmod_optab; break;
2011 CASE_FLT_FN (BUILT_IN_REMAINDER):
2012 CASE_FLT_FN (BUILT_IN_DREM):
2013 builtin_optab = remainder_optab; break;
2018 /* Make a suitable register to place result in. */
2019 mode = TYPE_MODE (TREE_TYPE (exp));
2021 /* Before working hard, check whether the instruction is available. */
2022 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2025 target = gen_reg_rtx (mode);
2027 if (! flag_errno_math || ! HONOR_NANS (mode))
2030 /* Always stabilize the argument list. */
2031 narg = builtin_save_expr (arg1);
2037 narg = builtin_save_expr (arg0);
2045 exp = build_call_expr (fndecl, 2, arg0, arg1);
2047 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2048 op1 = expand_normal (arg1);
2052 /* Compute into TARGET.
2053 Set TARGET to wherever the result comes back. */
2054 target = expand_binop (mode, builtin_optab, op0, op1,
2055 target, 0, OPTAB_DIRECT);
2057 /* If we were unable to expand via the builtin, stop the sequence
2058 (without outputting the insns) and call to the library function
2059 with the stabilized argument list. */
2063 return expand_call (exp, target, target == const0_rtx);
2067 expand_errno_check (exp, target);
2069 /* Output the entire sequence. */
2070 insns = get_insns ();
2077 /* Expand a call to the builtin sin and cos math functions.
2078 Return NULL_RTX if a normal call should be emitted rather than expanding the
2079 function in-line. EXP is the expression that is a call to the builtin
2080 function; if convenient, the result should be placed in TARGET.
2081 SUBTARGET may be used as the target for computing one of EXP's
2085 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2087 optab builtin_optab;
2089 tree fndecl = get_callee_fndecl (exp);
2090 enum machine_mode mode;
2093 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2096 arg = CALL_EXPR_ARG (exp, 0);
2098 switch (DECL_FUNCTION_CODE (fndecl))
2100 CASE_FLT_FN (BUILT_IN_SIN):
2101 CASE_FLT_FN (BUILT_IN_COS):
2102 builtin_optab = sincos_optab; break;
2107 /* Make a suitable register to place result in. */
2108 mode = TYPE_MODE (TREE_TYPE (exp));
2110 /* Check if sincos insn is available, otherwise fallback
2111 to sin or cos insn. */
2112 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2113 switch (DECL_FUNCTION_CODE (fndecl))
2115 CASE_FLT_FN (BUILT_IN_SIN):
2116 builtin_optab = sin_optab; break;
2117 CASE_FLT_FN (BUILT_IN_COS):
2118 builtin_optab = cos_optab; break;
2123 /* Before working hard, check whether the instruction is available. */
2124 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2126 target = gen_reg_rtx (mode);
2128 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2129 need to expand the argument again. This way, we will not perform
2130 side-effects more the once. */
2131 narg = save_expr (arg);
2135 exp = build_call_expr (fndecl, 1, arg);
2138 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2142 /* Compute into TARGET.
2143 Set TARGET to wherever the result comes back. */
2144 if (builtin_optab == sincos_optab)
2148 switch (DECL_FUNCTION_CODE (fndecl))
2150 CASE_FLT_FN (BUILT_IN_SIN):
2151 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2153 CASE_FLT_FN (BUILT_IN_COS):
2154 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2159 gcc_assert (result);
2163 target = expand_unop (mode, builtin_optab, op0, target, 0);
2168 /* Output the entire sequence. */
2169 insns = get_insns ();
2175 /* If we were unable to expand via the builtin, stop the sequence
2176 (without outputting the insns) and call to the library function
2177 with the stabilized argument list. */
2181 target = expand_call (exp, target, target == const0_rtx);
2186 /* Expand a call to one of the builtin math functions that operate on
2187 floating point argument and output an integer result (ilogb, isinf,
2189 Return 0 if a normal call should be emitted rather than expanding the
2190 function in-line. EXP is the expression that is a call to the builtin
2191 function; if convenient, the result should be placed in TARGET.
2192 SUBTARGET may be used as the target for computing one of EXP's operands. */
2195 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2197 optab builtin_optab;
2198 enum insn_code icode;
2200 tree fndecl = get_callee_fndecl (exp);
2201 enum machine_mode mode;
2202 bool errno_set = false;
2205 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2208 arg = CALL_EXPR_ARG (exp, 0);
2210 switch (DECL_FUNCTION_CODE (fndecl))
2212 CASE_FLT_FN (BUILT_IN_ILOGB):
2213 errno_set = true; builtin_optab = ilogb_optab; break;
2214 CASE_FLT_FN (BUILT_IN_ISINF):
2215 builtin_optab = isinf_optab; break;
2220 /* There's no easy way to detect the case we need to set EDOM. */
2221 if (flag_errno_math && errno_set)
2224 /* Optab mode depends on the mode of the input argument. */
2225 mode = TYPE_MODE (TREE_TYPE (arg));
2227 icode = builtin_optab->handlers[(int) mode].insn_code;
2229 /* Before working hard, check whether the instruction is available. */
2230 if (icode != CODE_FOR_nothing)
2232 /* Make a suitable register to place result in. */
2234 || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2235 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2237 gcc_assert (insn_data[icode].operand[0].predicate
2238 (target, GET_MODE (target)));
2240 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2241 need to expand the argument again. This way, we will not perform
2242 side-effects more the once. */
2243 narg = builtin_save_expr (arg);
2247 exp = build_call_expr (fndecl, 1, arg);
2250 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2252 if (mode != GET_MODE (op0))
2253 op0 = convert_to_mode (mode, op0, 0);
2255 /* Compute into TARGET.
2256 Set TARGET to wherever the result comes back. */
2257 emit_unop_insn (icode, target, op0, UNKNOWN);
2261 target = expand_call (exp, target, target == const0_rtx);
2266 /* Expand a call to the builtin sincos math function.
2267 Return NULL_RTX if a normal call should be emitted rather than expanding the
2268 function in-line. EXP is the expression that is a call to the builtin
2272 expand_builtin_sincos (tree exp)
2274 rtx op0, op1, op2, target1, target2;
2275 enum machine_mode mode;
2276 tree arg, sinp, cosp;
2279 if (!validate_arglist (exp, REAL_TYPE,
2280 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2283 arg = CALL_EXPR_ARG (exp, 0);
2284 sinp = CALL_EXPR_ARG (exp, 1);
2285 cosp = CALL_EXPR_ARG (exp, 2);
2287 /* Make a suitable register to place result in. */
2288 mode = TYPE_MODE (TREE_TYPE (arg));
2290 /* Check if sincos insn is available, otherwise emit the call. */
2291 if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2294 target1 = gen_reg_rtx (mode);
2295 target2 = gen_reg_rtx (mode);
2297 op0 = expand_normal (arg);
2298 op1 = expand_normal (build_fold_indirect_ref (sinp));
2299 op2 = expand_normal (build_fold_indirect_ref (cosp));
2301 /* Compute into target1 and target2.
2302 Set TARGET to wherever the result comes back. */
2303 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2304 gcc_assert (result);
2306 /* Move target1 and target2 to the memory locations indicated
2308 emit_move_insn (op1, target1);
2309 emit_move_insn (op2, target2);
2314 /* Expand a call to the internal cexpi builtin to the sincos math function.
2315 EXP is the expression that is a call to the builtin function; if convenient,
2316 the result should be placed in TARGET. SUBTARGET may be used as the target
2317 for computing one of EXP's operands. */
2320 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2322 tree fndecl = get_callee_fndecl (exp);
2324 enum machine_mode mode;
2327 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2330 arg = CALL_EXPR_ARG (exp, 0);
2331 type = TREE_TYPE (arg);
2332 mode = TYPE_MODE (TREE_TYPE (arg));
2334 /* Try expanding via a sincos optab, fall back to emitting a libcall
2335 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2336 is only generated from sincos, cexp or if we have either of them. */
2337 if (sincos_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2339 op1 = gen_reg_rtx (mode);
2340 op2 = gen_reg_rtx (mode);
2342 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2344 /* Compute into op1 and op2. */
2345 expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2347 else if (TARGET_HAS_SINCOS)
2349 tree call, fn = NULL_TREE;
2353 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2354 fn = built_in_decls[BUILT_IN_SINCOSF];
2355 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2356 fn = built_in_decls[BUILT_IN_SINCOS];
2357 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2358 fn = built_in_decls[BUILT_IN_SINCOSL];
2362 op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2363 op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2364 op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2365 op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2366 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2367 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2369 /* Make sure not to fold the sincos call again. */
2370 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2371 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2372 call, 3, arg, top1, top2));
2376 tree call, fn = NULL_TREE, narg;
2377 tree ctype = build_complex_type (type);
2379 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2380 fn = built_in_decls[BUILT_IN_CEXPF];
2381 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2382 fn = built_in_decls[BUILT_IN_CEXP];
2383 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2384 fn = built_in_decls[BUILT_IN_CEXPL];
2388 /* If we don't have a decl for cexp create one. This is the
2389 friendliest fallback if the user calls __builtin_cexpi
2390 without full target C99 function support. */
2391 if (fn == NULL_TREE)
2394 const char *name = NULL;
2396 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2398 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2400 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2403 fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2404 fn = build_fn_decl (name, fntype);
2407 narg = fold_build2 (COMPLEX_EXPR, ctype,
2408 build_real (type, dconst0), arg);
2410 /* Make sure not to fold the cexp call again. */
2411 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2412 return expand_expr (build_call_nary (ctype, call, 1, arg),
2413 target, VOIDmode, 0);
2416 /* Now build the proper return type. */
2417 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2418 make_tree (TREE_TYPE (arg), op2),
2419 make_tree (TREE_TYPE (arg), op1)),
2420 target, VOIDmode, 0);
2423 /* Expand a call to one of the builtin rounding functions gcc defines
2424 as an extension (lfloor and lceil). As these are gcc extensions we
2425 do not need to worry about setting errno to EDOM.
2426 If expanding via optab fails, lower expression to (int)(floor(x)).
2427 EXP is the expression that is a call to the builtin function;
2428 if convenient, the result should be placed in TARGET. SUBTARGET may
2429 be used as the target for computing one of EXP's operands. */
2432 expand_builtin_int_roundingfn (tree exp, rtx target, rtx subtarget)
2434 convert_optab builtin_optab;
2435 rtx op0, insns, tmp;
2436 tree fndecl = get_callee_fndecl (exp);
2437 enum built_in_function fallback_fn;
2438 tree fallback_fndecl;
2439 enum machine_mode mode;
2442 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2445 arg = CALL_EXPR_ARG (exp, 0);
2447 switch (DECL_FUNCTION_CODE (fndecl))
2449 CASE_FLT_FN (BUILT_IN_LCEIL):
2450 CASE_FLT_FN (BUILT_IN_LLCEIL):
2451 builtin_optab = lceil_optab;
2452 fallback_fn = BUILT_IN_CEIL;
2455 CASE_FLT_FN (BUILT_IN_LFLOOR):
2456 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2457 builtin_optab = lfloor_optab;
2458 fallback_fn = BUILT_IN_FLOOR;
2465 /* Make a suitable register to place result in. */
2466 mode = TYPE_MODE (TREE_TYPE (exp));
2468 target = gen_reg_rtx (mode);
2470 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2471 need to expand the argument again. This way, we will not perform
2472 side-effects more the once. */
2473 narg = builtin_save_expr (arg);
2477 exp = build_call_expr (fndecl, 1, arg);
2480 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2484 /* Compute into TARGET. */
2485 if (expand_sfix_optab (target, op0, builtin_optab))
2487 /* Output the entire sequence. */
2488 insns = get_insns ();
2494 /* If we were unable to expand via the builtin, stop the sequence
2495 (without outputting the insns). */
2498 /* Fall back to floating point rounding optab. */
2499 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2501 /* For non-C99 targets we may end up without a fallback fndecl here
2502 if the user called __builtin_lfloor directly. In this case emit
2503 a call to the floor/ceil variants nevertheless. This should result
2504 in the best user experience for not full C99 targets. */
2505 if (fallback_fndecl == NULL_TREE)
2508 const char *name = NULL;
2510 switch (DECL_FUNCTION_CODE (fndecl))
2512 case BUILT_IN_LCEIL:
2513 case BUILT_IN_LLCEIL:
2516 case BUILT_IN_LCEILF:
2517 case BUILT_IN_LLCEILF:
2520 case BUILT_IN_LCEILL:
2521 case BUILT_IN_LLCEILL:
2524 case BUILT_IN_LFLOOR:
2525 case BUILT_IN_LLFLOOR:
2528 case BUILT_IN_LFLOORF:
2529 case BUILT_IN_LLFLOORF:
2532 case BUILT_IN_LFLOORL:
2533 case BUILT_IN_LLFLOORL:
2540 fntype = build_function_type_list (TREE_TYPE (arg),
2541 TREE_TYPE (arg), NULL_TREE);
2542 fallback_fndecl = build_fn_decl (name, fntype);
2545 exp = build_call_expr (fallback_fndecl, 1, arg);
2547 tmp = expand_normal (exp);
2549 /* Truncate the result of floating point optab to integer
2550 via expand_fix (). */
2551 target = gen_reg_rtx (mode);
2552 expand_fix (target, tmp, 0);
2557 /* Expand a call to one of the builtin math functions doing integer
2559 Return 0 if a normal call should be emitted rather than expanding the
2560 function in-line. EXP is the expression that is a call to the builtin
2561 function; if convenient, the result should be placed in TARGET.
2562 SUBTARGET may be used as the target for computing one of EXP's operands. */
2565 expand_builtin_int_roundingfn_2 (tree exp, rtx target, rtx subtarget)
2567 convert_optab builtin_optab;
2569 tree fndecl = get_callee_fndecl (exp);
2571 enum machine_mode mode;
2573 /* There's no easy way to detect the case we need to set EDOM. */
2574 if (flag_errno_math)
2577 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2580 arg = CALL_EXPR_ARG (exp, 0);
2582 switch (DECL_FUNCTION_CODE (fndecl))
2584 CASE_FLT_FN (BUILT_IN_LRINT):
2585 CASE_FLT_FN (BUILT_IN_LLRINT):
2586 builtin_optab = lrint_optab; break;
2587 CASE_FLT_FN (BUILT_IN_LROUND):
2588 CASE_FLT_FN (BUILT_IN_LLROUND):
2589 builtin_optab = lround_optab; break;
2594 /* Make a suitable register to place result in. */
2595 mode = TYPE_MODE (TREE_TYPE (exp));
2597 target = gen_reg_rtx (mode);
2599 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2600 need to expand the argument again. This way, we will not perform
2601 side-effects more the once. */
2602 narg = builtin_save_expr (arg);
2606 exp = build_call_expr (fndecl, 1, arg);
2609 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2613 if (expand_sfix_optab (target, op0, builtin_optab))
2615 /* Output the entire sequence. */
2616 insns = get_insns ();
2622 /* If we were unable to expand via the builtin, stop the sequence
2623 (without outputting the insns) and call to the library function
2624 with the stabilized argument list. */
2627 target = expand_call (exp, target, target == const0_rtx);
2632 /* To evaluate powi(x,n), the floating point value x raised to the
2633 constant integer exponent n, we use a hybrid algorithm that
2634 combines the "window method" with look-up tables. For an
2635 introduction to exponentiation algorithms and "addition chains",
2636 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2637 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2638 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2639 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2641 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2642 multiplications to inline before calling the system library's pow
2643 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2644 so this default never requires calling pow, powf or powl. */
2646 #ifndef POWI_MAX_MULTS
2647 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2650 /* The size of the "optimal power tree" lookup table. All
2651 exponents less than this value are simply looked up in the
2652 powi_table below. This threshold is also used to size the
2653 cache of pseudo registers that hold intermediate results. */
2654 #define POWI_TABLE_SIZE 256
2656 /* The size, in bits of the window, used in the "window method"
2657 exponentiation algorithm. This is equivalent to a radix of
2658 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2659 #define POWI_WINDOW_SIZE 3
2661 /* The following table is an efficient representation of an
2662 "optimal power tree". For each value, i, the corresponding
2663 value, j, in the table states than an optimal evaluation
2664 sequence for calculating pow(x,i) can be found by evaluating
2665 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2666 100 integers is given in Knuth's "Seminumerical algorithms". */
2668 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2670 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2671 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2672 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2673 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2674 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2675 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2676 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2677 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2678 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2679 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2680 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2681 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2682 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2683 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2684 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2685 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2686 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2687 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2688 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2689 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2690 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2691 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2692 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2693 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2694 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2695 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2696 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2697 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2698 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2699 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2700 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2701 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2705 /* Return the number of multiplications required to calculate
2706 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2707 subroutine of powi_cost. CACHE is an array indicating
2708 which exponents have already been calculated. */
2711 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2713 /* If we've already calculated this exponent, then this evaluation
2714 doesn't require any additional multiplications. */
2719 return powi_lookup_cost (n - powi_table[n], cache)
2720 + powi_lookup_cost (powi_table[n], cache) + 1;
2723 /* Return the number of multiplications required to calculate
2724 powi(x,n) for an arbitrary x, given the exponent N. This
2725 function needs to be kept in sync with expand_powi below. */
2728 powi_cost (HOST_WIDE_INT n)
2730 bool cache[POWI_TABLE_SIZE];
2731 unsigned HOST_WIDE_INT digit;
2732 unsigned HOST_WIDE_INT val;
2738 /* Ignore the reciprocal when calculating the cost. */
2739 val = (n < 0) ? -n : n;
2741 /* Initialize the exponent cache. */
2742 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2747 while (val >= POWI_TABLE_SIZE)
2751 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2752 result += powi_lookup_cost (digit, cache)
2753 + POWI_WINDOW_SIZE + 1;
2754 val >>= POWI_WINDOW_SIZE;
2763 return result + powi_lookup_cost (val, cache);
2766 /* Recursive subroutine of expand_powi. This function takes the array,
2767 CACHE, of already calculated exponents and an exponent N and returns
2768 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2771 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2773 unsigned HOST_WIDE_INT digit;
2777 if (n < POWI_TABLE_SIZE)
2782 target = gen_reg_rtx (mode);
2785 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2786 op1 = expand_powi_1 (mode, powi_table[n], cache);
2790 target = gen_reg_rtx (mode);
2791 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2792 op0 = expand_powi_1 (mode, n - digit, cache);
2793 op1 = expand_powi_1 (mode, digit, cache);
2797 target = gen_reg_rtx (mode);
2798 op0 = expand_powi_1 (mode, n >> 1, cache);
2802 result = expand_mult (mode, op0, op1, target, 0);
2803 if (result != target)
2804 emit_move_insn (target, result);
2808 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2809 floating point operand in mode MODE, and N is the exponent. This
2810 function needs to be kept in sync with powi_cost above. */
2813 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2815 unsigned HOST_WIDE_INT val;
2816 rtx cache[POWI_TABLE_SIZE];
2820 return CONST1_RTX (mode);
2822 val = (n < 0) ? -n : n;
2824 memset (cache, 0, sizeof (cache));
2827 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2829 /* If the original exponent was negative, reciprocate the result. */
2831 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2832 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2837 /* Expand a call to the pow built-in mathematical function. Return NULL_RTX if
2838 a normal call should be emitted rather than expanding the function
2839 in-line. EXP is the expression that is a call to the builtin
2840 function; if convenient, the result should be placed in TARGET. */
2843 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2847 tree type = TREE_TYPE (exp);
2848 REAL_VALUE_TYPE cint, c, c2;
2851 enum machine_mode mode = TYPE_MODE (type);
2853 if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2856 arg0 = CALL_EXPR_ARG (exp, 0);
2857 arg1 = CALL_EXPR_ARG (exp, 1);
2859 if (TREE_CODE (arg1) != REAL_CST
2860 || TREE_OVERFLOW (arg1))
2861 return expand_builtin_mathfn_2 (exp, target, subtarget);
2863 /* Handle constant exponents. */
2865 /* For integer valued exponents we can expand to an optimal multiplication
2866 sequence using expand_powi. */
2867 c = TREE_REAL_CST (arg1);
2868 n = real_to_integer (&c);
2869 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2870 if (real_identical (&c, &cint)
2871 && ((n >= -1 && n <= 2)
2872 || (flag_unsafe_math_optimizations
2874 && powi_cost (n) <= POWI_MAX_MULTS)))
2876 op = expand_expr (arg0, subtarget, VOIDmode, 0);
2879 op = force_reg (mode, op);
2880 op = expand_powi (op, mode, n);
2885 narg0 = builtin_save_expr (arg0);
2887 /* If the exponent is not integer valued, check if it is half of an integer.
2888 In this case we can expand to sqrt (x) * x**(n/2). */
2889 fn = mathfn_built_in (type, BUILT_IN_SQRT);
2890 if (fn != NULL_TREE)
2892 real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2893 n = real_to_integer (&c2);
2894 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2895 if (real_identical (&c2, &cint)
2896 && ((flag_unsafe_math_optimizations
2898 && powi_cost (n/2) <= POWI_MAX_MULTS)
2901 tree call_expr = build_call_expr (fn, 1, narg0);
2902 op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
2905 op2 = expand_expr (narg0, subtarget, VOIDmode, 0);
2906 op2 = force_reg (mode, op2);
2907 op2 = expand_powi (op2, mode, abs (n / 2));
2908 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
2909 0, OPTAB_LIB_WIDEN);
2910 /* If the original exponent was negative, reciprocate the
2913 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2914 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2920 /* Try if the exponent is a third of an integer. In this case
2921 we can expand to x**(n/3) * cbrt(x)**(n%3). As cbrt (x) is
2922 different from pow (x, 1./3.) due to rounding and behavior
2923 with negative x we need to constrain this transformation to
2924 unsafe math and positive x or finite math. */
2925 fn = mathfn_built_in (type, BUILT_IN_CBRT);
2927 && flag_unsafe_math_optimizations
2928 && (tree_expr_nonnegative_p (arg0)
2929 || !HONOR_NANS (mode)))
2931 real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
2932 real_round (&c2, mode, &c2);
2933 n = real_to_integer (&c2);
2934 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2935 real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
2936 real_convert (&c2, mode, &c2);
2937 if (real_identical (&c2, &c)
2939 && powi_cost (n/3) <= POWI_MAX_MULTS)
2942 tree call_expr = build_call_expr (fn, 1,narg0);
2943 op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
2944 if (abs (n) % 3 == 2)
2945 op = expand_simple_binop (mode, MULT, op, op, op,
2946 0, OPTAB_LIB_WIDEN);
2949 op2 = expand_expr (narg0, subtarget, VOIDmode, 0);
2950 op2 = force_reg (mode, op2);
2951 op2 = expand_powi (op2, mode, abs (n / 3));
2952 op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
2953 0, OPTAB_LIB_WIDEN);
2954 /* If the original exponent was negative, reciprocate the
2957 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2958 op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2964 /* Fall back to optab expansion. */
2965 return expand_builtin_mathfn_2 (exp, target, subtarget);
2968 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2969 a normal call should be emitted rather than expanding the function
2970 in-line. EXP is the expression that is a call to the builtin
2971 function; if convenient, the result should be placed in TARGET. */
2974 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
2978 enum machine_mode mode;
2979 enum machine_mode mode2;
2981 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2984 arg0 = CALL_EXPR_ARG (exp, 0);
2985 arg1 = CALL_EXPR_ARG (exp, 1);
2986 mode = TYPE_MODE (TREE_TYPE (exp));
2988 /* Handle constant power. */
2990 if (TREE_CODE (arg1) == INTEGER_CST
2991 && !TREE_OVERFLOW (arg1))
2993 HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
2995 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2996 Otherwise, check the number of multiplications required. */
2997 if ((TREE_INT_CST_HIGH (arg1) == 0
2998 || TREE_INT_CST_HIGH (arg1) == -1)
2999 && ((n >= -1 && n <= 2)
3001 && powi_cost (n) <= POWI_MAX_MULTS)))
3003 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
3004 op0 = force_reg (mode, op0);
3005 return expand_powi (op0, mode, n);
3009 /* Emit a libcall to libgcc. */
3011 /* Mode of the 2nd argument must match that of an int. */
3012 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3014 if (target == NULL_RTX)
3015 target = gen_reg_rtx (mode);
3017 op0 = expand_expr (arg0, subtarget, mode, 0);
3018 if (GET_MODE (op0) != mode)
3019 op0 = convert_to_mode (mode, op0, 0);
3020 op1 = expand_expr (arg1, 0, mode2, 0);
3021 if (GET_MODE (op1) != mode2)
3022 op1 = convert_to_mode (mode2, op1, 0);
3024 target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
3025 target, LCT_CONST_MAKE_BLOCK, mode, 2,
3026 op0, mode, op1, mode2);
3031 /* Expand expression EXP which is a call to the strlen builtin. Return
3032 NULL_RTX if we failed the caller should emit a normal call, otherwise
3033 try to get the result in TARGET, if convenient. */
3036 expand_builtin_strlen (tree exp, rtx target,
3037 enum machine_mode target_mode)
3039 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3045 tree src = CALL_EXPR_ARG (exp, 0);
3046 rtx result, src_reg, char_rtx, before_strlen;
3047 enum machine_mode insn_mode = target_mode, char_mode;
3048 enum insn_code icode = CODE_FOR_nothing;
3051 /* If the length can be computed at compile-time, return it. */
3052 len = c_strlen (src, 0);
3054 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3056 /* If the length can be computed at compile-time and is constant
3057 integer, but there are side-effects in src, evaluate
3058 src for side-effects, then return len.
3059 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3060 can be optimized into: i++; x = 3; */
3061 len = c_strlen (src, 1);
3062 if (len && TREE_CODE (len) == INTEGER_CST)
3064 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3065 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3068 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3070 /* If SRC is not a pointer type, don't do this operation inline. */
3074 /* Bail out if we can't compute strlen in the right mode. */
3075 while (insn_mode != VOIDmode)
3077 icode = strlen_optab->handlers[(int) insn_mode].insn_code;
3078 if (icode != CODE_FOR_nothing)
3081 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3083 if (insn_mode == VOIDmode)
3086 /* Make a place to write the result of the instruction. */
3090 && GET_MODE (result) == insn_mode
3091 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3092 result = gen_reg_rtx (insn_mode);
3094 /* Make a place to hold the source address. We will not expand
3095 the actual source until we are sure that the expansion will
3096 not fail -- there are trees that cannot be expanded twice. */
3097 src_reg = gen_reg_rtx (Pmode);
3099 /* Mark the beginning of the strlen sequence so we can emit the
3100 source operand later. */
3101 before_strlen = get_last_insn ();
3103 char_rtx = const0_rtx;
3104 char_mode = insn_data[(int) icode].operand[2].mode;
3105 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3107 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3109 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3110 char_rtx, GEN_INT (align));
3115 /* Now that we are assured of success, expand the source. */
3117 pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3119 emit_move_insn (src_reg, pat);
3124 emit_insn_after (pat, before_strlen);
3126 emit_insn_before (pat, get_insns ());
3128 /* Return the value in the proper mode for this function. */
3129 if (GET_MODE (result) == target_mode)
3131 else if (target != 0)
3132 convert_move (target, result, 0);
3134 target = convert_to_mode (target_mode, result, 0);
3140 /* Expand a call to the strstr builtin. Return NULL_RTX if we failed the
3141 caller should emit a normal call, otherwise try to get the result
3142 in TARGET, if convenient (and in mode MODE if that's convenient). */
3145 expand_builtin_strstr (tree exp, rtx target, enum machine_mode mode)
3147 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3149 tree type = TREE_TYPE (exp);
3150 tree result = fold_builtin_strstr (CALL_EXPR_ARG (exp, 0),
3151 CALL_EXPR_ARG (exp, 1), type);
3153 return expand_expr (result, target, mode, EXPAND_NORMAL);
3158 /* Expand a call to the strchr builtin. Return NULL_RTX if we failed the
3159 caller should emit a normal call, otherwise try to get the result
3160 in TARGET, if convenient (and in mode MODE if that's convenient). */
3163 expand_builtin_strchr (tree exp, rtx target, enum machine_mode mode)
3165 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3167 tree type = TREE_TYPE (exp);
3168 tree result = fold_builtin_strchr (CALL_EXPR_ARG (exp, 0),
3169 CALL_EXPR_ARG (exp, 1), type);
3171 return expand_expr (result, target, mode, EXPAND_NORMAL);
3173 /* FIXME: Should use strchrM optab so that ports can optimize this. */
3178 /* Expand a call to the strrchr builtin. Return NULL_RTX if we failed the
3179 caller should emit a normal call, otherwise try to get the result
3180 in TARGET, if convenient (and in mode MODE if that's convenient). */
3183 expand_builtin_strrchr (tree exp, rtx target, enum machine_mode mode)
3185 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3187 tree type = TREE_TYPE (exp);
3188 tree result = fold_builtin_strrchr (CALL_EXPR_ARG (exp, 0),
3189 CALL_EXPR_ARG (exp, 1), type);
3191 return expand_expr (result, target, mode, EXPAND_NORMAL);
3196 /* Expand a call to the strpbrk builtin. Return NULL_RTX if we failed the
3197 caller should emit a normal call, otherwise try to get the result
3198 in TARGET, if convenient (and in mode MODE if that's convenient). */
3201 expand_builtin_strpbrk (tree exp, rtx target, enum machine_mode mode)
3203 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3205 tree type = TREE_TYPE (exp);
3206 tree result = fold_builtin_strpbrk (CALL_EXPR_ARG (exp, 0),
3207 CALL_EXPR_ARG (exp, 1), type);
3209 return expand_expr (result, target, mode, EXPAND_NORMAL);
3214 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3215 bytes from constant string DATA + OFFSET and return it as target
3219 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3220 enum machine_mode mode)
3222 const char *str = (const char *) data;
3224 gcc_assert (offset >= 0
3225 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3226 <= strlen (str) + 1));
3228 return c_readstr (str + offset, mode);
3231 /* Expand a call EXP to the memcpy builtin.
3232 Return NULL_RTX if we failed, the caller should emit a normal call,
3233 otherwise try to get the result in TARGET, if convenient (and in
3234 mode MODE if that's convenient). */
3237 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
3239 tree fndecl = get_callee_fndecl (exp);
3241 if (!validate_arglist (exp,
3242 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3246 tree dest = CALL_EXPR_ARG (exp, 0);
3247 tree src = CALL_EXPR_ARG (exp, 1);
3248 tree len = CALL_EXPR_ARG (exp, 2);
3249 const char *src_str;
3250 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3251 unsigned int dest_align
3252 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3253 rtx dest_mem, src_mem, dest_addr, len_rtx;
3254 tree result = fold_builtin_memory_op (dest, src, len,
3255 TREE_TYPE (TREE_TYPE (fndecl)),
3257 HOST_WIDE_INT expected_size = -1;
3258 unsigned int expected_align = 0;
3262 while (TREE_CODE (result) == COMPOUND_EXPR)
3264 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3266 result = TREE_OPERAND (result, 1);
3268 return expand_expr (result, target, mode, EXPAND_NORMAL);
3271 /* If DEST is not a pointer type, call the normal function. */
3272 if (dest_align == 0)
3275 /* If either SRC is not a pointer type, don't do this
3276 operation in-line. */
3280 stringop_block_profile (exp, &expected_align, &expected_size);
3281 if (expected_align < dest_align)
3282 expected_align = dest_align;
3283 dest_mem = get_memory_rtx (dest, len);
3284 set_mem_align (dest_mem, dest_align);
3285 len_rtx = expand_normal (len);
3286 src_str = c_getstr (src);
3288 /* If SRC is a string constant and block move would be done
3289 by pieces, we can avoid loading the string from memory
3290 and only stored the computed constants. */
3292 && GET_CODE (len_rtx) == CONST_INT
3293 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3294 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3295 (void *) src_str, dest_align))
3297 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3298 builtin_memcpy_read_str,
3299 (void *) src_str, dest_align, 0);
3300 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3301 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3305 src_mem = get_memory_rtx (src, len);
3306 set_mem_align (src_mem, src_align);
3308 /* Copy word part most expediently. */
3309 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3310 CALL_EXPR_TAILCALL (exp)
3311 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3312 expected_align, expected_size);
3316 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3317 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3323 /* Expand a call EXP to the mempcpy builtin.
3324 Return NULL_RTX if we failed; the caller should emit a normal call,
3325 otherwise try to get the result in TARGET, if convenient (and in
3326 mode MODE if that's convenient). If ENDP is 0 return the
3327 destination pointer, if ENDP is 1 return the end pointer ala
3328 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3332 expand_builtin_mempcpy(tree exp, rtx target, enum machine_mode mode)
3334 if (!validate_arglist (exp,
3335 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3339 tree dest = CALL_EXPR_ARG (exp, 0);
3340 tree src = CALL_EXPR_ARG (exp, 1);
3341 tree len = CALL_EXPR_ARG (exp, 2);
3342 return expand_builtin_mempcpy_args (dest, src, len,
3344 target, mode, /*endp=*/ 1);
3348 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3349 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3350 so that this can also be called without constructing an actual CALL_EXPR.
3351 TYPE is the return type of the call. The other arguments and return value
3352 are the same as for expand_builtin_mempcpy. */
3355 expand_builtin_mempcpy_args (tree dest, tree src, tree len, tree type,
3356 rtx target, enum machine_mode mode, int endp)
3358 /* If return value is ignored, transform mempcpy into memcpy. */
3359 if (target == const0_rtx)
3361 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3366 return expand_expr (build_call_expr (fn, 3, dest, src, len),
3367 target, mode, EXPAND_NORMAL);
3371 const char *src_str;
3372 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3373 unsigned int dest_align
3374 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3375 rtx dest_mem, src_mem, len_rtx;
3376 tree result = fold_builtin_memory_op (dest, src, len, type, false, endp);
3380 while (TREE_CODE (result) == COMPOUND_EXPR)
3382 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3384 result = TREE_OPERAND (result, 1);
3386 return expand_expr (result, target, mode, EXPAND_NORMAL);
3389 /* If either SRC or DEST is not a pointer type, don't do this
3390 operation in-line. */
3391 if (dest_align == 0 || src_align == 0)
3394 /* If LEN is not constant, call the normal function. */
3395 if (! host_integerp (len, 1))
3398 len_rtx = expand_normal (len);
3399 src_str = c_getstr (src);
3401 /* If SRC is a string constant and block move would be done
3402 by pieces, we can avoid loading the string from memory
3403 and only stored the computed constants. */
3405 && GET_CODE (len_rtx) == CONST_INT
3406 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3407 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3408 (void *) src_str, dest_align))
3410 dest_mem = get_memory_rtx (dest, len);
3411 set_mem_align (dest_mem, dest_align);
3412 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3413 builtin_memcpy_read_str,
3414 (void *) src_str, dest_align, endp);
3415 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3416 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3420 if (GET_CODE (len_rtx) == CONST_INT
3421 && can_move_by_pieces (INTVAL (len_rtx),
3422 MIN (dest_align, src_align)))
3424 dest_mem = get_memory_rtx (dest, len);
3425 set_mem_align (dest_mem, dest_align);
3426 src_mem = get_memory_rtx (src, len);
3427 set_mem_align (src_mem, src_align);
3428 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3429 MIN (dest_align, src_align), endp);
3430 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3431 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3439 /* Expand expression EXP, which is a call to the memmove builtin. Return
3440 NULL_RTX if we failed; the caller should emit a normal call. */
3443 expand_builtin_memmove (tree exp, rtx target, enum machine_mode mode, int ignore)
3445 if (!validate_arglist (exp,
3446 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3450 tree dest = CALL_EXPR_ARG (exp, 0);
3451 tree src = CALL_EXPR_ARG (exp, 1);
3452 tree len = CALL_EXPR_ARG (exp, 2);
3453 return expand_builtin_memmove_args (dest, src, len, TREE_TYPE (exp),
3454 target, mode, ignore);
3458 /* Helper function to do the actual work for expand_builtin_memmove. The
3459 arguments to the builtin_memmove call DEST, SRC, and LEN are broken out
3460 so that this can also be called without constructing an actual CALL_EXPR.
3461 TYPE is the return type of the call. The other arguments and return value
3462 are the same as for expand_builtin_memmove. */
3465 expand_builtin_memmove_args (tree dest, tree src, tree len,
3466 tree type, rtx target, enum machine_mode mode,
3469 tree result = fold_builtin_memory_op (dest, src, len, type, ignore, /*endp=*/3);
3473 while (TREE_CODE (result) == COMPOUND_EXPR)
3475 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3477 result = TREE_OPERAND (result, 1);
3479 return expand_expr (result, target, mode, EXPAND_NORMAL);
3482 /* Otherwise, call the normal function. */
3486 /* Expand expression EXP, which is a call to the bcopy builtin. Return
3487 NULL_RTX if we failed the caller should emit a normal call. */
3490 expand_builtin_bcopy (tree exp, int ignore)
3492 tree type = TREE_TYPE (exp);
3493 tree src, dest, size;
3495 if (!validate_arglist (exp,
3496 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3499 src = CALL_EXPR_ARG (exp, 0);
3500 dest = CALL_EXPR_ARG (exp, 1);
3501 size = CALL_EXPR_ARG (exp, 2);
3503 /* Transform bcopy(ptr x, ptr y, int z) to memmove(ptr y, ptr x, size_t z).
3504 This is done this way so that if it isn't expanded inline, we fall
3505 back to calling bcopy instead of memmove. */
3506 return expand_builtin_memmove_args (dest, src,
3507 fold_convert (sizetype, size),
3508 type, const0_rtx, VOIDmode,
3513 # define HAVE_movstr 0
3514 # define CODE_FOR_movstr CODE_FOR_nothing
3517 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3518 we failed, the caller should emit a normal call, otherwise try to
3519 get the result in TARGET, if convenient. If ENDP is 0 return the
3520 destination pointer, if ENDP is 1 return the end pointer ala
3521 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3525 expand_movstr (tree dest, tree src, rtx target, int endp)
3531 const struct insn_data * data;
3536 dest_mem = get_memory_rtx (dest, NULL);
3537 src_mem = get_memory_rtx (src, NULL);
3540 target = force_reg (Pmode, XEXP (dest_mem, 0));
3541 dest_mem = replace_equiv_address (dest_mem, target);
3542 end = gen_reg_rtx (Pmode);
3546 if (target == 0 || target == const0_rtx)
3548 end = gen_reg_rtx (Pmode);
3556 data = insn_data + CODE_FOR_movstr;
3558 if (data->operand[0].mode != VOIDmode)
3559 end = gen_lowpart (data->operand[0].mode, end);
3561 insn = data->genfun (end, dest_mem, src_mem);
3567 /* movstr is supposed to set end to the address of the NUL
3568 terminator. If the caller requested a mempcpy-like return value,
3570 if (endp == 1 && target != const0_rtx)
3572 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3573 emit_move_insn (target, force_operand (tem, NULL_RTX));
3579 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3580 NULL_RTX if we failed the caller should emit a normal call, otherwise
3581 try to get the result in TARGET, if convenient (and in mode MODE if that's
3585 expand_builtin_strcpy (tree fndecl, tree exp, rtx target, enum machine_mode mode)
3587 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3589 tree dest = CALL_EXPR_ARG (exp, 0);
3590 tree src = CALL_EXPR_ARG (exp, 1);
3591 return expand_builtin_strcpy_args (fndecl, dest, src, target, mode);
3596 /* Helper function to do the actual work for expand_builtin_strcpy. The
3597 arguments to the builtin_strcpy call DEST and SRC are broken out
3598 so that this can also be called without constructing an actual CALL_EXPR.
3599 The other arguments and return value are the same as for
3600 expand_builtin_strcpy. */
3603 expand_builtin_strcpy_args (tree fndecl, tree dest, tree src,
3604 rtx target, enum machine_mode mode)
3606 tree result = fold_builtin_strcpy (fndecl, dest, src, 0);
3608 return expand_expr (result, target, mode, EXPAND_NORMAL);
3609 return expand_movstr (dest, src, target, /*endp=*/0);
3613 /* Expand a call EXP to the stpcpy builtin.
3614 Return NULL_RTX if we failed the caller should emit a normal call,
3615 otherwise try to get the result in TARGET, if convenient (and in
3616 mode MODE if that's convenient). */
3619 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3623 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3626 dst = CALL_EXPR_ARG (exp, 0);
3627 src = CALL_EXPR_ARG (exp, 1);
3629 /* If return value is ignored, transform stpcpy into strcpy. */
3630 if (target == const0_rtx)
3632 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3636 return expand_expr (build_call_expr (fn, 2, dst, src),
3637 target, mode, EXPAND_NORMAL);
3644 /* Ensure we get an actual string whose length can be evaluated at
3645 compile-time, not an expression containing a string. This is
3646 because the latter will potentially produce pessimized code
3647 when used to produce the return value. */
3648 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3649 return expand_movstr (dst, src, target, /*endp=*/2);
3651 lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
3652 ret = expand_builtin_mempcpy_args (dst, src, lenp1, TREE_TYPE (exp),
3653 target, mode, /*endp=*/2);
3658 if (TREE_CODE (len) == INTEGER_CST)
3660 rtx len_rtx = expand_normal (len);
3662 if (GET_CODE (len_rtx) == CONST_INT)
3664 ret = expand_builtin_strcpy_args (get_callee_fndecl (exp),
3665 dst, src, target, mode);
3671 if (mode != VOIDmode)
3672 target = gen_reg_rtx (mode);
3674 target = gen_reg_rtx (GET_MODE (ret));
3676 if (GET_MODE (target) != GET_MODE (ret))
3677 ret = gen_lowpart (GET_MODE (target), ret);
3679 ret = plus_constant (ret, INTVAL (len_rtx));
3680 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3688 return expand_movstr (dst, src, target, /*endp=*/2);
3692 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3693 bytes from constant string DATA + OFFSET and return it as target
3697 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3698 enum machine_mode mode)
3700 const char *str = (const char *) data;
3702 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3705 return c_readstr (str + offset, mode);
3708 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3709 NULL_RTX if we failed the caller should emit a normal call. */
3712 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3714 tree fndecl = get_callee_fndecl (exp);
3716 if (validate_arglist (exp,
3717 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3719 tree dest = CALL_EXPR_ARG (exp, 0);
3720 tree src = CALL_EXPR_ARG (exp, 1);
3721 tree len = CALL_EXPR_ARG (exp, 2);
3722 tree slen = c_strlen (src, 1);
3723 tree result = fold_builtin_strncpy (fndecl, dest, src, len, slen);
3727 while (TREE_CODE (result) == COMPOUND_EXPR)
3729 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3731 result = TREE_OPERAND (result, 1);
3733 return expand_expr (result, target, mode, EXPAND_NORMAL);
3736 /* We must be passed a constant len and src parameter. */
3737 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3740 slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
3742 /* We're required to pad with trailing zeros if the requested
3743 len is greater than strlen(s2)+1. In that case try to
3744 use store_by_pieces, if it fails, punt. */
3745 if (tree_int_cst_lt (slen, len))
3747 unsigned int dest_align
3748 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3749 const char *p = c_getstr (src);
3752 if (!p || dest_align == 0 || !host_integerp (len, 1)
3753 || !can_store_by_pieces (tree_low_cst (len, 1),
3754 builtin_strncpy_read_str,
3755 (void *) p, dest_align))
3758 dest_mem = get_memory_rtx (dest, len);
3759 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3760 builtin_strncpy_read_str,
3761 (void *) p, dest_align, 0);
3762 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3763 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3770 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3771 bytes from constant string DATA + OFFSET and return it as target
3775 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3776 enum machine_mode mode)
3778 const char *c = (const char *) data;
3779 char *p = alloca (GET_MODE_SIZE (mode));
3781 memset (p, *c, GET_MODE_SIZE (mode));
3783 return c_readstr (p, mode);
3786 /* Callback routine for store_by_pieces. Return the RTL of a register
3787 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3788 char value given in the RTL register data. For example, if mode is
3789 4 bytes wide, return the RTL for 0x01010101*data. */
3792 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3793 enum machine_mode mode)
3799 size = GET_MODE_SIZE (mode);
3804 memset (p, 1, size);
3805 coeff = c_readstr (p, mode);
3807 target = convert_to_mode (mode, (rtx) data, 1);
3808 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3809 return force_reg (mode, target);
3812 /* Expand expression EXP, which is a call to the memset builtin. Return
3813 NULL_RTX if we failed the caller should emit a normal call, otherwise
3814 try to get the result in TARGET, if convenient (and in mode MODE if that's
3818 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3820 if (!validate_arglist (exp,
3821 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3825 tree dest = CALL_EXPR_ARG (exp, 0);
3826 tree val = CALL_EXPR_ARG (exp, 1);
3827 tree len = CALL_EXPR_ARG (exp, 2);
3828 return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3832 /* Helper function to do the actual work for expand_builtin_memset. The
3833 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3834 so that this can also be called without constructing an actual CALL_EXPR.
3835 The other arguments and return value are the same as for
3836 expand_builtin_memset. */
3839 expand_builtin_memset_args (tree dest, tree val, tree len,
3840 rtx target, enum machine_mode mode, tree orig_exp)
3843 enum built_in_function fcode;
3845 unsigned int dest_align;
3846 rtx dest_mem, dest_addr, len_rtx;
3847 HOST_WIDE_INT expected_size = -1;
3848 unsigned int expected_align = 0;
3850 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3852 /* If DEST is not a pointer type, don't do this operation in-line. */
3853 if (dest_align == 0)
3856 stringop_block_profile (orig_exp, &expected_align, &expected_size);
3857 if (expected_align < dest_align)
3858 expected_align = dest_align;
3860 /* If the LEN parameter is zero, return DEST. */
3861 if (integer_zerop (len))
3863 /* Evaluate and ignore VAL in case it has side-effects. */
3864 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3865 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3868 /* Stabilize the arguments in case we fail. */
3869 dest = builtin_save_expr (dest);
3870 val = builtin_save_expr (val);
3871 len = builtin_save_expr (len);
3873 len_rtx = expand_normal (len);
3874 dest_mem = get_memory_rtx (dest, len);
3876 if (TREE_CODE (val) != INTEGER_CST)
3880 val_rtx = expand_normal (val);
3881 val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3884 /* Assume that we can memset by pieces if we can store
3885 * the coefficients by pieces (in the required modes).
3886 * We can't pass builtin_memset_gen_str as that emits RTL. */
3888 if (host_integerp (len, 1)
3889 && !(optimize_size && tree_low_cst (len, 1) > 1)
3890 && can_store_by_pieces (tree_low_cst (len, 1),
3891 builtin_memset_read_str, &c, dest_align))
3893 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3895 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3896 builtin_memset_gen_str, val_rtx, dest_align, 0);
3898 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3899 dest_align, expected_align,
3903 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3904 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3908 if (target_char_cast (val, &c))
3913 if (host_integerp (len, 1)
3914 && !(optimize_size && tree_low_cst (len, 1) > 1)
3915 && can_store_by_pieces (tree_low_cst (len, 1),
3916 builtin_memset_read_str, &c, dest_align))
3917 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3918 builtin_memset_read_str, &c, dest_align, 0);
3919 else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3920 dest_align, expected_align,
3924 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3925 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3929 set_mem_align (dest_mem, dest_align);
3930 dest_addr = clear_storage_hints (dest_mem, len_rtx,
3931 CALL_EXPR_TAILCALL (orig_exp)
3932 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3933 expected_align, expected_size);
3937 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3938 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3944 fndecl = get_callee_fndecl (orig_exp);
3945 fcode = DECL_FUNCTION_CODE (fndecl);
3946 if (fcode == BUILT_IN_MEMSET)
3947 fn = build_call_expr (fndecl, 3, dest, val, len);
3948 else if (fcode == BUILT_IN_BZERO)
3949 fn = build_call_expr (fndecl, 2, dest, len);
3952 if (TREE_CODE (fn) == CALL_EXPR)
3953 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3954 return expand_call (fn, target, target == const0_rtx);
3957 /* Expand expression EXP, which is a call to the bzero builtin. Return
3958 NULL_RTX if we failed the caller should emit a normal call. */
3961 expand_builtin_bzero (tree exp)
3965 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3968 dest = CALL_EXPR_ARG (exp, 0);
3969 size = CALL_EXPR_ARG (exp, 1);
3971 /* New argument list transforming bzero(ptr x, int y) to
3972 memset(ptr x, int 0, size_t y). This is done this way
3973 so that if it isn't expanded inline, we fallback to
3974 calling bzero instead of memset. */
3976 return expand_builtin_memset_args (dest, integer_zero_node,
3977 fold_convert (sizetype, size),
3978 const0_rtx, VOIDmode, exp);
3981 /* Expand expression EXP, which is a call to the memcmp built-in function.
3982 Return NULL_RTX if we failed and the
3983 caller should emit a normal call, otherwise try to get the result in
3984 TARGET, if convenient (and in mode MODE, if that's convenient). */
3987 expand_builtin_memcmp (tree exp, rtx target, enum machine_mode mode)
3989 if (!validate_arglist (exp,
3990 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3994 tree result = fold_builtin_memcmp (CALL_EXPR_ARG (exp, 0),
3995 CALL_EXPR_ARG (exp, 1),
3996 CALL_EXPR_ARG (exp, 2));
3998 return expand_expr (result, target, mode, EXPAND_NORMAL);
4001 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4003 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4006 tree arg1 = CALL_EXPR_ARG (exp, 0);
4007 tree arg2 = CALL_EXPR_ARG (exp, 1);
4008 tree len = CALL_EXPR_ARG (exp, 2);
4011 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4013 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4014 enum machine_mode insn_mode;
4016 #ifdef HAVE_cmpmemsi
4018 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4021 #ifdef HAVE_cmpstrnsi
4023 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4028 /* If we don't have POINTER_TYPE, call the function. */
4029 if (arg1_align == 0 || arg2_align == 0)
4032 /* Make a place to write the result of the instruction. */
4035 && REG_P (result) && GET_MODE (result) == insn_mode
4036 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4037 result = gen_reg_rtx (insn_mode);
4039 arg1_rtx = get_memory_rtx (arg1, len);
4040 arg2_rtx = get_memory_rtx (arg2, len);
4041 arg3_rtx = expand_normal (len);
4043 /* Set MEM_SIZE as appropriate. */
4044 if (GET_CODE (arg3_rtx) == CONST_INT)
4046 set_mem_size (arg1_rtx, arg3_rtx);
4047 set_mem_size (arg2_rtx, arg3_rtx);
4050 #ifdef HAVE_cmpmemsi
4052 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4053 GEN_INT (MIN (arg1_align, arg2_align)));
4056 #ifdef HAVE_cmpstrnsi
4058 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4059 GEN_INT (MIN (arg1_align, arg2_align)));
4067 emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
4068 TYPE_MODE (integer_type_node), 3,
4069 XEXP (arg1_rtx, 0), Pmode,
4070 XEXP (arg2_rtx, 0), Pmode,
4071 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4072 TYPE_UNSIGNED (sizetype)),
4073 TYPE_MODE (sizetype));
4075 /* Return the value in the proper mode for this function. */
4076 mode = TYPE_MODE (TREE_TYPE (exp));
4077 if (GET_MODE (result) == mode)
4079 else if (target != 0)
4081 convert_move (target, result, 0);
4085 return convert_to_mode (mode, result, 0);
4092 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4093 if we failed the caller should emit a normal call, otherwise try to get
4094 the result in TARGET, if convenient. */
4097 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
4099 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4103 tree result = fold_builtin_strcmp (CALL_EXPR_ARG (exp, 0),
4104 CALL_EXPR_ARG (exp, 1));
4106 return expand_expr (result, target, mode, EXPAND_NORMAL);
4109 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4110 if (cmpstr_optab[SImode] != CODE_FOR_nothing
4111 || cmpstrn_optab[SImode] != CODE_FOR_nothing)
4113 rtx arg1_rtx, arg2_rtx;
4114 rtx result, insn = NULL_RTX;
4116 tree arg1 = CALL_EXPR_ARG (exp, 0);
4117 tree arg2 = CALL_EXPR_ARG (exp, 1);
4120 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4122 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4124 /* If we don't have POINTER_TYPE, call the function. */
4125 if (arg1_align == 0 || arg2_align == 0)
4128 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4129 arg1 = builtin_save_expr (arg1);
4130 arg2 = builtin_save_expr (arg2);
4132 arg1_rtx = get_memory_rtx (arg1, NULL);
4133 arg2_rtx = get_memory_rtx (arg2, NULL);
4135 #ifdef HAVE_cmpstrsi
4136 /* Try to call cmpstrsi. */
4139 enum machine_mode insn_mode
4140 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4142 /* Make a place to write the result of the instruction. */
4145 && REG_P (result) && GET_MODE (result) == insn_mode
4146 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4147 result = gen_reg_rtx (insn_mode);
4149 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4150 GEN_INT (MIN (arg1_align, arg2_align)));
4153 #ifdef HAVE_cmpstrnsi
4154 /* Try to determine at least one length and call cmpstrnsi. */
4155 if (!insn && HAVE_cmpstrnsi)
4160 enum machine_mode insn_mode
4161 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4162 tree len1 = c_strlen (arg1, 1);
4163 tree len2 = c_strlen (arg2, 1);
4166 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4168 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4170 /* If we don't have a constant length for the first, use the length
4171 of the second, if we know it. We don't require a constant for
4172 this case; some cost analysis could be done if both are available
4173 but neither is constant. For now, assume they're equally cheap,
4174 unless one has side effects. If both strings have constant lengths,
4181 else if (TREE_SIDE_EFFECTS (len1))
4183 else if (TREE_SIDE_EFFECTS (len2))
4185 else if (TREE_CODE (len1) != INTEGER_CST)
4187 else if (TREE_CODE (len2) != INTEGER_CST)
4189 else if (tree_int_cst_lt (len1, len2))
4194 /* If both arguments have side effects, we cannot optimize. */
4195 if (!len || TREE_SIDE_EFFECTS (len))
4198 arg3_rtx = expand_normal (len);
4200 /* Make a place to write the result of the instruction. */
4203 && REG_P (result) && GET_MODE (result) == insn_mode
4204 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4205 result = gen_reg_rtx (insn_mode);
4207 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4208 GEN_INT (MIN (arg1_align, arg2_align)));
4216 /* Return the value in the proper mode for this function. */
4217 mode = TYPE_MODE (TREE_TYPE (exp));
4218 if (GET_MODE (result) == mode)
4221 return convert_to_mode (mode, result, 0);
4222 convert_move (target, result, 0);
4226 /* Expand the library call ourselves using a stabilized argument
4227 list to avoid re-evaluating the function's arguments twice. */
4228 #ifdef HAVE_cmpstrnsi
4231 fndecl = get_callee_fndecl (exp);
4232 fn = build_call_expr (fndecl, 2, arg1, arg2);
4233 if (TREE_CODE (fn) == CALL_EXPR)
4234 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4235 return expand_call (fn, target, target == const0_rtx);
4241 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4242 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4243 the result in TARGET, if convenient. */
4246 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
4248 if (!validate_arglist (exp,
4249 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4253 tree result = fold_builtin_strncmp (CALL_EXPR_ARG (exp, 0),
4254 CALL_EXPR_ARG (exp, 1),
4255 CALL_EXPR_ARG (exp, 2));
4257 return expand_expr (result, target, mode, EXPAND_NORMAL);
4260 /* If c_strlen can determine an expression for one of the string
4261 lengths, and it doesn't have side effects, then emit cmpstrnsi
4262 using length MIN(strlen(string)+1, arg3). */
4263 #ifdef HAVE_cmpstrnsi
4266 tree len, len1, len2;
4267 rtx arg1_rtx, arg2_rtx, arg3_rtx;
4270 tree arg1 = CALL_EXPR_ARG (exp, 0);
4271 tree arg2 = CALL_EXPR_ARG (exp, 1);
4272 tree arg3 = CALL_EXPR_ARG (exp, 2);
4275 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4277 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4278 enum machine_mode insn_mode
4279 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4281 len1 = c_strlen (arg1, 1);
4282 len2 = c_strlen (arg2, 1);
4285 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4287 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4289 /* If we don't have a constant length for the first, use the length
4290 of the second, if we know it. We don't require a constant for
4291 this case; some cost analysis could be done if both are available
4292 but neither is constant. For now, assume they're equally cheap,
4293 unless one has side effects. If both strings have constant lengths,
4300 else if (TREE_SIDE_EFFECTS (len1))
4302 else if (TREE_SIDE_EFFECTS (len2))
4304 else if (TREE_CODE (len1) != INTEGER_CST)
4306 else if (TREE_CODE (len2) != INTEGER_CST)
4308 else if (tree_int_cst_lt (len1, len2))
4313 /* If both arguments have side effects, we cannot optimize. */
4314 if (!len || TREE_SIDE_EFFECTS (len))
4317 /* The actual new length parameter is MIN(len,arg3). */
4318 len = fold_build2 (MIN_EXPR, TREE_TYPE (len), len,
4319 fold_convert (TREE_TYPE (len), arg3));
4321 /* If we don't have POINTER_TYPE, call the function. */
4322 if (arg1_align == 0 || arg2_align == 0)
4325 /* Make a place to write the result of the instruction. */
4328 && REG_P (result) && GET_MODE (result) == insn_mode
4329 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4330 result = gen_reg_rtx (insn_mode);
4332 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
4333 arg1 = builtin_save_expr (arg1);
4334 arg2 = builtin_save_expr (arg2);
4335 len = builtin_save_expr (len);
4337 arg1_rtx = get_memory_rtx (arg1, len);
4338 arg2_rtx = get_memory_rtx (arg2, len);
4339 arg3_rtx = expand_normal (len);
4340 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4341 GEN_INT (MIN (arg1_align, arg2_align)));
4346 /* Return the value in the proper mode for this function. */
4347 mode = TYPE_MODE (TREE_TYPE (exp));
4348 if (GET_MODE (result) == mode)
4351 return convert_to_mode (mode, result, 0);
4352 convert_move (target, result, 0);
4356 /* Expand the library call ourselves using a stabilized argument
4357 list to avoid re-evaluating the function's arguments twice. */
4358 fndecl = get_callee_fndecl (exp);
4359 fn = build_call_expr (fndecl, 3, arg1, arg2, len);
4360 if (TREE_CODE (fn) == CALL_EXPR)
4361 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4362 return expand_call (fn, target, target == const0_rtx);
4368 /* Expand expression EXP, which is a call to the strcat builtin.
4369 Return NULL_RTX if we failed the caller should emit a normal call,
4370 otherwise try to get the result in TARGET, if convenient. */
4373 expand_builtin_strcat (tree fndecl, tree exp, rtx target, enum machine_mode mode)
4375 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4379 tree dst = CALL_EXPR_ARG (exp, 0);
4380 tree src = CALL_EXPR_ARG (exp, 1);
4381 const char *p = c_getstr (src);
4383 /* If the string length is zero, return the dst parameter. */
4384 if (p && *p == '\0')
4385 return expand_expr (dst, target, mode, EXPAND_NORMAL);
4389 /* See if we can store by pieces into (dst + strlen(dst)). */
4390 tree newsrc, newdst,
4391 strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
4394 /* Stabilize the argument list. */
4395 newsrc = builtin_save_expr (src);
4396 dst = builtin_save_expr (dst);
4400 /* Create strlen (dst). */
4401 newdst = build_call_expr (strlen_fn, 1, dst);
4402 /* Create (dst + (cast) strlen (dst)). */
4403 newdst = fold_convert (TREE_TYPE (dst), newdst);
4404 newdst = fold_build2 (PLUS_EXPR, TREE_TYPE (dst), dst, newdst);
4406 newdst = builtin_save_expr (newdst);
4408 if (!expand_builtin_strcpy_args (fndecl, newdst, newsrc, target, mode))
4410 end_sequence (); /* Stop sequence. */
4414 /* Output the entire sequence. */
4415 insns = get_insns ();
4419 return expand_expr (dst, target, mode, EXPAND_NORMAL);
4426 /* Expand expression EXP, which is a call to the strncat builtin.
4427 Return NULL_RTX if we failed the caller should emit a normal call,
4428 otherwise try to get the result in TARGET, if convenient. */
4431 expand_builtin_strncat (tree exp, rtx target, enum machine_mode mode)
4433 if (validate_arglist (exp,
4434 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4436 tree result = fold_builtin_strncat (CALL_EXPR_ARG (exp, 0),
4437 CALL_EXPR_ARG (exp, 1),
4438 CALL_EXPR_ARG (exp, 2));
4440 return expand_expr (result, target, mode, EXPAND_NORMAL);
4445 /* Expand expression EXP, which is a call to the strspn builtin.
4446 Return NULL_RTX if we failed the caller should emit a normal call,
4447 otherwise try to get the result in TARGET, if convenient. */
4450 expand_builtin_strspn (tree exp, rtx target, enum machine_mode mode)
4452 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4454 tree result = fold_builtin_strspn (CALL_EXPR_ARG (exp, 0),
4455 CALL_EXPR_ARG (exp, 1));
4457 return expand_expr (result, target, mode, EXPAND_NORMAL);
4462 /* Expand expression EXP, which is a call to the strcspn builtin.
4463 Return NULL_RTX if we failed the caller should emit a normal call,
4464 otherwise try to get the result in TARGET, if convenient. */
4467 expand_builtin_strcspn (tree exp, rtx target, enum machine_mode mode)
4469 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4471 tree result = fold_builtin_strcspn (CALL_EXPR_ARG (exp, 0),
4472 CALL_EXPR_ARG (exp, 1));
4474 return expand_expr (result, target, mode, EXPAND_NORMAL);
4479 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4480 if that's convenient. */
4483 expand_builtin_saveregs (void)
4487 /* Don't do __builtin_saveregs more than once in a function.
4488 Save the result of the first call and reuse it. */
4489 if (saveregs_value != 0)
4490 return saveregs_value;
4492 /* When this function is called, it means that registers must be
4493 saved on entry to this function. So we migrate the call to the
4494 first insn of this function. */
4498 /* Do whatever the machine needs done in this case. */
4499 val = targetm.calls.expand_builtin_saveregs ();
4504 saveregs_value = val;
4506 /* Put the insns after the NOTE that starts the function. If this
4507 is inside a start_sequence, make the outer-level insn chain current, so
4508 the code is placed at the start of the function. */
4509 push_topmost_sequence ();
4510 emit_insn_after (seq, entry_of_function ());
4511 pop_topmost_sequence ();
4516 /* __builtin_args_info (N) returns word N of the arg space info
4517 for the current function. The number and meanings of words
4518 is controlled by the definition of CUMULATIVE_ARGS. */
4521 expand_builtin_args_info (tree exp)
4523 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4524 int *word_ptr = (int *) ¤t_function_args_info;
4526 gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4528 if (call_expr_nargs (exp) != 0)
4530 if (!host_integerp (CALL_EXPR_ARG (exp, 0), 0))
4531 error ("argument of %<__builtin_args_info%> must be constant");
4534 HOST_WIDE_INT wordnum = tree_low_cst (CALL_EXPR_ARG (exp, 0), 0);
4536 if (wordnum < 0 || wordnum >= nwords)
4537 error ("argument of %<__builtin_args_info%> out of range");
4539 return GEN_INT (word_ptr[wordnum]);
4543 error ("missing argument in %<__builtin_args_info%>");
4548 /* Expand a call to __builtin_next_arg. */
4551 expand_builtin_next_arg (void)
4553 /* Checking arguments is already done in fold_builtin_next_arg
4554 that must be called before this function. */
4555 return expand_binop (Pmode, add_optab,
4556 current_function_internal_arg_pointer,
4557 current_function_arg_offset_rtx,
4558 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4561 /* Make it easier for the backends by protecting the valist argument
4562 from multiple evaluations. */
4565 stabilize_va_list (tree valist, int needs_lvalue)
4567 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4569 if (TREE_SIDE_EFFECTS (valist))
4570 valist = save_expr (valist);
4572 /* For this case, the backends will be expecting a pointer to
4573 TREE_TYPE (va_list_type_node), but it's possible we've
4574 actually been given an array (an actual va_list_type_node).
4576 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4578 tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
4579 valist = build_fold_addr_expr_with_type (valist, p1);
4588 if (! TREE_SIDE_EFFECTS (valist))
4591 pt = build_pointer_type (va_list_type_node);
4592 valist = fold_build1 (ADDR_EXPR, pt, valist);
4593 TREE_SIDE_EFFECTS (valist) = 1;
4596 if (TREE_SIDE_EFFECTS (valist))
4597 valist = save_expr (valist);
4598 valist = build_fold_indirect_ref (valist);
4604 /* The "standard" definition of va_list is void*. */
4607 std_build_builtin_va_list (void)
4609 return ptr_type_node;
4612 /* The "standard" implementation of va_start: just assign `nextarg' to
4616 std_expand_builtin_va_start (tree valist, rtx nextarg)
4620 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
4621 make_tree (ptr_type_node, nextarg));
4622 TREE_SIDE_EFFECTS (t) = 1;
4624 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4627 /* Expand EXP, a call to __builtin_va_start. */
4630 expand_builtin_va_start (tree exp)
4635 if (call_expr_nargs (exp) < 2)
4637 error ("too few arguments to function %<va_start%>");
4641 if (fold_builtin_next_arg (exp, true))
4644 nextarg = expand_builtin_next_arg ();
4645 valist = stabilize_va_list (CALL_EXPR_ARG (exp, 0), 1);
4647 #ifdef EXPAND_BUILTIN_VA_START
4648 EXPAND_BUILTIN_VA_START (valist, nextarg);
4650 std_expand_builtin_va_start (valist, nextarg);
4656 /* The "standard" implementation of va_arg: read the value from the
4657 current (padded) address and increment by the (padded) size. */
4660 std_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
4662 tree addr, t, type_size, rounded_size, valist_tmp;
4663 unsigned HOST_WIDE_INT align, boundary;
4666 #ifdef ARGS_GROW_DOWNWARD
4667 /* All of the alignment and movement below is for args-grow-up machines.
4668 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4669 implement their own specialized gimplify_va_arg_expr routines. */
4673 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4675 type = build_pointer_type (type);
4677 align = PARM_BOUNDARY / BITS_PER_UNIT;
4678 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type) / BITS_PER_UNIT;
4680 /* Hoist the valist value into a temporary for the moment. */
4681 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4683 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4684 requires greater alignment, we must perform dynamic alignment. */
4685 if (boundary > align
4686 && !integer_zerop (TYPE_SIZE (type)))
4688 t = fold_convert (TREE_TYPE (valist), size_int (boundary - 1));
4689 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4690 build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t));
4691 gimplify_and_add (t, pre_p);
4693 t = fold_convert (TREE_TYPE (valist), size_int (-boundary));
4694 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4695 build2 (BIT_AND_EXPR, TREE_TYPE (valist), valist_tmp, t));
4696 gimplify_and_add (t, pre_p);
4701 /* If the actual alignment is less than the alignment of the type,
4702 adjust the type accordingly so that we don't assume strict alignment
4703 when deferencing the pointer. */
4704 boundary *= BITS_PER_UNIT;
4705 if (boundary < TYPE_ALIGN (type))
4707 type = build_variant_type_copy (type);
4708 TYPE_ALIGN (type) = boundary;
4711 /* Compute the rounded size of the type. */
4712 type_size = size_in_bytes (type);
4713 rounded_size = round_up (type_size, align);
4715 /* Reduce rounded_size so it's sharable with the postqueue. */
4716 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4720 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4722 /* Small args are padded downward. */
4723 t = fold_build2 (GT_EXPR, sizetype, rounded_size, size_int (align));
4724 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4725 size_binop (MINUS_EXPR, rounded_size, type_size));
4726 t = fold_convert (TREE_TYPE (addr), t);
4727 addr = fold_build2 (PLUS_EXPR, TREE_TYPE (addr), addr, t);
4730 /* Compute new value for AP. */
4731 t = fold_convert (TREE_TYPE (valist), rounded_size);
4732 t = build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t);
4733 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4734 gimplify_and_add (t, pre_p);
4736 addr = fold_convert (build_pointer_type (type), addr);
4739 addr = build_va_arg_indirect_ref (addr);
4741 return build_va_arg_indirect_ref (addr);
4744 /* Build an indirect-ref expression over the given TREE, which represents a
4745 piece of a va_arg() expansion. */
4747 build_va_arg_indirect_ref (tree addr)
4749 addr = build_fold_indirect_ref (addr);
4751 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4757 /* Return a dummy expression of type TYPE in order to keep going after an
4761 dummy_object (tree type)
4763 tree t = build_int_cst (build_pointer_type (type), 0);
4764 return build1 (INDIRECT_REF, type, t);
4767 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4768 builtin function, but a very special sort of operator. */
4770 enum gimplify_status
4771 gimplify_va_arg_expr (tree *expr_p, tree *pre_p, tree *post_p)
4773 tree promoted_type, want_va_type, have_va_type;
4774 tree valist = TREE_OPERAND (*expr_p, 0);
4775 tree type = TREE_TYPE (*expr_p);
4778 /* Verify that valist is of the proper type. */
4779 want_va_type = va_list_type_node;
4780 have_va_type = TREE_TYPE (valist);
4782 if (have_va_type == error_mark_node)
4785 if (TREE_CODE (want_va_type) == ARRAY_TYPE)
4787 /* If va_list is an array type, the argument may have decayed
4788 to a pointer type, e.g. by being passed to another function.
4789 In that case, unwrap both types so that we can compare the
4790 underlying records. */
4791 if (TREE_CODE (have_va_type) == ARRAY_TYPE
4792 || POINTER_TYPE_P (have_va_type))
4794 want_va_type = TREE_TYPE (want_va_type);
4795 have_va_type = TREE_TYPE (have_va_type);
4799 if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
4801 error ("first argument to %<va_arg%> not of type %<va_list%>");
4805 /* Generate a diagnostic for requesting data of a type that cannot
4806 be passed through `...' due to type promotion at the call site. */
4807 else if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4810 static bool gave_help;
4812 /* Unfortunately, this is merely undefined, rather than a constraint
4813 violation, so we cannot make this an error. If this call is never
4814 executed, the program is still strictly conforming. */
4815 warning (0, "%qT is promoted to %qT when passed through %<...%>",
4816 type, promoted_type);
4820 warning (0, "(so you should pass %qT not %qT to %<va_arg%>)",
4821 promoted_type, type);
4824 /* We can, however, treat "undefined" any way we please.
4825 Call abort to encourage the user to fix the program. */
4826 inform ("if this code is reached, the program will abort");
4827 t = build_call_expr (implicit_built_in_decls[BUILT_IN_TRAP], 0);
4828 append_to_statement_list (t, pre_p);
4830 /* This is dead code, but go ahead and finish so that the
4831 mode of the result comes out right. */
4832 *expr_p = dummy_object (type);
4837 /* Make it easier for the backends by protecting the valist argument
4838 from multiple evaluations. */
4839 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4841 /* For this case, the backends will be expecting a pointer to
4842 TREE_TYPE (va_list_type_node), but it's possible we've
4843 actually been given an array (an actual va_list_type_node).
4845 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4847 tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
4848 valist = build_fold_addr_expr_with_type (valist, p1);
4850 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4853 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4855 if (!targetm.gimplify_va_arg_expr)
4856 /* FIXME:Once most targets are converted we should merely
4857 assert this is non-null. */
4860 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4865 /* Expand EXP, a call to __builtin_va_end. */
4868 expand_builtin_va_end (tree exp)
4870 tree valist = CALL_EXPR_ARG (exp, 0);
4872 /* Evaluate for side effects, if needed. I hate macros that don't
4874 if (TREE_SIDE_EFFECTS (valist))
4875 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4880 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4881 builtin rather than just as an assignment in stdarg.h because of the
4882 nastiness of array-type va_list types. */
4885 expand_builtin_va_copy (tree exp)
4889 dst = CALL_EXPR_ARG (exp, 0);
4890 src = CALL_EXPR_ARG (exp, 1);
4892 dst = stabilize_va_list (dst, 1);
4893 src = stabilize_va_list (src, 0);
4895 if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
4897 t = build2 (MODIFY_EXPR, va_list_type_node, dst, src);
4898 TREE_SIDE_EFFECTS (t) = 1;
4899 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4903 rtx dstb, srcb, size;
4905 /* Evaluate to pointers. */
4906 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4907 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4908 size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
4909 VOIDmode, EXPAND_NORMAL);
4911 dstb = convert_memory_address (Pmode, dstb);
4912 srcb = convert_memory_address (Pmode, srcb);
4914 /* "Dereference" to BLKmode memories. */
4915 dstb = gen_rtx_MEM (BLKmode, dstb);
4916 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4917 set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
4918 srcb = gen_rtx_MEM (BLKmode, srcb);
4919 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4920 set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
4923 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4929 /* Expand a call to one of the builtin functions __builtin_frame_address or
4930 __builtin_return_address. */
4933 expand_builtin_frame_address (tree fndecl, tree exp)
4935 /* The argument must be a nonnegative integer constant.
4936 It counts the number of frames to scan up the stack.
4937 The value is the return address saved in that frame. */
4938 if (call_expr_nargs (exp) == 0)
4939 /* Warning about missing arg was already issued. */
4941 else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4943 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4944 error ("invalid argument to %<__builtin_frame_address%>");
4946 error ("invalid argument to %<__builtin_return_address%>");
4952 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4953 tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4955 /* Some ports cannot access arbitrary stack frames. */
4958 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4959 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4961 warning (0, "unsupported argument to %<__builtin_return_address%>");
4965 /* For __builtin_frame_address, return what we've got. */
4966 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4970 && ! CONSTANT_P (tem))
4971 tem = copy_to_mode_reg (Pmode, tem);
4976 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if
4977 we failed and the caller should emit a normal call, otherwise try to get
4978 the result in TARGET, if convenient. */
4981 expand_builtin_alloca (tree exp, rtx target)
4986 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4987 should always expand to function calls. These can be intercepted
4992 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4995 /* Compute the argument. */
4996 op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4998 /* Allocate the desired space. */
4999 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
5000 result = convert_memory_address (ptr_mode, result);
5005 /* Expand a call to a bswap builtin with argument ARG0. MODE
5006 is the mode to expand with. */
5009 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
5011 enum machine_mode mode;
5015 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5018 arg = CALL_EXPR_ARG (exp, 0);
5019 mode = TYPE_MODE (TREE_TYPE (arg));
5020 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
5022 target = expand_unop (mode, bswap_optab, op0, target, 1);
5024 gcc_assert (target);
5026 return convert_to_mode (mode, target, 0);
5029 /* Expand a call to a unary builtin in EXP.
5030 Return NULL_RTX if a normal call should be emitted rather than expanding the
5031 function in-line. If convenient, the result should be placed in TARGET.
5032 SUBTARGET may be used as the target for computing one of EXP's operands. */
5035 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
5036 rtx subtarget, optab op_optab)
5040 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5043 /* Compute the argument. */
5044 op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget, VOIDmode, 0);
5045 /* Compute op, into TARGET if possible.
5046 Set TARGET to wherever the result comes back. */
5047 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5048 op_optab, op0, target, 1);
5049 gcc_assert (target);
5051 return convert_to_mode (target_mode, target, 0);
5054 /* If the string passed to fputs is a constant and is one character
5055 long, we attempt to transform this call into __builtin_fputc(). */
5058 expand_builtin_fputs (tree exp, rtx target, bool unlocked)
5060 /* Verify the arguments in the original call. */
5061 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5063 tree result = fold_builtin_fputs (CALL_EXPR_ARG (exp, 0),
5064 CALL_EXPR_ARG (exp, 1),
5065 (target == const0_rtx),
5066 unlocked, NULL_TREE);
5068 return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
5073 /* Expand a call to __builtin_expect. We just return our argument
5074 as the builtin_expect semantic should've been already executed by
5075 tree branch prediction pass. */
5078 expand_builtin_expect (tree exp, rtx target)
5082 if (call_expr_nargs (exp) < 2)
5084 arg = CALL_EXPR_ARG (exp, 0);
5085 c = CALL_EXPR_ARG (exp, 1);
5087 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5088 /* When guessing was done, the hints should be already stripped away. */
5089 gcc_assert (!flag_guess_branch_prob);
5094 expand_builtin_trap (void)
5098 emit_insn (gen_trap ());
5101 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5105 /* Expand EXP, a call to fabs, fabsf or fabsl.
5106 Return NULL_RTX if a normal call should be emitted rather than expanding
5107 the function inline. If convenient, the result should be placed
5108 in TARGET. SUBTARGET may be used as the target for computing
5112 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5114 enum machine_mode mode;
5118 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5121 arg = CALL_EXPR_ARG (exp, 0);
5122 mode = TYPE_MODE (TREE_TYPE (arg));
5123 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
5124 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5127 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5128 Return NULL is a normal call should be emitted rather than expanding the
5129 function inline. If convenient, the result should be placed in TARGET.
5130 SUBTARGET may be used as the target for computing the operand. */
5133 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5138 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5141 arg = CALL_EXPR_ARG (exp, 0);
5142 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5144 arg = CALL_EXPR_ARG (exp, 1);
5145 op1 = expand_normal (arg);
5147 return expand_copysign (op0, op1, target);
5150 /* Create a new constant string literal and return a char* pointer to it.
5151 The STRING_CST value is the LEN characters at STR. */
5153 build_string_literal (int len, const char *str)
5155 tree t, elem, index, type;
5157 t = build_string (len, str);
5158 elem = build_type_variant (char_type_node, 1, 0);
5159 index = build_index_type (build_int_cst (NULL_TREE, len - 1));
5160 type = build_array_type (elem, index);
5161 TREE_TYPE (t) = type;
5162 TREE_CONSTANT (t) = 1;
5163 TREE_INVARIANT (t) = 1;
5164 TREE_READONLY (t) = 1;
5165 TREE_STATIC (t) = 1;
5167 type = build_pointer_type (type);
5168 t = build1 (ADDR_EXPR, type, t);
5170 type = build_pointer_type (elem);
5171 t = build1 (NOP_EXPR, type, t);
5175 /* Expand EXP, a call to printf or printf_unlocked.
5176 Return NULL_RTX if a normal call should be emitted rather than transforming
5177 the function inline. If convenient, the result should be placed in
5178 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
5181 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
5184 /* If we're using an unlocked function, assume the other unlocked
5185 functions exist explicitly. */
5186 tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
5187 : implicit_built_in_decls[BUILT_IN_PUTCHAR];
5188 tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
5189 : implicit_built_in_decls[BUILT_IN_PUTS];
5190 const char *fmt_str;
5193 int nargs = call_expr_nargs (exp);
5195 /* If the return value is used, don't do the transformation. */
5196 if (target != const0_rtx)
5199 /* Verify the required arguments in the original call. */
5202 fmt = CALL_EXPR_ARG (exp, 0);
5203 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5206 /* Check whether the format is a literal string constant. */
5207 fmt_str = c_getstr (fmt);
5208 if (fmt_str == NULL)
5211 if (!init_target_chars ())
5214 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
5215 if (strcmp (fmt_str, target_percent_s_newline) == 0)
5218 || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 1))))
5221 fn = build_call_expr (fn_puts, 1, CALL_EXPR_ARG (exp, 1));
5223 /* If the format specifier was "%c", call __builtin_putchar(arg). */
5224 else if (strcmp (fmt_str, target_percent_c) == 0)
5227 || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))) != INTEGER_TYPE)
5230 fn = build_call_expr (fn_putchar, 1, CALL_EXPR_ARG (exp, 1));
5234 /* We can't handle anything else with % args or %% ... yet. */
5235 if (strchr (fmt_str, target_percent))
5241 /* If the format specifier was "", printf does nothing. */
5242 if (fmt_str[0] == '\0')
5244 /* If the format specifier has length of 1, call putchar. */
5245 if (fmt_str[1] == '\0')
5247 /* Given printf("c"), (where c is any one character,)
5248 convert "c"[0] to an int and pass that to the replacement
5250 arg = build_int_cst (NULL_TREE, fmt_str[0]);
5252 fn = build_call_expr (fn_putchar, 1, arg);
5256 /* If the format specifier was "string\n", call puts("string"). */
5257 size_t len = strlen (fmt_str);
5258 if ((unsigned char)fmt_str[len - 1] == target_newline)
5260 /* Create a NUL-terminated string that's one char shorter
5261 than the original, stripping off the trailing '\n'. */
5262 char *newstr = alloca (len);
5263 memcpy (newstr, fmt_str, len - 1);
5264 newstr[len - 1] = 0;
5265 arg = build_string_literal (len, newstr);
5267 fn = build_call_expr (fn_puts, 1, arg);
5270 /* We'd like to arrange to call fputs(string,stdout) here,
5271 but we need stdout and don't have a way to get it yet. */
5278 if (TREE_CODE (fn) == CALL_EXPR)
5279 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5280 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5283 /* Expand EXP, a call to fprintf or fprintf_unlocked.
5284 Return NULL_RTX if a normal call should be emitted rather than transforming
5285 the function inline. If convenient, the result should be placed in
5286 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
5289 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
5292 /* If we're using an unlocked function, assume the other unlocked
5293 functions exist explicitly. */
5294 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
5295 : implicit_built_in_decls[BUILT_IN_FPUTC];
5296 tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
5297 : implicit_built_in_decls[BUILT_IN_FPUTS];
5298 const char *fmt_str;
5301 int nargs = call_expr_nargs (exp);
5303 /* If the return value is used, don't do the transformation. */
5304 if (target != const0_rtx)
5307 /* Verify the required arguments in the original call. */
5310 fp = CALL_EXPR_ARG (exp, 0);
5311 if (! POINTER_TYPE_P (TREE_TYPE (fp)))
5313 fmt = CALL_EXPR_ARG (exp, 1);
5314 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5317 /* Check whether the format is a literal string constant. */
5318 fmt_str = c_getstr (fmt);
5319 if (fmt_str == NULL)
5322 if (!init_target_chars ())
5325 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
5326 if (strcmp (fmt_str, target_percent_s) == 0)
5329 || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 2))))
5331 arg = CALL_EXPR_ARG (exp, 2);
5333 fn = build_call_expr (fn_fputs, 2, arg, fp);
5335 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
5336 else if (strcmp (fmt_str, target_percent_c) == 0)
5339 || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2))) != INTEGER_TYPE)
5341 arg = CALL_EXPR_ARG (exp, 2);
5343 fn = build_call_expr (fn_fputc, 2, arg, fp);
5347 /* We can't handle anything else with % args or %% ... yet. */
5348 if (strchr (fmt_str, target_percent))
5354 /* If the format specifier was "", fprintf does nothing. */
5355 if (fmt_str[0] == '\0')
5357 /* Evaluate and ignore FILE* argument for side-effects. */
5358 expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5362 /* When "string" doesn't contain %, replace all cases of
5363 fprintf(stream,string) with fputs(string,stream). The fputs
5364 builtin will take care of special cases like length == 1. */
5366 fn = build_call_expr (fn_fputs, 2, fmt, fp);
5371 if (TREE_CODE (fn) == CALL_EXPR)
5372 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5373 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5376 /* Expand a call EXP to sprintf. Return NULL_RTX if
5377 a normal call should be emitted rather than expanding the function
5378 inline. If convenient, the result should be placed in TARGET with
5382 expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
5385 const char *fmt_str;
5386 int nargs = call_expr_nargs (exp);
5388 /* Verify the required arguments in the original call. */
5391 dest = CALL_EXPR_ARG (exp, 0);
5392 if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5394 fmt = CALL_EXPR_ARG (exp, 0);
5395 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5398 /* Check whether the format is a literal string constant. */
5399 fmt_str = c_getstr (fmt);
5400 if (fmt_str == NULL)
5403 if (!init_target_chars ())
5406 /* If the format doesn't contain % args or %%, use strcpy. */
5407 if (strchr (fmt_str, target_percent) == 0)
5409 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5412 if ((nargs > 2) || ! fn)
5414 expand_expr (build_call_expr (fn, 2, dest, fmt),
5415 const0_rtx, VOIDmode, EXPAND_NORMAL);
5416 if (target == const0_rtx)
5418 exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5419 return expand_expr (exp, target, mode, EXPAND_NORMAL);
5421 /* If the format is "%s", use strcpy if the result isn't used. */
5422 else if (strcmp (fmt_str, target_percent_s) == 0)
5425 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5431 arg = CALL_EXPR_ARG (exp, 2);
5432 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5435 if (target != const0_rtx)
5437 len = c_strlen (arg, 1);
5438 if (! len || TREE_CODE (len) != INTEGER_CST)
5444 expand_expr (build_call_expr (fn, 2, dest, arg),
5445 const0_rtx, VOIDmode, EXPAND_NORMAL);
5447 if (target == const0_rtx)
5449 return expand_expr (len, target, mode, EXPAND_NORMAL);
5455 /* Expand a call to either the entry or exit function profiler. */
5458 expand_builtin_profile_func (bool exitp)
5462 this = DECL_RTL (current_function_decl);
5463 gcc_assert (MEM_P (this));
5464 this = XEXP (this, 0);
5467 which = profile_function_exit_libfunc;
5469 which = profile_function_entry_libfunc;
5471 emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this, Pmode,
5472 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5479 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5482 round_trampoline_addr (rtx tramp)
5484 rtx temp, addend, mask;
5486 /* If we don't need too much alignment, we'll have been guaranteed
5487 proper alignment by get_trampoline_type. */
5488 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5491 /* Round address up to desired boundary. */
5492 temp = gen_reg_rtx (Pmode);
5493 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5494 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5496 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
5497 temp, 0, OPTAB_LIB_WIDEN);
5498 tramp = expand_simple_binop (Pmode, AND, temp, mask,
5499 temp, 0, OPTAB_LIB_WIDEN);
5505 expand_builtin_init_trampoline (tree exp)
5507 tree t_tramp, t_func, t_chain;
5508 rtx r_tramp, r_func, r_chain;
5509 #ifdef TRAMPOLINE_TEMPLATE
5513 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5514 POINTER_TYPE, VOID_TYPE))
5517 t_tramp = CALL_EXPR_ARG (exp, 0);
5518 t_func = CALL_EXPR_ARG (exp, 1);
5519 t_chain = CALL_EXPR_ARG (exp, 2);
5521 r_tramp = expand_normal (t_tramp);
5522 r_func = expand_normal (t_func);
5523 r_chain = expand_normal (t_chain);
5525 /* Generate insns to initialize the trampoline. */
5526 r_tramp = round_trampoline_addr (r_tramp);
5527 #ifdef TRAMPOLINE_TEMPLATE
5528 blktramp = gen_rtx_MEM (BLKmode, r_tramp);
5529 set_mem_align (blktramp, TRAMPOLINE_ALIGNMENT);
5530 emit_block_move (blktramp, assemble_trampoline_template (),
5531 GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
5533 trampolines_created = 1;
5534 INITIALIZE_TRAMPOLINE (r_tramp, r_func, r_chain);
5540 expand_builtin_adjust_trampoline (tree exp)
5544 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5547 tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5548 tramp = round_trampoline_addr (tramp);
5549 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5550 TRAMPOLINE_ADJUST_ADDRESS (tramp);
5556 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5557 Return NULL_RTX if a normal call should be emitted rather than expanding
5558 the function in-line. EXP is the expression that is a call to the builtin
5559 function; if convenient, the result should be placed in TARGET. */
5562 expand_builtin_signbit (tree exp, rtx target)
5564 const struct real_format *fmt;
5565 enum machine_mode fmode, imode, rmode;
5566 HOST_WIDE_INT hi, lo;
5571 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5574 arg = CALL_EXPR_ARG (exp, 0);
5575 fmode = TYPE_MODE (TREE_TYPE (arg));
5576 rmode = TYPE_MODE (TREE_TYPE (exp));
5577 fmt = REAL_MODE_FORMAT (fmode);
5579 /* For floating point formats without a sign bit, implement signbit
5581 bitpos = fmt->signbit_ro;
5584 /* But we can't do this if the format supports signed zero. */
5585 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5588 arg = fold_build2 (LT_EXPR, TREE_TYPE (exp), arg,
5589 build_real (TREE_TYPE (arg), dconst0));
5590 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5593 temp = expand_normal (arg);
5594 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5596 imode = int_mode_for_mode (fmode);
5597 if (imode == BLKmode)
5599 temp = gen_lowpart (imode, temp);
5604 /* Handle targets with different FP word orders. */
5605 if (FLOAT_WORDS_BIG_ENDIAN)
5606 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5608 word = bitpos / BITS_PER_WORD;
5609 temp = operand_subword_force (temp, word, fmode);
5610 bitpos = bitpos % BITS_PER_WORD;
5613 /* Force the intermediate word_mode (or narrower) result into a
5614 register. This avoids attempting to create paradoxical SUBREGs
5615 of floating point modes below. */
5616 temp = force_reg (imode, temp);
5618 /* If the bitpos is within the "result mode" lowpart, the operation
5619 can be implement with a single bitwise AND. Otherwise, we need
5620 a right shift and an AND. */
5622 if (bitpos < GET_MODE_BITSIZE (rmode))
5624 if (bitpos < HOST_BITS_PER_WIDE_INT)
5627 lo = (HOST_WIDE_INT) 1 << bitpos;
5631 hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5636 temp = gen_lowpart (rmode, temp);
5637 temp = expand_binop (rmode, and_optab, temp,
5638 immed_double_const (lo, hi, rmode),
5639 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5643 /* Perform a logical right shift to place the signbit in the least
5644 significant bit, then truncate the result to the desired mode
5645 and mask just this bit. */
5646 temp = expand_shift (RSHIFT_EXPR, imode, temp,
5647 build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5648 temp = gen_lowpart (rmode, temp);
5649 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5650 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5656 /* Expand fork or exec calls. TARGET is the desired target of the
5657 call. EXP is the call. FN is the
5658 identificator of the actual function. IGNORE is nonzero if the
5659 value is to be ignored. */
5662 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5667 /* If we are not profiling, just call the function. */
5668 if (!profile_arc_flag)
5671 /* Otherwise call the wrapper. This should be equivalent for the rest of
5672 compiler, so the code does not diverge, and the wrapper may run the
5673 code necessary for keeping the profiling sane. */
5675 switch (DECL_FUNCTION_CODE (fn))
5678 id = get_identifier ("__gcov_fork");
5681 case BUILT_IN_EXECL:
5682 id = get_identifier ("__gcov_execl");
5685 case BUILT_IN_EXECV:
5686 id = get_identifier ("__gcov_execv");
5689 case BUILT_IN_EXECLP:
5690 id = get_identifier ("__gcov_execlp");
5693 case BUILT_IN_EXECLE:
5694 id = get_identifier ("__gcov_execle");
5697 case BUILT_IN_EXECVP:
5698 id = get_identifier ("__gcov_execvp");
5701 case BUILT_IN_EXECVE:
5702 id = get_identifier ("__gcov_execve");
5709 decl = build_decl (FUNCTION_DECL, id, TREE_TYPE (fn));
5710 DECL_EXTERNAL (decl) = 1;
5711 TREE_PUBLIC (decl) = 1;
5712 DECL_ARTIFICIAL (decl) = 1;
5713 TREE_NOTHROW (decl) = 1;
5714 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5715 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5716 call = rewrite_call_expr (exp, 0, decl, 0);
5717 return expand_call (call, target, ignore);
5722 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5723 the pointer in these functions is void*, the tree optimizers may remove
5724 casts. The mode computed in expand_builtin isn't reliable either, due
5725 to __sync_bool_compare_and_swap.
5727 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5728 group of builtins. This gives us log2 of the mode size. */
5730 static inline enum machine_mode
5731 get_builtin_sync_mode (int fcode_diff)
5733 /* The size is not negotiable, so ask not to get BLKmode in return
5734 if the target indicates that a smaller size would be better. */
5735 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5738 /* Expand the memory expression LOC and return the appropriate memory operand
5739 for the builtin_sync operations. */
5742 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5746 addr = expand_expr (loc, NULL, Pmode, EXPAND_SUM);
5748 /* Note that we explicitly do not want any alias information for this
5749 memory, so that we kill all other live memories. Otherwise we don't
5750 satisfy the full barrier semantics of the intrinsic. */
5751 mem = validize_mem (gen_rtx_MEM (mode, addr));
5753 set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
5754 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5755 MEM_VOLATILE_P (mem) = 1;
5760 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5761 EXP is the CALL_EXPR. CODE is the rtx code
5762 that corresponds to the arithmetic or logical operation from the name;
5763 an exception here is that NOT actually means NAND. TARGET is an optional
5764 place for us to store the results; AFTER is true if this is the
5765 fetch_and_xxx form. IGNORE is true if we don't actually care about
5766 the result of the operation at all. */
5769 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5770 enum rtx_code code, bool after,
5771 rtx target, bool ignore)
5775 /* Expand the operands. */
5776 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5778 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL, mode, EXPAND_NORMAL);
5779 /* If VAL is promoted to a wider mode, convert it back to MODE. */
5780 val = convert_to_mode (mode, val, 1);
5783 return expand_sync_operation (mem, val, code);
5785 return expand_sync_fetch_operation (mem, val, code, after, target);
5788 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5789 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5790 true if this is the boolean form. TARGET is a place for us to store the
5791 results; this is NOT optional if IS_BOOL is true. */
5794 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5795 bool is_bool, rtx target)
5797 rtx old_val, new_val, mem;
5799 /* Expand the operands. */
5800 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5803 old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL, mode, EXPAND_NORMAL);
5804 /* If OLD_VAL is promoted to a wider mode, convert it back to MODE. */
5805 old_val = convert_to_mode (mode, old_val, 1);
5807 new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL, mode, EXPAND_NORMAL);
5808 /* If NEW_VAL is promoted to a wider mode, convert it back to MODE. */
5809 new_val = convert_to_mode (mode, new_val, 1);
5812 return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5814 return expand_val_compare_and_swap (mem, old_val, new_val, target);
5817 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5818 general form is actually an atomic exchange, and some targets only
5819 support a reduced form with the second argument being a constant 1.
5820 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5824 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5829 /* Expand the operands. */
5830 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5831 val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL, mode, EXPAND_NORMAL);
5832 /* If VAL is promoted to a wider mode, convert it back to MODE. */
5833 val = convert_to_mode (mode, val, 1);
5835 return expand_sync_lock_test_and_set (mem, val, target);
5838 /* Expand the __sync_synchronize intrinsic. */
5841 expand_builtin_synchronize (void)
5845 #ifdef HAVE_memory_barrier
5846 if (HAVE_memory_barrier)
5848 emit_insn (gen_memory_barrier ());
5853 /* If no explicit memory barrier instruction is available, create an
5854 empty asm stmt with a memory clobber. */
5855 x = build4 (ASM_EXPR, void_type_node, build_string (0, ""), NULL, NULL,
5856 tree_cons (NULL, build_string (6, "memory"), NULL));
5857 ASM_VOLATILE_P (x) = 1;
5858 expand_asm_expr (x);
5861 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5864 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5866 enum insn_code icode;
5868 rtx val = const0_rtx;
5870 /* Expand the operands. */
5871 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5873 /* If there is an explicit operation in the md file, use it. */
5874 icode = sync_lock_release[mode];
5875 if (icode != CODE_FOR_nothing)
5877 if (!insn_data[icode].operand[1].predicate (val, mode))
5878 val = force_reg (mode, val);
5880 insn = GEN_FCN (icode) (mem, val);
5888 /* Otherwise we can implement this operation by emitting a barrier
5889 followed by a store of zero. */
5890 expand_builtin_synchronize ();
5891 emit_move_insn (mem, val);
5894 /* Expand an expression EXP that calls a built-in function,
5895 with result going to TARGET if that's convenient
5896 (and in mode MODE if that's convenient).
5897 SUBTARGET may be used as the target for computing one of EXP's operands.
5898 IGNORE is nonzero if the value is to be ignored. */
5901 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5904 tree fndecl = get_callee_fndecl (exp);
5905 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5906 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5908 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5909 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5911 /* When not optimizing, generate calls to library functions for a certain
5914 && !called_as_built_in (fndecl)
5915 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5916 && fcode != BUILT_IN_ALLOCA)
5917 return expand_call (exp, target, ignore);
5919 /* The built-in function expanders test for target == const0_rtx
5920 to determine whether the function's result will be ignored. */
5922 target = const0_rtx;
5924 /* If the result of a pure or const built-in function is ignored, and
5925 none of its arguments are volatile, we can avoid expanding the
5926 built-in call and just evaluate the arguments for side-effects. */
5927 if (target == const0_rtx
5928 && (DECL_IS_PURE (fndecl) || TREE_READONLY (fndecl)))
5930 bool volatilep = false;
5932 call_expr_arg_iterator iter;
5934 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5935 if (TREE_THIS_VOLATILE (arg))
5943 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5944 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5951 CASE_FLT_FN (BUILT_IN_FABS):
5952 target = expand_builtin_fabs (exp, target, subtarget);
5957 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5958 target = expand_builtin_copysign (exp, target, subtarget);
5963 /* Just do a normal library call if we were unable to fold
5965 CASE_FLT_FN (BUILT_IN_CABS):
5968 CASE_FLT_FN (BUILT_IN_EXP):
5969 CASE_FLT_FN (BUILT_IN_EXP10):
5970 CASE_FLT_FN (BUILT_IN_POW10):
5971 CASE_FLT_FN (BUILT_IN_EXP2):
5972 CASE_FLT_FN (BUILT_IN_EXPM1):
5973 CASE_FLT_FN (BUILT_IN_LOGB):
5974 CASE_FLT_FN (BUILT_IN_LOG):
5975 CASE_FLT_FN (BUILT_IN_LOG10):
5976 CASE_FLT_FN (BUILT_IN_LOG2):
5977 CASE_FLT_FN (BUILT_IN_LOG1P):
5978 CASE_FLT_FN (BUILT_IN_TAN):
5979 CASE_FLT_FN (BUILT_IN_ASIN):
5980 CASE_FLT_FN (BUILT_IN_ACOS):
5981 CASE_FLT_FN (BUILT_IN_ATAN):
5982 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5983 because of possible accuracy problems. */
5984 if (! flag_unsafe_math_optimizations)
5986 CASE_FLT_FN (BUILT_IN_SQRT):
5987 CASE_FLT_FN (BUILT_IN_FLOOR):
5988 CASE_FLT_FN (BUILT_IN_CEIL):
5989 CASE_FLT_FN (BUILT_IN_TRUNC):
5990 CASE_FLT_FN (BUILT_IN_ROUND):
5991 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5992 CASE_FLT_FN (BUILT_IN_RINT):
5993 target = expand_builtin_mathfn (exp, target, subtarget);
5998 CASE_FLT_FN (BUILT_IN_ILOGB):
5999 if (! flag_unsafe_math_optimizations)
6001 CASE_FLT_FN (BUILT_IN_ISINF):
6002 target = expand_builtin_interclass_mathfn (exp, target, subtarget);
6007 CASE_FLT_FN (BUILT_IN_LCEIL):
6008 CASE_FLT_FN (BUILT_IN_LLCEIL):
6009 CASE_FLT_FN (BUILT_IN_LFLOOR):
6010 CASE_FLT_FN (BUILT_IN_LLFLOOR):
6011 target = expand_builtin_int_roundingfn (exp, target, subtarget);
6016 CASE_FLT_FN (BUILT_IN_LRINT):
6017 CASE_FLT_FN (BUILT_IN_LLRINT):
6018 CASE_FLT_FN (BUILT_IN_LROUND):
6019 CASE_FLT_FN (BUILT_IN_LLROUND):
6020 target = expand_builtin_int_roundingfn_2 (exp, target, subtarget);
6025 CASE_FLT_FN (BUILT_IN_POW):
6026 target = expand_builtin_pow (exp, target, subtarget);
6031 CASE_FLT_FN (BUILT_IN_POWI):
6032 target = expand_builtin_powi (exp, target, subtarget);
6037 CASE_FLT_FN (BUILT_IN_ATAN2):
6038 CASE_FLT_FN (BUILT_IN_LDEXP):
6039 CASE_FLT_FN (BUILT_IN_SCALB):
6040 CASE_FLT_FN (BUILT_IN_SCALBN):
6041 CASE_FLT_FN (BUILT_IN_SCALBLN):
6042 if (! flag_unsafe_math_optimizations)
6045 CASE_FLT_FN (BUILT_IN_FMOD):
6046 CASE_FLT_FN (BUILT_IN_REMAINDER):
6047 CASE_FLT_FN (BUILT_IN_DREM):
6048 target = expand_builtin_mathfn_2 (exp, target, subtarget);
6053 CASE_FLT_FN (BUILT_IN_CEXPI):
6054 target = expand_builtin_cexpi (exp, target, subtarget);
6055 gcc_assert (target);
6058 CASE_FLT_FN (BUILT_IN_SIN):
6059 CASE_FLT_FN (BUILT_IN_COS):
6060 if (! flag_unsafe_math_optimizations)
6062 target = expand_builtin_mathfn_3 (exp, target, subtarget);
6067 CASE_FLT_FN (BUILT_IN_SINCOS):
6068 if (! flag_unsafe_math_optimizations)
6070 target = expand_builtin_sincos (exp);
6075 case BUILT_IN_APPLY_ARGS:
6076 return expand_builtin_apply_args ();
6078 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6079 FUNCTION with a copy of the parameters described by
6080 ARGUMENTS, and ARGSIZE. It returns a block of memory
6081 allocated on the stack into which is stored all the registers
6082 that might possibly be used for returning the result of a
6083 function. ARGUMENTS is the value returned by
6084 __builtin_apply_args. ARGSIZE is the number of bytes of
6085 arguments that must be copied. ??? How should this value be
6086 computed? We'll also need a safe worst case value for varargs
6088 case BUILT_IN_APPLY:
6089 if (!validate_arglist (exp, POINTER_TYPE,
6090 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
6091 && !validate_arglist (exp, REFERENCE_TYPE,
6092 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6098 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6099 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6100 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6102 return expand_builtin_apply (ops[0], ops[1], ops[2]);
6105 /* __builtin_return (RESULT) causes the function to return the
6106 value described by RESULT. RESULT is address of the block of
6107 memory returned by __builtin_apply. */
6108 case BUILT_IN_RETURN:
6109 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6110 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6113 case BUILT_IN_SAVEREGS:
6114 return expand_builtin_saveregs ();
6116 case BUILT_IN_ARGS_INFO:
6117 return expand_builtin_args_info (exp);
6119 /* Return the address of the first anonymous stack arg. */
6120 case BUILT_IN_NEXT_ARG:
6121 if (fold_builtin_next_arg (exp, false))
6123 return expand_builtin_next_arg ();
6125 case BUILT_IN_CLASSIFY_TYPE:
6126 return expand_builtin_classify_type (exp);
6128 case BUILT_IN_CONSTANT_P:
6131 case BUILT_IN_FRAME_ADDRESS:
6132 case BUILT_IN_RETURN_ADDRESS:
6133 return expand_builtin_frame_address (fndecl, exp);
6135 /* Returns the address of the area where the structure is returned.
6137 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6138 if (call_expr_nargs (exp) != 0
6139 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6140 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6143 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6145 case BUILT_IN_ALLOCA:
6146 target = expand_builtin_alloca (exp, target);
6151 case BUILT_IN_STACK_SAVE:
6152 return expand_stack_save ();
6154 case BUILT_IN_STACK_RESTORE:
6155 expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6158 case BUILT_IN_BSWAP32:
6159 case BUILT_IN_BSWAP64:
6160 target = expand_builtin_bswap (exp, target, subtarget);
6166 CASE_INT_FN (BUILT_IN_FFS):
6167 case BUILT_IN_FFSIMAX:
6168 target = expand_builtin_unop (target_mode, exp, target,
6169 subtarget, ffs_optab);
6174 CASE_INT_FN (BUILT_IN_CLZ):
6175 case BUILT_IN_CLZIMAX:
6176 target = expand_builtin_unop (target_mode, exp, target,
6177 subtarget, clz_optab);
6182 CASE_INT_FN (BUILT_IN_CTZ):
6183 case BUILT_IN_CTZIMAX:
6184 target = expand_builtin_unop (target_mode, exp, target,
6185 subtarget, ctz_optab);
6190 CASE_INT_FN (BUILT_IN_POPCOUNT):
6191 case BUILT_IN_POPCOUNTIMAX:
6192 target = expand_builtin_unop (target_mode, exp, target,
6193 subtarget, popcount_optab);
6198 CASE_INT_FN (BUILT_IN_PARITY):
6199 case BUILT_IN_PARITYIMAX:
6200 target = expand_builtin_unop (target_mode, exp, target,
6201 subtarget, parity_optab);
6206 case BUILT_IN_STRLEN:
6207 target = expand_builtin_strlen (exp, target, target_mode);
6212 case BUILT_IN_STRCPY:
6213 target = expand_builtin_strcpy (fndecl, exp, target, mode);
6218 case BUILT_IN_STRNCPY:
6219 target = expand_builtin_strncpy (exp, target, mode);
6224 case BUILT_IN_STPCPY:
6225 target = expand_builtin_stpcpy (exp, target, mode);
6230 case BUILT_IN_STRCAT:
6231 target = expand_builtin_strcat (fndecl, exp, target, mode);
6236 case BUILT_IN_STRNCAT:
6237 target = expand_builtin_strncat (exp, target, mode);
6242 case BUILT_IN_STRSPN:
6243 target = expand_builtin_strspn (exp, target, mode);
6248 case BUILT_IN_STRCSPN:
6249 target = expand_builtin_strcspn (exp, target, mode);
6254 case BUILT_IN_STRSTR:
6255 target = expand_builtin_strstr (exp, target, mode);
6260 case BUILT_IN_STRPBRK:
6261 target = expand_builtin_strpbrk (exp, target, mode);
6266 case BUILT_IN_INDEX:
6267 case BUILT_IN_STRCHR:
6268 target = expand_builtin_strchr (exp, target, mode);
6273 case BUILT_IN_RINDEX:
6274 case BUILT_IN_STRRCHR:
6275 target = expand_builtin_strrchr (exp, target, mode);
6280 case BUILT_IN_MEMCPY:
6281 target = expand_builtin_memcpy (exp, target, mode);
6286 case BUILT_IN_MEMPCPY:
6287 target = expand_builtin_mempcpy (exp, target, mode);
6292 case BUILT_IN_MEMMOVE:
6293 target = expand_builtin_memmove (exp, target, mode, ignore);
6298 case BUILT_IN_BCOPY:
6299 target = expand_builtin_bcopy (exp, ignore);
6304 case BUILT_IN_MEMSET:
6305 target = expand_builtin_memset (exp, target, mode);
6310 case BUILT_IN_BZERO:
6311 target = expand_builtin_bzero (exp);
6316 case BUILT_IN_STRCMP:
6317 target = expand_builtin_strcmp (exp, target, mode);
6322 case BUILT_IN_STRNCMP:
6323 target = expand_builtin_strncmp (exp, target, mode);
6329 case BUILT_IN_MEMCMP:
6330 target = expand_builtin_memcmp (exp, target, mode);
6335 case BUILT_IN_SETJMP:
6336 /* This should have been lowered to the builtins below. */
6339 case BUILT_IN_SETJMP_SETUP:
6340 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6341 and the receiver label. */
6342 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6344 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6345 VOIDmode, EXPAND_NORMAL);
6346 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6347 rtx label_r = label_rtx (label);
6349 /* This is copied from the handling of non-local gotos. */
6350 expand_builtin_setjmp_setup (buf_addr, label_r);
6351 nonlocal_goto_handler_labels
6352 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6353 nonlocal_goto_handler_labels);
6354 /* ??? Do not let expand_label treat us as such since we would
6355 not want to be both on the list of non-local labels and on
6356 the list of forced labels. */
6357 FORCED_LABEL (label) = 0;
6362 case BUILT_IN_SETJMP_DISPATCHER:
6363 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6364 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6366 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6367 rtx label_r = label_rtx (label);
6369 /* Remove the dispatcher label from the list of non-local labels
6370 since the receiver labels have been added to it above. */
6371 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6376 case BUILT_IN_SETJMP_RECEIVER:
6377 /* __builtin_setjmp_receiver is passed the receiver label. */
6378 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6380 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6381 rtx label_r = label_rtx (label);
6383 expand_builtin_setjmp_receiver (label_r);
6388 /* __builtin_longjmp is passed a pointer to an array of five words.
6389 It's similar to the C library longjmp function but works with
6390 __builtin_setjmp above. */
6391 case BUILT_IN_LONGJMP:
6392 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6394 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6395 VOIDmode, EXPAND_NORMAL);
6396 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6398 if (value != const1_rtx)
6400 error ("%<__builtin_longjmp%> second argument must be 1");
6404 expand_builtin_longjmp (buf_addr, value);
6409 case BUILT_IN_NONLOCAL_GOTO:
6410 target = expand_builtin_nonlocal_goto (exp);
6415 /* This updates the setjmp buffer that is its argument with the value
6416 of the current stack pointer. */
6417 case BUILT_IN_UPDATE_SETJMP_BUF:
6418 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6421 = expand_normal (CALL_EXPR_ARG (exp, 0));
6423 expand_builtin_update_setjmp_buf (buf_addr);
6429 expand_builtin_trap ();
6432 case BUILT_IN_PRINTF:
6433 target = expand_builtin_printf (exp, target, mode, false);
6438 case BUILT_IN_PRINTF_UNLOCKED:
6439 target = expand_builtin_printf (exp, target, mode, true);
6444 case BUILT_IN_FPUTS:
6445 target = expand_builtin_fputs (exp, target, false);
6449 case BUILT_IN_FPUTS_UNLOCKED:
6450 target = expand_builtin_fputs (exp, target, true);
6455 case BUILT_IN_FPRINTF:
6456 target = expand_builtin_fprintf (exp, target, mode, false);
6461 case BUILT_IN_FPRINTF_UNLOCKED:
6462 target = expand_builtin_fprintf (exp, target, mode, true);
6467 case BUILT_IN_SPRINTF:
6468 target = expand_builtin_sprintf (exp, target, mode);
6473 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6474 target = expand_builtin_signbit (exp, target);
6479 /* Various hooks for the DWARF 2 __throw routine. */
6480 case BUILT_IN_UNWIND_INIT:
6481 expand_builtin_unwind_init ();
6483 case BUILT_IN_DWARF_CFA:
6484 return virtual_cfa_rtx;
6485 #ifdef DWARF2_UNWIND_INFO
6486 case BUILT_IN_DWARF_SP_COLUMN:
6487 return expand_builtin_dwarf_sp_column ();
6488 case BUILT_IN_INIT_DWARF_REG_SIZES:
6489 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6492 case BUILT_IN_FROB_RETURN_ADDR:
6493 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6494 case BUILT_IN_EXTRACT_RETURN_ADDR:
6495 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6496 case BUILT_IN_EH_RETURN:
6497 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6498 CALL_EXPR_ARG (exp, 1));
6500 #ifdef EH_RETURN_DATA_REGNO
6501 case BUILT_IN_EH_RETURN_DATA_REGNO:
6502 return expand_builtin_eh_return_data_regno (exp);
6504 case BUILT_IN_EXTEND_POINTER:
6505 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6507 case BUILT_IN_VA_START:
6508 case BUILT_IN_STDARG_START:
6509 return expand_builtin_va_start (exp);
6510 case BUILT_IN_VA_END:
6511 return expand_builtin_va_end (exp);
6512 case BUILT_IN_VA_COPY:
6513 return expand_builtin_va_copy (exp);
6514 case BUILT_IN_EXPECT:
6515 return expand_builtin_expect (exp, target);
6516 case BUILT_IN_PREFETCH:
6517 expand_builtin_prefetch (exp);
6520 case BUILT_IN_PROFILE_FUNC_ENTER:
6521 return expand_builtin_profile_func (false);
6522 case BUILT_IN_PROFILE_FUNC_EXIT:
6523 return expand_builtin_profile_func (true);
6525 case BUILT_IN_INIT_TRAMPOLINE:
6526 return expand_builtin_init_trampoline (exp);
6527 case BUILT_IN_ADJUST_TRAMPOLINE:
6528 return expand_builtin_adjust_trampoline (exp);
6531 case BUILT_IN_EXECL:
6532 case BUILT_IN_EXECV:
6533 case BUILT_IN_EXECLP:
6534 case BUILT_IN_EXECLE:
6535 case BUILT_IN_EXECVP:
6536 case BUILT_IN_EXECVE:
6537 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6542 case BUILT_IN_FETCH_AND_ADD_1:
6543 case BUILT_IN_FETCH_AND_ADD_2:
6544 case BUILT_IN_FETCH_AND_ADD_4:
6545 case BUILT_IN_FETCH_AND_ADD_8:
6546 case BUILT_IN_FETCH_AND_ADD_16:
6547 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6548 target = expand_builtin_sync_operation (mode, exp, PLUS,
6549 false, target, ignore);
6554 case BUILT_IN_FETCH_AND_SUB_1:
6555 case BUILT_IN_FETCH_AND_SUB_2:
6556 case BUILT_IN_FETCH_AND_SUB_4:
6557 case BUILT_IN_FETCH_AND_SUB_8:
6558 case BUILT_IN_FETCH_AND_SUB_16:
6559 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6560 target = expand_builtin_sync_operation (mode, exp, MINUS,
6561 false, target, ignore);
6566 case BUILT_IN_FETCH_AND_OR_1:
6567 case BUILT_IN_FETCH_AND_OR_2:
6568 case BUILT_IN_FETCH_AND_OR_4:
6569 case BUILT_IN_FETCH_AND_OR_8:
6570 case BUILT_IN_FETCH_AND_OR_16:
6571 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6572 target = expand_builtin_sync_operation (mode, exp, IOR,
6573 false, target, ignore);
6578 case BUILT_IN_FETCH_AND_AND_1:
6579 case BUILT_IN_FETCH_AND_AND_2:
6580 case BUILT_IN_FETCH_AND_AND_4:
6581 case BUILT_IN_FETCH_AND_AND_8:
6582 case BUILT_IN_FETCH_AND_AND_16:
6583 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6584 target = expand_builtin_sync_operation (mode, exp, AND,
6585 false, target, ignore);
6590 case BUILT_IN_FETCH_AND_XOR_1:
6591 case BUILT_IN_FETCH_AND_XOR_2:
6592 case BUILT_IN_FETCH_AND_XOR_4:
6593 case BUILT_IN_FETCH_AND_XOR_8:
6594 case BUILT_IN_FETCH_AND_XOR_16:
6595 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6596 target = expand_builtin_sync_operation (mode, exp, XOR,
6597 false, target, ignore);
6602 case BUILT_IN_FETCH_AND_NAND_1:
6603 case BUILT_IN_FETCH_AND_NAND_2:
6604 case BUILT_IN_FETCH_AND_NAND_4:
6605 case BUILT_IN_FETCH_AND_NAND_8:
6606 case BUILT_IN_FETCH_AND_NAND_16:
6607 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6608 target = expand_builtin_sync_operation (mode, exp, NOT,
6609 false, target, ignore);
6614 case BUILT_IN_ADD_AND_FETCH_1:
6615 case BUILT_IN_ADD_AND_FETCH_2:
6616 case BUILT_IN_ADD_AND_FETCH_4:
6617 case BUILT_IN_ADD_AND_FETCH_8:
6618 case BUILT_IN_ADD_AND_FETCH_16:
6619 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6620 target = expand_builtin_sync_operation (mode, exp, PLUS,
6621 true, target, ignore);
6626 case BUILT_IN_SUB_AND_FETCH_1:
6627 case BUILT_IN_SUB_AND_FETCH_2:
6628 case BUILT_IN_SUB_AND_FETCH_4:
6629 case BUILT_IN_SUB_AND_FETCH_8:
6630 case BUILT_IN_SUB_AND_FETCH_16:
6631 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6632 target = expand_builtin_sync_operation (mode, exp, MINUS,
6633 true, target, ignore);
6638 case BUILT_IN_OR_AND_FETCH_1:
6639 case BUILT_IN_OR_AND_FETCH_2:
6640 case BUILT_IN_OR_AND_FETCH_4:
6641 case BUILT_IN_OR_AND_FETCH_8:
6642 case BUILT_IN_OR_AND_FETCH_16:
6643 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6644 target = expand_builtin_sync_operation (mode, exp, IOR,
6645 true, target, ignore);
6650 case BUILT_IN_AND_AND_FETCH_1:
6651 case BUILT_IN_AND_AND_FETCH_2:
6652 case BUILT_IN_AND_AND_FETCH_4:
6653 case BUILT_IN_AND_AND_FETCH_8:
6654 case BUILT_IN_AND_AND_FETCH_16:
6655 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6656 target = expand_builtin_sync_operation (mode, exp, AND,
6657 true, target, ignore);
6662 case BUILT_IN_XOR_AND_FETCH_1:
6663 case BUILT_IN_XOR_AND_FETCH_2:
6664 case BUILT_IN_XOR_AND_FETCH_4:
6665 case BUILT_IN_XOR_AND_FETCH_8:
6666 case BUILT_IN_XOR_AND_FETCH_16:
6667 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6668 target = expand_builtin_sync_operation (mode, exp, XOR,
6669 true, target, ignore);
6674 case BUILT_IN_NAND_AND_FETCH_1:
6675 case BUILT_IN_NAND_AND_FETCH_2:
6676 case BUILT_IN_NAND_AND_FETCH_4:
6677 case BUILT_IN_NAND_AND_FETCH_8:
6678 case BUILT_IN_NAND_AND_FETCH_16:
6679 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6680 target = expand_builtin_sync_operation (mode, exp, NOT,
6681 true, target, ignore);
6686 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6687 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6688 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6689 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6690 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6691 if (mode == VOIDmode)
6692 mode = TYPE_MODE (boolean_type_node);
6693 if (!target || !register_operand (target, mode))
6694 target = gen_reg_rtx (mode);
6696 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6697 target = expand_builtin_compare_and_swap (mode, exp, true, target);
6702 case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6703 case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6704 case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6705 case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6706 case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6707 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6708 target = expand_builtin_compare_and_swap (mode, exp, false, target);
6713 case BUILT_IN_LOCK_TEST_AND_SET_1:
6714 case BUILT_IN_LOCK_TEST_AND_SET_2:
6715 case BUILT_IN_LOCK_TEST_AND_SET_4:
6716 case BUILT_IN_LOCK_TEST_AND_SET_8:
6717 case BUILT_IN_LOCK_TEST_AND_SET_16:
6718 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6719 target = expand_builtin_lock_test_and_set (mode, exp, target);
6724 case BUILT_IN_LOCK_RELEASE_1:
6725 case BUILT_IN_LOCK_RELEASE_2:
6726 case BUILT_IN_LOCK_RELEASE_4:
6727 case BUILT_IN_LOCK_RELEASE_8:
6728 case BUILT_IN_LOCK_RELEASE_16:
6729 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6730 expand_builtin_lock_release (mode, exp);
6733 case BUILT_IN_SYNCHRONIZE:
6734 expand_builtin_synchronize ();
6737 case BUILT_IN_OBJECT_SIZE:
6738 return expand_builtin_object_size (exp);
6740 case BUILT_IN_MEMCPY_CHK:
6741 case BUILT_IN_MEMPCPY_CHK:
6742 case BUILT_IN_MEMMOVE_CHK:
6743 case BUILT_IN_MEMSET_CHK:
6744 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6749 case BUILT_IN_STRCPY_CHK:
6750 case BUILT_IN_STPCPY_CHK:
6751 case BUILT_IN_STRNCPY_CHK:
6752 case BUILT_IN_STRCAT_CHK:
6753 case BUILT_IN_STRNCAT_CHK:
6754 case BUILT_IN_SNPRINTF_CHK:
6755 case BUILT_IN_VSNPRINTF_CHK:
6756 maybe_emit_chk_warning (exp, fcode);
6759 case BUILT_IN_SPRINTF_CHK:
6760 case BUILT_IN_VSPRINTF_CHK:
6761 maybe_emit_sprintf_chk_warning (exp, fcode);
6764 default: /* just do library call, if unknown builtin */
6768 /* The switch statement above can drop through to cause the function
6769 to be called normally. */
6770 return expand_call (exp, target, ignore);
6773 /* Determine whether a tree node represents a call to a built-in
6774 function. If the tree T is a call to a built-in function with
6775 the right number of arguments of the appropriate types, return
6776 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6777 Otherwise the return value is END_BUILTINS. */
6779 enum built_in_function
6780 builtin_mathfn_code (tree t)
6782 tree fndecl, arg, parmlist;
6783 tree argtype, parmtype;
6784 call_expr_arg_iterator iter;
6786 if (TREE_CODE (t) != CALL_EXPR
6787 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6788 return END_BUILTINS;
6790 fndecl = get_callee_fndecl (t);
6791 if (fndecl == NULL_TREE
6792 || TREE_CODE (fndecl) != FUNCTION_DECL
6793 || ! DECL_BUILT_IN (fndecl)
6794 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6795 return END_BUILTINS;
6797 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6798 init_call_expr_arg_iterator (t, &iter);
6799 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6801 /* If a function doesn't take a variable number of arguments,
6802 the last element in the list will have type `void'. */
6803 parmtype = TREE_VALUE (parmlist);
6804 if (VOID_TYPE_P (parmtype))
6806 if (more_call_expr_args_p (&iter))
6807 return END_BUILTINS;
6808 return DECL_FUNCTION_CODE (fndecl);
6811 if (! more_call_expr_args_p (&iter))
6812 return END_BUILTINS;
6814 arg = next_call_expr_arg (&iter);
6815 argtype = TREE_TYPE (arg);
6817 if (SCALAR_FLOAT_TYPE_P (parmtype))
6819 if (! SCALAR_FLOAT_TYPE_P (argtype))
6820 return END_BUILTINS;
6822 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6824 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6825 return END_BUILTINS;
6827 else if (POINTER_TYPE_P (parmtype))
6829 if (! POINTER_TYPE_P (argtype))
6830 return END_BUILTINS;
6832 else if (INTEGRAL_TYPE_P (parmtype))
6834 if (! INTEGRAL_TYPE_P (argtype))
6835 return END_BUILTINS;
6838 return END_BUILTINS;
6841 /* Variable-length argument list. */
6842 return DECL_FUNCTION_CODE (fndecl);
6845 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6846 evaluate to a constant. */
6849 fold_builtin_constant_p (tree arg)
6851 /* We return 1 for a numeric type that's known to be a constant
6852 value at compile-time or for an aggregate type that's a
6853 literal constant. */
6856 /* If we know this is a constant, emit the constant of one. */
6857 if (CONSTANT_CLASS_P (arg)
6858 || (TREE_CODE (arg) == CONSTRUCTOR
6859 && TREE_CONSTANT (arg)))
6860 return integer_one_node;
6861 if (TREE_CODE (arg) == ADDR_EXPR)
6863 tree op = TREE_OPERAND (arg, 0);
6864 if (TREE_CODE (op) == STRING_CST
6865 || (TREE_CODE (op) == ARRAY_REF
6866 && integer_zerop (TREE_OPERAND (op, 1))
6867 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6868 return integer_one_node;
6871 /* If this expression has side effects, show we don't know it to be a
6872 constant. Likewise if it's a pointer or aggregate type since in
6873 those case we only want literals, since those are only optimized
6874 when generating RTL, not later.
6875 And finally, if we are compiling an initializer, not code, we
6876 need to return a definite result now; there's not going to be any
6877 more optimization done. */
6878 if (TREE_SIDE_EFFECTS (arg)
6879 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6880 || POINTER_TYPE_P (TREE_TYPE (arg))
6882 || folding_initializer)
6883 return integer_zero_node;
6888 /* Fold a call to __builtin_expect with argument ARG, if we expect that a
6889 comparison against the argument will fold to a constant. In practice,
6890 this means a true constant or the address of a non-weak symbol. */
6893 fold_builtin_expect (tree arg)
6897 /* If the argument isn't invariant, then there's nothing we can do. */
6898 if (!TREE_INVARIANT (arg))
6901 /* If we're looking at an address of a weak decl, then do not fold. */
6904 if (TREE_CODE (inner) == ADDR_EXPR)
6908 inner = TREE_OPERAND (inner, 0);
6910 while (TREE_CODE (inner) == COMPONENT_REF
6911 || TREE_CODE (inner) == ARRAY_REF);
6912 if (DECL_P (inner) && DECL_WEAK (inner))
6916 /* Otherwise, ARG already has the proper type for the return value. */
6920 /* Fold a call to __builtin_classify_type with argument ARG. */
6923 fold_builtin_classify_type (tree arg)
6926 return build_int_cst (NULL_TREE, no_type_class);
6928 return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6931 /* Fold a call to __builtin_strlen with argument ARG. */
6934 fold_builtin_strlen (tree arg)
6936 if (!validate_arg (arg, POINTER_TYPE))
6940 tree len = c_strlen (arg, 0);
6944 /* Convert from the internal "sizetype" type to "size_t". */
6946 len = fold_convert (size_type_node, len);
6954 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6957 fold_builtin_inf (tree type, int warn)
6959 REAL_VALUE_TYPE real;
6961 /* __builtin_inff is intended to be usable to define INFINITY on all
6962 targets. If an infinity is not available, INFINITY expands "to a
6963 positive constant of type float that overflows at translation
6964 time", footnote "In this case, using INFINITY will violate the
6965 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6966 Thus we pedwarn to ensure this constraint violation is
6968 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6969 pedwarn ("target format does not support infinity");
6972 return build_real (type, real);
6975 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG. */
6978 fold_builtin_nan (tree arg, tree type, int quiet)
6980 REAL_VALUE_TYPE real;
6983 if (!validate_arg (arg, POINTER_TYPE))
6985 str = c_getstr (arg);
6989 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6992 return build_real (type, real);
6995 /* Return true if the floating point expression T has an integer value.
6996 We also allow +Inf, -Inf and NaN to be considered integer values. */
6999 integer_valued_real_p (tree t)
7001 switch (TREE_CODE (t))
7008 case NON_LVALUE_EXPR:
7009 return integer_valued_real_p (TREE_OPERAND (t, 0));
7014 return integer_valued_real_p (GENERIC_TREE_OPERAND (t, 1));
7021 return integer_valued_real_p (TREE_OPERAND (t, 0))
7022 && integer_valued_real_p (TREE_OPERAND (t, 1));
7025 return integer_valued_real_p (TREE_OPERAND (t, 1))
7026 && integer_valued_real_p (TREE_OPERAND (t, 2));
7029 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7033 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7034 if (TREE_CODE (type) == INTEGER_TYPE)
7036 if (TREE_CODE (type) == REAL_TYPE)
7037 return integer_valued_real_p (TREE_OPERAND (t, 0));
7042 switch (builtin_mathfn_code (t))
7044 CASE_FLT_FN (BUILT_IN_CEIL):
7045 CASE_FLT_FN (BUILT_IN_FLOOR):
7046 CASE_FLT_FN (BUILT_IN_NEARBYINT):
7047 CASE_FLT_FN (BUILT_IN_RINT):
7048 CASE_FLT_FN (BUILT_IN_ROUND):
7049 CASE_FLT_FN (BUILT_IN_TRUNC):
7052 CASE_FLT_FN (BUILT_IN_FMIN):
7053 CASE_FLT_FN (BUILT_IN_FMAX):
7054 return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7055 && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7068 /* FNDECL is assumed to be a builtin where truncation can be propagated
7069 across (for instance floor((double)f) == (double)floorf (f).
7070 Do the transformation for a call with argument ARG. */
7073 fold_trunc_transparent_mathfn (tree fndecl, tree arg)
7075 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7077 if (!validate_arg (arg, REAL_TYPE))
7080 /* Integer rounding functions are idempotent. */
7081 if (fcode == builtin_mathfn_code (arg))
7084 /* If argument is already integer valued, and we don't need to worry
7085 about setting errno, there's no need to perform rounding. */
7086 if (! flag_errno_math && integer_valued_real_p (arg))
7091 tree arg0 = strip_float_extensions (arg);
7092 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7093 tree newtype = TREE_TYPE (arg0);
7096 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7097 && (decl = mathfn_built_in (newtype, fcode)))
7098 return fold_convert (ftype,
7099 build_call_expr (decl, 1,
7100 fold_convert (newtype, arg0)));
7105 /* FNDECL is assumed to be builtin which can narrow the FP type of
7106 the argument, for instance lround((double)f) -> lroundf (f).
7107 Do the transformation for a call with argument ARG. */
7110 fold_fixed_mathfn (tree fndecl, tree arg)
7112 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7114 if (!validate_arg (arg, REAL_TYPE))
7117 /* If argument is already integer valued, and we don't need to worry
7118 about setting errno, there's no need to perform rounding. */
7119 if (! flag_errno_math && integer_valued_real_p (arg))
7120 return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)), arg);
7124 tree ftype = TREE_TYPE (arg);
7125 tree arg0 = strip_float_extensions (arg);
7126 tree newtype = TREE_TYPE (arg0);
7129 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7130 && (decl = mathfn_built_in (newtype, fcode)))
7131 return build_call_expr (decl, 1, fold_convert (newtype, arg0));
7134 /* Canonicalize llround (x) to lround (x) on LP64 targets where
7135 sizeof (long long) == sizeof (long). */
7136 if (TYPE_PRECISION (long_long_integer_type_node)
7137 == TYPE_PRECISION (long_integer_type_node))
7139 tree newfn = NULL_TREE;
7142 CASE_FLT_FN (BUILT_IN_LLCEIL):
7143 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7146 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7147 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7150 CASE_FLT_FN (BUILT_IN_LLROUND):
7151 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7154 CASE_FLT_FN (BUILT_IN_LLRINT):
7155 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7164 tree newcall = build_call_expr(newfn, 1, arg);
7165 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7172 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG. TYPE is the
7173 return type. Return NULL_TREE if no simplification can be made. */
7176 fold_builtin_cabs (tree arg, tree type, tree fndecl)
7180 if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
7181 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7184 /* Calculate the result when the argument is a constant. */
7185 if (TREE_CODE (arg) == COMPLEX_CST
7186 && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7190 if (TREE_CODE (arg) == COMPLEX_EXPR)
7192 tree real = TREE_OPERAND (arg, 0);
7193 tree imag = TREE_OPERAND (arg, 1);
7195 /* If either part is zero, cabs is fabs of the other. */
7196 if (real_zerop (real))
7197 return fold_build1 (ABS_EXPR, type, imag);
7198 if (real_zerop (imag))
7199 return fold_build1 (ABS_EXPR, type, real);
7201 /* cabs(x+xi) -> fabs(x)*sqrt(2). */
7202 if (flag_unsafe_math_optimizations
7203 && operand_equal_p (real, imag, OEP_PURE_SAME))
7205 const REAL_VALUE_TYPE sqrt2_trunc
7206 = real_value_truncate (TYPE_MODE (type), dconstsqrt2);
7208 return fold_build2 (MULT_EXPR, type,
7209 fold_build1 (ABS_EXPR, type, real),
7210 build_real (type, sqrt2_trunc));
7214 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
7215 if (TREE_CODE (arg) == NEGATE_EXPR
7216 || TREE_CODE (arg) == CONJ_EXPR)
7217 return build_call_expr (fndecl, 1, TREE_OPERAND (arg, 0));
7219 /* Don't do this when optimizing for size. */
7220 if (flag_unsafe_math_optimizations
7221 && optimize && !optimize_size)
7223 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7225 if (sqrtfn != NULL_TREE)
7227 tree rpart, ipart, result;
7229 arg = builtin_save_expr (arg);
7231 rpart = fold_build1 (REALPART_EXPR, type, arg);
7232 ipart = fold_build1 (IMAGPART_EXPR, type, arg);
7234 rpart = builtin_save_expr (rpart);
7235 ipart = builtin_save_expr (ipart);
7237 result = fold_build2 (PLUS_EXPR, type,
7238 fold_build2 (MULT_EXPR, type,
7240 fold_build2 (MULT_EXPR, type,
7243 return build_call_expr (sqrtfn, 1, result);
7250 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7251 Return NULL_TREE if no simplification can be made. */
7254 fold_builtin_sqrt (tree arg, tree type)
7257 enum built_in_function fcode;
7260 if (!validate_arg (arg, REAL_TYPE))
7263 /* Calculate the result when the argument is a constant. */
7264 if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7267 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
7268 fcode = builtin_mathfn_code (arg);
7269 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7271 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7272 arg = fold_build2 (MULT_EXPR, type,
7273 CALL_EXPR_ARG (arg, 0),
7274 build_real (type, dconsthalf));
7275 return build_call_expr (expfn, 1, arg);
7278 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7279 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7281 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7285 tree arg0 = CALL_EXPR_ARG (arg, 0);
7287 /* The inner root was either sqrt or cbrt. */
7288 REAL_VALUE_TYPE dconstroot =
7289 BUILTIN_SQRT_P (fcode) ? dconsthalf : dconstthird;
7291 /* Adjust for the outer root. */
7292 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7293 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7294 tree_root = build_real (type, dconstroot);
7295 return build_call_expr (powfn, 2, arg0, tree_root);
7299 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7300 if (flag_unsafe_math_optimizations
7301 && (fcode == BUILT_IN_POW
7302 || fcode == BUILT_IN_POWF
7303 || fcode == BUILT_IN_POWL))
7305 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7306 tree arg0 = CALL_EXPR_ARG (arg, 0);
7307 tree arg1 = CALL_EXPR_ARG (arg, 1);
7309 if (!tree_expr_nonnegative_p (arg0))
7310 arg0 = build1 (ABS_EXPR, type, arg0);
7311 narg1 = fold_build2 (MULT_EXPR, type, arg1,
7312 build_real (type, dconsthalf));
7313 return build_call_expr (powfn, 2, arg0, narg1);
7319 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7320 Return NULL_TREE if no simplification can be made. */
7323 fold_builtin_cbrt (tree arg, tree type)
7325 const enum built_in_function fcode = builtin_mathfn_code (arg);
7328 if (!validate_arg (arg, REAL_TYPE))
7331 /* Calculate the result when the argument is a constant. */
7332 if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7335 if (flag_unsafe_math_optimizations)
7337 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7338 if (BUILTIN_EXPONENT_P (fcode))
7340 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7341 const REAL_VALUE_TYPE third_trunc =
7342 real_value_truncate (TYPE_MODE (type), dconstthird);
7343 arg = fold_build2 (MULT_EXPR, type,
7344 CALL_EXPR_ARG (arg, 0),
7345 build_real (type, third_trunc));
7346 return build_call_expr (expfn, 1, arg);
7349 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7350 if (BUILTIN_SQRT_P (fcode))
7352 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7356 tree arg0 = CALL_EXPR_ARG (arg, 0);
7358 REAL_VALUE_TYPE dconstroot = dconstthird;
7360 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7361 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7362 tree_root = build_real (type, dconstroot);
7363 return build_call_expr (powfn, 2, arg0, tree_root);
7367 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7368 if (BUILTIN_CBRT_P (fcode))
7370 tree arg0 = CALL_EXPR_ARG (arg, 0);
7371 if (tree_expr_nonnegative_p (arg0))
7373 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7378 REAL_VALUE_TYPE dconstroot;
7380 real_arithmetic (&dconstroot, MULT_EXPR, &dconstthird, &dconstthird);
7381 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7382 tree_root = build_real (type, dconstroot);
7383 return build_call_expr (powfn, 2, arg0, tree_root);
7388 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7389 if (fcode == BUILT_IN_POW
7390 || fcode == BUILT_IN_POWF
7391 || fcode == BUILT_IN_POWL)
7393 tree arg00 = CALL_EXPR_ARG (arg, 0);
7394 tree arg01 = CALL_EXPR_ARG (arg, 1);
7395 if (tree_expr_nonnegative_p (arg00))
7397 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7398 const REAL_VALUE_TYPE dconstroot
7399 = real_value_truncate (TYPE_MODE (type), dconstthird);
7400 tree narg01 = fold_build2 (MULT_EXPR, type, arg01,
7401 build_real (type, dconstroot));
7402 return build_call_expr (powfn, 2, arg00, narg01);
7409 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7410 TYPE is the type of the return value. Return NULL_TREE if no
7411 simplification can be made. */
7414 fold_builtin_cos (tree arg, tree type, tree fndecl)
7418 if (!validate_arg (arg, REAL_TYPE))
7421 /* Calculate the result when the argument is a constant. */
7422 if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7425 /* Optimize cos(-x) into cos (x). */
7426 if ((narg = fold_strip_sign_ops (arg)))
7427 return build_call_expr (fndecl, 1, narg);
7432 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7433 Return NULL_TREE if no simplification can be made. */
7436 fold_builtin_cosh (tree arg, tree type, tree fndecl)
7438 if (validate_arg (arg, REAL_TYPE))
7442 /* Calculate the result when the argument is a constant. */
7443 if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7446 /* Optimize cosh(-x) into cosh (x). */
7447 if ((narg = fold_strip_sign_ops (arg)))
7448 return build_call_expr (fndecl, 1, narg);
7454 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7455 Return NULL_TREE if no simplification can be made. */
7458 fold_builtin_tan (tree arg, tree type)
7460 enum built_in_function fcode;
7463 if (!validate_arg (arg, REAL_TYPE))
7466 /* Calculate the result when the argument is a constant. */
7467 if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7470 /* Optimize tan(atan(x)) = x. */
7471 fcode = builtin_mathfn_code (arg);
7472 if (flag_unsafe_math_optimizations
7473 && (fcode == BUILT_IN_ATAN
7474 || fcode == BUILT_IN_ATANF
7475 || fcode == BUILT_IN_ATANL))
7476 return CALL_EXPR_ARG (arg, 0);
7481 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7482 NULL_TREE if no simplification can be made. */
7485 fold_builtin_sincos (tree arg0, tree arg1, tree arg2)
7490 if (!validate_arg (arg0, REAL_TYPE)
7491 || !validate_arg (arg1, POINTER_TYPE)
7492 || !validate_arg (arg2, POINTER_TYPE))
7495 type = TREE_TYPE (arg0);
7497 /* Calculate the result when the argument is a constant. */
7498 if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7501 /* Canonicalize sincos to cexpi. */
7502 if (!TARGET_C99_FUNCTIONS)
7504 fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7508 call = build_call_expr (fn, 1, arg0);
7509 call = builtin_save_expr (call);
7511 return build2 (COMPOUND_EXPR, type,
7512 build2 (MODIFY_EXPR, void_type_node,
7513 build_fold_indirect_ref (arg1),
7514 build1 (IMAGPART_EXPR, type, call)),
7515 build2 (MODIFY_EXPR, void_type_node,
7516 build_fold_indirect_ref (arg2),
7517 build1 (REALPART_EXPR, type, call)));
7520 /* Fold function call to builtin cexp, cexpf, or cexpl. Return
7521 NULL_TREE if no simplification can be made. */
7524 fold_builtin_cexp (tree arg0, tree type)
7527 tree realp, imagp, ifn;
7529 if (!validate_arg (arg0, COMPLEX_TYPE))
7532 rtype = TREE_TYPE (TREE_TYPE (arg0));
7534 /* In case we can figure out the real part of arg0 and it is constant zero
7536 if (!TARGET_C99_FUNCTIONS)
7538 ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7542 if ((realp = fold_unary (REALPART_EXPR, rtype, arg0))
7543 && real_zerop (realp))
7545 tree narg = fold_build1 (IMAGPART_EXPR, rtype, arg0);
7546 return build_call_expr (ifn, 1, narg);
7549 /* In case we can easily decompose real and imaginary parts split cexp
7550 to exp (r) * cexpi (i). */
7551 if (flag_unsafe_math_optimizations
7554 tree rfn, rcall, icall;
7556 rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7560 imagp = fold_unary (IMAGPART_EXPR, rtype, arg0);
7564 icall = build_call_expr (ifn, 1, imagp);
7565 icall = builtin_save_expr (icall);
7566 rcall = build_call_expr (rfn, 1, realp);
7567 rcall = builtin_save_expr (rcall);
7568 return build2 (COMPLEX_EXPR, type,
7569 build2 (MULT_EXPR, rtype,
7571 build1 (REALPART_EXPR, rtype, icall)),
7572 build2 (MULT_EXPR, rtype,
7574 build1 (IMAGPART_EXPR, rtype, icall)));
7580 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7581 Return NULL_TREE if no simplification can be made. */
7584 fold_builtin_trunc (tree fndecl, tree arg)
7586 if (!validate_arg (arg, REAL_TYPE))
7589 /* Optimize trunc of constant value. */
7590 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7592 REAL_VALUE_TYPE r, x;
7593 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7595 x = TREE_REAL_CST (arg);
7596 real_trunc (&r, TYPE_MODE (type), &x);
7597 return build_real (type, r);
7600 return fold_trunc_transparent_mathfn (fndecl, arg);
7603 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7604 Return NULL_TREE if no simplification can be made. */
7607 fold_builtin_floor (tree fndecl, tree arg)
7609 if (!validate_arg (arg, REAL_TYPE))
7612 /* Optimize floor of constant value. */
7613 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7617 x = TREE_REAL_CST (arg);
7618 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7620 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7623 real_floor (&r, TYPE_MODE (type), &x);
7624 return build_real (type, r);
7628 /* Fold floor (x) where x is nonnegative to trunc (x). */
7629 if (tree_expr_nonnegative_p (arg))
7631 tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7633 return build_call_expr (truncfn, 1, arg);
7636 return fold_trunc_transparent_mathfn (fndecl, arg);
7639 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7640 Return NULL_TREE if no simplification can be made. */
7643 fold_builtin_ceil (tree fndecl, tree arg)
7645 if (!validate_arg (arg, REAL_TYPE))
7648 /* Optimize ceil of constant value. */
7649 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7653 x = TREE_REAL_CST (arg);
7654 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7656 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7659 real_ceil (&r, TYPE_MODE (type), &x);
7660 return build_real (type, r);
7664 return fold_trunc_transparent_mathfn (fndecl, arg);
7667 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7668 Return NULL_TREE if no simplification can be made. */
7671 fold_builtin_round (tree fndecl, tree arg)
7673 if (!validate_arg (arg, REAL_TYPE))
7676 /* Optimize round of constant value. */
7677 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7681 x = TREE_REAL_CST (arg);
7682 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7684 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7687 real_round (&r, TYPE_MODE (type), &x);
7688 return build_real (type, r);
7692 return fold_trunc_transparent_mathfn (fndecl, arg);
7695 /* Fold function call to builtin lround, lroundf or lroundl (or the
7696 corresponding long long versions) and other rounding functions. ARG
7697 is the argument to the call. Return NULL_TREE if no simplification
7701 fold_builtin_int_roundingfn (tree fndecl, tree arg)
7703 if (!validate_arg (arg, REAL_TYPE))
7706 /* Optimize lround of constant value. */
7707 if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7709 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7711 if (! REAL_VALUE_ISNAN (x) && ! REAL_VALUE_ISINF (x))
7713 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7714 tree ftype = TREE_TYPE (arg);
7715 unsigned HOST_WIDE_INT lo2;
7716 HOST_WIDE_INT hi, lo;
7719 switch (DECL_FUNCTION_CODE (fndecl))
7721 CASE_FLT_FN (BUILT_IN_LFLOOR):
7722 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7723 real_floor (&r, TYPE_MODE (ftype), &x);
7726 CASE_FLT_FN (BUILT_IN_LCEIL):
7727 CASE_FLT_FN (BUILT_IN_LLCEIL):
7728 real_ceil (&r, TYPE_MODE (ftype), &x);
7731 CASE_FLT_FN (BUILT_IN_LROUND):
7732 CASE_FLT_FN (BUILT_IN_LLROUND):
7733 real_round (&r, TYPE_MODE (ftype), &x);
7740 REAL_VALUE_TO_INT (&lo, &hi, r);
7741 if (!fit_double_type (lo, hi, &lo2, &hi, itype))
7742 return build_int_cst_wide (itype, lo2, hi);
7746 switch (DECL_FUNCTION_CODE (fndecl))
7748 CASE_FLT_FN (BUILT_IN_LFLOOR):
7749 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7750 /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x). */
7751 if (tree_expr_nonnegative_p (arg))
7752 return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)),
7758 return fold_fixed_mathfn (fndecl, arg);
7761 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7762 and their long and long long variants (i.e. ffsl and ffsll). ARG is
7763 the argument to the call. Return NULL_TREE if no simplification can
7767 fold_builtin_bitop (tree fndecl, tree arg)
7769 if (!validate_arg (arg, INTEGER_TYPE))
7772 /* Optimize for constant argument. */
7773 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7775 HOST_WIDE_INT hi, width, result;
7776 unsigned HOST_WIDE_INT lo;
7779 type = TREE_TYPE (arg);
7780 width = TYPE_PRECISION (type);
7781 lo = TREE_INT_CST_LOW (arg);
7783 /* Clear all the bits that are beyond the type's precision. */
7784 if (width > HOST_BITS_PER_WIDE_INT)
7786 hi = TREE_INT_CST_HIGH (arg);
7787 if (width < 2 * HOST_BITS_PER_WIDE_INT)
7788 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7793 if (width < HOST_BITS_PER_WIDE_INT)
7794 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7797 switch (DECL_FUNCTION_CODE (fndecl))
7799 CASE_INT_FN (BUILT_IN_FFS):
7801 result = exact_log2 (lo & -lo) + 1;
7803 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
7808 CASE_INT_FN (BUILT_IN_CLZ):
7810 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7812 result = width - floor_log2 (lo) - 1;
7813 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7817 CASE_INT_FN (BUILT_IN_CTZ):
7819 result = exact_log2 (lo & -lo);
7821 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
7822 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7826 CASE_INT_FN (BUILT_IN_POPCOUNT):
7829 result++, lo &= lo - 1;
7831 result++, hi &= hi - 1;
7834 CASE_INT_FN (BUILT_IN_PARITY):
7837 result++, lo &= lo - 1;
7839 result++, hi &= hi - 1;
7847 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7853 /* Fold function call to builtin_bswap and the long and long long
7854 variants. Return NULL_TREE if no simplification can be made. */
7856 fold_builtin_bswap (tree fndecl, tree arg)
7858 if (! validate_arg (arg, INTEGER_TYPE))
7861 /* Optimize constant value. */
7862 if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7864 HOST_WIDE_INT hi, width, r_hi = 0;
7865 unsigned HOST_WIDE_INT lo, r_lo = 0;
7868 type = TREE_TYPE (arg);
7869 width = TYPE_PRECISION (type);
7870 lo = TREE_INT_CST_LOW (arg);
7871 hi = TREE_INT_CST_HIGH (arg);
7873 switch (DECL_FUNCTION_CODE (fndecl))
7875 case BUILT_IN_BSWAP32:
7876 case BUILT_IN_BSWAP64:
7880 for (s = 0; s < width; s += 8)
7882 int d = width - s - 8;
7883 unsigned HOST_WIDE_INT byte;
7885 if (s < HOST_BITS_PER_WIDE_INT)
7886 byte = (lo >> s) & 0xff;
7888 byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7890 if (d < HOST_BITS_PER_WIDE_INT)
7893 r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7903 if (width < HOST_BITS_PER_WIDE_INT)
7904 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7906 return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7912 /* Return true if EXPR is the real constant contained in VALUE. */
7915 real_dconstp (tree expr, const REAL_VALUE_TYPE *value)
7919 return ((TREE_CODE (expr) == REAL_CST
7920 && !TREE_OVERFLOW (expr)
7921 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
7922 || (TREE_CODE (expr) == COMPLEX_CST
7923 && real_dconstp (TREE_REALPART (expr), value)
7924 && real_zerop (TREE_IMAGPART (expr))));
7927 /* A subroutine of fold_builtin to fold the various logarithmic
7928 functions. Return NULL_TREE if no simplification can me made.
7929 FUNC is the corresponding MPFR logarithm function. */
7932 fold_builtin_logarithm (tree fndecl, tree arg,
7933 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7935 if (validate_arg (arg, REAL_TYPE))
7937 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7939 const enum built_in_function fcode = builtin_mathfn_code (arg);
7941 /* Optimize log(e) = 1.0. We're never passed an exact 'e',
7942 instead we'll look for 'e' truncated to MODE. So only do
7943 this if flag_unsafe_math_optimizations is set. */
7944 if (flag_unsafe_math_optimizations && func == mpfr_log)
7946 const REAL_VALUE_TYPE e_truncated =
7947 real_value_truncate (TYPE_MODE (type), dconste);
7948 if (real_dconstp (arg, &e_truncated))
7949 return build_real (type, dconst1);
7952 /* Calculate the result when the argument is a constant. */
7953 if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7956 /* Special case, optimize logN(expN(x)) = x. */
7957 if (flag_unsafe_math_optimizations
7958 && ((func == mpfr_log
7959 && (fcode == BUILT_IN_EXP
7960 || fcode == BUILT_IN_EXPF
7961 || fcode == BUILT_IN_EXPL))
7962 || (func == mpfr_log2
7963 && (fcode == BUILT_IN_EXP2
7964 || fcode == BUILT_IN_EXP2F
7965 || fcode == BUILT_IN_EXP2L))
7966 || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7967 return fold_convert (type, CALL_EXPR_ARG (arg, 0));
7969 /* Optimize logN(func()) for various exponential functions. We
7970 want to determine the value "x" and the power "exponent" in
7971 order to transform logN(x**exponent) into exponent*logN(x). */
7972 if (flag_unsafe_math_optimizations)
7974 tree exponent = 0, x = 0;
7978 CASE_FLT_FN (BUILT_IN_EXP):
7979 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7980 x = build_real (type,
7981 real_value_truncate (TYPE_MODE (type), dconste));
7982 exponent = CALL_EXPR_ARG (arg, 0);
7984 CASE_FLT_FN (BUILT_IN_EXP2):
7985 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7986 x = build_real (type, dconst2);
7987 exponent = CALL_EXPR_ARG (arg, 0);
7989 CASE_FLT_FN (BUILT_IN_EXP10):
7990 CASE_FLT_FN (BUILT_IN_POW10):
7991 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7992 x = build_real (type, dconst10);
7993 exponent = CALL_EXPR_ARG (arg, 0);
7995 CASE_FLT_FN (BUILT_IN_SQRT):
7996 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7997 x = CALL_EXPR_ARG (arg, 0);
7998 exponent = build_real (type, dconsthalf);
8000 CASE_FLT_FN (BUILT_IN_CBRT):
8001 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
8002 x = CALL_EXPR_ARG (arg, 0);
8003 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8006 CASE_FLT_FN (BUILT_IN_POW):
8007 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
8008 x = CALL_EXPR_ARG (arg, 0);
8009 exponent = CALL_EXPR_ARG (arg, 1);
8015 /* Now perform the optimization. */
8018 tree logfn = build_call_expr (fndecl, 1, x);
8019 return fold_build2 (MULT_EXPR, type, exponent, logfn);
8027 /* Fold a builtin function call to hypot, hypotf, or hypotl. Return
8028 NULL_TREE if no simplification can be made. */
8031 fold_builtin_hypot (tree fndecl, tree arg0, tree arg1, tree type)
8033 tree res, narg0, narg1;
8035 if (!validate_arg (arg0, REAL_TYPE)
8036 || !validate_arg (arg1, REAL_TYPE))
8039 /* Calculate the result when the argument is a constant. */
8040 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8043 /* If either argument to hypot has a negate or abs, strip that off.
8044 E.g. hypot(-x,fabs(y)) -> hypot(x,y). */
8045 narg0 = fold_strip_sign_ops (arg0);
8046 narg1 = fold_strip_sign_ops (arg1);
8049 return build_call_expr (fndecl, 2, narg0 ? narg0 : arg0,
8050 narg1 ? narg1 : arg1);
8053 /* If either argument is zero, hypot is fabs of the other. */
8054 if (real_zerop (arg0))
8055 return fold_build1 (ABS_EXPR, type, arg1);
8056 else if (real_zerop (arg1))
8057 return fold_build1 (ABS_EXPR, type, arg0);
8059 /* hypot(x,x) -> fabs(x)*sqrt(2). */
8060 if (flag_unsafe_math_optimizations
8061 && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8063 const REAL_VALUE_TYPE sqrt2_trunc
8064 = real_value_truncate (TYPE_MODE (type), dconstsqrt2);
8065 return fold_build2 (MULT_EXPR, type,
8066 fold_build1 (ABS_EXPR, type, arg0),
8067 build_real (type, sqrt2_trunc));
8074 /* Fold a builtin function call to pow, powf, or powl. Return
8075 NULL_TREE if no simplification can be made. */
8077 fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
8081 if (!validate_arg (arg0, REAL_TYPE)
8082 || !validate_arg (arg1, REAL_TYPE))
8085 /* Calculate the result when the argument is a constant. */
8086 if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8089 /* Optimize pow(1.0,y) = 1.0. */
8090 if (real_onep (arg0))
8091 return omit_one_operand (type, build_real (type, dconst1), arg1);
8093 if (TREE_CODE (arg1) == REAL_CST
8094 && !TREE_OVERFLOW (arg1))
8096 REAL_VALUE_TYPE cint;
8100 c = TREE_REAL_CST (arg1);
8102 /* Optimize pow(x,0.0) = 1.0. */
8103 if (REAL_VALUES_EQUAL (c, dconst0))
8104 return omit_one_operand (type, build_real (type, dconst1),
8107 /* Optimize pow(x,1.0) = x. */
8108 if (REAL_VALUES_EQUAL (c, dconst1))
8111 /* Optimize pow(x,-1.0) = 1.0/x. */
8112 if (REAL_VALUES_EQUAL (c, dconstm1))
8113 return fold_build2 (RDIV_EXPR, type,
8114 build_real (type, dconst1), arg0);
8116 /* Optimize pow(x,0.5) = sqrt(x). */
8117 if (flag_unsafe_math_optimizations
8118 && REAL_VALUES_EQUAL (c, dconsthalf))
8120 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8122 if (sqrtfn != NULL_TREE)
8123 return build_call_expr (sqrtfn, 1, arg0);
8126 /* Optimize pow(x,1.0/3.0) = cbrt(x). */
8127 if (flag_unsafe_math_optimizations)
8129 const REAL_VALUE_TYPE dconstroot
8130 = real_value_truncate (TYPE_MODE (type), dconstthird);
8132 if (REAL_VALUES_EQUAL (c, dconstroot))
8134 tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8135 if (cbrtfn != NULL_TREE)
8136 return build_call_expr (cbrtfn, 1, arg0);
8140 /* Check for an integer exponent. */
8141 n = real_to_integer (&c);
8142 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8143 if (real_identical (&c, &cint))
8145 /* Attempt to evaluate pow at compile-time. */
8146 if (TREE_CODE (arg0) == REAL_CST
8147 && !TREE_OVERFLOW (arg0))
8152 x = TREE_REAL_CST (arg0);
8153 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8154 if (flag_unsafe_math_optimizations || !inexact)
8155 return build_real (type, x);
8158 /* Strip sign ops from even integer powers. */
8159 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8161 tree narg0 = fold_strip_sign_ops (arg0);
8163 return build_call_expr (fndecl, 2, narg0, arg1);
8168 if (flag_unsafe_math_optimizations)
8170 const enum built_in_function fcode = builtin_mathfn_code (arg0);
8172 /* Optimize pow(expN(x),y) = expN(x*y). */
8173 if (BUILTIN_EXPONENT_P (fcode))
8175 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8176 tree arg = CALL_EXPR_ARG (arg0, 0);
8177 arg = fold_build2 (MULT_EXPR, type, arg, arg1);
8178 return build_call_expr (expfn, 1, arg);
8181 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
8182 if (BUILTIN_SQRT_P (fcode))
8184 tree narg0 = CALL_EXPR_ARG (arg0, 0);
8185 tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
8186 build_real (type, dconsthalf));
8187 return build_call_expr (fndecl, 2, narg0, narg1);
8190 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
8191 if (BUILTIN_CBRT_P (fcode))
8193 tree arg = CALL_EXPR_ARG (arg0, 0);
8194 if (tree_expr_nonnegative_p (arg))
8196 const REAL_VALUE_TYPE dconstroot
8197 = real_value_truncate (TYPE_MODE (type), dconstthird);
8198 tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
8199 build_real (type, dconstroot));
8200 return build_call_expr (fndecl, 2, arg, narg1);
8204 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
8205 if (fcode == BUILT_IN_POW
8206 || fcode == BUILT_IN_POWF
8207 || fcode == BUILT_IN_POWL)
8209 tree arg00 = CALL_EXPR_ARG (arg0, 0);
8210 tree arg01 = CALL_EXPR_ARG (arg0, 1);
8211 tree narg1 = fold_build2 (MULT_EXPR, type, arg01, arg1);
8212 return build_call_expr (fndecl, 2, arg00, narg1);
8219 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8220 Return NULL_TREE if no simplification can be made. */
8222 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
8223 tree arg0, tree arg1, tree type)
8225 if (!validate_arg (arg0, REAL_TYPE)
8226 || !validate_arg (arg1, INTEGER_TYPE))
8229 /* Optimize pow(1.0,y) = 1.0. */
8230 if (real_onep (arg0))
8231 return omit_one_operand (type, build_real (type, dconst1), arg1);
8233 if (host_integerp (arg1, 0))
8235 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8237 /* Evaluate powi at compile-time. */
8238 if (TREE_CODE (arg0) == REAL_CST
8239 && !TREE_OVERFLOW (arg0))
8242 x = TREE_REAL_CST (arg0);
8243 real_powi (&x, TYPE_MODE (type), &x, c);
8244 return build_real (type, x);
8247 /* Optimize pow(x,0) = 1.0. */
8249 return omit_one_operand (type, build_real (type, dconst1),
8252 /* Optimize pow(x,1) = x. */
8256 /* Optimize pow(x,-1) = 1.0/x. */
8258 return fold_build2 (RDIV_EXPR, type,
8259 build_real (type, dconst1), arg0);
8265 /* A subroutine of fold_builtin to fold the various exponent
8266 functions. Return NULL_TREE if no simplification can be made.
8267 FUNC is the corresponding MPFR exponent function. */
8270 fold_builtin_exponent (tree fndecl, tree arg,
8271 int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8273 if (validate_arg (arg, REAL_TYPE))
8275 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8278 /* Calculate the result when the argument is a constant. */
8279 if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8282 /* Optimize expN(logN(x)) = x. */
8283 if (flag_unsafe_math_optimizations)
8285 const enum built_in_function fcode = builtin_mathfn_code (arg);
8287 if ((func == mpfr_exp
8288 && (fcode == BUILT_IN_LOG
8289 || fcode == BUILT_IN_LOGF
8290 || fcode == BUILT_IN_LOGL))
8291 || (func == mpfr_exp2
8292 && (fcode == BUILT_IN_LOG2
8293 || fcode == BUILT_IN_LOG2F
8294 || fcode == BUILT_IN_LOG2L))
8295 || (func == mpfr_exp10
8296 && (fcode == BUILT_IN_LOG10
8297 || fcode == BUILT_IN_LOG10F
8298 || fcode == BUILT_IN_LOG10L)))
8299 return fold_convert (type, CALL_EXPR_ARG (arg, 0));
8306 /* Return true if VAR is a VAR_DECL or a component thereof. */
8309 var_decl_component_p (tree var)
8312 while (handled_component_p (inner))
8313 inner = TREE_OPERAND (inner, 0);
8314 return SSA_VAR_P (inner);
8317 /* Fold function call to builtin memset. Return
8318 NULL_TREE if no simplification can be made. */
8321 fold_builtin_memset (tree dest, tree c, tree len, tree type, bool ignore)
8324 unsigned HOST_WIDE_INT length, cval;
8326 if (! validate_arg (dest, POINTER_TYPE)
8327 || ! validate_arg (c, INTEGER_TYPE)
8328 || ! validate_arg (len, INTEGER_TYPE))
8331 if (! host_integerp (len, 1))
8334 /* If the LEN parameter is zero, return DEST. */
8335 if (integer_zerop (len))
8336 return omit_one_operand (type, dest, c);
8338 if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8343 if (TREE_CODE (var) != ADDR_EXPR)
8346 var = TREE_OPERAND (var, 0);
8347 if (TREE_THIS_VOLATILE (var))
8350 if (!INTEGRAL_TYPE_P (TREE_TYPE (var))
8351 && !POINTER_TYPE_P (TREE_TYPE (var)))
8354 if (! var_decl_component_p (var))
8357 length = tree_low_cst (len, 1);
8358 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (var))) != length
8359 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8363 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8366 if (integer_zerop (c))
8370 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8373 cval = tree_low_cst (c, 1);
8377 cval |= (cval << 31) << 1;
8380 ret = build_int_cst_type (TREE_TYPE (var), cval);
8381 ret = build2 (MODIFY_EXPR, TREE_TYPE (var), var, ret);
8385 return omit_one_operand (type, dest, ret);
8388 /* Fold function call to builtin memset. Return
8389 NULL_TREE if no simplification can be made. */
8392 fold_builtin_bzero (tree dest, tree size, bool ignore)
8394 if (! validate_arg (dest, POINTER_TYPE)
8395 || ! validate_arg (size, INTEGER_TYPE))
8401 /* New argument list transforming bzero(ptr x, int y) to
8402 memset(ptr x, int 0, size_t y). This is done this way
8403 so that if it isn't expanded inline, we fallback to
8404 calling bzero instead of memset. */
8406 return fold_builtin_memset (dest, integer_zero_node,
8407 fold_convert (sizetype, size),
8408 void_type_node, ignore);
8411 /* Fold function call to builtin mem{{,p}cpy,move}. Return
8412 NULL_TREE if no simplification can be made.
8413 If ENDP is 0, return DEST (like memcpy).
8414 If ENDP is 1, return DEST+LEN (like mempcpy).
8415 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8416 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8420 fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, int endp)
8422 tree destvar, srcvar, expr;
8424 if (! validate_arg (dest, POINTER_TYPE)
8425 || ! validate_arg (src, POINTER_TYPE)
8426 || ! validate_arg (len, INTEGER_TYPE))
8429 /* If the LEN parameter is zero, return DEST. */
8430 if (integer_zerop (len))
8431 return omit_one_operand (type, dest, src);
8433 /* If SRC and DEST are the same (and not volatile), return
8434 DEST{,+LEN,+LEN-1}. */
8435 if (operand_equal_p (src, dest, 0))
8439 tree srctype, desttype;
8442 int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8443 int dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8445 /* Both DEST and SRC must be pointer types.
8446 ??? This is what old code did. Is the testing for pointer types
8449 If either SRC is readonly or length is 1, we can use memcpy. */
8450 if (dest_align && src_align
8451 && (readonly_data_expr (src)
8452 || (host_integerp (len, 1)
8453 && (MIN (src_align, dest_align) / BITS_PER_UNIT >=
8454 tree_low_cst (len, 1)))))
8456 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8459 return build_call_expr (fn, 3, dest, src, len);
8464 if (!host_integerp (len, 0))
8467 This logic lose for arguments like (type *)malloc (sizeof (type)),
8468 since we strip the casts of up to VOID return value from malloc.
8469 Perhaps we ought to inherit type from non-VOID argument here? */
8472 srctype = TREE_TYPE (TREE_TYPE (src));
8473 desttype = TREE_TYPE (TREE_TYPE (dest));
8474 if (!srctype || !desttype
8475 || !TYPE_SIZE_UNIT (srctype)
8476 || !TYPE_SIZE_UNIT (desttype)
8477 || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8478 || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST
8479 || !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)
8480 || !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8483 if (get_pointer_alignment (dest, BIGGEST_ALIGNMENT)
8484 < (int) TYPE_ALIGN (desttype)
8485 || (get_pointer_alignment (src, BIGGEST_ALIGNMENT)
8486 < (int) TYPE_ALIGN (srctype)))
8490 dest = builtin_save_expr (dest);
8492 srcvar = build_fold_indirect_ref (src);
8493 if (TREE_THIS_VOLATILE (srcvar))
8495 if (!tree_int_cst_equal (lang_hooks.expr_size (srcvar), len))
8497 /* With memcpy, it is possible to bypass aliasing rules, so without
8498 this check i. e. execute/20060930-2.c would be misoptimized, because
8499 it use conflicting alias set to hold argument for the memcpy call.
8500 This check is probably unnecesary with -fno-strict-aliasing.
8501 Similarly for destvar. See also PR29286. */
8502 if (!var_decl_component_p (srcvar)
8503 /* Accept: memcpy (*char_var, "test", 1); that simplify
8505 || is_gimple_min_invariant (srcvar)
8506 || readonly_data_expr (src))
8509 destvar = build_fold_indirect_ref (dest);
8510 if (TREE_THIS_VOLATILE (destvar))
8512 if (!tree_int_cst_equal (lang_hooks.expr_size (destvar), len))
8514 if (!var_decl_component_p (destvar))
8517 if (srctype == desttype
8518 || (gimple_in_ssa_p (cfun)
8519 && tree_ssa_useless_type_conversion_1 (desttype, srctype)))
8521 else if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
8522 || POINTER_TYPE_P (TREE_TYPE (srcvar)))
8523 && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
8524 || POINTER_TYPE_P (TREE_TYPE (destvar))))
8525 expr = fold_convert (TREE_TYPE (destvar), srcvar);
8527 expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
8528 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
8534 if (endp == 0 || endp == 3)
8535 return omit_one_operand (type, dest, expr);
8541 len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
8544 len = fold_convert (TREE_TYPE (dest), len);
8545 dest = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
8546 dest = fold_convert (type, dest);
8548 dest = omit_one_operand (type, dest, expr);
8552 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8553 If LEN is not NULL, it represents the length of the string to be
8554 copied. Return NULL_TREE if no simplification can be made. */
8557 fold_builtin_strcpy (tree fndecl, tree dest, tree src, tree len)
8561 if (!validate_arg (dest, POINTER_TYPE)
8562 || !validate_arg (src, POINTER_TYPE))
8565 /* If SRC and DEST are the same (and not volatile), return DEST. */
8566 if (operand_equal_p (src, dest, 0))
8567 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
8572 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8578 len = c_strlen (src, 1);
8579 if (! len || TREE_SIDE_EFFECTS (len))
8583 len = size_binop (PLUS_EXPR, len, ssize_int (1));
8584 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
8585 build_call_expr (fn, 3, dest, src, len));
8588 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8589 If SLEN is not NULL, it represents the length of the source string.
8590 Return NULL_TREE if no simplification can be made. */
8593 fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
8597 if (!validate_arg (dest, POINTER_TYPE)
8598 || !validate_arg (src, POINTER_TYPE)
8599 || !validate_arg (len, INTEGER_TYPE))
8602 /* If the LEN parameter is zero, return DEST. */
8603 if (integer_zerop (len))
8604 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8606 /* We can't compare slen with len as constants below if len is not a
8608 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8612 slen = c_strlen (src, 1);
8614 /* Now, we must be passed a constant src ptr parameter. */
8615 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8618 slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
8620 /* We do not support simplification of this case, though we do
8621 support it when expanding trees into RTL. */
8622 /* FIXME: generate a call to __builtin_memset. */
8623 if (tree_int_cst_lt (slen, len))
8626 /* OK transform into builtin memcpy. */
8627 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8630 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
8631 build_call_expr (fn, 3, dest, src, len));
8634 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8635 Return NULL_TREE if no simplification can be made. */
8638 fold_builtin_memcmp (tree arg1, tree arg2, tree len)
8640 const char *p1, *p2;
8642 if (!validate_arg (arg1, POINTER_TYPE)
8643 || !validate_arg (arg2, POINTER_TYPE)
8644 || !validate_arg (len, INTEGER_TYPE))
8647 /* If the LEN parameter is zero, return zero. */
8648 if (integer_zerop (len))
8649 return omit_two_operands (integer_type_node, integer_zero_node,
8652 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8653 if (operand_equal_p (arg1, arg2, 0))
8654 return omit_one_operand (integer_type_node, integer_zero_node, len);
8656 p1 = c_getstr (arg1);
8657 p2 = c_getstr (arg2);
8659 /* If all arguments are constant, and the value of len is not greater
8660 than the lengths of arg1 and arg2, evaluate at compile-time. */
8661 if (host_integerp (len, 1) && p1 && p2
8662 && compare_tree_int (len, strlen (p1) + 1) <= 0
8663 && compare_tree_int (len, strlen (p2) + 1) <= 0)
8665 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8668 return integer_one_node;
8670 return integer_minus_one_node;
8672 return integer_zero_node;
8675 /* If len parameter is one, return an expression corresponding to
8676 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8677 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8679 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8680 tree cst_uchar_ptr_node
8681 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8683 tree ind1 = fold_convert (integer_type_node,
8684 build1 (INDIRECT_REF, cst_uchar_node,
8685 fold_convert (cst_uchar_ptr_node,
8687 tree ind2 = fold_convert (integer_type_node,
8688 build1 (INDIRECT_REF, cst_uchar_node,
8689 fold_convert (cst_uchar_ptr_node,
8691 return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
8697 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8698 Return NULL_TREE if no simplification can be made. */
8701 fold_builtin_strcmp (tree arg1, tree arg2)
8703 const char *p1, *p2;
8705 if (!validate_arg (arg1, POINTER_TYPE)
8706 || !validate_arg (arg2, POINTER_TYPE))
8709 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8710 if (operand_equal_p (arg1, arg2, 0))
8711 return integer_zero_node;
8713 p1 = c_getstr (arg1);
8714 p2 = c_getstr (arg2);
8718 const int i = strcmp (p1, p2);
8720 return integer_minus_one_node;
8722 return integer_one_node;
8724 return integer_zero_node;
8727 /* If the second arg is "", return *(const unsigned char*)arg1. */
8728 if (p2 && *p2 == '\0')
8730 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8731 tree cst_uchar_ptr_node
8732 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8734 return fold_convert (integer_type_node,
8735 build1 (INDIRECT_REF, cst_uchar_node,
8736 fold_convert (cst_uchar_ptr_node,
8740 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8741 if (p1 && *p1 == '\0')
8743 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8744 tree cst_uchar_ptr_node
8745 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8747 tree temp = fold_convert (integer_type_node,
8748 build1 (INDIRECT_REF, cst_uchar_node,
8749 fold_convert (cst_uchar_ptr_node,
8751 return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
8757 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8758 Return NULL_TREE if no simplification can be made. */
8761 fold_builtin_strncmp (tree arg1, tree arg2, tree len)
8763 const char *p1, *p2;
8765 if (!validate_arg (arg1, POINTER_TYPE)
8766 || !validate_arg (arg2, POINTER_TYPE)
8767 || !validate_arg (len, INTEGER_TYPE))
8770 /* If the LEN parameter is zero, return zero. */
8771 if (integer_zerop (len))
8772 return omit_two_operands (integer_type_node, integer_zero_node,
8775 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8776 if (operand_equal_p (arg1, arg2, 0))
8777 return omit_one_operand (integer_type_node, integer_zero_node, len);
8779 p1 = c_getstr (arg1);
8780 p2 = c_getstr (arg2);
8782 if (host_integerp (len, 1) && p1 && p2)
8784 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8786 return integer_one_node;
8788 return integer_minus_one_node;
8790 return integer_zero_node;
8793 /* If the second arg is "", and the length is greater than zero,
8794 return *(const unsigned char*)arg1. */
8795 if (p2 && *p2 == '\0'
8796 && TREE_CODE (len) == INTEGER_CST
8797 && tree_int_cst_sgn (len) == 1)
8799 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8800 tree cst_uchar_ptr_node
8801 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8803 return fold_convert (integer_type_node,
8804 build1 (INDIRECT_REF, cst_uchar_node,
8805 fold_convert (cst_uchar_ptr_node,
8809 /* If the first arg is "", and the length is greater than zero,
8810 return -*(const unsigned char*)arg2. */
8811 if (p1 && *p1 == '\0'
8812 && TREE_CODE (len) == INTEGER_CST
8813 && tree_int_cst_sgn (len) == 1)
8815 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8816 tree cst_uchar_ptr_node
8817 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8819 tree temp = fold_convert (integer_type_node,
8820 build1 (INDIRECT_REF, cst_uchar_node,
8821 fold_convert (cst_uchar_ptr_node,
8823 return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
8826 /* If len parameter is one, return an expression corresponding to
8827 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8828 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8830 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8831 tree cst_uchar_ptr_node
8832 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8834 tree ind1 = fold_convert (integer_type_node,
8835 build1 (INDIRECT_REF, cst_uchar_node,
8836 fold_convert (cst_uchar_ptr_node,
8838 tree ind2 = fold_convert (integer_type_node,
8839 build1 (INDIRECT_REF, cst_uchar_node,
8840 fold_convert (cst_uchar_ptr_node,
8842 return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
8848 /* Fold function call to builtin signbit, signbitf or signbitl with argument
8849 ARG. Return NULL_TREE if no simplification can be made. */
8852 fold_builtin_signbit (tree arg, tree type)
8856 if (!validate_arg (arg, REAL_TYPE))
8859 /* If ARG is a compile-time constant, determine the result. */
8860 if (TREE_CODE (arg) == REAL_CST
8861 && !TREE_OVERFLOW (arg))
8865 c = TREE_REAL_CST (arg);
8866 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
8867 return fold_convert (type, temp);
8870 /* If ARG is non-negative, the result is always zero. */
8871 if (tree_expr_nonnegative_p (arg))
8872 return omit_one_operand (type, integer_zero_node, arg);
8874 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
8875 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
8876 return fold_build2 (LT_EXPR, type, arg,
8877 build_real (TREE_TYPE (arg), dconst0));
8882 /* Fold function call to builtin copysign, copysignf or copysignl with
8883 arguments ARG1 and ARG2. Return NULL_TREE if no simplification can
8887 fold_builtin_copysign (tree fndecl, tree arg1, tree arg2, tree type)
8891 if (!validate_arg (arg1, REAL_TYPE)
8892 || !validate_arg (arg2, REAL_TYPE))
8895 /* copysign(X,X) is X. */
8896 if (operand_equal_p (arg1, arg2, 0))
8897 return fold_convert (type, arg1);
8899 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
8900 if (TREE_CODE (arg1) == REAL_CST
8901 && TREE_CODE (arg2) == REAL_CST
8902 && !TREE_OVERFLOW (arg1)
8903 && !TREE_OVERFLOW (arg2))
8905 REAL_VALUE_TYPE c1, c2;
8907 c1 = TREE_REAL_CST (arg1);
8908 c2 = TREE_REAL_CST (arg2);
8909 /* c1.sign := c2.sign. */
8910 real_copysign (&c1, &c2);
8911 return build_real (type, c1);
8914 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
8915 Remember to evaluate Y for side-effects. */
8916 if (tree_expr_nonnegative_p (arg2))
8917 return omit_one_operand (type,
8918 fold_build1 (ABS_EXPR, type, arg1),
8921 /* Strip sign changing operations for the first argument. */
8922 tem = fold_strip_sign_ops (arg1);
8924 return build_call_expr (fndecl, 2, tem, arg2);
8929 /* Fold a call to builtin isascii with argument ARG. */
8932 fold_builtin_isascii (tree arg)
8934 if (!validate_arg (arg, INTEGER_TYPE))
8938 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
8939 arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
8940 build_int_cst (NULL_TREE,
8941 ~ (unsigned HOST_WIDE_INT) 0x7f));
8942 return fold_build2 (EQ_EXPR, integer_type_node,
8943 arg, integer_zero_node);
8947 /* Fold a call to builtin toascii with argument ARG. */
8950 fold_builtin_toascii (tree arg)
8952 if (!validate_arg (arg, INTEGER_TYPE))
8955 /* Transform toascii(c) -> (c & 0x7f). */
8956 return fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
8957 build_int_cst (NULL_TREE, 0x7f));
8960 /* Fold a call to builtin isdigit with argument ARG. */
8963 fold_builtin_isdigit (tree arg)
8965 if (!validate_arg (arg, INTEGER_TYPE))
8969 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
8970 /* According to the C standard, isdigit is unaffected by locale.
8971 However, it definitely is affected by the target character set. */
8972 unsigned HOST_WIDE_INT target_digit0
8973 = lang_hooks.to_target_charset ('0');
8975 if (target_digit0 == 0)
8978 arg = fold_convert (unsigned_type_node, arg);
8979 arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
8980 build_int_cst (unsigned_type_node, target_digit0));
8981 return fold_build2 (LE_EXPR, integer_type_node, arg,
8982 build_int_cst (unsigned_type_node, 9));
8986 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
8989 fold_builtin_fabs (tree arg, tree type)
8991 if (!validate_arg (arg, REAL_TYPE))
8994 arg = fold_convert (type, arg);
8995 if (TREE_CODE (arg) == REAL_CST)
8996 return fold_abs_const (arg, type);
8997 return fold_build1 (ABS_EXPR, type, arg);
9000 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
9003 fold_builtin_abs (tree arg, tree type)
9005 if (!validate_arg (arg, INTEGER_TYPE))
9008 arg = fold_convert (type, arg);
9009 if (TREE_CODE (arg) == INTEGER_CST)
9010 return fold_abs_const (arg, type);
9011 return fold_build1 (ABS_EXPR, type, arg);
9014 /* Fold a call to builtin fmin or fmax. */
9017 fold_builtin_fmin_fmax (tree arg0, tree arg1, tree type, bool max)
9019 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9021 /* Calculate the result when the argument is a constant. */
9022 tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9027 /* If either argument is NaN, return the other one. Avoid the
9028 transformation if we get (and honor) a signalling NaN. Using
9029 omit_one_operand() ensures we create a non-lvalue. */
9030 if (TREE_CODE (arg0) == REAL_CST
9031 && real_isnan (&TREE_REAL_CST (arg0))
9032 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9033 || ! TREE_REAL_CST (arg0).signalling))
9034 return omit_one_operand (type, arg1, arg0);
9035 if (TREE_CODE (arg1) == REAL_CST
9036 && real_isnan (&TREE_REAL_CST (arg1))
9037 && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9038 || ! TREE_REAL_CST (arg1).signalling))
9039 return omit_one_operand (type, arg0, arg1);
9041 /* Transform fmin/fmax(x,x) -> x. */
9042 if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9043 return omit_one_operand (type, arg0, arg1);
9045 /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR. C99 requires these
9046 functions to return the numeric arg if the other one is NaN.
9047 These tree codes don't honor that, so only transform if
9048 -ffinite-math-only is set. C99 doesn't require -0.0 to be
9049 handled, so we don't have to worry about it either. */
9050 if (flag_finite_math_only)
9051 return fold_build2 ((max ? MAX_EXPR : MIN_EXPR), type,
9052 fold_convert (type, arg0),
9053 fold_convert (type, arg1));
9058 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
9061 fold_builtin_carg (tree arg, tree type)
9063 if (validate_arg (arg, COMPLEX_TYPE))
9065 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9069 tree new_arg = builtin_save_expr (arg);
9070 tree r_arg = fold_build1 (REALPART_EXPR, type, new_arg);
9071 tree i_arg = fold_build1 (IMAGPART_EXPR, type, new_arg);
9072 return build_call_expr (atan2_fn, 2, i_arg, r_arg);
9079 /* Fold a call to builtin logb/ilogb. */
9082 fold_builtin_logb (tree arg, tree rettype)
9084 if (! validate_arg (arg, REAL_TYPE))
9089 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9091 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9097 /* If arg is Inf or NaN and we're logb, return it. */
9098 if (TREE_CODE (rettype) == REAL_TYPE)
9099 return fold_convert (rettype, arg);
9100 /* Fall through... */
9102 /* Zero may set errno and/or raise an exception for logb, also
9103 for ilogb we don't know FP_ILOGB0. */
9106 /* For normal numbers, proceed iff radix == 2. In GCC,
9107 normalized significands are in the range [0.5, 1.0). We
9108 want the exponent as if they were [1.0, 2.0) so get the
9109 exponent and subtract 1. */
9110 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9111 return fold_convert (rettype, build_int_cst (NULL_TREE,
9112 REAL_EXP (value)-1));
9120 /* Fold a call to builtin significand, if radix == 2. */
9123 fold_builtin_significand (tree arg, tree rettype)
9125 if (! validate_arg (arg, REAL_TYPE))
9130 if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9132 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9139 /* If arg is +-0, +-Inf or +-NaN, then return it. */
9140 return fold_convert (rettype, arg);
9142 /* For normal numbers, proceed iff radix == 2. */
9143 if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9145 REAL_VALUE_TYPE result = *value;
9146 /* In GCC, normalized significands are in the range [0.5,
9147 1.0). We want them to be [1.0, 2.0) so set the
9149 SET_REAL_EXP (&result, 1);
9150 return build_real (rettype, result);
9159 /* Fold a call to builtin frexp, we can assume the base is 2. */
9162 fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
9164 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9169 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9172 arg1 = build_fold_indirect_ref (arg1);
9174 /* Proceed if a valid pointer type was passed in. */
9175 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9177 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9183 /* For +-0, return (*exp = 0, +-0). */
9184 exp = integer_zero_node;
9189 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
9190 return omit_one_operand (rettype, arg0, arg1);
9193 /* Since the frexp function always expects base 2, and in
9194 GCC normalized significands are already in the range
9195 [0.5, 1.0), we have exactly what frexp wants. */
9196 REAL_VALUE_TYPE frac_rvt = *value;
9197 SET_REAL_EXP (&frac_rvt, 0);
9198 frac = build_real (rettype, frac_rvt);
9199 exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9206 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9207 arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1, exp);
9208 TREE_SIDE_EFFECTS (arg1) = 1;
9209 return fold_build2 (COMPOUND_EXPR, rettype, arg1, frac);
9215 /* Fold a call to builtin ldexp or scalbn/scalbln. If LDEXP is true
9216 then we can assume the base is two. If it's false, then we have to
9217 check the mode of the TYPE parameter in certain cases. */
9220 fold_builtin_load_exponent (tree arg0, tree arg1, tree type, bool ldexp)
9222 if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9227 /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0. */
9228 if (real_zerop (arg0) || integer_zerop (arg1)
9229 || (TREE_CODE (arg0) == REAL_CST
9230 && (real_isnan (&TREE_REAL_CST (arg0))
9231 || real_isinf (&TREE_REAL_CST (arg0)))))
9232 return omit_one_operand (type, arg0, arg1);
9234 /* If both arguments are constant, then try to evaluate it. */
9235 if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9236 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9237 && host_integerp (arg1, 0))
9239 /* Bound the maximum adjustment to twice the range of the
9240 mode's valid exponents. Use abs to ensure the range is
9241 positive as a sanity check. */
9242 const long max_exp_adj = 2 *
9243 labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9244 - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9246 /* Get the user-requested adjustment. */
9247 const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9249 /* The requested adjustment must be inside this range. This
9250 is a preliminary cap to avoid things like overflow, we
9251 may still fail to compute the result for other reasons. */
9252 if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9254 REAL_VALUE_TYPE initial_result;
9256 real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9258 /* Ensure we didn't overflow. */
9259 if (! real_isinf (&initial_result))
9261 const REAL_VALUE_TYPE trunc_result
9262 = real_value_truncate (TYPE_MODE (type), initial_result);
9264 /* Only proceed if the target mode can hold the
9266 if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9267 return build_real (type, trunc_result);
9276 /* Fold a call to builtin modf. */
9279 fold_builtin_modf (tree arg0, tree arg1, tree rettype)
9281 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9286 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9289 arg1 = build_fold_indirect_ref (arg1);
9291 /* Proceed if a valid pointer type was passed in. */
9292 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9294 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9295 REAL_VALUE_TYPE trunc, frac;
9301 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
9302 trunc = frac = *value;
9305 /* For +-Inf, return (*arg1 = arg0, +-0). */
9307 frac.sign = value->sign;
9311 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
9312 real_trunc (&trunc, VOIDmode, value);
9313 real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9314 /* If the original number was negative and already
9315 integral, then the fractional part is -0.0. */
9316 if (value->sign && frac.cl == rvc_zero)
9317 frac.sign = value->sign;
9321 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9322 arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1,
9323 build_real (rettype, trunc));
9324 TREE_SIDE_EFFECTS (arg1) = 1;
9325 return fold_build2 (COMPOUND_EXPR, rettype, arg1,
9326 build_real (rettype, frac));
9332 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9333 ARG is the argument for the call. */
9336 fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
9338 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9341 if (!validate_arg (arg, REAL_TYPE))
9343 error ("non-floating-point argument to function %qs",
9344 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
9345 return error_mark_node;
9348 switch (builtin_index)
9350 case BUILT_IN_ISINF:
9351 if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9352 return omit_one_operand (type, integer_zero_node, arg);
9354 if (TREE_CODE (arg) == REAL_CST)
9356 r = TREE_REAL_CST (arg);
9357 if (real_isinf (&r))
9358 return real_compare (GT_EXPR, &r, &dconst0)
9359 ? integer_one_node : integer_minus_one_node;
9361 return integer_zero_node;
9366 case BUILT_IN_FINITE:
9367 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9368 && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9369 return omit_one_operand (type, integer_one_node, arg);
9371 if (TREE_CODE (arg) == REAL_CST)
9373 r = TREE_REAL_CST (arg);
9374 return real_isinf (&r) || real_isnan (&r)
9375 ? integer_zero_node : integer_one_node;
9380 case BUILT_IN_ISNAN:
9381 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9382 return omit_one_operand (type, integer_zero_node, arg);
9384 if (TREE_CODE (arg) == REAL_CST)
9386 r = TREE_REAL_CST (arg);
9387 return real_isnan (&r) ? integer_one_node : integer_zero_node;
9390 arg = builtin_save_expr (arg);
9391 return fold_build2 (UNORDERED_EXPR, type, arg, arg);
9398 /* Fold a call to an unordered comparison function such as
9399 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9400 being called and ARG0 and ARG1 are the arguments for the call.
9401 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9402 the opposite of the desired result. UNORDERED_CODE is used
9403 for modes that can hold NaNs and ORDERED_CODE is used for
9407 fold_builtin_unordered_cmp (tree fndecl, tree arg0, tree arg1,
9408 enum tree_code unordered_code,
9409 enum tree_code ordered_code)
9411 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9412 enum tree_code code;
9414 enum tree_code code0, code1;
9415 tree cmp_type = NULL_TREE;
9417 type0 = TREE_TYPE (arg0);
9418 type1 = TREE_TYPE (arg1);
9420 code0 = TREE_CODE (type0);
9421 code1 = TREE_CODE (type1);
9423 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9424 /* Choose the wider of two real types. */
9425 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9427 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9429 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9433 error ("non-floating-point argument to function %qs",
9434 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
9435 return error_mark_node;
9438 arg0 = fold_convert (cmp_type, arg0);
9439 arg1 = fold_convert (cmp_type, arg1);
9441 if (unordered_code == UNORDERED_EXPR)
9443 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9444 return omit_two_operands (type, integer_zero_node, arg0, arg1);
9445 return fold_build2 (UNORDERED_EXPR, type, arg0, arg1);
9448 code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9450 return fold_build1 (TRUTH_NOT_EXPR, type,
9451 fold_build2 (code, type, arg0, arg1));
9454 /* Fold a call to built-in function FNDECL with 0 arguments.
9455 IGNORE is true if the result of the function call is ignored. This
9456 function returns NULL_TREE if no simplification was possible. */
9459 fold_builtin_0 (tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9461 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9462 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9465 CASE_FLT_FN (BUILT_IN_INF):
9466 case BUILT_IN_INFD32:
9467 case BUILT_IN_INFD64:
9468 case BUILT_IN_INFD128:
9469 return fold_builtin_inf (type, true);
9471 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9472 return fold_builtin_inf (type, false);
9474 case BUILT_IN_CLASSIFY_TYPE:
9475 return fold_builtin_classify_type (NULL_TREE);
9483 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9484 IGNORE is true if the result of the function call is ignored. This
9485 function returns NULL_TREE if no simplification was possible. */
9488 fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
9490 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9491 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9495 case BUILT_IN_CONSTANT_P:
9497 tree val = fold_builtin_constant_p (arg0);
9499 /* Gimplification will pull the CALL_EXPR for the builtin out of
9500 an if condition. When not optimizing, we'll not CSE it back.
9501 To avoid link error types of regressions, return false now. */
9502 if (!val && !optimize)
9503 val = integer_zero_node;
9508 case BUILT_IN_CLASSIFY_TYPE:
9509 return fold_builtin_classify_type (arg0);
9511 case BUILT_IN_STRLEN:
9512 return fold_builtin_strlen (arg0);
9514 CASE_FLT_FN (BUILT_IN_FABS):
9515 return fold_builtin_fabs (arg0, type);
9519 case BUILT_IN_LLABS:
9520 case BUILT_IN_IMAXABS:
9521 return fold_builtin_abs (arg0, type);
9523 CASE_FLT_FN (BUILT_IN_CONJ):
9524 if (validate_arg (arg0, COMPLEX_TYPE))
9525 return fold_build1 (CONJ_EXPR, type, arg0);
9528 CASE_FLT_FN (BUILT_IN_CREAL):
9529 if (validate_arg (arg0, COMPLEX_TYPE))
9530 return non_lvalue (fold_build1 (REALPART_EXPR, type, arg0));;
9533 CASE_FLT_FN (BUILT_IN_CIMAG):
9534 if (validate_arg (arg0, COMPLEX_TYPE))
9535 return non_lvalue (fold_build1 (IMAGPART_EXPR, type, arg0));
9538 CASE_FLT_FN (BUILT_IN_CCOS):
9539 CASE_FLT_FN (BUILT_IN_CCOSH):
9540 /* These functions are "even", i.e. f(x) == f(-x). */
9541 if (validate_arg (arg0, COMPLEX_TYPE))
9543 tree narg = fold_strip_sign_ops (arg0);
9545 return build_call_expr (fndecl, 1, narg);
9549 CASE_FLT_FN (BUILT_IN_CABS):
9550 return fold_builtin_cabs (arg0, type, fndecl);
9552 CASE_FLT_FN (BUILT_IN_CARG):
9553 return fold_builtin_carg (arg0, type);
9555 CASE_FLT_FN (BUILT_IN_SQRT):
9556 return fold_builtin_sqrt (arg0, type);
9558 CASE_FLT_FN (BUILT_IN_CBRT):
9559 return fold_builtin_cbrt (arg0, type);
9561 CASE_FLT_FN (BUILT_IN_ASIN):
9562 if (validate_arg (arg0, REAL_TYPE))
9563 return do_mpfr_arg1 (arg0, type, mpfr_asin,
9564 &dconstm1, &dconst1, true);
9567 CASE_FLT_FN (BUILT_IN_ACOS):
9568 if (validate_arg (arg0, REAL_TYPE))
9569 return do_mpfr_arg1 (arg0, type, mpfr_acos,
9570 &dconstm1, &dconst1, true);
9573 CASE_FLT_FN (BUILT_IN_ATAN):
9574 if (validate_arg (arg0, REAL_TYPE))
9575 return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
9578 CASE_FLT_FN (BUILT_IN_ASINH):
9579 if (validate_arg (arg0, REAL_TYPE))
9580 return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
9583 CASE_FLT_FN (BUILT_IN_ACOSH):
9584 if (validate_arg (arg0, REAL_TYPE))
9585 return do_mpfr_arg1 (arg0, type, mpfr_acosh,
9586 &dconst1, NULL, true);
9589 CASE_FLT_FN (BUILT_IN_ATANH):
9590 if (validate_arg (arg0, REAL_TYPE))
9591 return do_mpfr_arg1 (arg0, type, mpfr_atanh,
9592 &dconstm1, &dconst1, false);
9595 CASE_FLT_FN (BUILT_IN_SIN):
9596 if (validate_arg (arg0, REAL_TYPE))
9597 return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
9600 CASE_FLT_FN (BUILT_IN_COS):
9601 return fold_builtin_cos (arg0, type, fndecl);
9604 CASE_FLT_FN (BUILT_IN_TAN):
9605 return fold_builtin_tan (arg0, type);
9607 CASE_FLT_FN (BUILT_IN_CEXP):
9608 return fold_builtin_cexp (arg0, type);
9610 CASE_FLT_FN (BUILT_IN_CEXPI):
9611 if (validate_arg (arg0, REAL_TYPE))
9612 return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
9615 CASE_FLT_FN (BUILT_IN_SINH):
9616 if (validate_arg (arg0, REAL_TYPE))
9617 return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
9620 CASE_FLT_FN (BUILT_IN_COSH):
9621 return fold_builtin_cosh (arg0, type, fndecl);
9623 CASE_FLT_FN (BUILT_IN_TANH):
9624 if (validate_arg (arg0, REAL_TYPE))
9625 return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
9628 CASE_FLT_FN (BUILT_IN_ERF):
9629 if (validate_arg (arg0, REAL_TYPE))
9630 return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
9633 CASE_FLT_FN (BUILT_IN_ERFC):
9634 if (validate_arg (arg0, REAL_TYPE))
9635 return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
9638 CASE_FLT_FN (BUILT_IN_TGAMMA):
9639 if (validate_arg (arg0, REAL_TYPE))
9640 return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
9643 CASE_FLT_FN (BUILT_IN_EXP):
9644 return fold_builtin_exponent (fndecl, arg0, mpfr_exp);
9646 CASE_FLT_FN (BUILT_IN_EXP2):
9647 return fold_builtin_exponent (fndecl, arg0, mpfr_exp2);
9649 CASE_FLT_FN (BUILT_IN_EXP10):
9650 CASE_FLT_FN (BUILT_IN_POW10):
9651 return fold_builtin_exponent (fndecl, arg0, mpfr_exp10);
9653 CASE_FLT_FN (BUILT_IN_EXPM1):
9654 if (validate_arg (arg0, REAL_TYPE))
9655 return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
9658 CASE_FLT_FN (BUILT_IN_LOG):
9659 return fold_builtin_logarithm (fndecl, arg0, mpfr_log);
9661 CASE_FLT_FN (BUILT_IN_LOG2):
9662 return fold_builtin_logarithm (fndecl, arg0, mpfr_log2);
9664 CASE_FLT_FN (BUILT_IN_LOG10):
9665 return fold_builtin_logarithm (fndecl, arg0, mpfr_log10);
9667 CASE_FLT_FN (BUILT_IN_LOG1P):
9668 if (validate_arg (arg0, REAL_TYPE))
9669 return do_mpfr_arg1 (arg0, type, mpfr_log1p,
9670 &dconstm1, NULL, false);
9673 CASE_FLT_FN (BUILT_IN_NAN):
9674 case BUILT_IN_NAND32:
9675 case BUILT_IN_NAND64:
9676 case BUILT_IN_NAND128:
9677 return fold_builtin_nan (arg0, type, true);
9679 CASE_FLT_FN (BUILT_IN_NANS):
9680 return fold_builtin_nan (arg0, type, false);
9682 CASE_FLT_FN (BUILT_IN_FLOOR):
9683 return fold_builtin_floor (fndecl, arg0);
9685 CASE_FLT_FN (BUILT_IN_CEIL):
9686 return fold_builtin_ceil (fndecl, arg0);
9688 CASE_FLT_FN (BUILT_IN_TRUNC):
9689 return fold_builtin_trunc (fndecl, arg0);
9691 CASE_FLT_FN (BUILT_IN_ROUND):
9692 return fold_builtin_round (fndecl, arg0);
9694 CASE_FLT_FN (BUILT_IN_NEARBYINT):
9695 CASE_FLT_FN (BUILT_IN_RINT):
9696 return fold_trunc_transparent_mathfn (fndecl, arg0);
9698 CASE_FLT_FN (BUILT_IN_LCEIL):
9699 CASE_FLT_FN (BUILT_IN_LLCEIL):
9700 CASE_FLT_FN (BUILT_IN_LFLOOR):
9701 CASE_FLT_FN (BUILT_IN_LLFLOOR):
9702 CASE_FLT_FN (BUILT_IN_LROUND):
9703 CASE_FLT_FN (BUILT_IN_LLROUND):
9704 return fold_builtin_int_roundingfn (fndecl, arg0);
9706 CASE_FLT_FN (BUILT_IN_LRINT):
9707 CASE_FLT_FN (BUILT_IN_LLRINT):
9708 return fold_fixed_mathfn (fndecl, arg0);
9710 case BUILT_IN_BSWAP32:
9711 case BUILT_IN_BSWAP64:
9712 return fold_builtin_bswap (fndecl, arg0);
9714 CASE_INT_FN (BUILT_IN_FFS):
9715 CASE_INT_FN (BUILT_IN_CLZ):
9716 CASE_INT_FN (BUILT_IN_CTZ):
9717 CASE_INT_FN (BUILT_IN_POPCOUNT):
9718 CASE_INT_FN (BUILT_IN_PARITY):
9719 return fold_builtin_bitop (fndecl, arg0);
9721 CASE_FLT_FN (BUILT_IN_SIGNBIT):
9722 return fold_builtin_signbit (arg0, type);
9724 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
9725 return fold_builtin_significand (arg0, type);
9727 CASE_FLT_FN (BUILT_IN_ILOGB):
9728 CASE_FLT_FN (BUILT_IN_LOGB):
9729 return fold_builtin_logb (arg0, type);
9731 case BUILT_IN_ISASCII:
9732 return fold_builtin_isascii (arg0);
9734 case BUILT_IN_TOASCII:
9735 return fold_builtin_toascii (arg0);
9737 case BUILT_IN_ISDIGIT:
9738 return fold_builtin_isdigit (arg0);
9740 CASE_FLT_FN (BUILT_IN_FINITE):
9741 case BUILT_IN_FINITED32:
9742 case BUILT_IN_FINITED64:
9743 case BUILT_IN_FINITED128:
9744 return fold_builtin_classify (fndecl, arg0, BUILT_IN_FINITE);
9746 CASE_FLT_FN (BUILT_IN_ISINF):
9747 case BUILT_IN_ISINFD32:
9748 case BUILT_IN_ISINFD64:
9749 case BUILT_IN_ISINFD128:
9750 return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISINF);
9752 CASE_FLT_FN (BUILT_IN_ISNAN):
9753 case BUILT_IN_ISNAND32:
9754 case BUILT_IN_ISNAND64:
9755 case BUILT_IN_ISNAND128:
9756 return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISNAN);
9758 case BUILT_IN_PRINTF:
9759 case BUILT_IN_PRINTF_UNLOCKED:
9760 case BUILT_IN_VPRINTF:
9761 return fold_builtin_printf (fndecl, arg0, NULL_TREE, ignore, fcode);
9771 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
9772 IGNORE is true if the result of the function call is ignored. This
9773 function returns NULL_TREE if no simplification was possible. */
9776 fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
9778 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9779 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9784 CASE_FLT_FN (BUILT_IN_ATAN2):
9785 if (validate_arg (arg0, REAL_TYPE)
9786 && validate_arg(arg1, REAL_TYPE))
9787 return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
9790 CASE_FLT_FN (BUILT_IN_FDIM):
9791 if (validate_arg (arg0, REAL_TYPE)
9792 && validate_arg(arg1, REAL_TYPE))
9793 return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
9796 CASE_FLT_FN (BUILT_IN_HYPOT):
9797 return fold_builtin_hypot (fndecl, arg0, arg1, type);
9799 CASE_FLT_FN (BUILT_IN_LDEXP):
9800 return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/true);
9801 CASE_FLT_FN (BUILT_IN_SCALBN):
9802 CASE_FLT_FN (BUILT_IN_SCALBLN):
9803 return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/false);
9805 CASE_FLT_FN (BUILT_IN_FREXP):
9806 return fold_builtin_frexp (arg0, arg1, type);
9808 CASE_FLT_FN (BUILT_IN_MODF):
9809 return fold_builtin_modf (arg0, arg1, type);
9811 case BUILT_IN_BZERO:
9812 return fold_builtin_bzero (arg0, arg1, ignore);
9814 case BUILT_IN_FPUTS:
9815 return fold_builtin_fputs (arg0, arg1, ignore, false, NULL_TREE);
9817 case BUILT_IN_FPUTS_UNLOCKED:
9818 return fold_builtin_fputs (arg0, arg1, ignore, true, NULL_TREE);
9820 case BUILT_IN_STRSTR:
9821 return fold_builtin_strstr (arg0, arg1, type);
9823 case BUILT_IN_STRCAT:
9824 return fold_builtin_strcat (arg0, arg1);
9826 case BUILT_IN_STRSPN:
9827 return fold_builtin_strspn (arg0, arg1);
9829 case BUILT_IN_STRCSPN:
9830 return fold_builtin_strcspn (arg0, arg1);
9832 case BUILT_IN_STRCHR:
9833 case BUILT_IN_INDEX:
9834 return fold_builtin_strchr (arg0, arg1, type);
9836 case BUILT_IN_STRRCHR:
9837 case BUILT_IN_RINDEX:
9838 return fold_builtin_strrchr (arg0, arg1, type);
9840 case BUILT_IN_STRCPY:
9841 return fold_builtin_strcpy (fndecl, arg0, arg1, NULL_TREE);
9843 case BUILT_IN_STRCMP:
9844 return fold_builtin_strcmp (arg0, arg1);
9846 case BUILT_IN_STRPBRK:
9847 return fold_builtin_strpbrk (arg0, arg1, type);
9849 case BUILT_IN_EXPECT:
9850 return fold_builtin_expect (arg0);
9852 CASE_FLT_FN (BUILT_IN_POW):
9853 return fold_builtin_pow (fndecl, arg0, arg1, type);
9855 CASE_FLT_FN (BUILT_IN_POWI):
9856 return fold_builtin_powi (fndecl, arg0, arg1, type);
9858 CASE_FLT_FN (BUILT_IN_COPYSIGN):
9859 return fold_builtin_copysign (fndecl, arg0, arg1, type);
9861 CASE_FLT_FN (BUILT_IN_FMIN):
9862 return fold_builtin_fmin_fmax (arg0, arg1, type, /*max=*/false);
9864 CASE_FLT_FN (BUILT_IN_FMAX):
9865 return fold_builtin_fmin_fmax (arg0, arg1, type, /*max=*/true);
9867 case BUILT_IN_ISGREATER:
9868 return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNLE_EXPR, LE_EXPR);
9869 case BUILT_IN_ISGREATEREQUAL:
9870 return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNLT_EXPR, LT_EXPR);
9871 case BUILT_IN_ISLESS:
9872 return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNGE_EXPR, GE_EXPR);
9873 case BUILT_IN_ISLESSEQUAL:
9874 return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNGT_EXPR, GT_EXPR);
9875 case BUILT_IN_ISLESSGREATER:
9876 return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNEQ_EXPR, EQ_EXPR);
9877 case BUILT_IN_ISUNORDERED:
9878 return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNORDERED_EXPR,
9881 /* We do the folding for va_start in the expander. */
9882 case BUILT_IN_VA_START:
9885 case BUILT_IN_SPRINTF:
9886 return fold_builtin_sprintf (arg0, arg1, NULL_TREE, ignore);
9888 case BUILT_IN_OBJECT_SIZE:
9889 return fold_builtin_object_size (arg0, arg1);
9891 case BUILT_IN_PRINTF:
9892 case BUILT_IN_PRINTF_UNLOCKED:
9893 case BUILT_IN_VPRINTF:
9894 return fold_builtin_printf (fndecl, arg0, arg1, ignore, fcode);
9896 case BUILT_IN_PRINTF_CHK:
9897 case BUILT_IN_VPRINTF_CHK:
9898 if (!validate_arg (arg0, INTEGER_TYPE)
9899 || TREE_SIDE_EFFECTS (arg0))
9902 return fold_builtin_printf (fndecl, arg1, NULL_TREE, ignore, fcode);
9905 case BUILT_IN_FPRINTF:
9906 case BUILT_IN_FPRINTF_UNLOCKED:
9907 case BUILT_IN_VFPRINTF:
9908 return fold_builtin_fprintf (fndecl, arg0, arg1, NULL_TREE,
9917 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
9918 and ARG2. IGNORE is true if the result of the function call is ignored.
9919 This function returns NULL_TREE if no simplification was possible. */
9922 fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
9924 tree type = TREE_TYPE (TREE_TYPE (fndecl));
9925 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9929 CASE_FLT_FN (BUILT_IN_SINCOS):
9930 return fold_builtin_sincos (arg0, arg1, arg2);
9932 CASE_FLT_FN (BUILT_IN_FMA):
9933 if (validate_arg (arg0, REAL_TYPE)
9934 && validate_arg(arg1, REAL_TYPE)
9935 && validate_arg(arg2, REAL_TYPE))
9936 return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
9939 case BUILT_IN_MEMSET:
9940 return fold_builtin_memset (arg0, arg1, arg2, type, ignore);
9942 case BUILT_IN_BCOPY:
9943 return fold_builtin_memory_op (arg1, arg0, arg2, void_type_node, true, /*endp=*/3);
9945 case BUILT_IN_MEMCPY:
9946 return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/0);
9948 case BUILT_IN_MEMPCPY:
9949 return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/1);
9951 case BUILT_IN_MEMMOVE:
9952 return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/3);
9954 case BUILT_IN_STRNCAT:
9955 return fold_builtin_strncat (arg0, arg1, arg2);
9957 case BUILT_IN_STRNCPY:
9958 return fold_builtin_strncpy (fndecl, arg0, arg1, arg2, NULL_TREE);
9960 case BUILT_IN_STRNCMP:
9961 return fold_builtin_strncmp (arg0, arg1, arg2);
9964 case BUILT_IN_MEMCMP:
9965 return fold_builtin_memcmp (arg0, arg1, arg2);;
9967 case BUILT_IN_SPRINTF:
9968 return fold_builtin_sprintf (arg0, arg1, arg2, ignore);
9970 case BUILT_IN_STRCPY_CHK:
9971 case BUILT_IN_STPCPY_CHK:
9972 return fold_builtin_stxcpy_chk (fndecl, arg0, arg1, arg2, NULL_TREE,
9975 case BUILT_IN_STRCAT_CHK:
9976 return fold_builtin_strcat_chk (fndecl, arg0, arg1, arg2);
9978 case BUILT_IN_PRINTF_CHK:
9979 case BUILT_IN_VPRINTF_CHK:
9980 if (!validate_arg (arg0, INTEGER_TYPE)
9981 || TREE_SIDE_EFFECTS (arg0))
9984 return fold_builtin_printf (fndecl, arg1, arg2, ignore, fcode);
9987 case BUILT_IN_FPRINTF:
9988 case BUILT_IN_FPRINTF_UNLOCKED:
9989 case BUILT_IN_VFPRINTF:
9990 return fold_builtin_fprintf (fndecl, arg0, arg1, arg2, ignore, fcode);
9992 case BUILT_IN_FPRINTF_CHK:
9993 case BUILT_IN_VFPRINTF_CHK:
9994 if (!validate_arg (arg1, INTEGER_TYPE)
9995 || TREE_SIDE_EFFECTS (arg1))
9998 return fold_builtin_fprintf (fndecl, arg0, arg2, NULL_TREE,
10007 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10008 ARG2, and ARG3. IGNORE is true if the result of the function call is
10009 ignored. This function returns NULL_TREE if no simplification was
10013 fold_builtin_4 (tree fndecl, tree arg0, tree arg1, tree arg2, tree arg3,
10016 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10020 case BUILT_IN_MEMCPY_CHK:
10021 case BUILT_IN_MEMPCPY_CHK:
10022 case BUILT_IN_MEMMOVE_CHK:
10023 case BUILT_IN_MEMSET_CHK:
10024 return fold_builtin_memory_chk (fndecl, arg0, arg1, arg2, arg3,
10026 DECL_FUNCTION_CODE (fndecl));
10028 case BUILT_IN_STRNCPY_CHK:
10029 return fold_builtin_strncpy_chk (arg0, arg1, arg2, arg3, NULL_TREE);
10031 case BUILT_IN_STRNCAT_CHK:
10032 return fold_builtin_strncat_chk (fndecl, arg0, arg1, arg2, arg3);
10034 case BUILT_IN_FPRINTF_CHK:
10035 case BUILT_IN_VFPRINTF_CHK:
10036 if (!validate_arg (arg1, INTEGER_TYPE)
10037 || TREE_SIDE_EFFECTS (arg1))
10040 return fold_builtin_fprintf (fndecl, arg0, arg2, arg3,
10050 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
10051 arguments, where NARGS <= 4. IGNORE is true if the result of the
10052 function call is ignored. This function returns NULL_TREE if no
10053 simplification was possible. Note that this only folds builtins with
10054 fixed argument patterns. Foldings that do varargs-to-varargs
10055 transformations, or that match calls with more than 4 arguments,
10056 need to be handled with fold_builtin_varargs instead. */
10058 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10061 fold_builtin_n (tree fndecl, tree *args, int nargs, bool ignore)
10063 tree ret = NULL_TREE;
10067 ret = fold_builtin_0 (fndecl, ignore);
10070 ret = fold_builtin_1 (fndecl, args[0], ignore);
10073 ret = fold_builtin_2 (fndecl, args[0], args[1], ignore);
10076 ret = fold_builtin_3 (fndecl, args[0], args[1], args[2], ignore);
10079 ret = fold_builtin_4 (fndecl, args[0], args[1], args[2], args[3],
10087 ret = build1 (NOP_EXPR, GENERIC_TREE_TYPE (ret), ret);
10088 TREE_NO_WARNING (ret) = 1;
10094 /* Builtins with folding operations that operate on "..." arguments
10095 need special handling; we need to store the arguments in a convenient
10096 data structure before attempting any folding. Fortunately there are
10097 only a few builtins that fall into this category. FNDECL is the
10098 function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10099 result of the function call is ignored. */
10102 fold_builtin_varargs (tree fndecl, tree exp, bool ignore ATTRIBUTE_UNUSED)
10104 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10105 tree ret = NULL_TREE;
10109 case BUILT_IN_SPRINTF_CHK:
10110 case BUILT_IN_VSPRINTF_CHK:
10111 ret = fold_builtin_sprintf_chk (exp, fcode);
10114 case BUILT_IN_SNPRINTF_CHK:
10115 case BUILT_IN_VSNPRINTF_CHK:
10116 ret = fold_builtin_snprintf_chk (exp, NULL_TREE, fcode);
10123 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10124 TREE_NO_WARNING (ret) = 1;
10130 /* A wrapper function for builtin folding that prevents warnings for
10131 "statement without effect" and the like, caused by removing the
10132 call node earlier than the warning is generated. */
10135 fold_call_expr (tree exp, bool ignore)
10137 tree ret = NULL_TREE;
10138 tree fndecl = get_callee_fndecl (exp);
10140 && TREE_CODE (fndecl) == FUNCTION_DECL
10141 && DECL_BUILT_IN (fndecl))
10143 /* FIXME: Don't use a list in this interface. */
10144 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10145 return targetm.fold_builtin (fndecl, CALL_EXPR_ARGS (exp), ignore);
10148 int nargs = call_expr_nargs (exp);
10149 if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10151 tree *args = CALL_EXPR_ARGP (exp);
10152 ret = fold_builtin_n (fndecl, args, nargs, ignore);
10155 ret = fold_builtin_varargs (fndecl, exp, ignore);
10158 /* Propagate location information from original call to
10159 expansion of builtin. Otherwise things like
10160 maybe_emit_chk_warning, that operate on the expansion
10161 of a builtin, will use the wrong location information. */
10162 if (CAN_HAVE_LOCATION_P (exp) && EXPR_HAS_LOCATION (exp))
10164 tree realret = ret;
10165 if (TREE_CODE (ret) == NOP_EXPR)
10166 realret = TREE_OPERAND (ret, 0);
10167 if (CAN_HAVE_LOCATION_P (realret)
10168 && !EXPR_HAS_LOCATION (realret))
10169 SET_EXPR_LOCATION (realret, EXPR_LOCATION (exp));
10178 /* Conveniently construct a function call expression. FNDECL names the
10179 function to be called and ARGLIST is a TREE_LIST of arguments. */
10182 build_function_call_expr (tree fndecl, tree arglist)
10184 tree fntype = TREE_TYPE (fndecl);
10185 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10186 int n = list_length (arglist);
10187 tree *argarray = (tree *) alloca (n * sizeof (tree));
10190 for (i = 0; i < n; i++, arglist = TREE_CHAIN (arglist))
10191 argarray[i] = TREE_VALUE (arglist);
10192 return fold_builtin_call_array (TREE_TYPE (fntype), fn, n, argarray);
10195 /* Conveniently construct a function call expression. FNDECL names the
10196 function to be called, N is the number of arguments, and the "..."
10197 parameters are the argument expressions. */
10200 build_call_expr (tree fndecl, int n, ...)
10203 tree fntype = TREE_TYPE (fndecl);
10204 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10205 tree *argarray = (tree *) alloca (n * sizeof (tree));
10209 for (i = 0; i < n; i++)
10210 argarray[i] = va_arg (ap, tree);
10212 return fold_builtin_call_array (TREE_TYPE (fntype), fn, n, argarray);
10215 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10216 N arguments are passed in the array ARGARRAY. */
10219 fold_builtin_call_array (tree type,
10224 tree ret = NULL_TREE;
10228 if (TREE_CODE (fn) == ADDR_EXPR)
10230 tree fndecl = TREE_OPERAND (fn, 0);
10231 if (TREE_CODE (fndecl) == FUNCTION_DECL
10232 && DECL_BUILT_IN (fndecl))
10234 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10236 tree arglist = NULL_TREE;
10237 for (i = n - 1; i >= 0; i--)
10238 arglist = tree_cons (NULL_TREE, argarray[i], arglist);
10239 ret = targetm.fold_builtin (fndecl, arglist, false);
10243 else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10245 /* First try the transformations that don't require consing up
10247 ret = fold_builtin_n (fndecl, argarray, n, false);
10252 /* If we got this far, we need to build an exp. */
10253 exp = build_call_array (type, fn, n, argarray);
10254 ret = fold_builtin_varargs (fndecl, exp, false);
10255 return ret ? ret : exp;
10259 return build_call_array (type, fn, n, argarray);
10262 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10263 along with N new arguments specified as the "..." parameters. SKIP
10264 is the number of arguments in EXP to be omitted. This function is used
10265 to do varargs-to-varargs transformations. */
10268 rewrite_call_expr (tree exp, int skip, tree fndecl, int n, ...)
10270 int oldnargs = call_expr_nargs (exp);
10271 int nargs = oldnargs - skip + n;
10272 tree fntype = TREE_TYPE (fndecl);
10273 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10281 buffer = alloca (nargs * sizeof (tree));
10283 for (i = 0; i < n; i++)
10284 buffer[i] = va_arg (ap, tree);
10286 for (j = skip; j < oldnargs; j++, i++)
10287 buffer[i] = CALL_EXPR_ARG (exp, j);
10290 buffer = CALL_EXPR_ARGP (exp) + skip;
10292 return fold (build_call_array (TREE_TYPE (exp), fn, nargs, buffer));
10295 /* Validate a single argument ARG against a tree code CODE representing
10299 validate_arg (tree arg, enum tree_code code)
10303 else if (code == POINTER_TYPE)
10304 return POINTER_TYPE_P (TREE_TYPE (arg));
10305 return code == TREE_CODE (TREE_TYPE (arg));
10308 /* This function validates the types of a function call argument list
10309 against a specified list of tree_codes. If the last specifier is a 0,
10310 that represents an ellipses, otherwise the last specifier must be a
10314 validate_arglist (tree callexpr, ...)
10316 enum tree_code code;
10319 call_expr_arg_iterator iter;
10322 va_start (ap, callexpr);
10323 init_call_expr_arg_iterator (callexpr, &iter);
10327 code = va_arg (ap, enum tree_code);
10331 /* This signifies an ellipses, any further arguments are all ok. */
10335 /* This signifies an endlink, if no arguments remain, return
10336 true, otherwise return false. */
10337 res = !more_call_expr_args_p (&iter);
10340 /* If no parameters remain or the parameter's code does not
10341 match the specified code, return false. Otherwise continue
10342 checking any remaining arguments. */
10343 arg = next_call_expr_arg (&iter);
10344 if (!validate_arg (arg, code))
10351 /* We need gotos here since we can only have one VA_CLOSE in a
10359 /* Default target-specific builtin expander that does nothing. */
10362 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
10363 rtx target ATTRIBUTE_UNUSED,
10364 rtx subtarget ATTRIBUTE_UNUSED,
10365 enum machine_mode mode ATTRIBUTE_UNUSED,
10366 int ignore ATTRIBUTE_UNUSED)
10371 /* Returns true is EXP represents data that would potentially reside
10372 in a readonly section. */
10375 readonly_data_expr (tree exp)
10379 if (TREE_CODE (exp) != ADDR_EXPR)
10382 exp = get_base_address (TREE_OPERAND (exp, 0));
10386 /* Make sure we call decl_readonly_section only for trees it
10387 can handle (since it returns true for everything it doesn't
10389 if (TREE_CODE (exp) == STRING_CST
10390 || TREE_CODE (exp) == CONSTRUCTOR
10391 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
10392 return decl_readonly_section (exp, 0);
10397 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments
10398 to the call, and TYPE is its return type.
10400 Return NULL_TREE if no simplification was possible, otherwise return the
10401 simplified form of the call as a tree.
10403 The simplified form may be a constant or other expression which
10404 computes the same value, but in a more efficient manner (including
10405 calls to other builtin functions).
10407 The call may contain arguments which need to be evaluated, but
10408 which are not useful to determine the result of the call. In
10409 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10410 COMPOUND_EXPR will be an argument which must be evaluated.
10411 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10412 COMPOUND_EXPR in the chain will contain the tree for the simplified
10413 form of the builtin function call. */
10416 fold_builtin_strstr (tree s1, tree s2, tree type)
10418 if (!validate_arg (s1, POINTER_TYPE)
10419 || !validate_arg (s2, POINTER_TYPE))
10424 const char *p1, *p2;
10426 p2 = c_getstr (s2);
10430 p1 = c_getstr (s1);
10433 const char *r = strstr (p1, p2);
10437 return build_int_cst (TREE_TYPE (s1), 0);
10439 /* Return an offset into the constant string argument. */
10440 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
10441 s1, build_int_cst (TREE_TYPE (s1), r - p1));
10442 return fold_convert (type, tem);
10445 /* The argument is const char *, and the result is char *, so we need
10446 a type conversion here to avoid a warning. */
10448 return fold_convert (type, s1);
10453 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
10457 /* New argument list transforming strstr(s1, s2) to
10458 strchr(s1, s2[0]). */
10459 return build_call_expr (fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
10463 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to
10464 the call, and TYPE is its return type.
10466 Return NULL_TREE if no simplification was possible, otherwise return the
10467 simplified form of the call as a tree.
10469 The simplified form may be a constant or other expression which
10470 computes the same value, but in a more efficient manner (including
10471 calls to other builtin functions).
10473 The call may contain arguments which need to be evaluated, but
10474 which are not useful to determine the result of the call. In
10475 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10476 COMPOUND_EXPR will be an argument which must be evaluated.
10477 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10478 COMPOUND_EXPR in the chain will contain the tree for the simplified
10479 form of the builtin function call. */
10482 fold_builtin_strchr (tree s1, tree s2, tree type)
10484 if (!validate_arg (s1, POINTER_TYPE)
10485 || !validate_arg (s2, INTEGER_TYPE))
10491 if (TREE_CODE (s2) != INTEGER_CST)
10494 p1 = c_getstr (s1);
10501 if (target_char_cast (s2, &c))
10504 r = strchr (p1, c);
10507 return build_int_cst (TREE_TYPE (s1), 0);
10509 /* Return an offset into the constant string argument. */
10510 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
10511 s1, build_int_cst (TREE_TYPE (s1), r - p1));
10512 return fold_convert (type, tem);
10518 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to
10519 the call, and TYPE is its return type.
10521 Return NULL_TREE if no simplification was possible, otherwise return the
10522 simplified form of the call as a tree.
10524 The simplified form may be a constant or other expression which
10525 computes the same value, but in a more efficient manner (including
10526 calls to other builtin functions).
10528 The call may contain arguments which need to be evaluated, but
10529 which are not useful to determine the result of the call. In
10530 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10531 COMPOUND_EXPR will be an argument which must be evaluated.
10532 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10533 COMPOUND_EXPR in the chain will contain the tree for the simplified
10534 form of the builtin function call. */
10537 fold_builtin_strrchr (tree s1, tree s2, tree type)
10539 if (!validate_arg (s1, POINTER_TYPE)
10540 || !validate_arg (s2, INTEGER_TYPE))
10547 if (TREE_CODE (s2) != INTEGER_CST)
10550 p1 = c_getstr (s1);
10557 if (target_char_cast (s2, &c))
10560 r = strrchr (p1, c);
10563 return build_int_cst (TREE_TYPE (s1), 0);
10565 /* Return an offset into the constant string argument. */
10566 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
10567 s1, build_int_cst (TREE_TYPE (s1), r - p1));
10568 return fold_convert (type, tem);
10571 if (! integer_zerop (s2))
10574 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
10578 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
10579 return build_call_expr (fn, 2, s1, s2);
10583 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
10584 to the call, and TYPE is its return type.
10586 Return NULL_TREE if no simplification was possible, otherwise return the
10587 simplified form of the call as a tree.
10589 The simplified form may be a constant or other expression which
10590 computes the same value, but in a more efficient manner (including
10591 calls to other builtin functions).
10593 The call may contain arguments which need to be evaluated, but
10594 which are not useful to determine the result of the call. In
10595 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10596 COMPOUND_EXPR will be an argument which must be evaluated.
10597 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10598 COMPOUND_EXPR in the chain will contain the tree for the simplified
10599 form of the builtin function call. */
10602 fold_builtin_strpbrk (tree s1, tree s2, tree type)
10604 if (!validate_arg (s1, POINTER_TYPE)
10605 || !validate_arg (s2, POINTER_TYPE))
10610 const char *p1, *p2;
10612 p2 = c_getstr (s2);
10616 p1 = c_getstr (s1);
10619 const char *r = strpbrk (p1, p2);
10623 return build_int_cst (TREE_TYPE (s1), 0);
10625 /* Return an offset into the constant string argument. */
10626 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
10627 s1, build_int_cst (TREE_TYPE (s1), r - p1));
10628 return fold_convert (type, tem);
10632 /* strpbrk(x, "") == NULL.
10633 Evaluate and ignore s1 in case it had side-effects. */
10634 return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
10637 return NULL_TREE; /* Really call strpbrk. */
10639 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
10643 /* New argument list transforming strpbrk(s1, s2) to
10644 strchr(s1, s2[0]). */
10645 return build_call_expr (fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
10649 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
10652 Return NULL_TREE if no simplification was possible, otherwise return the
10653 simplified form of the call as a tree.
10655 The simplified form may be a constant or other expression which
10656 computes the same value, but in a more efficient manner (including
10657 calls to other builtin functions).
10659 The call may contain arguments which need to be evaluated, but
10660 which are not useful to determine the result of the call. In
10661 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10662 COMPOUND_EXPR will be an argument which must be evaluated.
10663 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10664 COMPOUND_EXPR in the chain will contain the tree for the simplified
10665 form of the builtin function call. */
10668 fold_builtin_strcat (tree dst, tree src)
10670 if (!validate_arg (dst, POINTER_TYPE)
10671 || !validate_arg (src, POINTER_TYPE))
10675 const char *p = c_getstr (src);
10677 /* If the string length is zero, return the dst parameter. */
10678 if (p && *p == '\0')
10685 /* Simplify a call to the strncat builtin. DST, SRC, and LEN are the
10686 arguments to the call.
10688 Return NULL_TREE if no simplification was possible, otherwise return the
10689 simplified form of the call as a tree.
10691 The simplified form may be a constant or other expression which
10692 computes the same value, but in a more efficient manner (including
10693 calls to other builtin functions).
10695 The call may contain arguments which need to be evaluated, but
10696 which are not useful to determine the result of the call. In
10697 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10698 COMPOUND_EXPR will be an argument which must be evaluated.
10699 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10700 COMPOUND_EXPR in the chain will contain the tree for the simplified
10701 form of the builtin function call. */
10704 fold_builtin_strncat (tree dst, tree src, tree len)
10706 if (!validate_arg (dst, POINTER_TYPE)
10707 || !validate_arg (src, POINTER_TYPE)
10708 || !validate_arg (len, INTEGER_TYPE))
10712 const char *p = c_getstr (src);
10714 /* If the requested length is zero, or the src parameter string
10715 length is zero, return the dst parameter. */
10716 if (integer_zerop (len) || (p && *p == '\0'))
10717 return omit_two_operands (TREE_TYPE (dst), dst, src, len);
10719 /* If the requested len is greater than or equal to the string
10720 length, call strcat. */
10721 if (TREE_CODE (len) == INTEGER_CST && p
10722 && compare_tree_int (len, strlen (p)) >= 0)
10724 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
10726 /* If the replacement _DECL isn't initialized, don't do the
10731 return build_call_expr (fn, 2, dst, src);
10737 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
10740 Return NULL_TREE if no simplification was possible, otherwise return the
10741 simplified form of the call as a tree.
10743 The simplified form may be a constant or other expression which
10744 computes the same value, but in a more efficient manner (including
10745 calls to other builtin functions).
10747 The call may contain arguments which need to be evaluated, but
10748 which are not useful to determine the result of the call. In
10749 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10750 COMPOUND_EXPR will be an argument which must be evaluated.
10751 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10752 COMPOUND_EXPR in the chain will contain the tree for the simplified
10753 form of the builtin function call. */
10756 fold_builtin_strspn (tree s1, tree s2)
10758 if (!validate_arg (s1, POINTER_TYPE)
10759 || !validate_arg (s2, POINTER_TYPE))
10763 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
10765 /* If both arguments are constants, evaluate at compile-time. */
10768 const size_t r = strspn (p1, p2);
10769 return size_int (r);
10772 /* If either argument is "", return NULL_TREE. */
10773 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
10774 /* Evaluate and ignore both arguments in case either one has
10776 return omit_two_operands (integer_type_node, integer_zero_node,
10782 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
10785 Return NULL_TREE if no simplification was possible, otherwise return the
10786 simplified form of the call as a tree.
10788 The simplified form may be a constant or other expression which
10789 computes the same value, but in a more efficient manner (including
10790 calls to other builtin functions).
10792 The call may contain arguments which need to be evaluated, but
10793 which are not useful to determine the result of the call. In
10794 this case we return a chain of COMPOUND_EXPRs. The LHS of each
10795 COMPOUND_EXPR will be an argument which must be evaluated.
10796 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
10797 COMPOUND_EXPR in the chain will contain the tree for the simplified
10798 form of the builtin function call. */
10801 fold_builtin_strcspn (tree s1, tree s2)
10803 if (!validate_arg (s1, POINTER_TYPE)
10804 || !validate_arg (s2, POINTER_TYPE))
10808 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
10810 /* If both arguments are constants, evaluate at compile-time. */
10813 const size_t r = strcspn (p1, p2);
10814 return size_int (r);
10817 /* If the first argument is "", return NULL_TREE. */
10818 if (p1 && *p1 == '\0')
10820 /* Evaluate and ignore argument s2 in case it has
10822 return omit_one_operand (integer_type_node,
10823 integer_zero_node, s2);
10826 /* If the second argument is "", return __builtin_strlen(s1). */
10827 if (p2 && *p2 == '\0')
10829 tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
10831 /* If the replacement _DECL isn't initialized, don't do the
10836 return build_call_expr (fn, 1, s1);
10842 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
10843 to the call. IGNORE is true if the value returned
10844 by the builtin will be ignored. UNLOCKED is true is true if this
10845 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
10846 the known length of the string. Return NULL_TREE if no simplification
10850 fold_builtin_fputs (tree arg0, tree arg1, bool ignore, bool unlocked, tree len)
10852 /* If we're using an unlocked function, assume the other unlocked
10853 functions exist explicitly. */
10854 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
10855 : implicit_built_in_decls[BUILT_IN_FPUTC];
10856 tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
10857 : implicit_built_in_decls[BUILT_IN_FWRITE];
10859 /* If the return value is used, don't do the transformation. */
10863 /* Verify the arguments in the original call. */
10864 if (!validate_arg (arg0, POINTER_TYPE)
10865 || !validate_arg (arg1, POINTER_TYPE))
10869 len = c_strlen (arg0, 0);
10871 /* Get the length of the string passed to fputs. If the length
10872 can't be determined, punt. */
10874 || TREE_CODE (len) != INTEGER_CST)
10877 switch (compare_tree_int (len, 1))
10879 case -1: /* length is 0, delete the call entirely . */
10880 return omit_one_operand (integer_type_node, integer_zero_node, arg1);;
10882 case 0: /* length is 1, call fputc. */
10884 const char *p = c_getstr (arg0);
10889 return build_call_expr (fn_fputc, 2,
10890 build_int_cst (NULL_TREE, p[0]), arg1);
10896 case 1: /* length is greater than 1, call fwrite. */
10898 /* If optimizing for size keep fputs. */
10901 /* New argument list transforming fputs(string, stream) to
10902 fwrite(string, 1, len, stream). */
10904 return build_call_expr (fn_fwrite, 4, arg0, size_one_node, len, arg1);
10909 gcc_unreachable ();
10914 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
10915 produced. False otherwise. This is done so that we don't output the error
10916 or warning twice or three times. */
10918 fold_builtin_next_arg (tree exp, bool va_start_p)
10920 tree fntype = TREE_TYPE (current_function_decl);
10921 int nargs = call_expr_nargs (exp);
10924 if (TYPE_ARG_TYPES (fntype) == 0
10925 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
10926 == void_type_node))
10928 error ("%<va_start%> used in function with fixed args");
10934 if (va_start_p && (nargs != 2))
10936 error ("wrong number of arguments to function %<va_start%>");
10939 arg = CALL_EXPR_ARG (exp, 1);
10941 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
10942 when we checked the arguments and if needed issued a warning. */
10947 /* Evidently an out of date version of <stdarg.h>; can't validate
10948 va_start's second argument, but can still work as intended. */
10949 warning (0, "%<__builtin_next_arg%> called without an argument");
10952 else if (nargs > 1)
10954 error ("wrong number of arguments to function %<__builtin_next_arg%>");
10957 arg = CALL_EXPR_ARG (exp, 0);
10960 /* We destructively modify the call to be __builtin_va_start (ap, 0)
10961 or __builtin_next_arg (0) the first time we see it, after checking
10962 the arguments and if needed issuing a warning. */
10963 if (!integer_zerop (arg))
10965 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
10967 /* Strip off all nops for the sake of the comparison. This
10968 is not quite the same as STRIP_NOPS. It does more.
10969 We must also strip off INDIRECT_EXPR for C++ reference
10971 while (TREE_CODE (arg) == NOP_EXPR
10972 || TREE_CODE (arg) == CONVERT_EXPR
10973 || TREE_CODE (arg) == NON_LVALUE_EXPR
10974 || TREE_CODE (arg) == INDIRECT_REF)
10975 arg = TREE_OPERAND (arg, 0);
10976 if (arg != last_parm)
10978 /* FIXME: Sometimes with the tree optimizers we can get the
10979 not the last argument even though the user used the last
10980 argument. We just warn and set the arg to be the last
10981 argument so that we will get wrong-code because of
10983 warning (0, "second parameter of %<va_start%> not last named argument");
10985 /* We want to verify the second parameter just once before the tree
10986 optimizers are run and then avoid keeping it in the tree,
10987 as otherwise we could warn even for correct code like:
10988 void foo (int i, ...)
10989 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
10991 CALL_EXPR_ARG (exp, 1) = integer_zero_node;
10993 CALL_EXPR_ARG (exp, 0) = integer_zero_node;
10999 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11000 ORIG may be null if this is a 2-argument call. We don't attempt to
11001 simplify calls with more than 3 arguments.
11003 Return NULL_TREE if no simplification was possible, otherwise return the
11004 simplified form of the call as a tree. If IGNORED is true, it means that
11005 the caller does not use the returned value of the function. */
11008 fold_builtin_sprintf (tree dest, tree fmt, tree orig, int ignored)
11011 const char *fmt_str = NULL;
11013 /* Verify the required arguments in the original call. We deal with two
11014 types of sprintf() calls: 'sprintf (str, fmt)' and
11015 'sprintf (dest, "%s", orig)'. */
11016 if (!validate_arg (dest, POINTER_TYPE)
11017 || !validate_arg (fmt, POINTER_TYPE))
11019 if (orig && !validate_arg (orig, POINTER_TYPE))
11022 /* Check whether the format is a literal string constant. */
11023 fmt_str = c_getstr (fmt);
11024 if (fmt_str == NULL)
11028 retval = NULL_TREE;
11030 if (!init_target_chars ())
11033 /* If the format doesn't contain % args or %%, use strcpy. */
11034 if (strchr (fmt_str, target_percent) == NULL)
11036 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11041 /* Don't optimize sprintf (buf, "abc", ptr++). */
11045 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11046 'format' is known to contain no % formats. */
11047 call = build_call_expr (fn, 2, dest, fmt);
11049 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11052 /* If the format is "%s", use strcpy if the result isn't used. */
11053 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11056 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11061 /* Don't crash on sprintf (str1, "%s"). */
11065 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
11068 retval = c_strlen (orig, 1);
11069 if (!retval || TREE_CODE (retval) != INTEGER_CST)
11072 call = build_call_expr (fn, 2, dest, orig);
11075 if (call && retval)
11077 retval = fold_convert
11078 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11080 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11086 /* Expand a call EXP to __builtin_object_size. */
11089 expand_builtin_object_size (tree exp)
11092 int object_size_type;
11093 tree fndecl = get_callee_fndecl (exp);
11094 location_t locus = EXPR_LOCATION (exp);
11096 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11098 error ("%Hfirst argument of %D must be a pointer, second integer constant",
11100 expand_builtin_trap ();
11104 ost = CALL_EXPR_ARG (exp, 1);
11107 if (TREE_CODE (ost) != INTEGER_CST
11108 || tree_int_cst_sgn (ost) < 0
11109 || compare_tree_int (ost, 3) > 0)
11111 error ("%Hlast argument of %D is not integer constant between 0 and 3",
11113 expand_builtin_trap ();
11117 object_size_type = tree_low_cst (ost, 0);
11119 return object_size_type < 2 ? constm1_rtx : const0_rtx;
11122 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11123 FCODE is the BUILT_IN_* to use.
11124 Return NULL_RTX if we failed; the caller should emit a normal call,
11125 otherwise try to get the result in TARGET, if convenient (and in
11126 mode MODE if that's convenient). */
11129 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11130 enum built_in_function fcode)
11132 tree dest, src, len, size;
11134 if (!validate_arglist (exp,
11136 fcode == BUILT_IN_MEMSET_CHK
11137 ? INTEGER_TYPE : POINTER_TYPE,
11138 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11141 dest = CALL_EXPR_ARG (exp, 0);
11142 src = CALL_EXPR_ARG (exp, 1);
11143 len = CALL_EXPR_ARG (exp, 2);
11144 size = CALL_EXPR_ARG (exp, 3);
11146 if (! host_integerp (size, 1))
11149 if (host_integerp (len, 1) || integer_all_onesp (size))
11153 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11155 location_t locus = EXPR_LOCATION (exp);
11156 warning (0, "%Hcall to %D will always overflow destination buffer",
11157 &locus, get_callee_fndecl (exp));
11162 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11163 mem{cpy,pcpy,move,set} is available. */
11166 case BUILT_IN_MEMCPY_CHK:
11167 fn = built_in_decls[BUILT_IN_MEMCPY];
11169 case BUILT_IN_MEMPCPY_CHK:
11170 fn = built_in_decls[BUILT_IN_MEMPCPY];
11172 case BUILT_IN_MEMMOVE_CHK:
11173 fn = built_in_decls[BUILT_IN_MEMMOVE];
11175 case BUILT_IN_MEMSET_CHK:
11176 fn = built_in_decls[BUILT_IN_MEMSET];
11185 fn = build_call_expr (fn, 3, dest, src, len);
11186 if (TREE_CODE (fn) == CALL_EXPR)
11187 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11188 return expand_expr (fn, target, mode, EXPAND_NORMAL);
11190 else if (fcode == BUILT_IN_MEMSET_CHK)
11194 unsigned int dest_align
11195 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
11197 /* If DEST is not a pointer type, call the normal function. */
11198 if (dest_align == 0)
11201 /* If SRC and DEST are the same (and not volatile), do nothing. */
11202 if (operand_equal_p (src, dest, 0))
11206 if (fcode != BUILT_IN_MEMPCPY_CHK)
11208 /* Evaluate and ignore LEN in case it has side-effects. */
11209 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
11210 return expand_expr (dest, target, mode, EXPAND_NORMAL);
11213 len = fold_convert (TREE_TYPE (dest), len);
11214 expr = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
11215 return expand_expr (expr, target, mode, EXPAND_NORMAL);
11218 /* __memmove_chk special case. */
11219 if (fcode == BUILT_IN_MEMMOVE_CHK)
11221 unsigned int src_align
11222 = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
11224 if (src_align == 0)
11227 /* If src is categorized for a readonly section we can use
11228 normal __memcpy_chk. */
11229 if (readonly_data_expr (src))
11231 tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11234 fn = build_call_expr (fn, 4, dest, src, len, size);
11235 if (TREE_CODE (fn) == CALL_EXPR)
11236 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11237 return expand_expr (fn, target, mode, EXPAND_NORMAL);
11244 /* Emit warning if a buffer overflow is detected at compile time. */
11247 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
11255 case BUILT_IN_STRCPY_CHK:
11256 case BUILT_IN_STPCPY_CHK:
11257 /* For __strcat_chk the warning will be emitted only if overflowing
11258 by at least strlen (dest) + 1 bytes. */
11259 case BUILT_IN_STRCAT_CHK:
11260 len = CALL_EXPR_ARG (exp, 1);
11261 size = CALL_EXPR_ARG (exp, 2);
11264 case BUILT_IN_STRNCAT_CHK:
11265 case BUILT_IN_STRNCPY_CHK:
11266 len = CALL_EXPR_ARG (exp, 2);
11267 size = CALL_EXPR_ARG (exp, 3);
11269 case BUILT_IN_SNPRINTF_CHK:
11270 case BUILT_IN_VSNPRINTF_CHK:
11271 len = CALL_EXPR_ARG (exp, 1);
11272 size = CALL_EXPR_ARG (exp, 3);
11275 gcc_unreachable ();
11281 if (! host_integerp (size, 1) || integer_all_onesp (size))
11286 len = c_strlen (len, 1);
11287 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
11290 else if (fcode == BUILT_IN_STRNCAT_CHK)
11292 tree src = CALL_EXPR_ARG (exp, 1);
11293 if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
11295 src = c_strlen (src, 1);
11296 if (! src || ! host_integerp (src, 1))
11298 locus = EXPR_LOCATION (exp);
11299 warning (0, "%Hcall to %D might overflow destination buffer",
11300 &locus, get_callee_fndecl (exp));
11303 else if (tree_int_cst_lt (src, size))
11306 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
11309 locus = EXPR_LOCATION (exp);
11310 warning (0, "%Hcall to %D will always overflow destination buffer",
11311 &locus, get_callee_fndecl (exp));
11314 /* Emit warning if a buffer overflow is detected at compile time
11315 in __sprintf_chk/__vsprintf_chk calls. */
11318 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
11320 tree dest, size, len, fmt, flag;
11321 const char *fmt_str;
11322 int nargs = call_expr_nargs (exp);
11324 /* Verify the required arguments in the original call. */
11328 dest = CALL_EXPR_ARG (exp, 0);
11329 flag = CALL_EXPR_ARG (exp, 1);
11330 size = CALL_EXPR_ARG (exp, 2);
11331 fmt = CALL_EXPR_ARG (exp, 3);
11333 if (! host_integerp (size, 1) || integer_all_onesp (size))
11336 /* Check whether the format is a literal string constant. */
11337 fmt_str = c_getstr (fmt);
11338 if (fmt_str == NULL)
11341 if (!init_target_chars ())
11344 /* If the format doesn't contain % args or %%, we know its size. */
11345 if (strchr (fmt_str, target_percent) == 0)
11346 len = build_int_cstu (size_type_node, strlen (fmt_str));
11347 /* If the format is "%s" and first ... argument is a string literal,
11349 else if (fcode == BUILT_IN_SPRINTF_CHK
11350 && strcmp (fmt_str, target_percent_s) == 0)
11356 arg = CALL_EXPR_ARG (exp, 4);
11357 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
11360 len = c_strlen (arg, 1);
11361 if (!len || ! host_integerp (len, 1))
11367 if (! tree_int_cst_lt (len, size))
11369 location_t locus = EXPR_LOCATION (exp);
11370 warning (0, "%Hcall to %D will always overflow destination buffer",
11371 &locus, get_callee_fndecl (exp));
11375 /* Fold a call to __builtin_object_size with arguments PTR and OST,
11379 fold_builtin_object_size (tree ptr, tree ost)
11381 tree ret = NULL_TREE;
11382 int object_size_type;
11384 if (!validate_arg (ptr, POINTER_TYPE)
11385 || !validate_arg (ost, INTEGER_TYPE))
11390 if (TREE_CODE (ost) != INTEGER_CST
11391 || tree_int_cst_sgn (ost) < 0
11392 || compare_tree_int (ost, 3) > 0)
11395 object_size_type = tree_low_cst (ost, 0);
11397 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
11398 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
11399 and (size_t) 0 for types 2 and 3. */
11400 if (TREE_SIDE_EFFECTS (ptr))
11401 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
11403 if (TREE_CODE (ptr) == ADDR_EXPR)
11404 ret = build_int_cstu (size_type_node,
11405 compute_builtin_object_size (ptr, object_size_type));
11407 else if (TREE_CODE (ptr) == SSA_NAME)
11409 unsigned HOST_WIDE_INT bytes;
11411 /* If object size is not known yet, delay folding until
11412 later. Maybe subsequent passes will help determining
11414 bytes = compute_builtin_object_size (ptr, object_size_type);
11415 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
11417 ret = build_int_cstu (size_type_node, bytes);
11422 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (ret);
11423 HOST_WIDE_INT high = TREE_INT_CST_HIGH (ret);
11424 if (fit_double_type (low, high, &low, &high, TREE_TYPE (ret)))
11431 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11432 DEST, SRC, LEN, and SIZE are the arguments to the call.
11433 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
11434 code of the builtin. If MAXLEN is not NULL, it is maximum length
11435 passed as third argument. */
11438 fold_builtin_memory_chk (tree fndecl,
11439 tree dest, tree src, tree len, tree size,
11440 tree maxlen, bool ignore,
11441 enum built_in_function fcode)
11445 if (!validate_arg (dest, POINTER_TYPE)
11446 || !validate_arg (src,
11447 (fcode == BUILT_IN_MEMSET_CHK
11448 ? INTEGER_TYPE : POINTER_TYPE))
11449 || !validate_arg (len, INTEGER_TYPE)
11450 || !validate_arg (size, INTEGER_TYPE))
11453 /* If SRC and DEST are the same (and not volatile), return DEST
11454 (resp. DEST+LEN for __mempcpy_chk). */
11455 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
11457 if (fcode != BUILT_IN_MEMPCPY_CHK)
11458 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
11461 tree temp = fold_convert (TREE_TYPE (dest), len);
11462 temp = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, temp);
11463 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), temp);
11467 if (! host_integerp (size, 1))
11470 if (! integer_all_onesp (size))
11472 if (! host_integerp (len, 1))
11474 /* If LEN is not constant, try MAXLEN too.
11475 For MAXLEN only allow optimizing into non-_ocs function
11476 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
11477 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
11479 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
11481 /* (void) __mempcpy_chk () can be optimized into
11482 (void) __memcpy_chk (). */
11483 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11487 return build_call_expr (fn, 4, dest, src, len, size);
11495 if (tree_int_cst_lt (size, maxlen))
11500 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11501 mem{cpy,pcpy,move,set} is available. */
11504 case BUILT_IN_MEMCPY_CHK:
11505 fn = built_in_decls[BUILT_IN_MEMCPY];
11507 case BUILT_IN_MEMPCPY_CHK:
11508 fn = built_in_decls[BUILT_IN_MEMPCPY];
11510 case BUILT_IN_MEMMOVE_CHK:
11511 fn = built_in_decls[BUILT_IN_MEMMOVE];
11513 case BUILT_IN_MEMSET_CHK:
11514 fn = built_in_decls[BUILT_IN_MEMSET];
11523 return build_call_expr (fn, 3, dest, src, len);
11526 /* Fold a call to the __st[rp]cpy_chk builtin.
11527 DEST, SRC, and SIZE are the arguments to the call.
11528 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
11529 code of the builtin. If MAXLEN is not NULL, it is maximum length of
11530 strings passed as second argument. */
11533 fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
11534 tree maxlen, bool ignore,
11535 enum built_in_function fcode)
11539 if (!validate_arg (dest, POINTER_TYPE)
11540 || !validate_arg (src, POINTER_TYPE)
11541 || !validate_arg (size, INTEGER_TYPE))
11544 /* If SRC and DEST are the same (and not volatile), return DEST. */
11545 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
11546 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
11548 if (! host_integerp (size, 1))
11551 if (! integer_all_onesp (size))
11553 len = c_strlen (src, 1);
11554 if (! len || ! host_integerp (len, 1))
11556 /* If LEN is not constant, try MAXLEN too.
11557 For MAXLEN only allow optimizing into non-_ocs function
11558 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
11559 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
11561 if (fcode == BUILT_IN_STPCPY_CHK)
11566 /* If return value of __stpcpy_chk is ignored,
11567 optimize into __strcpy_chk. */
11568 fn = built_in_decls[BUILT_IN_STRCPY_CHK];
11572 return build_call_expr (fn, 3, dest, src, size);
11575 if (! len || TREE_SIDE_EFFECTS (len))
11578 /* If c_strlen returned something, but not a constant,
11579 transform __strcpy_chk into __memcpy_chk. */
11580 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11584 len = size_binop (PLUS_EXPR, len, ssize_int (1));
11585 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
11586 build_call_expr (fn, 4,
11587 dest, src, len, size));
11593 if (! tree_int_cst_lt (maxlen, size))
11597 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
11598 fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
11599 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
11603 return build_call_expr (fn, 2, dest, src);
11606 /* Fold a call to the __strncpy_chk builtin. DEST, SRC, LEN, and SIZE
11607 are the arguments to the call. If MAXLEN is not NULL, it is maximum
11608 length passed as third argument. */
11611 fold_builtin_strncpy_chk (tree dest, tree src, tree len, tree size,
11616 if (!validate_arg (dest, POINTER_TYPE)
11617 || !validate_arg (src, POINTER_TYPE)
11618 || !validate_arg (len, INTEGER_TYPE)
11619 || !validate_arg (size, INTEGER_TYPE))
11622 if (! host_integerp (size, 1))
11625 if (! integer_all_onesp (size))
11627 if (! host_integerp (len, 1))
11629 /* If LEN is not constant, try MAXLEN too.
11630 For MAXLEN only allow optimizing into non-_ocs function
11631 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
11632 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
11638 if (tree_int_cst_lt (size, maxlen))
11642 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
11643 fn = built_in_decls[BUILT_IN_STRNCPY];
11647 return build_call_expr (fn, 3, dest, src, len);
11650 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
11651 are the arguments to the call. */
11654 fold_builtin_strcat_chk (tree fndecl, tree dest, tree src, tree size)
11659 if (!validate_arg (dest, POINTER_TYPE)
11660 || !validate_arg (src, POINTER_TYPE)
11661 || !validate_arg (size, INTEGER_TYPE))
11664 p = c_getstr (src);
11665 /* If the SRC parameter is "", return DEST. */
11666 if (p && *p == '\0')
11667 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
11669 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
11672 /* If __builtin_strcat_chk is used, assume strcat is available. */
11673 fn = built_in_decls[BUILT_IN_STRCAT];
11677 return build_call_expr (fn, 2, dest, src);
11680 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
11684 fold_builtin_strncat_chk (tree fndecl,
11685 tree dest, tree src, tree len, tree size)
11690 if (!validate_arg (dest, POINTER_TYPE)
11691 || !validate_arg (src, POINTER_TYPE)
11692 || !validate_arg (size, INTEGER_TYPE)
11693 || !validate_arg (size, INTEGER_TYPE))
11696 p = c_getstr (src);
11697 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
11698 if (p && *p == '\0')
11699 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
11700 else if (integer_zerop (len))
11701 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
11703 if (! host_integerp (size, 1))
11706 if (! integer_all_onesp (size))
11708 tree src_len = c_strlen (src, 1);
11710 && host_integerp (src_len, 1)
11711 && host_integerp (len, 1)
11712 && ! tree_int_cst_lt (len, src_len))
11714 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
11715 fn = built_in_decls[BUILT_IN_STRCAT_CHK];
11719 return build_call_expr (fn, 3, dest, src, size);
11724 /* If __builtin_strncat_chk is used, assume strncat is available. */
11725 fn = built_in_decls[BUILT_IN_STRNCAT];
11729 return build_call_expr (fn, 3, dest, src, len);
11732 /* Fold a call EXP to __{,v}sprintf_chk. Return NULL_TREE if
11733 a normal call should be emitted rather than expanding the function
11734 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
11737 fold_builtin_sprintf_chk (tree exp, enum built_in_function fcode)
11739 tree dest, size, len, fn, fmt, flag;
11740 const char *fmt_str;
11741 int nargs = call_expr_nargs (exp);
11743 /* Verify the required arguments in the original call. */
11746 dest = CALL_EXPR_ARG (exp, 0);
11747 if (!validate_arg (dest, POINTER_TYPE))
11749 flag = CALL_EXPR_ARG (exp, 1);
11750 if (!validate_arg (flag, INTEGER_TYPE))
11752 size = CALL_EXPR_ARG (exp, 2);
11753 if (!validate_arg (size, INTEGER_TYPE))
11755 fmt = CALL_EXPR_ARG (exp, 3);
11756 if (!validate_arg (fmt, POINTER_TYPE))
11759 if (! host_integerp (size, 1))
11764 if (!init_target_chars ())
11767 /* Check whether the format is a literal string constant. */
11768 fmt_str = c_getstr (fmt);
11769 if (fmt_str != NULL)
11771 /* If the format doesn't contain % args or %%, we know the size. */
11772 if (strchr (fmt_str, target_percent) == 0)
11774 if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
11775 len = build_int_cstu (size_type_node, strlen (fmt_str));
11777 /* If the format is "%s" and first ... argument is a string literal,
11778 we know the size too. */
11779 else if (fcode == BUILT_IN_SPRINTF_CHK
11780 && strcmp (fmt_str, target_percent_s) == 0)
11786 arg = CALL_EXPR_ARG (exp, 4);
11787 if (validate_arg (arg, POINTER_TYPE))
11789 len = c_strlen (arg, 1);
11790 if (! len || ! host_integerp (len, 1))
11797 if (! integer_all_onesp (size))
11799 if (! len || ! tree_int_cst_lt (len, size))
11803 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
11804 or if format doesn't contain % chars or is "%s". */
11805 if (! integer_zerop (flag))
11807 if (fmt_str == NULL)
11809 if (strchr (fmt_str, target_percent) != NULL
11810 && strcmp (fmt_str, target_percent_s))
11814 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
11815 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
11816 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
11820 return rewrite_call_expr (exp, 4, fn, 2, dest, fmt);
11823 /* Fold a call EXP to {,v}snprintf. Return NULL_TREE if
11824 a normal call should be emitted rather than expanding the function
11825 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
11826 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
11827 passed as second argument. */
11830 fold_builtin_snprintf_chk (tree exp, tree maxlen,
11831 enum built_in_function fcode)
11833 tree dest, size, len, fn, fmt, flag;
11834 const char *fmt_str;
11836 /* Verify the required arguments in the original call. */
11837 if (call_expr_nargs (exp) < 5)
11839 dest = CALL_EXPR_ARG (exp, 0);
11840 if (!validate_arg (dest, POINTER_TYPE))
11842 len = CALL_EXPR_ARG (exp, 1);
11843 if (!validate_arg (len, INTEGER_TYPE))
11845 flag = CALL_EXPR_ARG (exp, 2);
11846 if (!validate_arg (flag, INTEGER_TYPE))
11848 size = CALL_EXPR_ARG (exp, 3);
11849 if (!validate_arg (size, INTEGER_TYPE))
11851 fmt = CALL_EXPR_ARG (exp, 4);
11852 if (!validate_arg (fmt, POINTER_TYPE))
11855 if (! host_integerp (size, 1))
11858 if (! integer_all_onesp (size))
11860 if (! host_integerp (len, 1))
11862 /* If LEN is not constant, try MAXLEN too.
11863 For MAXLEN only allow optimizing into non-_ocs function
11864 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
11865 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
11871 if (tree_int_cst_lt (size, maxlen))
11875 if (!init_target_chars ())
11878 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
11879 or if format doesn't contain % chars or is "%s". */
11880 if (! integer_zerop (flag))
11882 fmt_str = c_getstr (fmt);
11883 if (fmt_str == NULL)
11885 if (strchr (fmt_str, target_percent) != NULL
11886 && strcmp (fmt_str, target_percent_s))
11890 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
11892 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
11893 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
11897 return rewrite_call_expr (exp, 5, fn, 3, dest, len, fmt);
11900 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
11901 FMT and ARG are the arguments to the call; we don't fold cases with
11902 more than 2 arguments, and ARG may be null if this is a 1-argument case.
11904 Return NULL_TREE if no simplification was possible, otherwise return the
11905 simplified form of the call as a tree. FCODE is the BUILT_IN_*
11906 code of the function to be simplified. */
11909 fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
11910 enum built_in_function fcode)
11912 tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
11913 const char *fmt_str = NULL;
11915 /* If the return value is used, don't do the transformation. */
11919 /* Verify the required arguments in the original call. */
11920 if (!validate_arg (fmt, POINTER_TYPE))
11923 /* Check whether the format is a literal string constant. */
11924 fmt_str = c_getstr (fmt);
11925 if (fmt_str == NULL)
11928 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
11930 /* If we're using an unlocked function, assume the other
11931 unlocked functions exist explicitly. */
11932 fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
11933 fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
11937 fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
11938 fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
11941 if (!init_target_chars ())
11944 if (strcmp (fmt_str, target_percent_s) == 0
11945 || strchr (fmt_str, target_percent) == NULL)
11949 if (strcmp (fmt_str, target_percent_s) == 0)
11951 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
11954 if (!arg || !validate_arg (arg, POINTER_TYPE))
11957 str = c_getstr (arg);
11963 /* The format specifier doesn't contain any '%' characters. */
11964 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
11970 /* If the string was "", printf does nothing. */
11971 if (str[0] == '\0')
11972 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
11974 /* If the string has length of 1, call putchar. */
11975 if (str[1] == '\0')
11977 /* Given printf("c"), (where c is any one character,)
11978 convert "c"[0] to an int and pass that to the replacement
11980 newarg = build_int_cst (NULL_TREE, str[0]);
11982 call = build_call_expr (fn_putchar, 1, newarg);
11986 /* If the string was "string\n", call puts("string"). */
11987 size_t len = strlen (str);
11988 if ((unsigned char)str[len - 1] == target_newline)
11990 /* Create a NUL-terminated string that's one char shorter
11991 than the original, stripping off the trailing '\n'. */
11992 char *newstr = alloca (len);
11993 memcpy (newstr, str, len - 1);
11994 newstr[len - 1] = 0;
11996 newarg = build_string_literal (len, newstr);
11998 call = build_call_expr (fn_puts, 1, newarg);
12001 /* We'd like to arrange to call fputs(string,stdout) here,
12002 but we need stdout and don't have a way to get it yet. */
12007 /* The other optimizations can be done only on the non-va_list variants. */
12008 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12011 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
12012 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12014 if (!arg || !validate_arg (arg, POINTER_TYPE))
12017 call = build_call_expr (fn_puts, 1, arg);
12020 /* If the format specifier was "%c", call __builtin_putchar(arg). */
12021 else if (strcmp (fmt_str, target_percent_c) == 0)
12023 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12026 call = build_call_expr (fn_putchar, 1, arg);
12032 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
12035 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12036 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
12037 more than 3 arguments, and ARG may be null in the 2-argument case.
12039 Return NULL_TREE if no simplification was possible, otherwise return the
12040 simplified form of the call as a tree. FCODE is the BUILT_IN_*
12041 code of the function to be simplified. */
12044 fold_builtin_fprintf (tree fndecl, tree fp, tree fmt, tree arg, bool ignore,
12045 enum built_in_function fcode)
12047 tree fn_fputc, fn_fputs, call = NULL_TREE;
12048 const char *fmt_str = NULL;
12050 /* If the return value is used, don't do the transformation. */
12054 /* Verify the required arguments in the original call. */
12055 if (!validate_arg (fp, POINTER_TYPE))
12057 if (!validate_arg (fmt, POINTER_TYPE))
12060 /* Check whether the format is a literal string constant. */
12061 fmt_str = c_getstr (fmt);
12062 if (fmt_str == NULL)
12065 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12067 /* If we're using an unlocked function, assume the other
12068 unlocked functions exist explicitly. */
12069 fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12070 fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12074 fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12075 fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12078 if (!init_target_chars ())
12081 /* If the format doesn't contain % args or %%, use strcpy. */
12082 if (strchr (fmt_str, target_percent) == NULL)
12084 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12088 /* If the format specifier was "", fprintf does nothing. */
12089 if (fmt_str[0] == '\0')
12091 /* If FP has side-effects, just wait until gimplification is
12093 if (TREE_SIDE_EFFECTS (fp))
12096 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12099 /* When "string" doesn't contain %, replace all cases of
12100 fprintf (fp, string) with fputs (string, fp). The fputs
12101 builtin will take care of special cases like length == 1. */
12103 call = build_call_expr (fn_fputs, 2, fmt, fp);
12106 /* The other optimizations can be done only on the non-va_list variants. */
12107 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12110 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
12111 else if (strcmp (fmt_str, target_percent_s) == 0)
12113 if (!arg || !validate_arg (arg, POINTER_TYPE))
12116 call = build_call_expr (fn_fputs, 2, arg, fp);
12119 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
12120 else if (strcmp (fmt_str, target_percent_c) == 0)
12122 if (!arg || !validate_arg (arg, INTEGER_TYPE))
12125 call = build_call_expr (fn_fputc, 2, arg, fp);
12130 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
12133 /* Initialize format string characters in the target charset. */
12136 init_target_chars (void)
12141 target_newline = lang_hooks.to_target_charset ('\n');
12142 target_percent = lang_hooks.to_target_charset ('%');
12143 target_c = lang_hooks.to_target_charset ('c');
12144 target_s = lang_hooks.to_target_charset ('s');
12145 if (target_newline == 0 || target_percent == 0 || target_c == 0
12149 target_percent_c[0] = target_percent;
12150 target_percent_c[1] = target_c;
12151 target_percent_c[2] = '\0';
12153 target_percent_s[0] = target_percent;
12154 target_percent_s[1] = target_s;
12155 target_percent_s[2] = '\0';
12157 target_percent_s_newline[0] = target_percent;
12158 target_percent_s_newline[1] = target_s;
12159 target_percent_s_newline[2] = target_newline;
12160 target_percent_s_newline[3] = '\0';
12167 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
12168 and no overflow/underflow occurred. INEXACT is true if M was not
12169 exactly calculated. TYPE is the tree type for the result. This
12170 function assumes that you cleared the MPFR flags and then
12171 calculated M to see if anything subsequently set a flag prior to
12172 entering this function. Return NULL_TREE if any checks fail. */
12175 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
12177 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12178 overflow/underflow occurred. If -frounding-math, proceed iff the
12179 result of calling FUNC was exact. */
12180 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12181 && (!flag_rounding_math || !inexact))
12183 REAL_VALUE_TYPE rr;
12185 real_from_mpfr (&rr, m);
12186 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12187 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
12188 but the mpft_t is not, then we underflowed in the
12190 if (!real_isnan (&rr) && !real_isinf (&rr)
12191 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
12193 REAL_VALUE_TYPE rmode;
12195 real_convert (&rmode, TYPE_MODE (type), &rr);
12196 /* Proceed iff the specified mode can hold the value. */
12197 if (real_identical (&rmode, &rr))
12198 return build_real (type, rmode);
12204 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
12205 FUNC on it and return the resulting value as a tree with type TYPE.
12206 If MIN and/or MAX are not NULL, then the supplied ARG must be
12207 within those bounds. If INCLUSIVE is true, then MIN/MAX are
12208 acceptable values, otherwise they are not. The mpfr precision is
12209 set to the precision of TYPE. We assume that function FUNC returns
12210 zero if the result could be calculated exactly within the requested
12214 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
12215 const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
12218 tree result = NULL_TREE;
12222 /* To proceed, MPFR must exactly represent the target floating point
12223 format, which only happens when the target base equals two. */
12224 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
12225 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
12227 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
12229 if (!real_isnan (ra) && !real_isinf (ra)
12230 && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
12231 && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
12233 const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p;
12237 mpfr_init2 (m, prec);
12238 mpfr_from_real (m, ra);
12239 mpfr_clear_flags ();
12240 inexact = func (m, m, GMP_RNDN);
12241 result = do_mpfr_ckconv (m, type, inexact);
12249 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
12250 FUNC on it and return the resulting value as a tree with type TYPE.
12251 The mpfr precision is set to the precision of TYPE. We assume that
12252 function FUNC returns zero if the result could be calculated
12253 exactly within the requested precision. */
12256 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
12257 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
12259 tree result = NULL_TREE;
12264 /* To proceed, MPFR must exactly represent the target floating point
12265 format, which only happens when the target base equals two. */
12266 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
12267 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
12268 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
12270 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
12271 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
12273 if (!real_isnan (ra1) && !real_isinf (ra1)
12274 && !real_isnan (ra2) && !real_isinf (ra2))
12276 const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p;
12280 mpfr_inits2 (prec, m1, m2, NULL);
12281 mpfr_from_real (m1, ra1);
12282 mpfr_from_real (m2, ra2);
12283 mpfr_clear_flags ();
12284 inexact = func (m1, m1, m2, GMP_RNDN);
12285 result = do_mpfr_ckconv (m1, type, inexact);
12286 mpfr_clears (m1, m2, NULL);
12293 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
12294 FUNC on it and return the resulting value as a tree with type TYPE.
12295 The mpfr precision is set to the precision of TYPE. We assume that
12296 function FUNC returns zero if the result could be calculated
12297 exactly within the requested precision. */
12300 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
12301 int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
12303 tree result = NULL_TREE;
12309 /* To proceed, MPFR must exactly represent the target floating point
12310 format, which only happens when the target base equals two. */
12311 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
12312 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
12313 && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
12314 && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
12316 const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
12317 const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
12318 const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
12320 if (!real_isnan (ra1) && !real_isinf (ra1)
12321 && !real_isnan (ra2) && !real_isinf (ra2)
12322 && !real_isnan (ra3) && !real_isinf (ra3))
12324 const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p;
12328 mpfr_inits2 (prec, m1, m2, m3, NULL);
12329 mpfr_from_real (m1, ra1);
12330 mpfr_from_real (m2, ra2);
12331 mpfr_from_real (m3, ra3);
12332 mpfr_clear_flags ();
12333 inexact = func (m1, m1, m2, m3, GMP_RNDN);
12334 result = do_mpfr_ckconv (m1, type, inexact);
12335 mpfr_clears (m1, m2, m3, NULL);
12342 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
12343 the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
12344 If ARG_SINP and ARG_COSP are NULL then the result is returned
12345 as a complex value.
12346 The type is taken from the type of ARG and is used for setting the
12347 precision of the calculation and results. */
12350 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
12352 tree const type = TREE_TYPE (arg);
12353 tree result = NULL_TREE;
12357 /* To proceed, MPFR must exactly represent the target floating point
12358 format, which only happens when the target base equals two. */
12359 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
12360 && TREE_CODE (arg) == REAL_CST
12361 && !TREE_OVERFLOW (arg))
12363 const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
12365 if (!real_isnan (ra) && !real_isinf (ra))
12367 const int prec = REAL_MODE_FORMAT (TYPE_MODE (type))->p;
12368 tree result_s, result_c;
12372 mpfr_inits2 (prec, m, ms, mc, NULL);
12373 mpfr_from_real (m, ra);
12374 mpfr_clear_flags ();
12375 inexact = mpfr_sin_cos (ms, mc, m, GMP_RNDN);
12376 result_s = do_mpfr_ckconv (ms, type, inexact);
12377 result_c = do_mpfr_ckconv (mc, type, inexact);
12378 mpfr_clears (m, ms, mc, NULL);
12379 if (result_s && result_c)
12381 /* If we are to return in a complex value do so. */
12382 if (!arg_sinp && !arg_cosp)
12383 return build_complex (build_complex_type (type),
12384 result_c, result_s);
12386 /* Dereference the sin/cos pointer arguments. */
12387 arg_sinp = build_fold_indirect_ref (arg_sinp);
12388 arg_cosp = build_fold_indirect_ref (arg_cosp);
12389 /* Proceed if valid pointer type were passed in. */
12390 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
12391 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
12393 /* Set the values. */
12394 result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
12396 TREE_SIDE_EFFECTS (result_s) = 1;
12397 result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
12399 TREE_SIDE_EFFECTS (result_c) = 1;
12400 /* Combine the assignments into a compound expr. */
12401 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
12402 result_s, result_c));