1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
30 #include "tree-gimple.h"
33 #include "hard-reg-set.h"
36 #include "insn-config.h"
42 #include "typeclass.h"
47 #include "langhooks.h"
48 #include "basic-block.h"
49 #include "tree-mudflap.h"
51 #ifndef PAD_VARARGS_DOWN
52 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
55 /* Define the names of the builtin function types and codes. */
56 const char *const built_in_class_names
[4]
57 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
59 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
60 const char * built_in_names
[(int) END_BUILTINS
] =
62 #include "builtins.def"
66 /* Setup an array of _DECL trees, make sure each element is
67 initialized to NULL_TREE. */
68 tree built_in_decls
[(int) END_BUILTINS
];
69 /* Declarations used when constructing the builtin implicitly in the compiler.
70 It may be NULL_TREE when this is invalid (for instance runtime is not
71 required to implement the function call in all cases). */
72 tree implicit_built_in_decls
[(int) END_BUILTINS
];
74 static int get_pointer_alignment (tree
, unsigned int);
75 static const char *c_getstr (tree
);
76 static rtx
c_readstr (const char *, enum machine_mode
);
77 static int target_char_cast (tree
, char *);
78 static rtx
get_memory_rtx (tree
, tree
);
79 static tree
build_string_literal (int, const char *);
80 static int apply_args_size (void);
81 static int apply_result_size (void);
82 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
83 static rtx
result_vector (int, rtx
);
85 static rtx
expand_builtin_setjmp (tree
, 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_int_roundingfn (tree
, rtx
, rtx
);
99 static rtx
expand_builtin_args_info (tree
);
100 static rtx
expand_builtin_next_arg (void);
101 static rtx
expand_builtin_va_start (tree
);
102 static rtx
expand_builtin_va_end (tree
);
103 static rtx
expand_builtin_va_copy (tree
);
104 static rtx
expand_builtin_memcmp (tree
, tree
, rtx
, enum machine_mode
);
105 static rtx
expand_builtin_strcmp (tree
, rtx
, enum machine_mode
);
106 static rtx
expand_builtin_strncmp (tree
, rtx
, enum machine_mode
);
107 static rtx
builtin_memcpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
108 static rtx
expand_builtin_strcat (tree
, tree
, rtx
, enum machine_mode
);
109 static rtx
expand_builtin_strncat (tree
, rtx
, enum machine_mode
);
110 static rtx
expand_builtin_strspn (tree
, rtx
, enum machine_mode
);
111 static rtx
expand_builtin_strcspn (tree
, rtx
, enum machine_mode
);
112 static rtx
expand_builtin_memcpy (tree
, rtx
, enum machine_mode
);
113 static rtx
expand_builtin_mempcpy (tree
, tree
, rtx
, enum machine_mode
, int);
114 static rtx
expand_builtin_memmove (tree
, tree
, rtx
, enum machine_mode
, tree
);
115 static rtx
expand_builtin_bcopy (tree
);
116 static rtx
expand_builtin_strcpy (tree
, tree
, rtx
, enum machine_mode
);
117 static rtx
expand_builtin_stpcpy (tree
, rtx
, enum machine_mode
);
118 static rtx
builtin_strncpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
119 static rtx
expand_builtin_strncpy (tree
, rtx
, enum machine_mode
);
120 static rtx
builtin_memset_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
121 static rtx
builtin_memset_gen_str (void *, HOST_WIDE_INT
, enum machine_mode
);
122 static rtx
expand_builtin_memset (tree
, rtx
, enum machine_mode
, tree
);
123 static rtx
expand_builtin_bzero (tree
);
124 static rtx
expand_builtin_strlen (tree
, rtx
, enum machine_mode
);
125 static rtx
expand_builtin_strstr (tree
, tree
, rtx
, enum machine_mode
);
126 static rtx
expand_builtin_strpbrk (tree
, tree
, rtx
, enum machine_mode
);
127 static rtx
expand_builtin_strchr (tree
, tree
, rtx
, enum machine_mode
);
128 static rtx
expand_builtin_strrchr (tree
, tree
, rtx
, enum machine_mode
);
129 static rtx
expand_builtin_alloca (tree
, rtx
);
130 static rtx
expand_builtin_unop (enum machine_mode
, tree
, rtx
, rtx
, optab
);
131 static rtx
expand_builtin_frame_address (tree
, tree
);
132 static rtx
expand_builtin_fputs (tree
, rtx
, bool);
133 static rtx
expand_builtin_printf (tree
, rtx
, enum machine_mode
, bool);
134 static rtx
expand_builtin_fprintf (tree
, rtx
, enum machine_mode
, bool);
135 static rtx
expand_builtin_sprintf (tree
, rtx
, enum machine_mode
);
136 static tree
stabilize_va_list (tree
, int);
137 static rtx
expand_builtin_expect (tree
, rtx
);
138 static tree
fold_builtin_constant_p (tree
);
139 static tree
fold_builtin_classify_type (tree
);
140 static tree
fold_builtin_strlen (tree
);
141 static tree
fold_builtin_inf (tree
, int);
142 static tree
fold_builtin_nan (tree
, tree
, int);
143 static int validate_arglist (tree
, ...);
144 static bool integer_valued_real_p (tree
);
145 static tree
fold_trunc_transparent_mathfn (tree
, tree
);
146 static bool readonly_data_expr (tree
);
147 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
148 static rtx
expand_builtin_signbit (tree
, rtx
);
149 static tree
fold_builtin_cabs (tree
, tree
);
150 static tree
fold_builtin_sqrt (tree
, tree
);
151 static tree
fold_builtin_cbrt (tree
, tree
);
152 static tree
fold_builtin_pow (tree
, tree
, tree
);
153 static tree
fold_builtin_powi (tree
, tree
, tree
);
154 static tree
fold_builtin_sin (tree
);
155 static tree
fold_builtin_cos (tree
, tree
, tree
);
156 static tree
fold_builtin_tan (tree
);
157 static tree
fold_builtin_atan (tree
, tree
);
158 static tree
fold_builtin_trunc (tree
, tree
);
159 static tree
fold_builtin_floor (tree
, tree
);
160 static tree
fold_builtin_ceil (tree
, tree
);
161 static tree
fold_builtin_round (tree
, tree
);
162 static tree
fold_builtin_int_roundingfn (tree
, tree
);
163 static tree
fold_builtin_bitop (tree
, tree
);
164 static tree
fold_builtin_memcpy (tree
, tree
);
165 static tree
fold_builtin_mempcpy (tree
, tree
, int);
166 static tree
fold_builtin_memmove (tree
, tree
);
167 static tree
fold_builtin_strchr (tree
, tree
);
168 static tree
fold_builtin_memcmp (tree
);
169 static tree
fold_builtin_strcmp (tree
);
170 static tree
fold_builtin_strncmp (tree
);
171 static tree
fold_builtin_signbit (tree
, tree
);
172 static tree
fold_builtin_copysign (tree
, tree
, tree
);
173 static tree
fold_builtin_isascii (tree
);
174 static tree
fold_builtin_toascii (tree
);
175 static tree
fold_builtin_isdigit (tree
);
176 static tree
fold_builtin_fabs (tree
, tree
);
177 static tree
fold_builtin_abs (tree
, tree
);
178 static tree
fold_builtin_unordered_cmp (tree
, tree
, enum tree_code
,
180 static tree
fold_builtin_1 (tree
, tree
, bool);
182 static tree
fold_builtin_strpbrk (tree
, tree
);
183 static tree
fold_builtin_strstr (tree
, tree
);
184 static tree
fold_builtin_strrchr (tree
, tree
);
185 static tree
fold_builtin_strcat (tree
);
186 static tree
fold_builtin_strncat (tree
);
187 static tree
fold_builtin_strspn (tree
);
188 static tree
fold_builtin_strcspn (tree
);
189 static tree
fold_builtin_sprintf (tree
, int);
191 static rtx
expand_builtin_object_size (tree
);
192 static rtx
expand_builtin_memory_chk (tree
, rtx
, enum machine_mode
,
193 enum built_in_function
);
194 static void maybe_emit_chk_warning (tree
, enum built_in_function
);
195 static void maybe_emit_sprintf_chk_warning (tree
, enum built_in_function
);
196 static tree
fold_builtin_object_size (tree
);
197 static tree
fold_builtin_strcat_chk (tree
, tree
);
198 static tree
fold_builtin_strncat_chk (tree
, tree
);
199 static tree
fold_builtin_sprintf_chk (tree
, enum built_in_function
);
200 static tree
fold_builtin_printf (tree
, tree
, bool, enum built_in_function
);
201 static tree
fold_builtin_fprintf (tree
, tree
, bool, enum built_in_function
);
203 /* Return true if NODE should be considered for inline expansion regardless
204 of the optimization level. This means whenever a function is invoked with
205 its "internal" name, which normally contains the prefix "__builtin". */
207 static bool called_as_built_in (tree node
)
209 const char *name
= IDENTIFIER_POINTER (DECL_NAME (node
));
210 if (strncmp (name
, "__builtin_", 10) == 0)
212 if (strncmp (name
, "__sync_", 7) == 0)
217 /* Return the alignment in bits of EXP, a pointer valued expression.
218 But don't return more than MAX_ALIGN no matter what.
219 The alignment returned is, by default, the alignment of the thing that
220 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
222 Otherwise, look at the expression to see if we can do better, i.e., if the
223 expression is actually pointing at an object whose alignment is tighter. */
226 get_pointer_alignment (tree exp
, unsigned int max_align
)
228 unsigned int align
, inner
;
230 if (! POINTER_TYPE_P (TREE_TYPE (exp
)))
233 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
234 align
= MIN (align
, max_align
);
238 switch (TREE_CODE (exp
))
242 case NON_LVALUE_EXPR
:
243 exp
= TREE_OPERAND (exp
, 0);
244 if (! POINTER_TYPE_P (TREE_TYPE (exp
)))
247 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
248 align
= MIN (inner
, max_align
);
252 /* If sum of pointer + int, restrict our maximum alignment to that
253 imposed by the integer. If not, we can't do any better than
255 if (! host_integerp (TREE_OPERAND (exp
, 1), 1))
258 while (((tree_low_cst (TREE_OPERAND (exp
, 1), 1))
259 & (max_align
/ BITS_PER_UNIT
- 1))
263 exp
= TREE_OPERAND (exp
, 0);
267 /* See what we are pointing at and look at its alignment. */
268 exp
= TREE_OPERAND (exp
, 0);
269 if (TREE_CODE (exp
) == FUNCTION_DECL
)
270 align
= FUNCTION_BOUNDARY
;
271 else if (DECL_P (exp
))
272 align
= DECL_ALIGN (exp
);
273 #ifdef CONSTANT_ALIGNMENT
274 else if (CONSTANT_CLASS_P (exp
))
275 align
= CONSTANT_ALIGNMENT (exp
, align
);
277 return MIN (align
, max_align
);
285 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
286 way, because it could contain a zero byte in the middle.
287 TREE_STRING_LENGTH is the size of the character array, not the string.
289 ONLY_VALUE should be nonzero if the result is not going to be emitted
290 into the instruction stream and zero if it is going to be expanded.
291 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
292 is returned, otherwise NULL, since
293 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
294 evaluate the side-effects.
296 The value returned is of type `ssizetype'.
298 Unfortunately, string_constant can't access the values of const char
299 arrays with initializers, so neither can we do so here. */
302 c_strlen (tree src
, int only_value
)
305 HOST_WIDE_INT offset
;
310 if (TREE_CODE (src
) == COND_EXPR
311 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
315 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
316 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
317 if (tree_int_cst_equal (len1
, len2
))
321 if (TREE_CODE (src
) == COMPOUND_EXPR
322 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
323 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
325 src
= string_constant (src
, &offset_node
);
329 max
= TREE_STRING_LENGTH (src
) - 1;
330 ptr
= TREE_STRING_POINTER (src
);
332 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
334 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
335 compute the offset to the following null if we don't know where to
336 start searching for it. */
339 for (i
= 0; i
< max
; i
++)
343 /* We don't know the starting offset, but we do know that the string
344 has no internal zero bytes. We can assume that the offset falls
345 within the bounds of the string; otherwise, the programmer deserves
346 what he gets. Subtract the offset from the length of the string,
347 and return that. This would perhaps not be valid if we were dealing
348 with named arrays in addition to literal string constants. */
350 return size_diffop (size_int (max
), offset_node
);
353 /* We have a known offset into the string. Start searching there for
354 a null character if we can represent it as a single HOST_WIDE_INT. */
355 if (offset_node
== 0)
357 else if (! host_integerp (offset_node
, 0))
360 offset
= tree_low_cst (offset_node
, 0);
362 /* If the offset is known to be out of bounds, warn, and call strlen at
364 if (offset
< 0 || offset
> max
)
366 warning (0, "offset outside bounds of constant string");
370 /* Use strlen to search for the first zero byte. Since any strings
371 constructed with build_string will have nulls appended, we win even
372 if we get handed something like (char[4])"abcd".
374 Since OFFSET is our starting index into the string, no further
375 calculation is needed. */
376 return ssize_int (strlen (ptr
+ offset
));
379 /* Return a char pointer for a C string if it is a string constant
380 or sum of string constant and integer constant. */
387 src
= string_constant (src
, &offset_node
);
391 if (offset_node
== 0)
392 return TREE_STRING_POINTER (src
);
393 else if (!host_integerp (offset_node
, 1)
394 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
397 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
400 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
401 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
404 c_readstr (const char *str
, enum machine_mode mode
)
410 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
415 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
418 if (WORDS_BIG_ENDIAN
)
419 j
= GET_MODE_SIZE (mode
) - i
- 1;
420 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
421 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
422 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
424 gcc_assert (j
<= 2 * HOST_BITS_PER_WIDE_INT
);
427 ch
= (unsigned char) str
[i
];
428 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
430 return immed_double_const (c
[0], c
[1], mode
);
433 /* Cast a target constant CST to target CHAR and if that value fits into
434 host char type, return zero and put that value into variable pointed to by
438 target_char_cast (tree cst
, char *p
)
440 unsigned HOST_WIDE_INT val
, hostval
;
442 if (!host_integerp (cst
, 1)
443 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
446 val
= tree_low_cst (cst
, 1);
447 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
448 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
451 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
452 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
461 /* Similar to save_expr, but assumes that arbitrary code is not executed
462 in between the multiple evaluations. In particular, we assume that a
463 non-addressable local variable will not be modified. */
466 builtin_save_expr (tree exp
)
468 if (TREE_ADDRESSABLE (exp
) == 0
469 && (TREE_CODE (exp
) == PARM_DECL
470 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
))))
473 return save_expr (exp
);
476 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
477 times to get the address of either a higher stack frame, or a return
478 address located within it (depending on FNDECL_CODE). */
481 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
485 #ifdef INITIAL_FRAME_ADDRESS_RTX
486 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
490 /* For a zero count, we don't care what frame address we return, so frame
491 pointer elimination is OK, and using the soft frame pointer is OK.
492 For a non-zero count, we require a stable offset from the current frame
493 pointer to the previous one, so we must use the hard frame pointer, and
494 we must disable frame pointer elimination. */
496 tem
= frame_pointer_rtx
;
499 tem
= hard_frame_pointer_rtx
;
501 /* Tell reload not to eliminate the frame pointer. */
502 current_function_accesses_prior_frames
= 1;
506 /* Some machines need special handling before we can access
507 arbitrary frames. For example, on the sparc, we must first flush
508 all register windows to the stack. */
509 #ifdef SETUP_FRAME_ADDRESSES
511 SETUP_FRAME_ADDRESSES ();
514 /* On the sparc, the return address is not in the frame, it is in a
515 register. There is no way to access it off of the current frame
516 pointer, but it can be accessed off the previous frame pointer by
517 reading the value from the register window save area. */
518 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
519 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
523 /* Scan back COUNT frames to the specified frame. */
524 for (i
= 0; i
< count
; i
++)
526 /* Assume the dynamic chain pointer is in the word that the
527 frame address points to, unless otherwise specified. */
528 #ifdef DYNAMIC_CHAIN_ADDRESS
529 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
531 tem
= memory_address (Pmode
, tem
);
532 tem
= gen_rtx_MEM (Pmode
, tem
);
533 set_mem_alias_set (tem
, get_frame_alias_set ());
534 tem
= copy_to_reg (tem
);
537 /* For __builtin_frame_address, return what we've got. */
538 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
541 /* For __builtin_return_address, Get the return address from that
543 #ifdef RETURN_ADDR_RTX
544 tem
= RETURN_ADDR_RTX (count
, tem
);
546 tem
= memory_address (Pmode
,
547 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
548 tem
= gen_rtx_MEM (Pmode
, tem
);
549 set_mem_alias_set (tem
, get_frame_alias_set ());
554 /* Alias set used for setjmp buffer. */
555 static HOST_WIDE_INT setjmp_alias_set
= -1;
557 /* Construct the leading half of a __builtin_setjmp call. Control will
558 return to RECEIVER_LABEL. This is used directly by sjlj exception
562 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
564 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
568 if (setjmp_alias_set
== -1)
569 setjmp_alias_set
= new_alias_set ();
571 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
573 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
575 /* We store the frame pointer and the address of receiver_label in
576 the buffer and use the rest of it for the stack save area, which
577 is machine-dependent. */
579 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
580 set_mem_alias_set (mem
, setjmp_alias_set
);
581 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
583 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
584 set_mem_alias_set (mem
, setjmp_alias_set
);
586 emit_move_insn (validize_mem (mem
),
587 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
589 stack_save
= gen_rtx_MEM (sa_mode
,
590 plus_constant (buf_addr
,
591 2 * GET_MODE_SIZE (Pmode
)));
592 set_mem_alias_set (stack_save
, setjmp_alias_set
);
593 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
595 /* If there is further processing to do, do it. */
596 #ifdef HAVE_builtin_setjmp_setup
597 if (HAVE_builtin_setjmp_setup
)
598 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
601 /* Tell optimize_save_area_alloca that extra work is going to
602 need to go on during alloca. */
603 current_function_calls_setjmp
= 1;
605 /* Set this so all the registers get saved in our frame; we need to be
606 able to copy the saved values for any registers from frames we unwind. */
607 current_function_has_nonlocal_label
= 1;
610 /* Construct the trailing part of a __builtin_setjmp call.
611 This is used directly by sjlj exception handling code. */
614 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
616 /* Clobber the FP when we get here, so we have to make sure it's
617 marked as used by this function. */
618 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
620 /* Mark the static chain as clobbered here so life information
621 doesn't get messed up for it. */
622 emit_insn (gen_rtx_CLOBBER (VOIDmode
, static_chain_rtx
));
624 /* Now put in the code to restore the frame pointer, and argument
625 pointer, if needed. */
626 #ifdef HAVE_nonlocal_goto
627 if (! HAVE_nonlocal_goto
)
629 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
631 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
632 if (fixed_regs
[ARG_POINTER_REGNUM
])
634 #ifdef ELIMINABLE_REGS
636 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
638 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
639 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
640 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
643 if (i
== ARRAY_SIZE (elim_regs
))
646 /* Now restore our arg pointer from the address at which it
647 was saved in our stack frame. */
648 emit_move_insn (virtual_incoming_args_rtx
,
649 copy_to_reg (get_arg_pointer_save_area (cfun
)));
654 #ifdef HAVE_builtin_setjmp_receiver
655 if (HAVE_builtin_setjmp_receiver
)
656 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
659 #ifdef HAVE_nonlocal_goto_receiver
660 if (HAVE_nonlocal_goto_receiver
)
661 emit_insn (gen_nonlocal_goto_receiver ());
666 /* @@@ This is a kludge. Not all machine descriptions define a blockage
667 insn, but we must not allow the code we just generated to be reordered
668 by scheduling. Specifically, the update of the frame pointer must
669 happen immediately, not later. So emit an ASM_INPUT to act as blockage
671 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
674 /* __builtin_setjmp is passed a pointer to an array of five words (not
675 all will be used on all machines). It operates similarly to the C
676 library function of the same name, but is more efficient. Much of
677 the code below (and for longjmp) is copied from the handling of
680 NOTE: This is intended for use by GNAT and the exception handling
681 scheme in the compiler and will only work in the method used by
685 expand_builtin_setjmp (tree arglist
, rtx target
)
687 rtx buf_addr
, next_lab
, cont_lab
;
689 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
692 if (target
== 0 || !REG_P (target
)
693 || REGNO (target
) < FIRST_PSEUDO_REGISTER
)
694 target
= gen_reg_rtx (TYPE_MODE (integer_type_node
));
696 buf_addr
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
698 next_lab
= gen_label_rtx ();
699 cont_lab
= gen_label_rtx ();
701 expand_builtin_setjmp_setup (buf_addr
, next_lab
);
703 /* Set TARGET to zero and branch to the continue label. Use emit_jump to
704 ensure that pending stack adjustments are flushed. */
705 emit_move_insn (target
, const0_rtx
);
706 emit_jump (cont_lab
);
708 emit_label (next_lab
);
710 expand_builtin_setjmp_receiver (next_lab
);
712 /* Set TARGET to one. */
713 emit_move_insn (target
, const1_rtx
);
714 emit_label (cont_lab
);
716 /* Tell flow about the strange goings on. Putting `next_lab' on
717 `nonlocal_goto_handler_labels' to indicates that function
718 calls may traverse the arc back to this label. */
720 current_function_has_nonlocal_label
= 1;
721 nonlocal_goto_handler_labels
722 = gen_rtx_EXPR_LIST (VOIDmode
, next_lab
, nonlocal_goto_handler_labels
);
727 /* __builtin_longjmp is passed a pointer to an array of five words (not
728 all will be used on all machines). It operates similarly to the C
729 library function of the same name, but is more efficient. Much of
730 the code below is copied from the handling of non-local gotos.
732 NOTE: This is intended for use by GNAT and the exception handling
733 scheme in the compiler and will only work in the method used by
737 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
739 rtx fp
, lab
, stack
, insn
, last
;
740 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
742 if (setjmp_alias_set
== -1)
743 setjmp_alias_set
= new_alias_set ();
745 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
747 buf_addr
= force_reg (Pmode
, buf_addr
);
749 /* We used to store value in static_chain_rtx, but that fails if pointers
750 are smaller than integers. We instead require that the user must pass
751 a second argument of 1, because that is what builtin_setjmp will
752 return. This also makes EH slightly more efficient, since we are no
753 longer copying around a value that we don't care about. */
754 gcc_assert (value
== const1_rtx
);
756 last
= get_last_insn ();
757 #ifdef HAVE_builtin_longjmp
758 if (HAVE_builtin_longjmp
)
759 emit_insn (gen_builtin_longjmp (buf_addr
));
763 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
764 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
765 GET_MODE_SIZE (Pmode
)));
767 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
768 2 * GET_MODE_SIZE (Pmode
)));
769 set_mem_alias_set (fp
, setjmp_alias_set
);
770 set_mem_alias_set (lab
, setjmp_alias_set
);
771 set_mem_alias_set (stack
, setjmp_alias_set
);
773 /* Pick up FP, label, and SP from the block and jump. This code is
774 from expand_goto in stmt.c; see there for detailed comments. */
775 #if HAVE_nonlocal_goto
776 if (HAVE_nonlocal_goto
)
777 /* We have to pass a value to the nonlocal_goto pattern that will
778 get copied into the static_chain pointer, but it does not matter
779 what that value is, because builtin_setjmp does not use it. */
780 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
784 lab
= copy_to_reg (lab
);
786 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
787 gen_rtx_MEM (BLKmode
,
788 gen_rtx_SCRATCH (VOIDmode
))));
789 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
790 gen_rtx_MEM (BLKmode
,
791 hard_frame_pointer_rtx
)));
793 emit_move_insn (hard_frame_pointer_rtx
, fp
);
794 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
796 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
797 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
798 emit_indirect_jump (lab
);
802 /* Search backwards and mark the jump insn as a non-local goto.
803 Note that this precludes the use of __builtin_longjmp to a
804 __builtin_setjmp target in the same function. However, we've
805 already cautioned the user that these functions are for
806 internal exception handling use only. */
807 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
809 gcc_assert (insn
!= last
);
813 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
, const0_rtx
,
817 else if (CALL_P (insn
))
822 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
823 and the address of the save area. */
826 expand_builtin_nonlocal_goto (tree arglist
)
828 tree t_label
, t_save_area
;
829 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
831 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
834 t_label
= TREE_VALUE (arglist
);
835 arglist
= TREE_CHAIN (arglist
);
836 t_save_area
= TREE_VALUE (arglist
);
838 r_label
= expand_expr (t_label
, NULL_RTX
, VOIDmode
, 0);
839 r_label
= convert_memory_address (Pmode
, r_label
);
840 r_save_area
= expand_expr (t_save_area
, NULL_RTX
, VOIDmode
, 0);
841 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
842 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
843 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
844 plus_constant (r_save_area
, GET_MODE_SIZE (Pmode
)));
846 current_function_has_nonlocal_goto
= 1;
848 #if HAVE_nonlocal_goto
849 /* ??? We no longer need to pass the static chain value, afaik. */
850 if (HAVE_nonlocal_goto
)
851 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
855 r_label
= copy_to_reg (r_label
);
857 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
858 gen_rtx_MEM (BLKmode
,
859 gen_rtx_SCRATCH (VOIDmode
))));
861 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
862 gen_rtx_MEM (BLKmode
,
863 hard_frame_pointer_rtx
)));
865 /* Restore frame pointer for containing function.
866 This sets the actual hard register used for the frame pointer
867 to the location of the function's incoming static chain info.
868 The non-local goto handler will then adjust it to contain the
869 proper value and reload the argument pointer, if needed. */
870 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
871 emit_stack_restore (SAVE_NONLOCAL
, r_sp
, NULL_RTX
);
873 /* USE of hard_frame_pointer_rtx added for consistency;
874 not clear if really needed. */
875 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
876 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
877 emit_indirect_jump (r_label
);
880 /* Search backwards to the jump insn and mark it as a
882 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
886 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
,
887 const0_rtx
, REG_NOTES (insn
));
890 else if (CALL_P (insn
))
897 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
898 (not all will be used on all machines) that was passed to __builtin_setjmp.
899 It updates the stack pointer in that block to correspond to the current
903 expand_builtin_update_setjmp_buf (rtx buf_addr
)
905 enum machine_mode sa_mode
= Pmode
;
909 #ifdef HAVE_save_stack_nonlocal
910 if (HAVE_save_stack_nonlocal
)
911 sa_mode
= insn_data
[(int) CODE_FOR_save_stack_nonlocal
].operand
[0].mode
;
913 #ifdef STACK_SAVEAREA_MODE
914 sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
918 = gen_rtx_MEM (sa_mode
,
921 plus_constant (buf_addr
, 2 * GET_MODE_SIZE (Pmode
))));
925 emit_insn (gen_setjmp ());
928 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
931 /* Expand a call to __builtin_prefetch. For a target that does not support
932 data prefetch, evaluate the memory address argument in case it has side
936 expand_builtin_prefetch (tree arglist
)
938 tree arg0
, arg1
, arg2
;
941 if (!validate_arglist (arglist
, POINTER_TYPE
, 0))
944 arg0
= TREE_VALUE (arglist
);
945 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
946 zero (read) and argument 2 (locality) defaults to 3 (high degree of
948 if (TREE_CHAIN (arglist
))
950 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
951 if (TREE_CHAIN (TREE_CHAIN (arglist
)))
952 arg2
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
954 arg2
= build_int_cst (NULL_TREE
, 3);
958 arg1
= integer_zero_node
;
959 arg2
= build_int_cst (NULL_TREE
, 3);
962 /* Argument 0 is an address. */
963 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
965 /* Argument 1 (read/write flag) must be a compile-time constant int. */
966 if (TREE_CODE (arg1
) != INTEGER_CST
)
968 error ("second argument to %<__builtin_prefetch%> must be a constant");
969 arg1
= integer_zero_node
;
971 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
972 /* Argument 1 must be either zero or one. */
973 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
975 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
980 /* Argument 2 (locality) must be a compile-time constant int. */
981 if (TREE_CODE (arg2
) != INTEGER_CST
)
983 error ("third argument to %<__builtin_prefetch%> must be a constant");
984 arg2
= integer_zero_node
;
986 op2
= expand_expr (arg2
, NULL_RTX
, VOIDmode
, 0);
987 /* Argument 2 must be 0, 1, 2, or 3. */
988 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
990 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
997 if ((! (*insn_data
[(int) CODE_FOR_prefetch
].operand
[0].predicate
)
999 insn_data
[(int) CODE_FOR_prefetch
].operand
[0].mode
))
1000 || (GET_MODE (op0
) != Pmode
))
1002 op0
= convert_memory_address (Pmode
, op0
);
1003 op0
= force_reg (Pmode
, op0
);
1005 emit_insn (gen_prefetch (op0
, op1
, op2
));
1009 /* Don't do anything with direct references to volatile memory, but
1010 generate code to handle other side effects. */
1011 if (!MEM_P (op0
) && side_effects_p (op0
))
1015 /* Get a MEM rtx for expression EXP which is the address of an operand
1016 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1017 the maximum length of the block of memory that might be accessed or
1021 get_memory_rtx (tree exp
, tree len
)
1023 rtx addr
= expand_expr (exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1024 rtx mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1026 /* Get an expression we can use to find the attributes to assign to MEM.
1027 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1028 we can. First remove any nops. */
1029 while ((TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
1030 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1031 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1032 exp
= TREE_OPERAND (exp
, 0);
1034 if (TREE_CODE (exp
) == ADDR_EXPR
)
1035 exp
= TREE_OPERAND (exp
, 0);
1036 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
1037 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
1041 /* Honor attributes derived from exp, except for the alias set
1042 (as builtin stringops may alias with anything) and the size
1043 (as stringops may access multiple array elements). */
1046 set_mem_attributes (mem
, exp
, 0);
1048 /* Allow the string and memory builtins to overflow from one
1049 field into another, see http://gcc.gnu.org/PR23561.
1050 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1051 memory accessed by the string or memory builtin will fit
1052 within the field. */
1053 if (MEM_EXPR (mem
) && TREE_CODE (MEM_EXPR (mem
)) == COMPONENT_REF
)
1055 tree mem_expr
= MEM_EXPR (mem
);
1056 HOST_WIDE_INT offset
= -1, length
= -1;
1059 while (TREE_CODE (inner
) == ARRAY_REF
1060 || TREE_CODE (inner
) == NOP_EXPR
1061 || TREE_CODE (inner
) == CONVERT_EXPR
1062 || TREE_CODE (inner
) == NON_LVALUE_EXPR
1063 || TREE_CODE (inner
) == VIEW_CONVERT_EXPR
1064 || TREE_CODE (inner
) == SAVE_EXPR
)
1065 inner
= TREE_OPERAND (inner
, 0);
1067 gcc_assert (TREE_CODE (inner
) == COMPONENT_REF
);
1069 if (MEM_OFFSET (mem
)
1070 && GET_CODE (MEM_OFFSET (mem
)) == CONST_INT
)
1071 offset
= INTVAL (MEM_OFFSET (mem
));
1073 if (offset
>= 0 && len
&& host_integerp (len
, 0))
1074 length
= tree_low_cst (len
, 0);
1076 while (TREE_CODE (inner
) == COMPONENT_REF
)
1078 tree field
= TREE_OPERAND (inner
, 1);
1079 gcc_assert (! DECL_BIT_FIELD (field
));
1080 gcc_assert (TREE_CODE (mem_expr
) == COMPONENT_REF
);
1081 gcc_assert (field
== TREE_OPERAND (mem_expr
, 1));
1084 && TYPE_SIZE_UNIT (TREE_TYPE (inner
))
1085 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner
)), 0))
1088 = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner
)), 0);
1089 /* If we can prove the memory starting at XEXP (mem, 0)
1090 and ending at XEXP (mem, 0) + LENGTH will fit into
1091 this field, we can keep that COMPONENT_REF in MEM_EXPR. */
1094 && offset
+ length
<= size
)
1099 && host_integerp (DECL_FIELD_OFFSET (field
), 0))
1100 offset
+= tree_low_cst (DECL_FIELD_OFFSET (field
), 0)
1101 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1109 mem_expr
= TREE_OPERAND (mem_expr
, 0);
1110 inner
= TREE_OPERAND (inner
, 0);
1113 if (mem_expr
== NULL
)
1115 if (mem_expr
!= MEM_EXPR (mem
))
1117 set_mem_expr (mem
, mem_expr
);
1118 set_mem_offset (mem
, offset
>= 0 ? GEN_INT (offset
) : NULL_RTX
);
1121 set_mem_alias_set (mem
, 0);
1122 set_mem_size (mem
, NULL_RTX
);
1128 /* Built-in functions to perform an untyped call and return. */
1130 /* For each register that may be used for calling a function, this
1131 gives a mode used to copy the register's value. VOIDmode indicates
1132 the register is not used for calling a function. If the machine
1133 has register windows, this gives only the outbound registers.
1134 INCOMING_REGNO gives the corresponding inbound register. */
1135 static enum machine_mode apply_args_mode
[FIRST_PSEUDO_REGISTER
];
1137 /* For each register that may be used for returning values, this gives
1138 a mode used to copy the register's value. VOIDmode indicates the
1139 register is not used for returning values. If the machine has
1140 register windows, this gives only the outbound registers.
1141 INCOMING_REGNO gives the corresponding inbound register. */
1142 static enum machine_mode apply_result_mode
[FIRST_PSEUDO_REGISTER
];
1144 /* For each register that may be used for calling a function, this
1145 gives the offset of that register into the block returned by
1146 __builtin_apply_args. 0 indicates that the register is not
1147 used for calling a function. */
1148 static int apply_args_reg_offset
[FIRST_PSEUDO_REGISTER
];
1150 /* Return the size required for the block returned by __builtin_apply_args,
1151 and initialize apply_args_mode. */
1154 apply_args_size (void)
1156 static int size
= -1;
1159 enum machine_mode mode
;
1161 /* The values computed by this function never change. */
1164 /* The first value is the incoming arg-pointer. */
1165 size
= GET_MODE_SIZE (Pmode
);
1167 /* The second value is the structure value address unless this is
1168 passed as an "invisible" first argument. */
1169 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1170 size
+= GET_MODE_SIZE (Pmode
);
1172 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1173 if (FUNCTION_ARG_REGNO_P (regno
))
1175 mode
= reg_raw_mode
[regno
];
1177 gcc_assert (mode
!= VOIDmode
);
1179 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1180 if (size
% align
!= 0)
1181 size
= CEIL (size
, align
) * align
;
1182 apply_args_reg_offset
[regno
] = size
;
1183 size
+= GET_MODE_SIZE (mode
);
1184 apply_args_mode
[regno
] = mode
;
1188 apply_args_mode
[regno
] = VOIDmode
;
1189 apply_args_reg_offset
[regno
] = 0;
1195 /* Return the size required for the block returned by __builtin_apply,
1196 and initialize apply_result_mode. */
1199 apply_result_size (void)
1201 static int size
= -1;
1203 enum machine_mode mode
;
1205 /* The values computed by this function never change. */
1210 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1211 if (FUNCTION_VALUE_REGNO_P (regno
))
1213 mode
= reg_raw_mode
[regno
];
1215 gcc_assert (mode
!= VOIDmode
);
1217 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1218 if (size
% align
!= 0)
1219 size
= CEIL (size
, align
) * align
;
1220 size
+= GET_MODE_SIZE (mode
);
1221 apply_result_mode
[regno
] = mode
;
1224 apply_result_mode
[regno
] = VOIDmode
;
1226 /* Allow targets that use untyped_call and untyped_return to override
1227 the size so that machine-specific information can be stored here. */
1228 #ifdef APPLY_RESULT_SIZE
1229 size
= APPLY_RESULT_SIZE
;
1235 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1236 /* Create a vector describing the result block RESULT. If SAVEP is true,
1237 the result block is used to save the values; otherwise it is used to
1238 restore the values. */
1241 result_vector (int savep
, rtx result
)
1243 int regno
, size
, align
, nelts
;
1244 enum machine_mode mode
;
1246 rtx
*savevec
= alloca (FIRST_PSEUDO_REGISTER
* sizeof (rtx
));
1249 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1250 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1252 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1253 if (size
% align
!= 0)
1254 size
= CEIL (size
, align
) * align
;
1255 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1256 mem
= adjust_address (result
, mode
, size
);
1257 savevec
[nelts
++] = (savep
1258 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1259 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1260 size
+= GET_MODE_SIZE (mode
);
1262 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1264 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1266 /* Save the state required to perform an untyped call with the same
1267 arguments as were passed to the current function. */
1270 expand_builtin_apply_args_1 (void)
1273 int size
, align
, regno
;
1274 enum machine_mode mode
;
1275 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1277 /* Create a block where the arg-pointer, structure value address,
1278 and argument registers can be saved. */
1279 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1281 /* Walk past the arg-pointer and structure value address. */
1282 size
= GET_MODE_SIZE (Pmode
);
1283 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1284 size
+= GET_MODE_SIZE (Pmode
);
1286 /* Save each register used in calling a function to the block. */
1287 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1288 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1290 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1291 if (size
% align
!= 0)
1292 size
= CEIL (size
, align
) * align
;
1294 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1296 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1297 size
+= GET_MODE_SIZE (mode
);
1300 /* Save the arg pointer to the block. */
1301 tem
= copy_to_reg (virtual_incoming_args_rtx
);
1302 #ifdef STACK_GROWS_DOWNWARD
1303 /* We need the pointer as the caller actually passed them to us, not
1304 as we might have pretended they were passed. Make sure it's a valid
1305 operand, as emit_move_insn isn't expected to handle a PLUS. */
1307 = force_operand (plus_constant (tem
, current_function_pretend_args_size
),
1310 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1312 size
= GET_MODE_SIZE (Pmode
);
1314 /* Save the structure value address unless this is passed as an
1315 "invisible" first argument. */
1316 if (struct_incoming_value
)
1318 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1319 copy_to_reg (struct_incoming_value
));
1320 size
+= GET_MODE_SIZE (Pmode
);
1323 /* Return the address of the block. */
1324 return copy_addr_to_reg (XEXP (registers
, 0));
1327 /* __builtin_apply_args returns block of memory allocated on
1328 the stack into which is stored the arg pointer, structure
1329 value address, static chain, and all the registers that might
1330 possibly be used in performing a function call. The code is
1331 moved to the start of the function so the incoming values are
1335 expand_builtin_apply_args (void)
1337 /* Don't do __builtin_apply_args more than once in a function.
1338 Save the result of the first call and reuse it. */
1339 if (apply_args_value
!= 0)
1340 return apply_args_value
;
1342 /* When this function is called, it means that registers must be
1343 saved on entry to this function. So we migrate the
1344 call to the first insn of this function. */
1349 temp
= expand_builtin_apply_args_1 ();
1353 apply_args_value
= temp
;
1355 /* Put the insns after the NOTE that starts the function.
1356 If this is inside a start_sequence, make the outer-level insn
1357 chain current, so the code is placed at the start of the
1359 push_topmost_sequence ();
1360 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1361 pop_topmost_sequence ();
1366 /* Perform an untyped call and save the state required to perform an
1367 untyped return of whatever value was returned by the given function. */
1370 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1372 int size
, align
, regno
;
1373 enum machine_mode mode
;
1374 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1375 rtx old_stack_level
= 0;
1376 rtx call_fusage
= 0;
1377 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1379 arguments
= convert_memory_address (Pmode
, arguments
);
1381 /* Create a block where the return registers can be saved. */
1382 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1384 /* Fetch the arg pointer from the ARGUMENTS block. */
1385 incoming_args
= gen_reg_rtx (Pmode
);
1386 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1387 #ifndef STACK_GROWS_DOWNWARD
1388 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1389 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1392 /* Push a new argument block and copy the arguments. Do not allow
1393 the (potential) memcpy call below to interfere with our stack
1395 do_pending_stack_adjust ();
1398 /* Save the stack with nonlocal if available. */
1399 #ifdef HAVE_save_stack_nonlocal
1400 if (HAVE_save_stack_nonlocal
)
1401 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1404 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1406 /* Allocate a block of memory onto the stack and copy the memory
1407 arguments to the outgoing arguments address. */
1408 allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
);
1409 dest
= virtual_outgoing_args_rtx
;
1410 #ifndef STACK_GROWS_DOWNWARD
1411 if (GET_CODE (argsize
) == CONST_INT
)
1412 dest
= plus_constant (dest
, -INTVAL (argsize
));
1414 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1416 dest
= gen_rtx_MEM (BLKmode
, dest
);
1417 set_mem_align (dest
, PARM_BOUNDARY
);
1418 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1419 set_mem_align (src
, PARM_BOUNDARY
);
1420 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1422 /* Refer to the argument block. */
1424 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1425 set_mem_align (arguments
, PARM_BOUNDARY
);
1427 /* Walk past the arg-pointer and structure value address. */
1428 size
= GET_MODE_SIZE (Pmode
);
1430 size
+= GET_MODE_SIZE (Pmode
);
1432 /* Restore each of the registers previously saved. Make USE insns
1433 for each of these registers for use in making the call. */
1434 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1435 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1437 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1438 if (size
% align
!= 0)
1439 size
= CEIL (size
, align
) * align
;
1440 reg
= gen_rtx_REG (mode
, regno
);
1441 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1442 use_reg (&call_fusage
, reg
);
1443 size
+= GET_MODE_SIZE (mode
);
1446 /* Restore the structure value address unless this is passed as an
1447 "invisible" first argument. */
1448 size
= GET_MODE_SIZE (Pmode
);
1451 rtx value
= gen_reg_rtx (Pmode
);
1452 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1453 emit_move_insn (struct_value
, value
);
1454 if (REG_P (struct_value
))
1455 use_reg (&call_fusage
, struct_value
);
1456 size
+= GET_MODE_SIZE (Pmode
);
1459 /* All arguments and registers used for the call are set up by now! */
1460 function
= prepare_call_address (function
, NULL
, &call_fusage
, 0, 0);
1462 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1463 and we don't want to load it into a register as an optimization,
1464 because prepare_call_address already did it if it should be done. */
1465 if (GET_CODE (function
) != SYMBOL_REF
)
1466 function
= memory_address (FUNCTION_MODE
, function
);
1468 /* Generate the actual call instruction and save the return value. */
1469 #ifdef HAVE_untyped_call
1470 if (HAVE_untyped_call
)
1471 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1472 result
, result_vector (1, result
)));
1475 #ifdef HAVE_call_value
1476 if (HAVE_call_value
)
1480 /* Locate the unique return register. It is not possible to
1481 express a call that sets more than one return register using
1482 call_value; use untyped_call for that. In fact, untyped_call
1483 only needs to save the return registers in the given block. */
1484 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1485 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1487 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1489 valreg
= gen_rtx_REG (mode
, regno
);
1492 emit_call_insn (GEN_CALL_VALUE (valreg
,
1493 gen_rtx_MEM (FUNCTION_MODE
, function
),
1494 const0_rtx
, NULL_RTX
, const0_rtx
));
1496 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1502 /* Find the CALL insn we just emitted, and attach the register usage
1504 call_insn
= last_call_insn ();
1505 add_function_usage_to (call_insn
, call_fusage
);
1507 /* Restore the stack. */
1508 #ifdef HAVE_save_stack_nonlocal
1509 if (HAVE_save_stack_nonlocal
)
1510 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1513 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1517 /* Return the address of the result block. */
1518 result
= copy_addr_to_reg (XEXP (result
, 0));
1519 return convert_memory_address (ptr_mode
, result
);
1522 /* Perform an untyped return. */
1525 expand_builtin_return (rtx result
)
1527 int size
, align
, regno
;
1528 enum machine_mode mode
;
1530 rtx call_fusage
= 0;
1532 result
= convert_memory_address (Pmode
, result
);
1534 apply_result_size ();
1535 result
= gen_rtx_MEM (BLKmode
, result
);
1537 #ifdef HAVE_untyped_return
1538 if (HAVE_untyped_return
)
1540 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1546 /* Restore the return value and note that each value is used. */
1548 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1549 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1551 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1552 if (size
% align
!= 0)
1553 size
= CEIL (size
, align
) * align
;
1554 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1555 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1557 push_to_sequence (call_fusage
);
1558 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1559 call_fusage
= get_insns ();
1561 size
+= GET_MODE_SIZE (mode
);
1564 /* Put the USE insns before the return. */
1565 emit_insn (call_fusage
);
1567 /* Return whatever values was restored by jumping directly to the end
1569 expand_naked_return ();
1572 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1574 static enum type_class
1575 type_to_class (tree type
)
1577 switch (TREE_CODE (type
))
1579 case VOID_TYPE
: return void_type_class
;
1580 case INTEGER_TYPE
: return integer_type_class
;
1581 case CHAR_TYPE
: return char_type_class
;
1582 case ENUMERAL_TYPE
: return enumeral_type_class
;
1583 case BOOLEAN_TYPE
: return boolean_type_class
;
1584 case POINTER_TYPE
: return pointer_type_class
;
1585 case REFERENCE_TYPE
: return reference_type_class
;
1586 case OFFSET_TYPE
: return offset_type_class
;
1587 case REAL_TYPE
: return real_type_class
;
1588 case COMPLEX_TYPE
: return complex_type_class
;
1589 case FUNCTION_TYPE
: return function_type_class
;
1590 case METHOD_TYPE
: return method_type_class
;
1591 case RECORD_TYPE
: return record_type_class
;
1593 case QUAL_UNION_TYPE
: return union_type_class
;
1594 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1595 ? string_type_class
: array_type_class
);
1596 case LANG_TYPE
: return lang_type_class
;
1597 default: return no_type_class
;
1601 /* Expand a call to __builtin_classify_type with arguments found in
1605 expand_builtin_classify_type (tree arglist
)
1608 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
1609 return GEN_INT (no_type_class
);
1612 /* This helper macro, meant to be used in mathfn_built_in below,
1613 determines which among a set of three builtin math functions is
1614 appropriate for a given type mode. The `F' and `L' cases are
1615 automatically generated from the `double' case. */
1616 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1617 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1618 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1619 fcodel = BUILT_IN_MATHFN##L ; break;
1621 /* Return mathematic function equivalent to FN but operating directly
1622 on TYPE, if available. If we can't do the conversion, return zero. */
1624 mathfn_built_in (tree type
, enum built_in_function fn
)
1626 enum built_in_function fcode
, fcodef
, fcodel
;
1630 CASE_MATHFN (BUILT_IN_ACOS
)
1631 CASE_MATHFN (BUILT_IN_ACOSH
)
1632 CASE_MATHFN (BUILT_IN_ASIN
)
1633 CASE_MATHFN (BUILT_IN_ASINH
)
1634 CASE_MATHFN (BUILT_IN_ATAN
)
1635 CASE_MATHFN (BUILT_IN_ATAN2
)
1636 CASE_MATHFN (BUILT_IN_ATANH
)
1637 CASE_MATHFN (BUILT_IN_CBRT
)
1638 CASE_MATHFN (BUILT_IN_CEIL
)
1639 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1640 CASE_MATHFN (BUILT_IN_COS
)
1641 CASE_MATHFN (BUILT_IN_COSH
)
1642 CASE_MATHFN (BUILT_IN_DREM
)
1643 CASE_MATHFN (BUILT_IN_ERF
)
1644 CASE_MATHFN (BUILT_IN_ERFC
)
1645 CASE_MATHFN (BUILT_IN_EXP
)
1646 CASE_MATHFN (BUILT_IN_EXP10
)
1647 CASE_MATHFN (BUILT_IN_EXP2
)
1648 CASE_MATHFN (BUILT_IN_EXPM1
)
1649 CASE_MATHFN (BUILT_IN_FABS
)
1650 CASE_MATHFN (BUILT_IN_FDIM
)
1651 CASE_MATHFN (BUILT_IN_FLOOR
)
1652 CASE_MATHFN (BUILT_IN_FMA
)
1653 CASE_MATHFN (BUILT_IN_FMAX
)
1654 CASE_MATHFN (BUILT_IN_FMIN
)
1655 CASE_MATHFN (BUILT_IN_FMOD
)
1656 CASE_MATHFN (BUILT_IN_FREXP
)
1657 CASE_MATHFN (BUILT_IN_GAMMA
)
1658 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1659 CASE_MATHFN (BUILT_IN_HYPOT
)
1660 CASE_MATHFN (BUILT_IN_ILOGB
)
1661 CASE_MATHFN (BUILT_IN_INF
)
1662 CASE_MATHFN (BUILT_IN_J0
)
1663 CASE_MATHFN (BUILT_IN_J1
)
1664 CASE_MATHFN (BUILT_IN_JN
)
1665 CASE_MATHFN (BUILT_IN_LCEIL
)
1666 CASE_MATHFN (BUILT_IN_LDEXP
)
1667 CASE_MATHFN (BUILT_IN_LFLOOR
)
1668 CASE_MATHFN (BUILT_IN_LGAMMA
)
1669 CASE_MATHFN (BUILT_IN_LLCEIL
)
1670 CASE_MATHFN (BUILT_IN_LLFLOOR
)
1671 CASE_MATHFN (BUILT_IN_LLRINT
)
1672 CASE_MATHFN (BUILT_IN_LLROUND
)
1673 CASE_MATHFN (BUILT_IN_LOG
)
1674 CASE_MATHFN (BUILT_IN_LOG10
)
1675 CASE_MATHFN (BUILT_IN_LOG1P
)
1676 CASE_MATHFN (BUILT_IN_LOG2
)
1677 CASE_MATHFN (BUILT_IN_LOGB
)
1678 CASE_MATHFN (BUILT_IN_LRINT
)
1679 CASE_MATHFN (BUILT_IN_LROUND
)
1680 CASE_MATHFN (BUILT_IN_MODF
)
1681 CASE_MATHFN (BUILT_IN_NAN
)
1682 CASE_MATHFN (BUILT_IN_NANS
)
1683 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1684 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1685 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1686 CASE_MATHFN (BUILT_IN_POW
)
1687 CASE_MATHFN (BUILT_IN_POWI
)
1688 CASE_MATHFN (BUILT_IN_POW10
)
1689 CASE_MATHFN (BUILT_IN_REMAINDER
)
1690 CASE_MATHFN (BUILT_IN_REMQUO
)
1691 CASE_MATHFN (BUILT_IN_RINT
)
1692 CASE_MATHFN (BUILT_IN_ROUND
)
1693 CASE_MATHFN (BUILT_IN_SCALB
)
1694 CASE_MATHFN (BUILT_IN_SCALBLN
)
1695 CASE_MATHFN (BUILT_IN_SCALBN
)
1696 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1697 CASE_MATHFN (BUILT_IN_SIN
)
1698 CASE_MATHFN (BUILT_IN_SINCOS
)
1699 CASE_MATHFN (BUILT_IN_SINH
)
1700 CASE_MATHFN (BUILT_IN_SQRT
)
1701 CASE_MATHFN (BUILT_IN_TAN
)
1702 CASE_MATHFN (BUILT_IN_TANH
)
1703 CASE_MATHFN (BUILT_IN_TGAMMA
)
1704 CASE_MATHFN (BUILT_IN_TRUNC
)
1705 CASE_MATHFN (BUILT_IN_Y0
)
1706 CASE_MATHFN (BUILT_IN_Y1
)
1707 CASE_MATHFN (BUILT_IN_YN
)
1713 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1714 return implicit_built_in_decls
[fcode
];
1715 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1716 return implicit_built_in_decls
[fcodef
];
1717 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1718 return implicit_built_in_decls
[fcodel
];
1723 /* If errno must be maintained, expand the RTL to check if the result,
1724 TARGET, of a built-in function call, EXP, is NaN, and if so set
1728 expand_errno_check (tree exp
, rtx target
)
1730 rtx lab
= gen_label_rtx ();
1732 /* Test the result; if it is NaN, set errno=EDOM because
1733 the argument was not in the domain. */
1734 emit_cmp_and_jump_insns (target
, target
, EQ
, 0, GET_MODE (target
),
1738 /* If this built-in doesn't throw an exception, set errno directly. */
1739 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
1741 #ifdef GEN_ERRNO_RTX
1742 rtx errno_rtx
= GEN_ERRNO_RTX
;
1745 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1747 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1753 /* We can't set errno=EDOM directly; let the library call do it.
1754 Pop the arguments right away in case the call gets deleted. */
1756 expand_call (exp
, target
, 0);
1762 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1763 Return 0 if a normal call should be emitted rather than expanding the
1764 function in-line. EXP is the expression that is a call to the builtin
1765 function; if convenient, the result should be placed in TARGET.
1766 SUBTARGET may be used as the target for computing one of EXP's operands. */
1769 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
1771 optab builtin_optab
;
1772 rtx op0
, insns
, before_call
;
1773 tree fndecl
= get_callee_fndecl (exp
);
1774 tree arglist
= TREE_OPERAND (exp
, 1);
1775 enum machine_mode mode
;
1776 bool errno_set
= false;
1779 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1782 arg
= TREE_VALUE (arglist
);
1784 switch (DECL_FUNCTION_CODE (fndecl
))
1787 case BUILT_IN_SQRTF
:
1788 case BUILT_IN_SQRTL
:
1789 errno_set
= ! tree_expr_nonnegative_p (arg
);
1790 builtin_optab
= sqrt_optab
;
1795 errno_set
= true; builtin_optab
= exp_optab
; break;
1796 case BUILT_IN_EXP10
:
1797 case BUILT_IN_EXP10F
:
1798 case BUILT_IN_EXP10L
:
1799 case BUILT_IN_POW10
:
1800 case BUILT_IN_POW10F
:
1801 case BUILT_IN_POW10L
:
1802 errno_set
= true; builtin_optab
= exp10_optab
; break;
1804 case BUILT_IN_EXP2F
:
1805 case BUILT_IN_EXP2L
:
1806 errno_set
= true; builtin_optab
= exp2_optab
; break;
1807 case BUILT_IN_EXPM1
:
1808 case BUILT_IN_EXPM1F
:
1809 case BUILT_IN_EXPM1L
:
1810 errno_set
= true; builtin_optab
= expm1_optab
; break;
1812 case BUILT_IN_LOGBF
:
1813 case BUILT_IN_LOGBL
:
1814 errno_set
= true; builtin_optab
= logb_optab
; break;
1815 case BUILT_IN_ILOGB
:
1816 case BUILT_IN_ILOGBF
:
1817 case BUILT_IN_ILOGBL
:
1818 errno_set
= true; builtin_optab
= ilogb_optab
; break;
1822 errno_set
= true; builtin_optab
= log_optab
; break;
1823 case BUILT_IN_LOG10
:
1824 case BUILT_IN_LOG10F
:
1825 case BUILT_IN_LOG10L
:
1826 errno_set
= true; builtin_optab
= log10_optab
; break;
1828 case BUILT_IN_LOG2F
:
1829 case BUILT_IN_LOG2L
:
1830 errno_set
= true; builtin_optab
= log2_optab
; break;
1831 case BUILT_IN_LOG1P
:
1832 case BUILT_IN_LOG1PF
:
1833 case BUILT_IN_LOG1PL
:
1834 errno_set
= true; builtin_optab
= log1p_optab
; break;
1836 case BUILT_IN_ASINF
:
1837 case BUILT_IN_ASINL
:
1838 builtin_optab
= asin_optab
; break;
1840 case BUILT_IN_ACOSF
:
1841 case BUILT_IN_ACOSL
:
1842 builtin_optab
= acos_optab
; break;
1846 builtin_optab
= tan_optab
; break;
1848 case BUILT_IN_ATANF
:
1849 case BUILT_IN_ATANL
:
1850 builtin_optab
= atan_optab
; break;
1851 case BUILT_IN_FLOOR
:
1852 case BUILT_IN_FLOORF
:
1853 case BUILT_IN_FLOORL
:
1854 builtin_optab
= floor_optab
; break;
1856 case BUILT_IN_CEILF
:
1857 case BUILT_IN_CEILL
:
1858 builtin_optab
= ceil_optab
; break;
1859 case BUILT_IN_TRUNC
:
1860 case BUILT_IN_TRUNCF
:
1861 case BUILT_IN_TRUNCL
:
1862 builtin_optab
= btrunc_optab
; break;
1863 case BUILT_IN_ROUND
:
1864 case BUILT_IN_ROUNDF
:
1865 case BUILT_IN_ROUNDL
:
1866 builtin_optab
= round_optab
; break;
1867 case BUILT_IN_NEARBYINT
:
1868 case BUILT_IN_NEARBYINTF
:
1869 case BUILT_IN_NEARBYINTL
:
1870 builtin_optab
= nearbyint_optab
; break;
1872 case BUILT_IN_RINTF
:
1873 case BUILT_IN_RINTL
:
1874 builtin_optab
= rint_optab
; break;
1875 case BUILT_IN_LRINT
:
1876 case BUILT_IN_LRINTF
:
1877 case BUILT_IN_LRINTL
:
1878 case BUILT_IN_LLRINT
:
1879 case BUILT_IN_LLRINTF
:
1880 case BUILT_IN_LLRINTL
:
1881 builtin_optab
= lrint_optab
; break;
1886 /* Make a suitable register to place result in. */
1887 mode
= TYPE_MODE (TREE_TYPE (exp
));
1889 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1892 /* Before working hard, check whether the instruction is available. */
1893 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
1895 target
= gen_reg_rtx (mode
);
1897 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1898 need to expand the argument again. This way, we will not perform
1899 side-effects more the once. */
1900 narg
= builtin_save_expr (arg
);
1904 arglist
= build_tree_list (NULL_TREE
, arg
);
1905 exp
= build_function_call_expr (fndecl
, arglist
);
1908 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
1912 /* Compute into TARGET.
1913 Set TARGET to wherever the result comes back. */
1914 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
1919 expand_errno_check (exp
, target
);
1921 /* Output the entire sequence. */
1922 insns
= get_insns ();
1928 /* If we were unable to expand via the builtin, stop the sequence
1929 (without outputting the insns) and call to the library function
1930 with the stabilized argument list. */
1934 before_call
= get_last_insn ();
1936 target
= expand_call (exp
, target
, target
== const0_rtx
);
1938 /* If this is a sqrt operation and we don't care about errno, try to
1939 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1940 This allows the semantics of the libcall to be visible to the RTL
1942 if (builtin_optab
== sqrt_optab
&& !errno_set
)
1944 /* Search backwards through the insns emitted by expand_call looking
1945 for the instruction with the REG_RETVAL note. */
1946 rtx last
= get_last_insn ();
1947 while (last
!= before_call
)
1949 if (find_reg_note (last
, REG_RETVAL
, NULL
))
1951 rtx note
= find_reg_note (last
, REG_EQUAL
, NULL
);
1952 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1953 two elements, i.e. symbol_ref(sqrt) and the operand. */
1955 && GET_CODE (note
) == EXPR_LIST
1956 && GET_CODE (XEXP (note
, 0)) == EXPR_LIST
1957 && XEXP (XEXP (note
, 0), 1) != NULL_RTX
1958 && XEXP (XEXP (XEXP (note
, 0), 1), 1) == NULL_RTX
)
1960 rtx operand
= XEXP (XEXP (XEXP (note
, 0), 1), 0);
1961 /* Check operand is a register with expected mode. */
1964 && GET_MODE (operand
) == mode
)
1966 /* Replace the REG_EQUAL note with a SQRT rtx. */
1967 rtx equiv
= gen_rtx_SQRT (mode
, operand
);
1968 set_unique_reg_note (last
, REG_EQUAL
, equiv
);
1973 last
= PREV_INSN (last
);
1980 /* Expand a call to the builtin binary math functions (pow and atan2).
1981 Return 0 if a normal call should be emitted rather than expanding the
1982 function in-line. EXP is the expression that is a call to the builtin
1983 function; if convenient, the result should be placed in TARGET.
1984 SUBTARGET may be used as the target for computing one of EXP's
1988 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
1990 optab builtin_optab
;
1991 rtx op0
, op1
, insns
;
1992 int op1_type
= REAL_TYPE
;
1993 tree fndecl
= get_callee_fndecl (exp
);
1994 tree arglist
= TREE_OPERAND (exp
, 1);
1995 tree arg0
, arg1
, temp
, narg
;
1996 enum machine_mode mode
;
1997 bool errno_set
= true;
2000 if ((DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXP
)
2001 || (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXPF
)
2002 || (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXPL
))
2003 op1_type
= INTEGER_TYPE
;
2005 if (!validate_arglist (arglist
, REAL_TYPE
, op1_type
, VOID_TYPE
))
2008 arg0
= TREE_VALUE (arglist
);
2009 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2011 switch (DECL_FUNCTION_CODE (fndecl
))
2016 builtin_optab
= pow_optab
; break;
2017 case BUILT_IN_ATAN2
:
2018 case BUILT_IN_ATAN2F
:
2019 case BUILT_IN_ATAN2L
:
2020 builtin_optab
= atan2_optab
; break;
2021 case BUILT_IN_LDEXP
:
2022 case BUILT_IN_LDEXPF
:
2023 case BUILT_IN_LDEXPL
:
2024 builtin_optab
= ldexp_optab
; break;
2026 case BUILT_IN_FMODF
:
2027 case BUILT_IN_FMODL
:
2028 builtin_optab
= fmod_optab
; break;
2030 case BUILT_IN_DREMF
:
2031 case BUILT_IN_DREML
:
2032 builtin_optab
= drem_optab
; break;
2037 /* Make a suitable register to place result in. */
2038 mode
= TYPE_MODE (TREE_TYPE (exp
));
2040 /* Before working hard, check whether the instruction is available. */
2041 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
2044 target
= gen_reg_rtx (mode
);
2046 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2049 /* Always stabilize the argument list. */
2050 narg
= builtin_save_expr (arg1
);
2054 temp
= build_tree_list (NULL_TREE
, narg
);
2058 temp
= TREE_CHAIN (arglist
);
2060 narg
= builtin_save_expr (arg0
);
2064 arglist
= tree_cons (NULL_TREE
, narg
, temp
);
2068 arglist
= tree_cons (NULL_TREE
, arg0
, temp
);
2071 exp
= build_function_call_expr (fndecl
, arglist
);
2073 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2074 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
2078 /* Compute into TARGET.
2079 Set TARGET to wherever the result comes back. */
2080 target
= expand_binop (mode
, builtin_optab
, op0
, op1
,
2081 target
, 0, OPTAB_DIRECT
);
2083 /* If we were unable to expand via the builtin, stop the sequence
2084 (without outputting the insns) and call to the library function
2085 with the stabilized argument list. */
2089 return expand_call (exp
, target
, target
== const0_rtx
);
2093 expand_errno_check (exp
, target
);
2095 /* Output the entire sequence. */
2096 insns
= get_insns ();
2103 /* Expand a call to the builtin sin and cos math functions.
2104 Return 0 if a normal call should be emitted rather than expanding the
2105 function in-line. EXP is the expression that is a call to the builtin
2106 function; if convenient, the result should be placed in TARGET.
2107 SUBTARGET may be used as the target for computing one of EXP's
2111 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2113 optab builtin_optab
;
2115 tree fndecl
= get_callee_fndecl (exp
);
2116 tree arglist
= TREE_OPERAND (exp
, 1);
2117 enum machine_mode mode
;
2118 bool errno_set
= false;
2121 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
2124 arg
= TREE_VALUE (arglist
);
2126 switch (DECL_FUNCTION_CODE (fndecl
))
2134 builtin_optab
= sincos_optab
; break;
2139 /* Make a suitable register to place result in. */
2140 mode
= TYPE_MODE (TREE_TYPE (exp
));
2142 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2145 /* Check if sincos insn is available, otherwise fallback
2146 to sin or cos insn. */
2147 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
) {
2148 switch (DECL_FUNCTION_CODE (fndecl
))
2153 builtin_optab
= sin_optab
; break;
2157 builtin_optab
= cos_optab
; break;
2163 /* Before working hard, check whether the instruction is available. */
2164 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2166 target
= gen_reg_rtx (mode
);
2168 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2169 need to expand the argument again. This way, we will not perform
2170 side-effects more the once. */
2171 narg
= save_expr (arg
);
2175 arglist
= build_tree_list (NULL_TREE
, arg
);
2176 exp
= build_function_call_expr (fndecl
, arglist
);
2179 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2183 /* Compute into TARGET.
2184 Set TARGET to wherever the result comes back. */
2185 if (builtin_optab
== sincos_optab
)
2189 switch (DECL_FUNCTION_CODE (fndecl
))
2194 result
= expand_twoval_unop (builtin_optab
, op0
, 0, target
, 0);
2199 result
= expand_twoval_unop (builtin_optab
, op0
, target
, 0, 0);
2204 gcc_assert (result
);
2208 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2214 expand_errno_check (exp
, target
);
2216 /* Output the entire sequence. */
2217 insns
= get_insns ();
2223 /* If we were unable to expand via the builtin, stop the sequence
2224 (without outputting the insns) and call to the library function
2225 with the stabilized argument list. */
2229 target
= expand_call (exp
, target
, target
== const0_rtx
);
2234 /* Expand a call to one of the builtin rounding functions (lfloor).
2235 If expanding via optab fails, lower expression to (int)(floor(x)).
2236 EXP is the expression that is a call to the builtin function;
2237 if convenient, the result should be placed in TARGET. SUBTARGET may
2238 be used as the target for computing one of EXP's operands. */
2241 expand_builtin_int_roundingfn (tree exp
, rtx target
, rtx subtarget
)
2243 optab builtin_optab
;
2244 rtx op0
, insns
, tmp
;
2245 tree fndecl
= get_callee_fndecl (exp
);
2246 tree arglist
= TREE_OPERAND (exp
, 1);
2247 enum built_in_function fallback_fn
;
2248 tree fallback_fndecl
;
2249 enum machine_mode mode
;
2252 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
2255 arg
= TREE_VALUE (arglist
);
2257 switch (DECL_FUNCTION_CODE (fndecl
))
2259 case BUILT_IN_LCEIL
:
2260 case BUILT_IN_LCEILF
:
2261 case BUILT_IN_LCEILL
:
2262 case BUILT_IN_LLCEIL
:
2263 case BUILT_IN_LLCEILF
:
2264 case BUILT_IN_LLCEILL
:
2265 builtin_optab
= lceil_optab
;
2266 fallback_fn
= BUILT_IN_CEIL
;
2269 case BUILT_IN_LFLOOR
:
2270 case BUILT_IN_LFLOORF
:
2271 case BUILT_IN_LFLOORL
:
2272 case BUILT_IN_LLFLOOR
:
2273 case BUILT_IN_LLFLOORF
:
2274 case BUILT_IN_LLFLOORL
:
2275 builtin_optab
= lfloor_optab
;
2276 fallback_fn
= BUILT_IN_FLOOR
;
2283 /* Make a suitable register to place result in. */
2284 mode
= TYPE_MODE (TREE_TYPE (exp
));
2286 /* Before working hard, check whether the instruction is available. */
2287 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2289 target
= gen_reg_rtx (mode
);
2291 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2292 need to expand the argument again. This way, we will not perform
2293 side-effects more the once. */
2294 narg
= builtin_save_expr (arg
);
2298 arglist
= build_tree_list (NULL_TREE
, arg
);
2299 exp
= build_function_call_expr (fndecl
, arglist
);
2302 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2306 /* Compute into TARGET.
2307 Set TARGET to wherever the result comes back. */
2308 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2312 /* Output the entire sequence. */
2313 insns
= get_insns ();
2319 /* If we were unable to expand via the builtin, stop the sequence
2320 (without outputting the insns). */
2324 /* Fall back to floating point rounding optab. */
2325 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
2326 /* We shouldn't get here on targets without TARGET_C99_FUNCTIONS.
2327 ??? Perhaps convert (int)floorf(x) into (int)floor((double)x). */
2328 gcc_assert (fallback_fndecl
!= NULL_TREE
);
2329 exp
= build_function_call_expr (fallback_fndecl
, arglist
);
2331 tmp
= expand_builtin_mathfn (exp
, NULL_RTX
, NULL_RTX
);
2333 /* Truncate the result of floating point optab to integer
2334 via expand_fix (). */
2335 target
= gen_reg_rtx (mode
);
2336 expand_fix (target
, tmp
, 0);
2341 /* To evaluate powi(x,n), the floating point value x raised to the
2342 constant integer exponent n, we use a hybrid algorithm that
2343 combines the "window method" with look-up tables. For an
2344 introduction to exponentiation algorithms and "addition chains",
2345 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2346 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2347 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2348 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2350 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2351 multiplications to inline before calling the system library's pow
2352 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2353 so this default never requires calling pow, powf or powl. */
2355 #ifndef POWI_MAX_MULTS
2356 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2359 /* The size of the "optimal power tree" lookup table. All
2360 exponents less than this value are simply looked up in the
2361 powi_table below. This threshold is also used to size the
2362 cache of pseudo registers that hold intermediate results. */
2363 #define POWI_TABLE_SIZE 256
2365 /* The size, in bits of the window, used in the "window method"
2366 exponentiation algorithm. This is equivalent to a radix of
2367 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2368 #define POWI_WINDOW_SIZE 3
2370 /* The following table is an efficient representation of an
2371 "optimal power tree". For each value, i, the corresponding
2372 value, j, in the table states than an optimal evaluation
2373 sequence for calculating pow(x,i) can be found by evaluating
2374 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2375 100 integers is given in Knuth's "Seminumerical algorithms". */
2377 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
2379 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2380 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2381 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2382 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2383 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2384 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2385 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2386 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2387 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2388 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2389 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2390 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2391 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2392 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2393 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2394 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2395 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2396 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2397 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2398 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2399 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2400 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2401 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2402 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2403 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2404 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2405 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2406 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2407 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2408 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2409 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2410 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2414 /* Return the number of multiplications required to calculate
2415 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2416 subroutine of powi_cost. CACHE is an array indicating
2417 which exponents have already been calculated. */
2420 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
2422 /* If we've already calculated this exponent, then this evaluation
2423 doesn't require any additional multiplications. */
2428 return powi_lookup_cost (n
- powi_table
[n
], cache
)
2429 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
2432 /* Return the number of multiplications required to calculate
2433 powi(x,n) for an arbitrary x, given the exponent N. This
2434 function needs to be kept in sync with expand_powi below. */
2437 powi_cost (HOST_WIDE_INT n
)
2439 bool cache
[POWI_TABLE_SIZE
];
2440 unsigned HOST_WIDE_INT digit
;
2441 unsigned HOST_WIDE_INT val
;
2447 /* Ignore the reciprocal when calculating the cost. */
2448 val
= (n
< 0) ? -n
: n
;
2450 /* Initialize the exponent cache. */
2451 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
2456 while (val
>= POWI_TABLE_SIZE
)
2460 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
2461 result
+= powi_lookup_cost (digit
, cache
)
2462 + POWI_WINDOW_SIZE
+ 1;
2463 val
>>= POWI_WINDOW_SIZE
;
2472 return result
+ powi_lookup_cost (val
, cache
);
2475 /* Recursive subroutine of expand_powi. This function takes the array,
2476 CACHE, of already calculated exponents and an exponent N and returns
2477 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2480 expand_powi_1 (enum machine_mode mode
, unsigned HOST_WIDE_INT n
, rtx
*cache
)
2482 unsigned HOST_WIDE_INT digit
;
2486 if (n
< POWI_TABLE_SIZE
)
2491 target
= gen_reg_rtx (mode
);
2494 op0
= expand_powi_1 (mode
, n
- powi_table
[n
], cache
);
2495 op1
= expand_powi_1 (mode
, powi_table
[n
], cache
);
2499 target
= gen_reg_rtx (mode
);
2500 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
2501 op0
= expand_powi_1 (mode
, n
- digit
, cache
);
2502 op1
= expand_powi_1 (mode
, digit
, cache
);
2506 target
= gen_reg_rtx (mode
);
2507 op0
= expand_powi_1 (mode
, n
>> 1, cache
);
2511 result
= expand_mult (mode
, op0
, op1
, target
, 0);
2512 if (result
!= target
)
2513 emit_move_insn (target
, result
);
2517 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2518 floating point operand in mode MODE, and N is the exponent. This
2519 function needs to be kept in sync with powi_cost above. */
2522 expand_powi (rtx x
, enum machine_mode mode
, HOST_WIDE_INT n
)
2524 unsigned HOST_WIDE_INT val
;
2525 rtx cache
[POWI_TABLE_SIZE
];
2529 return CONST1_RTX (mode
);
2531 val
= (n
< 0) ? -n
: n
;
2533 memset (cache
, 0, sizeof (cache
));
2536 result
= expand_powi_1 (mode
, (n
< 0) ? -n
: n
, cache
);
2538 /* If the original exponent was negative, reciprocate the result. */
2540 result
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
2541 result
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2546 /* Expand a call to the pow built-in mathematical function. Return 0 if
2547 a normal call should be emitted rather than expanding the function
2548 in-line. EXP is the expression that is a call to the builtin
2549 function; if convenient, the result should be placed in TARGET. */
2552 expand_builtin_pow (tree exp
, rtx target
, rtx subtarget
)
2554 tree arglist
= TREE_OPERAND (exp
, 1);
2557 if (! validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2560 arg0
= TREE_VALUE (arglist
);
2561 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2563 if (TREE_CODE (arg1
) == REAL_CST
2564 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2566 REAL_VALUE_TYPE cint
;
2570 c
= TREE_REAL_CST (arg1
);
2571 n
= real_to_integer (&c
);
2572 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
2573 if (real_identical (&c
, &cint
))
2575 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2576 Otherwise, check the number of multiplications required.
2577 Note that pow never sets errno for an integer exponent. */
2578 if ((n
>= -1 && n
<= 2)
2579 || (flag_unsafe_math_optimizations
2581 && powi_cost (n
) <= POWI_MAX_MULTS
))
2583 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2584 rtx op
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2585 op
= force_reg (mode
, op
);
2586 return expand_powi (op
, mode
, n
);
2591 if (! flag_unsafe_math_optimizations
)
2593 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
2596 /* Expand a call to the powi built-in mathematical function. Return 0 if
2597 a normal call should be emitted rather than expanding the function
2598 in-line. EXP is the expression that is a call to the builtin
2599 function; if convenient, the result should be placed in TARGET. */
2602 expand_builtin_powi (tree exp
, rtx target
, rtx subtarget
)
2604 tree arglist
= TREE_OPERAND (exp
, 1);
2607 enum machine_mode mode
;
2608 enum machine_mode mode2
;
2610 if (! validate_arglist (arglist
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2613 arg0
= TREE_VALUE (arglist
);
2614 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2615 mode
= TYPE_MODE (TREE_TYPE (exp
));
2617 /* Handle constant power. */
2619 if (TREE_CODE (arg1
) == INTEGER_CST
2620 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2622 HOST_WIDE_INT n
= TREE_INT_CST_LOW (arg1
);
2624 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2625 Otherwise, check the number of multiplications required. */
2626 if ((TREE_INT_CST_HIGH (arg1
) == 0
2627 || TREE_INT_CST_HIGH (arg1
) == -1)
2628 && ((n
>= -1 && n
<= 2)
2630 && powi_cost (n
) <= POWI_MAX_MULTS
)))
2632 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2633 op0
= force_reg (mode
, op0
);
2634 return expand_powi (op0
, mode
, n
);
2638 /* Emit a libcall to libgcc. */
2640 /* Mode of the 2nd argument must match that of an int. */
2641 mode2
= mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0);
2643 if (target
== NULL_RTX
)
2644 target
= gen_reg_rtx (mode
);
2646 op0
= expand_expr (arg0
, subtarget
, mode
, 0);
2647 if (GET_MODE (op0
) != mode
)
2648 op0
= convert_to_mode (mode
, op0
, 0);
2649 op1
= expand_expr (arg1
, 0, mode2
, 0);
2650 if (GET_MODE (op1
) != mode2
)
2651 op1
= convert_to_mode (mode2
, op1
, 0);
2653 target
= emit_library_call_value (powi_optab
->handlers
[(int) mode
].libfunc
,
2654 target
, LCT_CONST_MAKE_BLOCK
, mode
, 2,
2655 op0
, mode
, op1
, mode2
);
2660 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2661 if we failed the caller should emit a normal call, otherwise
2662 try to get the result in TARGET, if convenient. */
2665 expand_builtin_strlen (tree arglist
, rtx target
,
2666 enum machine_mode target_mode
)
2668 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
2673 tree len
, src
= TREE_VALUE (arglist
);
2674 rtx result
, src_reg
, char_rtx
, before_strlen
;
2675 enum machine_mode insn_mode
= target_mode
, char_mode
;
2676 enum insn_code icode
= CODE_FOR_nothing
;
2679 /* If the length can be computed at compile-time, return it. */
2680 len
= c_strlen (src
, 0);
2682 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2684 /* If the length can be computed at compile-time and is constant
2685 integer, but there are side-effects in src, evaluate
2686 src for side-effects, then return len.
2687 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2688 can be optimized into: i++; x = 3; */
2689 len
= c_strlen (src
, 1);
2690 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
2692 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2693 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2696 align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2698 /* If SRC is not a pointer type, don't do this operation inline. */
2702 /* Bail out if we can't compute strlen in the right mode. */
2703 while (insn_mode
!= VOIDmode
)
2705 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
2706 if (icode
!= CODE_FOR_nothing
)
2709 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
2711 if (insn_mode
== VOIDmode
)
2714 /* Make a place to write the result of the instruction. */
2718 && GET_MODE (result
) == insn_mode
2719 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
2720 result
= gen_reg_rtx (insn_mode
);
2722 /* Make a place to hold the source address. We will not expand
2723 the actual source until we are sure that the expansion will
2724 not fail -- there are trees that cannot be expanded twice. */
2725 src_reg
= gen_reg_rtx (Pmode
);
2727 /* Mark the beginning of the strlen sequence so we can emit the
2728 source operand later. */
2729 before_strlen
= get_last_insn ();
2731 char_rtx
= const0_rtx
;
2732 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
2733 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
2735 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
2737 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
2738 char_rtx
, GEN_INT (align
));
2743 /* Now that we are assured of success, expand the source. */
2745 pat
= expand_expr (src
, src_reg
, ptr_mode
, EXPAND_NORMAL
);
2747 emit_move_insn (src_reg
, pat
);
2752 emit_insn_after (pat
, before_strlen
);
2754 emit_insn_before (pat
, get_insns ());
2756 /* Return the value in the proper mode for this function. */
2757 if (GET_MODE (result
) == target_mode
)
2759 else if (target
!= 0)
2760 convert_move (target
, result
, 0);
2762 target
= convert_to_mode (target_mode
, result
, 0);
2768 /* Expand a call to the strstr builtin. Return 0 if we failed the
2769 caller should emit a normal call, otherwise try to get the result
2770 in TARGET, if convenient (and in mode MODE if that's convenient). */
2773 expand_builtin_strstr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2775 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2777 tree result
= fold_builtin_strstr (arglist
, type
);
2779 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2784 /* Expand a call to the strchr builtin. Return 0 if we failed the
2785 caller should emit a normal call, otherwise try to get the result
2786 in TARGET, if convenient (and in mode MODE if that's convenient). */
2789 expand_builtin_strchr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2791 if (validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2793 tree result
= fold_builtin_strchr (arglist
, type
);
2795 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2797 /* FIXME: Should use strchrM optab so that ports can optimize this. */
2802 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2803 caller should emit a normal call, otherwise try to get the result
2804 in TARGET, if convenient (and in mode MODE if that's convenient). */
2807 expand_builtin_strrchr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2809 if (validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2811 tree result
= fold_builtin_strrchr (arglist
, type
);
2813 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2818 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2819 caller should emit a normal call, otherwise try to get the result
2820 in TARGET, if convenient (and in mode MODE if that's convenient). */
2823 expand_builtin_strpbrk (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2825 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2827 tree result
= fold_builtin_strpbrk (arglist
, type
);
2829 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2834 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2835 bytes from constant string DATA + OFFSET and return it as target
2839 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
2840 enum machine_mode mode
)
2842 const char *str
= (const char *) data
;
2844 gcc_assert (offset
>= 0
2845 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
2846 <= strlen (str
) + 1));
2848 return c_readstr (str
+ offset
, mode
);
2851 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2852 Return 0 if we failed, the caller should emit a normal call,
2853 otherwise try to get the result in TARGET, if convenient (and in
2854 mode MODE if that's convenient). */
2856 expand_builtin_memcpy (tree exp
, rtx target
, enum machine_mode mode
)
2858 tree fndecl
= get_callee_fndecl (exp
);
2859 tree arglist
= TREE_OPERAND (exp
, 1);
2860 if (!validate_arglist (arglist
,
2861 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2865 tree dest
= TREE_VALUE (arglist
);
2866 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2867 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2868 const char *src_str
;
2869 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2870 unsigned int dest_align
2871 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2872 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
2873 tree result
= fold_builtin_memcpy (fndecl
, arglist
);
2876 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2878 /* If DEST is not a pointer type, call the normal function. */
2879 if (dest_align
== 0)
2882 /* If either SRC is not a pointer type, don't do this
2883 operation in-line. */
2887 dest_mem
= get_memory_rtx (dest
, len
);
2888 set_mem_align (dest_mem
, dest_align
);
2889 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2890 src_str
= c_getstr (src
);
2892 /* If SRC is a string constant and block move would be done
2893 by pieces, we can avoid loading the string from memory
2894 and only stored the computed constants. */
2896 && GET_CODE (len_rtx
) == CONST_INT
2897 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2898 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2899 (void *) src_str
, dest_align
))
2901 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2902 builtin_memcpy_read_str
,
2903 (void *) src_str
, dest_align
, 0);
2904 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2905 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2909 src_mem
= get_memory_rtx (src
, len
);
2910 set_mem_align (src_mem
, src_align
);
2912 /* Copy word part most expediently. */
2913 dest_addr
= emit_block_move (dest_mem
, src_mem
, len_rtx
,
2914 CALL_EXPR_TAILCALL (exp
)
2915 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
);
2919 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2920 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
2926 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2927 Return 0 if we failed; the caller should emit a normal call,
2928 otherwise try to get the result in TARGET, if convenient (and in
2929 mode MODE if that's convenient). If ENDP is 0 return the
2930 destination pointer, if ENDP is 1 return the end pointer ala
2931 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2935 expand_builtin_mempcpy (tree arglist
, tree type
, rtx target
, enum machine_mode mode
,
2938 if (!validate_arglist (arglist
,
2939 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2941 /* If return value is ignored, transform mempcpy into memcpy. */
2942 else if (target
== const0_rtx
)
2944 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2949 return expand_expr (build_function_call_expr (fn
, arglist
),
2950 target
, mode
, EXPAND_NORMAL
);
2954 tree dest
= TREE_VALUE (arglist
);
2955 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2956 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2957 const char *src_str
;
2958 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2959 unsigned int dest_align
2960 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2961 rtx dest_mem
, src_mem
, len_rtx
;
2962 tree result
= fold_builtin_mempcpy (arglist
, type
, endp
);
2965 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2967 /* If either SRC or DEST is not a pointer type, don't do this
2968 operation in-line. */
2969 if (dest_align
== 0 || src_align
== 0)
2972 /* If LEN is not constant, call the normal function. */
2973 if (! host_integerp (len
, 1))
2976 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2977 src_str
= c_getstr (src
);
2979 /* If SRC is a string constant and block move would be done
2980 by pieces, we can avoid loading the string from memory
2981 and only stored the computed constants. */
2983 && GET_CODE (len_rtx
) == CONST_INT
2984 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2985 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2986 (void *) src_str
, dest_align
))
2988 dest_mem
= get_memory_rtx (dest
, len
);
2989 set_mem_align (dest_mem
, dest_align
);
2990 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2991 builtin_memcpy_read_str
,
2992 (void *) src_str
, dest_align
, endp
);
2993 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2994 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2998 if (GET_CODE (len_rtx
) == CONST_INT
2999 && can_move_by_pieces (INTVAL (len_rtx
),
3000 MIN (dest_align
, src_align
)))
3002 dest_mem
= get_memory_rtx (dest
, len
);
3003 set_mem_align (dest_mem
, dest_align
);
3004 src_mem
= get_memory_rtx (src
, len
);
3005 set_mem_align (src_mem
, src_align
);
3006 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
3007 MIN (dest_align
, src_align
), endp
);
3008 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3009 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3017 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
3018 if we failed; the caller should emit a normal call. */
3021 expand_builtin_memmove (tree arglist
, tree type
, rtx target
,
3022 enum machine_mode mode
, tree orig_exp
)
3024 if (!validate_arglist (arglist
,
3025 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3029 tree dest
= TREE_VALUE (arglist
);
3030 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
3031 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3033 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
3034 unsigned int dest_align
3035 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3036 tree result
= fold_builtin_memmove (arglist
, type
);
3039 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3041 /* If DEST is not a pointer type, call the normal function. */
3042 if (dest_align
== 0)
3045 /* If either SRC is not a pointer type, don't do this
3046 operation in-line. */
3050 /* If src is categorized for a readonly section we can use
3052 if (readonly_data_expr (src
))
3054 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3057 fn
= build_function_call_expr (fn
, arglist
);
3058 if (TREE_CODE (fn
) == CALL_EXPR
)
3059 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
3060 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
3063 /* If length is 1 and we can expand memcpy call inline,
3064 it is ok to use memcpy as well. */
3065 if (integer_onep (len
))
3067 rtx ret
= expand_builtin_mempcpy (arglist
, type
, target
, mode
,
3073 /* Otherwise, call the normal function. */
3078 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
3079 if we failed the caller should emit a normal call. */
3082 expand_builtin_bcopy (tree exp
)
3084 tree arglist
= TREE_OPERAND (exp
, 1);
3085 tree type
= TREE_TYPE (exp
);
3086 tree src
, dest
, size
, newarglist
;
3088 if (!validate_arglist (arglist
,
3089 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3092 src
= TREE_VALUE (arglist
);
3093 dest
= TREE_VALUE (TREE_CHAIN (arglist
));
3094 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3096 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
3097 memmove(ptr y, ptr x, size_t z). This is done this way
3098 so that if it isn't expanded inline, we fallback to
3099 calling bcopy instead of memmove. */
3101 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3102 newarglist
= tree_cons (NULL_TREE
, src
, newarglist
);
3103 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3105 return expand_builtin_memmove (newarglist
, type
, const0_rtx
, VOIDmode
, exp
);
3109 # define HAVE_movstr 0
3110 # define CODE_FOR_movstr CODE_FOR_nothing
3113 /* Expand into a movstr instruction, if one is available. Return 0 if
3114 we failed, the caller should emit a normal call, otherwise try to
3115 get the result in TARGET, if convenient. If ENDP is 0 return the
3116 destination pointer, if ENDP is 1 return the end pointer ala
3117 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3121 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3127 const struct insn_data
* data
;
3132 dest_mem
= get_memory_rtx (dest
, NULL
);
3133 src_mem
= get_memory_rtx (src
, NULL
);
3136 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3137 dest_mem
= replace_equiv_address (dest_mem
, target
);
3138 end
= gen_reg_rtx (Pmode
);
3142 if (target
== 0 || target
== const0_rtx
)
3144 end
= gen_reg_rtx (Pmode
);
3152 data
= insn_data
+ CODE_FOR_movstr
;
3154 if (data
->operand
[0].mode
!= VOIDmode
)
3155 end
= gen_lowpart (data
->operand
[0].mode
, end
);
3157 insn
= data
->genfun (end
, dest_mem
, src_mem
);
3163 /* movstr is supposed to set end to the address of the NUL
3164 terminator. If the caller requested a mempcpy-like return value,
3166 if (endp
== 1 && target
!= const0_rtx
)
3168 rtx tem
= plus_constant (gen_lowpart (GET_MODE (target
), end
), 1);
3169 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3175 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
3176 if we failed the caller should emit a normal call, otherwise try to get
3177 the result in TARGET, if convenient (and in mode MODE if that's
3181 expand_builtin_strcpy (tree fndecl
, tree arglist
, rtx target
, enum machine_mode mode
)
3183 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3185 tree result
= fold_builtin_strcpy (fndecl
, arglist
, 0);
3187 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3189 return expand_movstr (TREE_VALUE (arglist
),
3190 TREE_VALUE (TREE_CHAIN (arglist
)),
3191 target
, /*endp=*/0);
3196 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3197 Return 0 if we failed the caller should emit a normal call,
3198 otherwise try to get the result in TARGET, if convenient (and in
3199 mode MODE if that's convenient). */
3202 expand_builtin_stpcpy (tree exp
, rtx target
, enum machine_mode mode
)
3204 tree arglist
= TREE_OPERAND (exp
, 1);
3205 /* If return value is ignored, transform stpcpy into strcpy. */
3206 if (target
== const0_rtx
)
3208 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
3212 return expand_expr (build_function_call_expr (fn
, arglist
),
3213 target
, mode
, EXPAND_NORMAL
);
3216 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3220 tree dst
, src
, len
, lenp1
;
3224 /* Ensure we get an actual string whose length can be evaluated at
3225 compile-time, not an expression containing a string. This is
3226 because the latter will potentially produce pessimized code
3227 when used to produce the return value. */
3228 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3229 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3230 return expand_movstr (TREE_VALUE (arglist
),
3231 TREE_VALUE (TREE_CHAIN (arglist
)),
3232 target
, /*endp=*/2);
3234 dst
= TREE_VALUE (arglist
);
3235 lenp1
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3236 narglist
= build_tree_list (NULL_TREE
, lenp1
);
3237 narglist
= tree_cons (NULL_TREE
, src
, narglist
);
3238 narglist
= tree_cons (NULL_TREE
, dst
, narglist
);
3239 ret
= expand_builtin_mempcpy (narglist
, TREE_TYPE (exp
),
3240 target
, mode
, /*endp=*/2);
3245 if (TREE_CODE (len
) == INTEGER_CST
)
3247 rtx len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3249 if (GET_CODE (len_rtx
) == CONST_INT
)
3251 ret
= expand_builtin_strcpy (get_callee_fndecl (exp
),
3252 arglist
, target
, mode
);
3258 if (mode
!= VOIDmode
)
3259 target
= gen_reg_rtx (mode
);
3261 target
= gen_reg_rtx (GET_MODE (ret
));
3263 if (GET_MODE (target
) != GET_MODE (ret
))
3264 ret
= gen_lowpart (GET_MODE (target
), ret
);
3266 ret
= plus_constant (ret
, INTVAL (len_rtx
));
3267 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3275 return expand_movstr (TREE_VALUE (arglist
),
3276 TREE_VALUE (TREE_CHAIN (arglist
)),
3277 target
, /*endp=*/2);
3281 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3282 bytes from constant string DATA + OFFSET and return it as target
3286 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3287 enum machine_mode mode
)
3289 const char *str
= (const char *) data
;
3291 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3294 return c_readstr (str
+ offset
, mode
);
3297 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
3298 if we failed the caller should emit a normal call. */
3301 expand_builtin_strncpy (tree exp
, rtx target
, enum machine_mode mode
)
3303 tree fndecl
= get_callee_fndecl (exp
);
3304 tree arglist
= TREE_OPERAND (exp
, 1);
3305 if (validate_arglist (arglist
,
3306 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3308 tree slen
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)), 1);
3309 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3310 tree result
= fold_builtin_strncpy (fndecl
, arglist
, slen
);
3313 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3315 /* We must be passed a constant len and src parameter. */
3316 if (!host_integerp (len
, 1) || !slen
|| !host_integerp (slen
, 1))
3319 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
3321 /* We're required to pad with trailing zeros if the requested
3322 len is greater than strlen(s2)+1. In that case try to
3323 use store_by_pieces, if it fails, punt. */
3324 if (tree_int_cst_lt (slen
, len
))
3326 tree dest
= TREE_VALUE (arglist
);
3327 unsigned int dest_align
3328 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3329 const char *p
= c_getstr (TREE_VALUE (TREE_CHAIN (arglist
)));
3332 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
3333 || !can_store_by_pieces (tree_low_cst (len
, 1),
3334 builtin_strncpy_read_str
,
3335 (void *) p
, dest_align
))
3338 dest_mem
= get_memory_rtx (dest
, len
);
3339 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3340 builtin_strncpy_read_str
,
3341 (void *) p
, dest_align
, 0);
3342 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3343 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3350 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3351 bytes from constant string DATA + OFFSET and return it as target
3355 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3356 enum machine_mode mode
)
3358 const char *c
= (const char *) data
;
3359 char *p
= alloca (GET_MODE_SIZE (mode
));
3361 memset (p
, *c
, GET_MODE_SIZE (mode
));
3363 return c_readstr (p
, mode
);
3366 /* Callback routine for store_by_pieces. Return the RTL of a register
3367 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3368 char value given in the RTL register data. For example, if mode is
3369 4 bytes wide, return the RTL for 0x01010101*data. */
3372 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3373 enum machine_mode mode
)
3379 size
= GET_MODE_SIZE (mode
);
3384 memset (p
, 1, size
);
3385 coeff
= c_readstr (p
, mode
);
3387 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3388 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3389 return force_reg (mode
, target
);
3392 /* Expand expression EXP, which is a call to the memset builtin. Return 0
3393 if we failed the caller should emit a normal call, otherwise try to get
3394 the result in TARGET, if convenient (and in mode MODE if that's
3398 expand_builtin_memset (tree arglist
, rtx target
, enum machine_mode mode
,
3401 if (!validate_arglist (arglist
,
3402 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3406 tree dest
= TREE_VALUE (arglist
);
3407 tree val
= TREE_VALUE (TREE_CHAIN (arglist
));
3408 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3411 unsigned int dest_align
3412 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3413 rtx dest_mem
, dest_addr
, len_rtx
;
3415 /* If DEST is not a pointer type, don't do this
3416 operation in-line. */
3417 if (dest_align
== 0)
3420 /* If the LEN parameter is zero, return DEST. */
3421 if (integer_zerop (len
))
3423 /* Evaluate and ignore VAL in case it has side-effects. */
3424 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3425 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3428 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3429 dest_mem
= get_memory_rtx (dest
, len
);
3431 if (TREE_CODE (val
) != INTEGER_CST
)
3435 val
= fold_build1 (CONVERT_EXPR
, unsigned_char_type_node
, val
);
3436 val_rtx
= expand_expr (val
, NULL_RTX
, VOIDmode
, 0);
3438 /* Assume that we can memset by pieces if we can store the
3439 * the coefficients by pieces (in the required modes).
3440 * We can't pass builtin_memset_gen_str as that emits RTL. */
3442 if (host_integerp (len
, 1)
3443 && !(optimize_size
&& tree_low_cst (len
, 1) > 1)
3444 && can_store_by_pieces (tree_low_cst (len
, 1),
3445 builtin_memset_read_str
, &c
, dest_align
))
3447 val_rtx
= force_reg (TYPE_MODE (unsigned_char_type_node
),
3449 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3450 builtin_memset_gen_str
, val_rtx
, dest_align
, 0);
3452 else if (!set_storage_via_setmem(dest_mem
, len_rtx
, val_rtx
,
3456 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3457 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3461 if (target_char_cast (val
, &c
))
3466 if (host_integerp (len
, 1)
3467 && !(optimize_size
&& tree_low_cst (len
, 1) > 1)
3468 && can_store_by_pieces (tree_low_cst (len
, 1),
3469 builtin_memset_read_str
, &c
, dest_align
))
3470 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3471 builtin_memset_read_str
, &c
, dest_align
, 0);
3472 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, GEN_INT (c
),
3476 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3477 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3481 set_mem_align (dest_mem
, dest_align
);
3482 dest_addr
= clear_storage (dest_mem
, len_rtx
,
3483 CALL_EXPR_TAILCALL (orig_exp
)
3484 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
);
3488 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3489 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3496 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3497 if we failed the caller should emit a normal call. */
3500 expand_builtin_bzero (tree exp
)
3502 tree arglist
= TREE_OPERAND (exp
, 1);
3503 tree dest
, size
, newarglist
;
3505 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3508 dest
= TREE_VALUE (arglist
);
3509 size
= TREE_VALUE (TREE_CHAIN (arglist
));
3511 /* New argument list transforming bzero(ptr x, int y) to
3512 memset(ptr x, int 0, size_t y). This is done this way
3513 so that if it isn't expanded inline, we fallback to
3514 calling bzero instead of memset. */
3516 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3517 newarglist
= tree_cons (NULL_TREE
, integer_zero_node
, newarglist
);
3518 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3520 return expand_builtin_memset (newarglist
, const0_rtx
, VOIDmode
, exp
);
3523 /* Expand expression EXP, which is a call to the memcmp built-in function.
3524 ARGLIST is the argument list for this call. Return 0 if we failed and the
3525 caller should emit a normal call, otherwise try to get the result in
3526 TARGET, if convenient (and in mode MODE, if that's convenient). */
3529 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED
, tree arglist
, rtx target
,
3530 enum machine_mode mode
)
3532 if (!validate_arglist (arglist
,
3533 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3537 tree result
= fold_builtin_memcmp (arglist
);
3539 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3542 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3544 tree arg1
= TREE_VALUE (arglist
);
3545 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3546 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3547 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3552 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3554 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3555 enum machine_mode insn_mode
;
3557 #ifdef HAVE_cmpmemsi
3559 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3562 #ifdef HAVE_cmpstrnsi
3564 insn_mode
= insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3569 /* If we don't have POINTER_TYPE, call the function. */
3570 if (arg1_align
== 0 || arg2_align
== 0)
3573 /* Make a place to write the result of the instruction. */
3576 && REG_P (result
) && GET_MODE (result
) == insn_mode
3577 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3578 result
= gen_reg_rtx (insn_mode
);
3580 arg1_rtx
= get_memory_rtx (arg1
, len
);
3581 arg2_rtx
= get_memory_rtx (arg2
, len
);
3582 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3584 /* Set MEM_SIZE as appropriate. */
3585 if (GET_CODE (arg3_rtx
) == CONST_INT
)
3587 set_mem_size (arg1_rtx
, arg3_rtx
);
3588 set_mem_size (arg2_rtx
, arg3_rtx
);
3591 #ifdef HAVE_cmpmemsi
3593 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3594 GEN_INT (MIN (arg1_align
, arg2_align
)));
3597 #ifdef HAVE_cmpstrnsi
3599 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3600 GEN_INT (MIN (arg1_align
, arg2_align
)));
3608 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE_MAKE_BLOCK
,
3609 TYPE_MODE (integer_type_node
), 3,
3610 XEXP (arg1_rtx
, 0), Pmode
,
3611 XEXP (arg2_rtx
, 0), Pmode
,
3612 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
3613 TYPE_UNSIGNED (sizetype
)),
3614 TYPE_MODE (sizetype
));
3616 /* Return the value in the proper mode for this function. */
3617 mode
= TYPE_MODE (TREE_TYPE (exp
));
3618 if (GET_MODE (result
) == mode
)
3620 else if (target
!= 0)
3622 convert_move (target
, result
, 0);
3626 return convert_to_mode (mode
, result
, 0);
3633 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3634 if we failed the caller should emit a normal call, otherwise try to get
3635 the result in TARGET, if convenient. */
3638 expand_builtin_strcmp (tree exp
, rtx target
, enum machine_mode mode
)
3640 tree arglist
= TREE_OPERAND (exp
, 1);
3642 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3646 tree result
= fold_builtin_strcmp (arglist
);
3648 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3651 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3652 if (cmpstr_optab
[SImode
] != CODE_FOR_nothing
3653 || cmpstrn_optab
[SImode
] != CODE_FOR_nothing
)
3655 rtx arg1_rtx
, arg2_rtx
;
3656 rtx result
, insn
= NULL_RTX
;
3659 tree arg1
= TREE_VALUE (arglist
);
3660 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3662 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3664 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3666 /* If we don't have POINTER_TYPE, call the function. */
3667 if (arg1_align
== 0 || arg2_align
== 0)
3670 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
3671 arg1
= builtin_save_expr (arg1
);
3672 arg2
= builtin_save_expr (arg2
);
3674 arg1_rtx
= get_memory_rtx (arg1
, NULL
);
3675 arg2_rtx
= get_memory_rtx (arg2
, NULL
);
3677 #ifdef HAVE_cmpstrsi
3678 /* Try to call cmpstrsi. */
3681 enum machine_mode insn_mode
3682 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3684 /* Make a place to write the result of the instruction. */
3687 && REG_P (result
) && GET_MODE (result
) == insn_mode
3688 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3689 result
= gen_reg_rtx (insn_mode
);
3691 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
,
3692 GEN_INT (MIN (arg1_align
, arg2_align
)));
3696 /* Try to determine at least one length and call cmpstrnsi. */
3697 if (!insn
&& HAVE_cmpstrnsi
)
3702 enum machine_mode insn_mode
3703 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3704 tree len1
= c_strlen (arg1
, 1);
3705 tree len2
= c_strlen (arg2
, 1);
3708 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3710 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3712 /* If we don't have a constant length for the first, use the length
3713 of the second, if we know it. We don't require a constant for
3714 this case; some cost analysis could be done if both are available
3715 but neither is constant. For now, assume they're equally cheap,
3716 unless one has side effects. If both strings have constant lengths,
3723 else if (TREE_SIDE_EFFECTS (len1
))
3725 else if (TREE_SIDE_EFFECTS (len2
))
3727 else if (TREE_CODE (len1
) != INTEGER_CST
)
3729 else if (TREE_CODE (len2
) != INTEGER_CST
)
3731 else if (tree_int_cst_lt (len1
, len2
))
3736 /* If both arguments have side effects, we cannot optimize. */
3737 if (!len
|| TREE_SIDE_EFFECTS (len
))
3740 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
3741 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3743 /* Make a place to write the result of the instruction. */
3746 && REG_P (result
) && GET_MODE (result
) == insn_mode
3747 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3748 result
= gen_reg_rtx (insn_mode
);
3750 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3751 GEN_INT (MIN (arg1_align
, arg2_align
)));
3759 /* Return the value in the proper mode for this function. */
3760 mode
= TYPE_MODE (TREE_TYPE (exp
));
3761 if (GET_MODE (result
) == mode
)
3764 return convert_to_mode (mode
, result
, 0);
3765 convert_move (target
, result
, 0);
3769 /* Expand the library call ourselves using a stabilized argument
3770 list to avoid re-evaluating the function's arguments twice. */
3771 arglist
= build_tree_list (NULL_TREE
, arg2
);
3772 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3773 fndecl
= get_callee_fndecl (exp
);
3774 fn
= build_function_call_expr (fndecl
, arglist
);
3775 if (TREE_CODE (fn
) == CALL_EXPR
)
3776 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
3777 return expand_call (fn
, target
, target
== const0_rtx
);
3783 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3784 if we failed the caller should emit a normal call, otherwise try to get
3785 the result in TARGET, if convenient. */
3788 expand_builtin_strncmp (tree exp
, rtx target
, enum machine_mode mode
)
3790 tree arglist
= TREE_OPERAND (exp
, 1);
3792 if (!validate_arglist (arglist
,
3793 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3797 tree result
= fold_builtin_strncmp (arglist
);
3799 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3802 /* If c_strlen can determine an expression for one of the string
3803 lengths, and it doesn't have side effects, then emit cmpstrnsi
3804 using length MIN(strlen(string)+1, arg3). */
3805 #ifdef HAVE_cmpstrnsi
3808 tree arg1
= TREE_VALUE (arglist
);
3809 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3810 tree arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3811 tree len
, len1
, len2
;
3812 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3817 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3819 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3820 enum machine_mode insn_mode
3821 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3823 len1
= c_strlen (arg1
, 1);
3824 len2
= c_strlen (arg2
, 1);
3827 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3829 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3831 /* If we don't have a constant length for the first, use the length
3832 of the second, if we know it. We don't require a constant for
3833 this case; some cost analysis could be done if both are available
3834 but neither is constant. For now, assume they're equally cheap,
3835 unless one has side effects. If both strings have constant lengths,
3842 else if (TREE_SIDE_EFFECTS (len1
))
3844 else if (TREE_SIDE_EFFECTS (len2
))
3846 else if (TREE_CODE (len1
) != INTEGER_CST
)
3848 else if (TREE_CODE (len2
) != INTEGER_CST
)
3850 else if (tree_int_cst_lt (len1
, len2
))
3855 /* If both arguments have side effects, we cannot optimize. */
3856 if (!len
|| TREE_SIDE_EFFECTS (len
))
3859 /* The actual new length parameter is MIN(len,arg3). */
3860 len
= fold_build2 (MIN_EXPR
, TREE_TYPE (len
), len
,
3861 fold_convert (TREE_TYPE (len
), arg3
));
3863 /* If we don't have POINTER_TYPE, call the function. */
3864 if (arg1_align
== 0 || arg2_align
== 0)
3867 /* Make a place to write the result of the instruction. */
3870 && REG_P (result
) && GET_MODE (result
) == insn_mode
3871 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3872 result
= gen_reg_rtx (insn_mode
);
3874 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
3875 arg1
= builtin_save_expr (arg1
);
3876 arg2
= builtin_save_expr (arg2
);
3877 len
= builtin_save_expr (len
);
3879 arg1_rtx
= get_memory_rtx (arg1
, len
);
3880 arg2_rtx
= get_memory_rtx (arg2
, len
);
3881 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3882 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3883 GEN_INT (MIN (arg1_align
, arg2_align
)));
3888 /* Return the value in the proper mode for this function. */
3889 mode
= TYPE_MODE (TREE_TYPE (exp
));
3890 if (GET_MODE (result
) == mode
)
3893 return convert_to_mode (mode
, result
, 0);
3894 convert_move (target
, result
, 0);
3898 /* Expand the library call ourselves using a stabilized argument
3899 list to avoid re-evaluating the function's arguments twice. */
3900 arglist
= build_tree_list (NULL_TREE
, len
);
3901 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3902 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3903 fndecl
= get_callee_fndecl (exp
);
3904 fn
= build_function_call_expr (fndecl
, arglist
);
3905 if (TREE_CODE (fn
) == CALL_EXPR
)
3906 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
3907 return expand_call (fn
, target
, target
== const0_rtx
);
3913 /* Expand expression EXP, which is a call to the strcat builtin.
3914 Return 0 if we failed the caller should emit a normal call,
3915 otherwise try to get the result in TARGET, if convenient. */
3918 expand_builtin_strcat (tree fndecl
, tree arglist
, rtx target
, enum machine_mode mode
)
3920 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3924 tree dst
= TREE_VALUE (arglist
),
3925 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3926 const char *p
= c_getstr (src
);
3928 /* If the string length is zero, return the dst parameter. */
3929 if (p
&& *p
== '\0')
3930 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3934 /* See if we can store by pieces into (dst + strlen(dst)). */
3935 tree newsrc
, newdst
,
3936 strlen_fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
3939 /* Stabilize the argument list. */
3940 newsrc
= builtin_save_expr (src
);
3942 arglist
= build_tree_list (NULL_TREE
, newsrc
);
3944 arglist
= TREE_CHAIN (arglist
); /* Reusing arglist if safe. */
3946 dst
= builtin_save_expr (dst
);
3950 /* Create strlen (dst). */
3952 build_function_call_expr (strlen_fn
,
3953 build_tree_list (NULL_TREE
, dst
));
3954 /* Create (dst + (cast) strlen (dst)). */
3955 newdst
= fold_convert (TREE_TYPE (dst
), newdst
);
3956 newdst
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dst
), dst
, newdst
);
3958 newdst
= builtin_save_expr (newdst
);
3959 arglist
= tree_cons (NULL_TREE
, newdst
, arglist
);
3961 if (!expand_builtin_strcpy (fndecl
, arglist
, target
, mode
))
3963 end_sequence (); /* Stop sequence. */
3967 /* Output the entire sequence. */
3968 insns
= get_insns ();
3972 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3979 /* Expand expression EXP, which is a call to the strncat builtin.
3980 Return 0 if we failed the caller should emit a normal call,
3981 otherwise try to get the result in TARGET, if convenient. */
3984 expand_builtin_strncat (tree arglist
, rtx target
, enum machine_mode mode
)
3986 if (validate_arglist (arglist
,
3987 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3989 tree result
= fold_builtin_strncat (arglist
);
3991 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3996 /* Expand expression EXP, which is a call to the strspn builtin.
3997 Return 0 if we failed the caller should emit a normal call,
3998 otherwise try to get the result in TARGET, if convenient. */
4001 expand_builtin_strspn (tree arglist
, rtx target
, enum machine_mode mode
)
4003 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4005 tree result
= fold_builtin_strspn (arglist
);
4007 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
4012 /* Expand expression EXP, which is a call to the strcspn builtin.
4013 Return 0 if we failed the caller should emit a normal call,
4014 otherwise try to get the result in TARGET, if convenient. */
4017 expand_builtin_strcspn (tree arglist
, rtx target
, enum machine_mode mode
)
4019 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4021 tree result
= fold_builtin_strcspn (arglist
);
4023 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
4028 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4029 if that's convenient. */
4032 expand_builtin_saveregs (void)
4036 /* Don't do __builtin_saveregs more than once in a function.
4037 Save the result of the first call and reuse it. */
4038 if (saveregs_value
!= 0)
4039 return saveregs_value
;
4041 /* When this function is called, it means that registers must be
4042 saved on entry to this function. So we migrate the call to the
4043 first insn of this function. */
4047 /* Do whatever the machine needs done in this case. */
4048 val
= targetm
.calls
.expand_builtin_saveregs ();
4053 saveregs_value
= val
;
4055 /* Put the insns after the NOTE that starts the function. If this
4056 is inside a start_sequence, make the outer-level insn chain current, so
4057 the code is placed at the start of the function. */
4058 push_topmost_sequence ();
4059 emit_insn_after (seq
, entry_of_function ());
4060 pop_topmost_sequence ();
4065 /* __builtin_args_info (N) returns word N of the arg space info
4066 for the current function. The number and meanings of words
4067 is controlled by the definition of CUMULATIVE_ARGS. */
4070 expand_builtin_args_info (tree arglist
)
4072 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
4073 int *word_ptr
= (int *) ¤t_function_args_info
;
4075 gcc_assert (sizeof (CUMULATIVE_ARGS
) % sizeof (int) == 0);
4079 if (!host_integerp (TREE_VALUE (arglist
), 0))
4080 error ("argument of %<__builtin_args_info%> must be constant");
4083 HOST_WIDE_INT wordnum
= tree_low_cst (TREE_VALUE (arglist
), 0);
4085 if (wordnum
< 0 || wordnum
>= nwords
)
4086 error ("argument of %<__builtin_args_info%> out of range");
4088 return GEN_INT (word_ptr
[wordnum
]);
4092 error ("missing argument in %<__builtin_args_info%>");
4097 /* Expand a call to __builtin_next_arg. */
4100 expand_builtin_next_arg (void)
4102 /* Checking arguments is already done in fold_builtin_next_arg
4103 that must be called before this function. */
4104 return expand_binop (Pmode
, add_optab
,
4105 current_function_internal_arg_pointer
,
4106 current_function_arg_offset_rtx
,
4107 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4110 /* Make it easier for the backends by protecting the valist argument
4111 from multiple evaluations. */
4114 stabilize_va_list (tree valist
, int needs_lvalue
)
4116 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4118 if (TREE_SIDE_EFFECTS (valist
))
4119 valist
= save_expr (valist
);
4121 /* For this case, the backends will be expecting a pointer to
4122 TREE_TYPE (va_list_type_node), but it's possible we've
4123 actually been given an array (an actual va_list_type_node).
4125 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4127 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4128 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4137 if (! TREE_SIDE_EFFECTS (valist
))
4140 pt
= build_pointer_type (va_list_type_node
);
4141 valist
= fold_build1 (ADDR_EXPR
, pt
, valist
);
4142 TREE_SIDE_EFFECTS (valist
) = 1;
4145 if (TREE_SIDE_EFFECTS (valist
))
4146 valist
= save_expr (valist
);
4147 valist
= build_fold_indirect_ref (valist
);
4153 /* The "standard" definition of va_list is void*. */
4156 std_build_builtin_va_list (void)
4158 return ptr_type_node
;
4161 /* The "standard" implementation of va_start: just assign `nextarg' to
4165 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4169 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4170 make_tree (ptr_type_node
, nextarg
));
4171 TREE_SIDE_EFFECTS (t
) = 1;
4173 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4176 /* Expand ARGLIST, from a call to __builtin_va_start. */
4179 expand_builtin_va_start (tree arglist
)
4184 chain
= TREE_CHAIN (arglist
);
4188 error ("too few arguments to function %<va_start%>");
4192 if (fold_builtin_next_arg (chain
))
4195 nextarg
= expand_builtin_next_arg ();
4196 valist
= stabilize_va_list (TREE_VALUE (arglist
), 1);
4198 #ifdef EXPAND_BUILTIN_VA_START
4199 EXPAND_BUILTIN_VA_START (valist
, nextarg
);
4201 std_expand_builtin_va_start (valist
, nextarg
);
4207 /* The "standard" implementation of va_arg: read the value from the
4208 current (padded) address and increment by the (padded) size. */
4211 std_gimplify_va_arg_expr (tree valist
, tree type
, tree
*pre_p
, tree
*post_p
)
4213 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
4214 unsigned HOST_WIDE_INT align
, boundary
;
4217 #ifdef ARGS_GROW_DOWNWARD
4218 /* All of the alignment and movement below is for args-grow-up machines.
4219 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4220 implement their own specialized gimplify_va_arg_expr routines. */
4224 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
4226 type
= build_pointer_type (type
);
4228 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
4229 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
) / BITS_PER_UNIT
;
4231 /* Hoist the valist value into a temporary for the moment. */
4232 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
4234 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4235 requires greater alignment, we must perform dynamic alignment. */
4236 if (boundary
> align
)
4238 t
= fold_convert (TREE_TYPE (valist
), size_int (boundary
- 1));
4239 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4240 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4241 gimplify_and_add (t
, pre_p
);
4243 t
= fold_convert (TREE_TYPE (valist
), size_int (-boundary
));
4244 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4245 build2 (BIT_AND_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4246 gimplify_and_add (t
, pre_p
);
4251 /* If the actual alignment is less than the alignment of the type,
4252 adjust the type accordingly so that we don't assume strict alignment
4253 when deferencing the pointer. */
4254 boundary
*= BITS_PER_UNIT
;
4255 if (boundary
< TYPE_ALIGN (type
))
4257 type
= build_variant_type_copy (type
);
4258 TYPE_ALIGN (type
) = boundary
;
4261 /* Compute the rounded size of the type. */
4262 type_size
= size_in_bytes (type
);
4263 rounded_size
= round_up (type_size
, align
);
4265 /* Reduce rounded_size so it's sharable with the postqueue. */
4266 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4270 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
4272 /* Small args are padded downward. */
4273 t
= fold_build2 (GT_EXPR
, sizetype
, rounded_size
, size_int (align
));
4274 t
= fold_build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
4275 size_binop (MINUS_EXPR
, rounded_size
, type_size
));
4276 t
= fold_convert (TREE_TYPE (addr
), t
);
4277 addr
= fold_build2 (PLUS_EXPR
, TREE_TYPE (addr
), addr
, t
);
4280 /* Compute new value for AP. */
4281 t
= fold_convert (TREE_TYPE (valist
), rounded_size
);
4282 t
= build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
);
4283 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
4284 gimplify_and_add (t
, pre_p
);
4286 addr
= fold_convert (build_pointer_type (type
), addr
);
4289 addr
= build_va_arg_indirect_ref (addr
);
4291 return build_va_arg_indirect_ref (addr
);
4294 /* Build an indirect-ref expression over the given TREE, which represents a
4295 piece of a va_arg() expansion. */
4297 build_va_arg_indirect_ref (tree addr
)
4299 addr
= build_fold_indirect_ref (addr
);
4301 if (flag_mudflap
) /* Don't instrument va_arg INDIRECT_REF. */
4307 /* Return a dummy expression of type TYPE in order to keep going after an
4311 dummy_object (tree type
)
4313 tree t
= convert (build_pointer_type (type
), null_pointer_node
);
4314 return build1 (INDIRECT_REF
, type
, t
);
4317 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4318 builtin function, but a very special sort of operator. */
4320 enum gimplify_status
4321 gimplify_va_arg_expr (tree
*expr_p
, tree
*pre_p
, tree
*post_p
)
4323 tree promoted_type
, want_va_type
, have_va_type
;
4324 tree valist
= TREE_OPERAND (*expr_p
, 0);
4325 tree type
= TREE_TYPE (*expr_p
);
4328 /* Verify that valist is of the proper type. */
4329 want_va_type
= va_list_type_node
;
4330 have_va_type
= TREE_TYPE (valist
);
4332 if (have_va_type
== error_mark_node
)
4335 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
4337 /* If va_list is an array type, the argument may have decayed
4338 to a pointer type, e.g. by being passed to another function.
4339 In that case, unwrap both types so that we can compare the
4340 underlying records. */
4341 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
4342 || POINTER_TYPE_P (have_va_type
))
4344 want_va_type
= TREE_TYPE (want_va_type
);
4345 have_va_type
= TREE_TYPE (have_va_type
);
4349 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
4351 error ("first argument to %<va_arg%> not of type %<va_list%>");
4355 /* Generate a diagnostic for requesting data of a type that cannot
4356 be passed through `...' due to type promotion at the call site. */
4357 else if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4360 static bool gave_help
;
4362 /* Unfortunately, this is merely undefined, rather than a constraint
4363 violation, so we cannot make this an error. If this call is never
4364 executed, the program is still strictly conforming. */
4365 warning (0, "%qT is promoted to %qT when passed through %<...%>",
4366 type
, promoted_type
);
4370 warning (0, "(so you should pass %qT not %qT to %<va_arg%>)",
4371 promoted_type
, type
);
4374 /* We can, however, treat "undefined" any way we please.
4375 Call abort to encourage the user to fix the program. */
4376 inform ("if this code is reached, the program will abort");
4377 t
= build_function_call_expr (implicit_built_in_decls
[BUILT_IN_TRAP
],
4379 append_to_statement_list (t
, pre_p
);
4381 /* This is dead code, but go ahead and finish so that the
4382 mode of the result comes out right. */
4383 *expr_p
= dummy_object (type
);
4388 /* Make it easier for the backends by protecting the valist argument
4389 from multiple evaluations. */
4390 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4392 /* For this case, the backends will be expecting a pointer to
4393 TREE_TYPE (va_list_type_node), but it's possible we've
4394 actually been given an array (an actual va_list_type_node).
4396 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4398 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4399 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4401 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4404 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
4406 if (!targetm
.gimplify_va_arg_expr
)
4407 /* FIXME:Once most targets are converted we should merely
4408 assert this is non-null. */
4411 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
4416 /* Expand ARGLIST, from a call to __builtin_va_end. */
4419 expand_builtin_va_end (tree arglist
)
4421 tree valist
= TREE_VALUE (arglist
);
4423 /* Evaluate for side effects, if needed. I hate macros that don't
4425 if (TREE_SIDE_EFFECTS (valist
))
4426 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4431 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4432 builtin rather than just as an assignment in stdarg.h because of the
4433 nastiness of array-type va_list types. */
4436 expand_builtin_va_copy (tree arglist
)
4440 dst
= TREE_VALUE (arglist
);
4441 src
= TREE_VALUE (TREE_CHAIN (arglist
));
4443 dst
= stabilize_va_list (dst
, 1);
4444 src
= stabilize_va_list (src
, 0);
4446 if (TREE_CODE (va_list_type_node
) != ARRAY_TYPE
)
4448 t
= build2 (MODIFY_EXPR
, va_list_type_node
, dst
, src
);
4449 TREE_SIDE_EFFECTS (t
) = 1;
4450 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4454 rtx dstb
, srcb
, size
;
4456 /* Evaluate to pointers. */
4457 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4458 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4459 size
= expand_expr (TYPE_SIZE_UNIT (va_list_type_node
), NULL_RTX
,
4460 VOIDmode
, EXPAND_NORMAL
);
4462 dstb
= convert_memory_address (Pmode
, dstb
);
4463 srcb
= convert_memory_address (Pmode
, srcb
);
4465 /* "Dereference" to BLKmode memories. */
4466 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4467 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4468 set_mem_align (dstb
, TYPE_ALIGN (va_list_type_node
));
4469 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4470 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4471 set_mem_align (srcb
, TYPE_ALIGN (va_list_type_node
));
4474 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4480 /* Expand a call to one of the builtin functions __builtin_frame_address or
4481 __builtin_return_address. */
4484 expand_builtin_frame_address (tree fndecl
, tree arglist
)
4486 /* The argument must be a nonnegative integer constant.
4487 It counts the number of frames to scan up the stack.
4488 The value is the return address saved in that frame. */
4490 /* Warning about missing arg was already issued. */
4492 else if (! host_integerp (TREE_VALUE (arglist
), 1))
4494 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4495 error ("invalid argument to %<__builtin_frame_address%>");
4497 error ("invalid argument to %<__builtin_return_address%>");
4503 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4504 tree_low_cst (TREE_VALUE (arglist
), 1));
4506 /* Some ports cannot access arbitrary stack frames. */
4509 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4510 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4512 warning (0, "unsupported argument to %<__builtin_return_address%>");
4516 /* For __builtin_frame_address, return what we've got. */
4517 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4521 && ! CONSTANT_P (tem
))
4522 tem
= copy_to_mode_reg (Pmode
, tem
);
4527 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4528 we failed and the caller should emit a normal call, otherwise try to get
4529 the result in TARGET, if convenient. */
4532 expand_builtin_alloca (tree arglist
, rtx target
)
4537 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4538 should always expand to function calls. These can be intercepted
4543 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4546 /* Compute the argument. */
4547 op0
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
4549 /* Allocate the desired space. */
4550 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
4551 result
= convert_memory_address (ptr_mode
, result
);
4556 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4557 Return 0 if a normal call should be emitted rather than expanding the
4558 function in-line. If convenient, the result should be placed in TARGET.
4559 SUBTARGET may be used as the target for computing one of EXP's operands. */
4562 expand_builtin_unop (enum machine_mode target_mode
, tree arglist
, rtx target
,
4563 rtx subtarget
, optab op_optab
)
4566 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4569 /* Compute the argument. */
4570 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4571 /* Compute op, into TARGET if possible.
4572 Set TARGET to wherever the result comes back. */
4573 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4574 op_optab
, op0
, target
, 1);
4575 gcc_assert (target
);
4577 return convert_to_mode (target_mode
, target
, 0);
4580 /* If the string passed to fputs is a constant and is one character
4581 long, we attempt to transform this call into __builtin_fputc(). */
4584 expand_builtin_fputs (tree arglist
, rtx target
, bool unlocked
)
4586 /* Verify the arguments in the original call. */
4587 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4589 tree result
= fold_builtin_fputs (arglist
, (target
== const0_rtx
),
4590 unlocked
, NULL_TREE
);
4592 return expand_expr (result
, target
, VOIDmode
, EXPAND_NORMAL
);
4597 /* Expand a call to __builtin_expect. We return our argument and emit a
4598 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4599 a non-jump context. */
4602 expand_builtin_expect (tree arglist
, rtx target
)
4607 if (arglist
== NULL_TREE
4608 || TREE_CHAIN (arglist
) == NULL_TREE
)
4610 exp
= TREE_VALUE (arglist
);
4611 c
= TREE_VALUE (TREE_CHAIN (arglist
));
4613 if (TREE_CODE (c
) != INTEGER_CST
)
4615 error ("second argument to %<__builtin_expect%> must be a constant");
4616 c
= integer_zero_node
;
4619 target
= expand_expr (exp
, target
, VOIDmode
, EXPAND_NORMAL
);
4621 /* Don't bother with expected value notes for integral constants. */
4622 if (flag_guess_branch_prob
&& GET_CODE (target
) != CONST_INT
)
4624 /* We do need to force this into a register so that we can be
4625 moderately sure to be able to correctly interpret the branch
4627 target
= force_reg (GET_MODE (target
), target
);
4629 rtx_c
= expand_expr (c
, NULL_RTX
, GET_MODE (target
), EXPAND_NORMAL
);
4631 note
= emit_note (NOTE_INSN_EXPECTED_VALUE
);
4632 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, target
, rtx_c
);
4638 /* Like expand_builtin_expect, except do this in a jump context. This is
4639 called from do_jump if the conditional is a __builtin_expect. Return either
4640 a list of insns to emit the jump or NULL if we cannot optimize
4641 __builtin_expect. We need to optimize this at jump time so that machines
4642 like the PowerPC don't turn the test into a SCC operation, and then jump
4643 based on the test being 0/1. */
4646 expand_builtin_expect_jump (tree exp
, rtx if_false_label
, rtx if_true_label
)
4648 tree arglist
= TREE_OPERAND (exp
, 1);
4649 tree arg0
= TREE_VALUE (arglist
);
4650 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
4653 /* Only handle __builtin_expect (test, 0) and
4654 __builtin_expect (test, 1). */
4655 if (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
4656 && (integer_zerop (arg1
) || integer_onep (arg1
)))
4658 rtx insn
, drop_through_label
, temp
;
4660 /* Expand the jump insns. */
4662 do_jump (arg0
, if_false_label
, if_true_label
);
4665 drop_through_label
= get_last_insn ();
4666 if (drop_through_label
&& NOTE_P (drop_through_label
))
4667 drop_through_label
= prev_nonnote_insn (drop_through_label
);
4668 if (drop_through_label
&& !LABEL_P (drop_through_label
))
4669 drop_through_label
= NULL_RTX
;
4672 if (! if_true_label
)
4673 if_true_label
= drop_through_label
;
4674 if (! if_false_label
)
4675 if_false_label
= drop_through_label
;
4677 /* Go through and add the expect's to each of the conditional jumps. */
4679 while (insn
!= NULL_RTX
)
4681 rtx next
= NEXT_INSN (insn
);
4683 if (JUMP_P (insn
) && any_condjump_p (insn
))
4685 rtx ifelse
= SET_SRC (pc_set (insn
));
4686 rtx then_dest
= XEXP (ifelse
, 1);
4687 rtx else_dest
= XEXP (ifelse
, 2);
4690 /* First check if we recognize any of the labels. */
4691 if (GET_CODE (then_dest
) == LABEL_REF
4692 && XEXP (then_dest
, 0) == if_true_label
)
4694 else if (GET_CODE (then_dest
) == LABEL_REF
4695 && XEXP (then_dest
, 0) == if_false_label
)
4697 else if (GET_CODE (else_dest
) == LABEL_REF
4698 && XEXP (else_dest
, 0) == if_false_label
)
4700 else if (GET_CODE (else_dest
) == LABEL_REF
4701 && XEXP (else_dest
, 0) == if_true_label
)
4703 /* Otherwise check where we drop through. */
4704 else if (else_dest
== pc_rtx
)
4706 if (next
&& NOTE_P (next
))
4707 next
= next_nonnote_insn (next
);
4709 if (next
&& JUMP_P (next
)
4710 && any_uncondjump_p (next
))
4711 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4715 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4716 else that can't possibly match either target label. */
4717 if (temp
== if_false_label
)
4719 else if (temp
== if_true_label
)
4722 else if (then_dest
== pc_rtx
)
4724 if (next
&& NOTE_P (next
))
4725 next
= next_nonnote_insn (next
);
4727 if (next
&& JUMP_P (next
)
4728 && any_uncondjump_p (next
))
4729 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4733 if (temp
== if_false_label
)
4735 else if (temp
== if_true_label
)
4741 /* If the test is expected to fail, reverse the
4743 if (integer_zerop (arg1
))
4745 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, taken
);
4757 expand_builtin_trap (void)
4761 emit_insn (gen_trap ());
4764 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4768 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4769 Return 0 if a normal call should be emitted rather than expanding
4770 the function inline. If convenient, the result should be placed
4771 in TARGET. SUBTARGET may be used as the target for computing
4775 expand_builtin_fabs (tree arglist
, rtx target
, rtx subtarget
)
4777 enum machine_mode mode
;
4781 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
4784 arg
= TREE_VALUE (arglist
);
4785 mode
= TYPE_MODE (TREE_TYPE (arg
));
4786 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4787 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4790 /* Expand a call to copysign, copysignf, or copysignl with arguments ARGLIST.
4791 Return NULL is a normal call should be emitted rather than expanding the
4792 function inline. If convenient, the result should be placed in TARGET.
4793 SUBTARGET may be used as the target for computing the operand. */
4796 expand_builtin_copysign (tree arglist
, rtx target
, rtx subtarget
)
4801 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
4804 arg
= TREE_VALUE (arglist
);
4805 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4807 arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4808 op1
= expand_expr (arg
, NULL
, VOIDmode
, 0);
4810 return expand_copysign (op0
, op1
, target
);
4813 /* Create a new constant string literal and return a char* pointer to it.
4814 The STRING_CST value is the LEN characters at STR. */
4816 build_string_literal (int len
, const char *str
)
4818 tree t
, elem
, index
, type
;
4820 t
= build_string (len
, str
);
4821 elem
= build_type_variant (char_type_node
, 1, 0);
4822 index
= build_index_type (build_int_cst (NULL_TREE
, len
- 1));
4823 type
= build_array_type (elem
, index
);
4824 TREE_TYPE (t
) = type
;
4825 TREE_CONSTANT (t
) = 1;
4826 TREE_INVARIANT (t
) = 1;
4827 TREE_READONLY (t
) = 1;
4828 TREE_STATIC (t
) = 1;
4830 type
= build_pointer_type (type
);
4831 t
= build1 (ADDR_EXPR
, type
, t
);
4833 type
= build_pointer_type (elem
);
4834 t
= build1 (NOP_EXPR
, type
, t
);
4838 /* Expand EXP, a call to printf or printf_unlocked.
4839 Return 0 if a normal call should be emitted rather than transforming
4840 the function inline. If convenient, the result should be placed in
4841 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4844 expand_builtin_printf (tree exp
, rtx target
, enum machine_mode mode
,
4847 tree arglist
= TREE_OPERAND (exp
, 1);
4848 tree fn_putchar
= unlocked
4849 ? implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
]
4850 : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4851 tree fn_puts
= unlocked
? implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
]
4852 : implicit_built_in_decls
[BUILT_IN_PUTS
];
4853 const char *fmt_str
;
4856 /* If the return value is used, don't do the transformation. */
4857 if (target
!= const0_rtx
)
4860 /* Verify the required arguments in the original call. */
4863 fmt
= TREE_VALUE (arglist
);
4864 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4866 arglist
= TREE_CHAIN (arglist
);
4868 /* Check whether the format is a literal string constant. */
4869 fmt_str
= c_getstr (fmt
);
4870 if (fmt_str
== NULL
)
4873 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4874 if (strcmp (fmt_str
, "%s\n") == 0)
4877 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
4878 || TREE_CHAIN (arglist
))
4882 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4883 else if (strcmp (fmt_str
, "%c") == 0)
4886 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
4887 || TREE_CHAIN (arglist
))
4893 /* We can't handle anything else with % args or %% ... yet. */
4894 if (strchr (fmt_str
, '%'))
4900 /* If the format specifier was "", printf does nothing. */
4901 if (fmt_str
[0] == '\0')
4903 /* If the format specifier has length of 1, call putchar. */
4904 if (fmt_str
[1] == '\0')
4906 /* Given printf("c"), (where c is any one character,)
4907 convert "c"[0] to an int and pass that to the replacement
4909 arg
= build_int_cst (NULL_TREE
, fmt_str
[0]);
4910 arglist
= build_tree_list (NULL_TREE
, arg
);
4915 /* If the format specifier was "string\n", call puts("string"). */
4916 size_t len
= strlen (fmt_str
);
4917 if (fmt_str
[len
- 1] == '\n')
4919 /* Create a NUL-terminated string that's one char shorter
4920 than the original, stripping off the trailing '\n'. */
4921 char *newstr
= alloca (len
);
4922 memcpy (newstr
, fmt_str
, len
- 1);
4923 newstr
[len
- 1] = 0;
4925 arg
= build_string_literal (len
, newstr
);
4926 arglist
= build_tree_list (NULL_TREE
, arg
);
4930 /* We'd like to arrange to call fputs(string,stdout) here,
4931 but we need stdout and don't have a way to get it yet. */
4938 fn
= build_function_call_expr (fn
, arglist
);
4939 if (TREE_CODE (fn
) == CALL_EXPR
)
4940 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4941 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
4944 /* Expand EXP, a call to fprintf or fprintf_unlocked.
4945 Return 0 if a normal call should be emitted rather than transforming
4946 the function inline. If convenient, the result should be placed in
4947 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4950 expand_builtin_fprintf (tree exp
, rtx target
, enum machine_mode mode
,
4953 tree arglist
= TREE_OPERAND (exp
, 1);
4954 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
4955 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4956 tree fn_fputs
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
]
4957 : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4958 const char *fmt_str
;
4959 tree fn
, fmt
, fp
, arg
;
4961 /* If the return value is used, don't do the transformation. */
4962 if (target
!= const0_rtx
)
4965 /* Verify the required arguments in the original call. */
4968 fp
= TREE_VALUE (arglist
);
4969 if (! POINTER_TYPE_P (TREE_TYPE (fp
)))
4971 arglist
= TREE_CHAIN (arglist
);
4974 fmt
= TREE_VALUE (arglist
);
4975 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4977 arglist
= TREE_CHAIN (arglist
);
4979 /* Check whether the format is a literal string constant. */
4980 fmt_str
= c_getstr (fmt
);
4981 if (fmt_str
== NULL
)
4984 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
4985 if (strcmp (fmt_str
, "%s") == 0)
4988 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
4989 || TREE_CHAIN (arglist
))
4991 arg
= TREE_VALUE (arglist
);
4992 arglist
= build_tree_list (NULL_TREE
, fp
);
4993 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
4996 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
4997 else if (strcmp (fmt_str
, "%c") == 0)
5000 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
5001 || TREE_CHAIN (arglist
))
5003 arg
= TREE_VALUE (arglist
);
5004 arglist
= build_tree_list (NULL_TREE
, fp
);
5005 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
5010 /* We can't handle anything else with % args or %% ... yet. */
5011 if (strchr (fmt_str
, '%'))
5017 /* If the format specifier was "", fprintf does nothing. */
5018 if (fmt_str
[0] == '\0')
5020 /* Evaluate and ignore FILE* argument for side-effects. */
5021 expand_expr (fp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5025 /* When "string" doesn't contain %, replace all cases of
5026 fprintf(stream,string) with fputs(string,stream). The fputs
5027 builtin will take care of special cases like length == 1. */
5028 arglist
= build_tree_list (NULL_TREE
, fp
);
5029 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
5035 fn
= build_function_call_expr (fn
, arglist
);
5036 if (TREE_CODE (fn
) == CALL_EXPR
)
5037 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
5038 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
5041 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
5042 a normal call should be emitted rather than expanding the function
5043 inline. If convenient, the result should be placed in TARGET with
5047 expand_builtin_sprintf (tree arglist
, rtx target
, enum machine_mode mode
)
5049 tree orig_arglist
, dest
, fmt
;
5050 const char *fmt_str
;
5052 orig_arglist
= arglist
;
5054 /* Verify the required arguments in the original call. */
5057 dest
= TREE_VALUE (arglist
);
5058 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
5060 arglist
= TREE_CHAIN (arglist
);
5063 fmt
= TREE_VALUE (arglist
);
5064 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
5066 arglist
= TREE_CHAIN (arglist
);
5068 /* Check whether the format is a literal string constant. */
5069 fmt_str
= c_getstr (fmt
);
5070 if (fmt_str
== NULL
)
5073 /* If the format doesn't contain % args or %%, use strcpy. */
5074 if (strchr (fmt_str
, '%') == 0)
5076 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5079 if (arglist
|| ! fn
)
5081 expand_expr (build_function_call_expr (fn
, orig_arglist
),
5082 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5083 if (target
== const0_rtx
)
5085 exp
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
5086 return expand_expr (exp
, target
, mode
, EXPAND_NORMAL
);
5088 /* If the format is "%s", use strcpy if the result isn't used. */
5089 else if (strcmp (fmt_str
, "%s") == 0)
5092 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5097 if (! arglist
|| TREE_CHAIN (arglist
))
5099 arg
= TREE_VALUE (arglist
);
5100 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
5103 if (target
!= const0_rtx
)
5105 len
= c_strlen (arg
, 1);
5106 if (! len
|| TREE_CODE (len
) != INTEGER_CST
)
5112 arglist
= build_tree_list (NULL_TREE
, arg
);
5113 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
5114 expand_expr (build_function_call_expr (fn
, arglist
),
5115 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5117 if (target
== const0_rtx
)
5119 return expand_expr (len
, target
, mode
, EXPAND_NORMAL
);
5125 /* Expand a call to either the entry or exit function profiler. */
5128 expand_builtin_profile_func (bool exitp
)
5132 this = DECL_RTL (current_function_decl
);
5133 gcc_assert (MEM_P (this));
5134 this = XEXP (this, 0);
5137 which
= profile_function_exit_libfunc
;
5139 which
= profile_function_entry_libfunc
;
5141 emit_library_call (which
, LCT_NORMAL
, VOIDmode
, 2, this, Pmode
,
5142 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
5149 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5152 round_trampoline_addr (rtx tramp
)
5154 rtx temp
, addend
, mask
;
5156 /* If we don't need too much alignment, we'll have been guaranteed
5157 proper alignment by get_trampoline_type. */
5158 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
5161 /* Round address up to desired boundary. */
5162 temp
= gen_reg_rtx (Pmode
);
5163 addend
= GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1);
5164 mask
= GEN_INT (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
5166 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
5167 temp
, 0, OPTAB_LIB_WIDEN
);
5168 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
5169 temp
, 0, OPTAB_LIB_WIDEN
);
5175 expand_builtin_init_trampoline (tree arglist
)
5177 tree t_tramp
, t_func
, t_chain
;
5178 rtx r_tramp
, r_func
, r_chain
;
5179 #ifdef TRAMPOLINE_TEMPLATE
5183 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
,
5184 POINTER_TYPE
, VOID_TYPE
))
5187 t_tramp
= TREE_VALUE (arglist
);
5188 arglist
= TREE_CHAIN (arglist
);
5189 t_func
= TREE_VALUE (arglist
);
5190 arglist
= TREE_CHAIN (arglist
);
5191 t_chain
= TREE_VALUE (arglist
);
5193 r_tramp
= expand_expr (t_tramp
, NULL_RTX
, VOIDmode
, 0);
5194 r_func
= expand_expr (t_func
, NULL_RTX
, VOIDmode
, 0);
5195 r_chain
= expand_expr (t_chain
, NULL_RTX
, VOIDmode
, 0);
5197 /* Generate insns to initialize the trampoline. */
5198 r_tramp
= round_trampoline_addr (r_tramp
);
5199 #ifdef TRAMPOLINE_TEMPLATE
5200 blktramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
5201 set_mem_align (blktramp
, TRAMPOLINE_ALIGNMENT
);
5202 emit_block_move (blktramp
, assemble_trampoline_template (),
5203 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
5205 trampolines_created
= 1;
5206 INITIALIZE_TRAMPOLINE (r_tramp
, r_func
, r_chain
);
5212 expand_builtin_adjust_trampoline (tree arglist
)
5216 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5219 tramp
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
5220 tramp
= round_trampoline_addr (tramp
);
5221 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5222 TRAMPOLINE_ADJUST_ADDRESS (tramp
);
5228 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5229 Return NULL_RTX if a normal call should be emitted rather than expanding
5230 the function in-line. EXP is the expression that is a call to the builtin
5231 function; if convenient, the result should be placed in TARGET. */
5234 expand_builtin_signbit (tree exp
, rtx target
)
5236 const struct real_format
*fmt
;
5237 enum machine_mode fmode
, imode
, rmode
;
5238 HOST_WIDE_INT hi
, lo
;
5243 arglist
= TREE_OPERAND (exp
, 1);
5244 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
5247 arg
= TREE_VALUE (arglist
);
5248 fmode
= TYPE_MODE (TREE_TYPE (arg
));
5249 rmode
= TYPE_MODE (TREE_TYPE (exp
));
5250 fmt
= REAL_MODE_FORMAT (fmode
);
5252 /* For floating point formats without a sign bit, implement signbit
5254 bitpos
= fmt
->signbit_ro
;
5257 /* But we can't do this if the format supports signed zero. */
5258 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5261 arg
= fold_build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
5262 build_real (TREE_TYPE (arg
), dconst0
));
5263 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5266 temp
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
5267 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
5269 imode
= int_mode_for_mode (fmode
);
5270 if (imode
== BLKmode
)
5272 temp
= gen_lowpart (imode
, temp
);
5277 /* Handle targets with different FP word orders. */
5278 if (FLOAT_WORDS_BIG_ENDIAN
)
5279 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
5281 word
= bitpos
/ BITS_PER_WORD
;
5282 temp
= operand_subword_force (temp
, word
, fmode
);
5283 bitpos
= bitpos
% BITS_PER_WORD
;
5286 /* Force the intermediate word_mode (or narrower) result into a
5287 register. This avoids attempting to create paradoxical SUBREGs
5288 of floating point modes below. */
5289 temp
= force_reg (imode
, temp
);
5291 /* If the bitpos is within the "result mode" lowpart, the operation
5292 can be implement with a single bitwise AND. Otherwise, we need
5293 a right shift and an AND. */
5295 if (bitpos
< GET_MODE_BITSIZE (rmode
))
5297 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5300 lo
= (HOST_WIDE_INT
) 1 << bitpos
;
5304 hi
= (HOST_WIDE_INT
) 1 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5309 temp
= gen_lowpart (rmode
, temp
);
5310 temp
= expand_binop (rmode
, and_optab
, temp
,
5311 immed_double_const (lo
, hi
, rmode
),
5312 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5316 /* Perform a logical right shift to place the signbit in the least
5317 significant bit, then truncate the result to the desired mode
5318 and mask just this bit. */
5319 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
,
5320 build_int_cst (NULL_TREE
, bitpos
), NULL_RTX
, 1);
5321 temp
= gen_lowpart (rmode
, temp
);
5322 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
5323 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5329 /* Expand fork or exec calls. TARGET is the desired target of the
5330 call. ARGLIST is the list of arguments of the call. FN is the
5331 identificator of the actual function. IGNORE is nonzero if the
5332 value is to be ignored. */
5335 expand_builtin_fork_or_exec (tree fn
, tree arglist
, rtx target
, int ignore
)
5340 /* If we are not profiling, just call the function. */
5341 if (!profile_arc_flag
)
5344 /* Otherwise call the wrapper. This should be equivalent for the rest of
5345 compiler, so the code does not diverge, and the wrapper may run the
5346 code necessary for keeping the profiling sane. */
5348 switch (DECL_FUNCTION_CODE (fn
))
5351 id
= get_identifier ("__gcov_fork");
5354 case BUILT_IN_EXECL
:
5355 id
= get_identifier ("__gcov_execl");
5358 case BUILT_IN_EXECV
:
5359 id
= get_identifier ("__gcov_execv");
5362 case BUILT_IN_EXECLP
:
5363 id
= get_identifier ("__gcov_execlp");
5366 case BUILT_IN_EXECLE
:
5367 id
= get_identifier ("__gcov_execle");
5370 case BUILT_IN_EXECVP
:
5371 id
= get_identifier ("__gcov_execvp");
5374 case BUILT_IN_EXECVE
:
5375 id
= get_identifier ("__gcov_execve");
5382 decl
= build_decl (FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5383 DECL_EXTERNAL (decl
) = 1;
5384 TREE_PUBLIC (decl
) = 1;
5385 DECL_ARTIFICIAL (decl
) = 1;
5386 TREE_NOTHROW (decl
) = 1;
5387 call
= build_function_call_expr (decl
, arglist
);
5389 return expand_call (call
, target
, ignore
);
5393 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5394 ARGLIST is the operands list to the function. CODE is the rtx code
5395 that corresponds to the arithmetic or logical operation from the name;
5396 an exception here is that NOT actually means NAND. TARGET is an optional
5397 place for us to store the results; AFTER is true if this is the
5398 fetch_and_xxx form. IGNORE is true if we don't actually care about
5399 the result of the operation at all. */
5402 expand_builtin_sync_operation (tree arglist
, enum rtx_code code
, bool after
,
5403 rtx target
, bool ignore
)
5405 enum machine_mode mode
;
5408 /* Expand the operands. */
5409 addr
= expand_expr (TREE_VALUE (arglist
), NULL
, Pmode
, EXPAND_SUM
);
5410 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (TREE_VALUE (arglist
))));
5412 arglist
= TREE_CHAIN (arglist
);
5413 val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5415 /* Note that we explicitly do not want any alias information for this
5416 memory, so that we kill all other live memories. Otherwise we don't
5417 satisfy the full barrier semantics of the intrinsic. */
5418 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5419 MEM_VOLATILE_P (mem
) = 1;
5422 return expand_sync_operation (mem
, val
, code
);
5424 return expand_sync_fetch_operation (mem
, val
, code
, after
, target
);
5427 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5428 intrinsics. ARGLIST is the operands list to the function. IS_BOOL is
5429 true if this is the boolean form. TARGET is a place for us to store the
5430 results; this is NOT optional if IS_BOOL is true. */
5433 expand_builtin_compare_and_swap (tree arglist
, bool is_bool
, rtx target
)
5435 enum machine_mode mode
;
5436 rtx addr
, old_val
, new_val
, mem
;
5438 /* Expand the operands. */
5439 addr
= expand_expr (TREE_VALUE (arglist
), NULL
, Pmode
, EXPAND_SUM
);
5440 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (TREE_VALUE (arglist
))));
5442 arglist
= TREE_CHAIN (arglist
);
5443 old_val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5445 arglist
= TREE_CHAIN (arglist
);
5446 new_val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5448 /* Note that we explicitly do not want any alias information for this
5449 memory, so that we kill all other live memories. Otherwise we don't
5450 satisfy the full barrier semantics of the intrinsic. */
5451 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5452 MEM_VOLATILE_P (mem
) = 1;
5455 return expand_bool_compare_and_swap (mem
, old_val
, new_val
, target
);
5457 return expand_val_compare_and_swap (mem
, old_val
, new_val
, target
);
5460 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5461 general form is actually an atomic exchange, and some targets only
5462 support a reduced form with the second argument being a constant 1.
5463 ARGLIST is the operands list to the function; TARGET is an optional
5464 place for us to store the results. */
5467 expand_builtin_lock_test_and_set (tree arglist
, rtx target
)
5469 enum machine_mode mode
;
5472 /* Expand the operands. */
5473 addr
= expand_expr (TREE_VALUE (arglist
), NULL
, Pmode
, EXPAND_NORMAL
);
5474 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (TREE_VALUE (arglist
))));
5476 arglist
= TREE_CHAIN (arglist
);
5477 val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5479 /* Note that we explicitly do not want any alias information for this
5480 memory, so that we kill all other live memories. Otherwise we don't
5481 satisfy the barrier semantics of the intrinsic. */
5482 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5483 MEM_VOLATILE_P (mem
) = 1;
5485 return expand_sync_lock_test_and_set (mem
, val
, target
);
5488 /* Expand the __sync_synchronize intrinsic. */
5491 expand_builtin_synchronize (void)
5495 #ifdef HAVE_memory_barrier
5496 if (HAVE_memory_barrier
)
5498 emit_insn (gen_memory_barrier ());
5503 /* If no explicit memory barrier instruction is available, create an empty
5504 asm stmt that will prevent compiler movement across the barrier. */
5505 body
= gen_rtx_ASM_INPUT (VOIDmode
, "");
5506 MEM_VOLATILE_P (body
) = 1;
5510 /* Expand the __sync_lock_release intrinsic. ARGLIST is the operands list
5514 expand_builtin_lock_release (tree arglist
)
5516 enum machine_mode mode
;
5517 enum insn_code icode
;
5518 rtx addr
, val
, mem
, insn
;
5520 /* Expand the operands. */
5521 addr
= expand_expr (TREE_VALUE (arglist
), NULL
, Pmode
, EXPAND_NORMAL
);
5522 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (TREE_VALUE (arglist
))));
5525 /* Note that we explicitly do not want any alias information for this
5526 memory, so that we kill all other live memories. Otherwise we don't
5527 satisfy the barrier semantics of the intrinsic. */
5528 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5529 MEM_VOLATILE_P (mem
) = 1;
5531 /* If there is an explicit operation in the md file, use it. */
5532 icode
= sync_lock_release
[mode
];
5533 if (icode
!= CODE_FOR_nothing
)
5535 if (!insn_data
[icode
].operand
[1].predicate (val
, mode
))
5536 val
= force_reg (mode
, val
);
5538 insn
= GEN_FCN (icode
) (mem
, val
);
5546 /* Otherwise we can implement this operation by emitting a barrier
5547 followed by a store of zero. */
5548 expand_builtin_synchronize ();
5549 emit_move_insn (mem
, val
);
5552 /* Expand an expression EXP that calls a built-in function,
5553 with result going to TARGET if that's convenient
5554 (and in mode MODE if that's convenient).
5555 SUBTARGET may be used as the target for computing one of EXP's operands.
5556 IGNORE is nonzero if the value is to be ignored. */
5559 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5562 tree fndecl
= get_callee_fndecl (exp
);
5563 tree arglist
= TREE_OPERAND (exp
, 1);
5564 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5565 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5567 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5568 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5570 /* When not optimizing, generate calls to library functions for a certain
5573 && !called_as_built_in (fndecl
)
5574 && DECL_ASSEMBLER_NAME_SET_P (fndecl
)
5575 && fcode
!= BUILT_IN_ALLOCA
)
5576 return expand_call (exp
, target
, ignore
);
5578 /* The built-in function expanders test for target == const0_rtx
5579 to determine whether the function's result will be ignored. */
5581 target
= const0_rtx
;
5583 /* If the result of a pure or const built-in function is ignored, and
5584 none of its arguments are volatile, we can avoid expanding the
5585 built-in call and just evaluate the arguments for side-effects. */
5586 if (target
== const0_rtx
5587 && (DECL_IS_PURE (fndecl
) || TREE_READONLY (fndecl
)))
5589 bool volatilep
= false;
5592 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5593 if (TREE_THIS_VOLATILE (TREE_VALUE (arg
)))
5601 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5602 expand_expr (TREE_VALUE (arg
), const0_rtx
,
5603 VOIDmode
, EXPAND_NORMAL
);
5611 case BUILT_IN_FABSF
:
5612 case BUILT_IN_FABSL
:
5613 target
= expand_builtin_fabs (arglist
, target
, subtarget
);
5618 case BUILT_IN_COPYSIGN
:
5619 case BUILT_IN_COPYSIGNF
:
5620 case BUILT_IN_COPYSIGNL
:
5621 target
= expand_builtin_copysign (arglist
, target
, subtarget
);
5626 /* Just do a normal library call if we were unable to fold
5629 case BUILT_IN_CABSF
:
5630 case BUILT_IN_CABSL
:
5636 case BUILT_IN_EXP10
:
5637 case BUILT_IN_EXP10F
:
5638 case BUILT_IN_EXP10L
:
5639 case BUILT_IN_POW10
:
5640 case BUILT_IN_POW10F
:
5641 case BUILT_IN_POW10L
:
5643 case BUILT_IN_EXP2F
:
5644 case BUILT_IN_EXP2L
:
5645 case BUILT_IN_EXPM1
:
5646 case BUILT_IN_EXPM1F
:
5647 case BUILT_IN_EXPM1L
:
5649 case BUILT_IN_LOGBF
:
5650 case BUILT_IN_LOGBL
:
5651 case BUILT_IN_ILOGB
:
5652 case BUILT_IN_ILOGBF
:
5653 case BUILT_IN_ILOGBL
:
5657 case BUILT_IN_LOG10
:
5658 case BUILT_IN_LOG10F
:
5659 case BUILT_IN_LOG10L
:
5661 case BUILT_IN_LOG2F
:
5662 case BUILT_IN_LOG2L
:
5663 case BUILT_IN_LOG1P
:
5664 case BUILT_IN_LOG1PF
:
5665 case BUILT_IN_LOG1PL
:
5670 case BUILT_IN_ASINF
:
5671 case BUILT_IN_ASINL
:
5673 case BUILT_IN_ACOSF
:
5674 case BUILT_IN_ACOSL
:
5676 case BUILT_IN_ATANF
:
5677 case BUILT_IN_ATANL
:
5678 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5679 because of possible accuracy problems. */
5680 if (! flag_unsafe_math_optimizations
)
5683 case BUILT_IN_SQRTF
:
5684 case BUILT_IN_SQRTL
:
5685 case BUILT_IN_FLOOR
:
5686 case BUILT_IN_FLOORF
:
5687 case BUILT_IN_FLOORL
:
5689 case BUILT_IN_CEILF
:
5690 case BUILT_IN_CEILL
:
5691 case BUILT_IN_TRUNC
:
5692 case BUILT_IN_TRUNCF
:
5693 case BUILT_IN_TRUNCL
:
5694 case BUILT_IN_ROUND
:
5695 case BUILT_IN_ROUNDF
:
5696 case BUILT_IN_ROUNDL
:
5697 case BUILT_IN_NEARBYINT
:
5698 case BUILT_IN_NEARBYINTF
:
5699 case BUILT_IN_NEARBYINTL
:
5701 case BUILT_IN_RINTF
:
5702 case BUILT_IN_RINTL
:
5703 case BUILT_IN_LRINT
:
5704 case BUILT_IN_LRINTF
:
5705 case BUILT_IN_LRINTL
:
5706 case BUILT_IN_LLRINT
:
5707 case BUILT_IN_LLRINTF
:
5708 case BUILT_IN_LLRINTL
:
5709 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5714 case BUILT_IN_LCEIL
:
5715 case BUILT_IN_LCEILF
:
5716 case BUILT_IN_LCEILL
:
5717 case BUILT_IN_LLCEIL
:
5718 case BUILT_IN_LLCEILF
:
5719 case BUILT_IN_LLCEILL
:
5720 case BUILT_IN_LFLOOR
:
5721 case BUILT_IN_LFLOORF
:
5722 case BUILT_IN_LFLOORL
:
5723 case BUILT_IN_LLFLOOR
:
5724 case BUILT_IN_LLFLOORF
:
5725 case BUILT_IN_LLFLOORL
:
5726 target
= expand_builtin_int_roundingfn (exp
, target
, subtarget
);
5734 target
= expand_builtin_pow (exp
, target
, subtarget
);
5740 case BUILT_IN_POWIF
:
5741 case BUILT_IN_POWIL
:
5742 target
= expand_builtin_powi (exp
, target
, subtarget
);
5747 case BUILT_IN_ATAN2
:
5748 case BUILT_IN_ATAN2F
:
5749 case BUILT_IN_ATAN2L
:
5750 case BUILT_IN_LDEXP
:
5751 case BUILT_IN_LDEXPF
:
5752 case BUILT_IN_LDEXPL
:
5754 case BUILT_IN_FMODF
:
5755 case BUILT_IN_FMODL
:
5757 case BUILT_IN_DREMF
:
5758 case BUILT_IN_DREML
:
5759 if (! flag_unsafe_math_optimizations
)
5761 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5772 if (! flag_unsafe_math_optimizations
)
5774 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5779 case BUILT_IN_APPLY_ARGS
:
5780 return expand_builtin_apply_args ();
5782 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5783 FUNCTION with a copy of the parameters described by
5784 ARGUMENTS, and ARGSIZE. It returns a block of memory
5785 allocated on the stack into which is stored all the registers
5786 that might possibly be used for returning the result of a
5787 function. ARGUMENTS is the value returned by
5788 __builtin_apply_args. ARGSIZE is the number of bytes of
5789 arguments that must be copied. ??? How should this value be
5790 computed? We'll also need a safe worst case value for varargs
5792 case BUILT_IN_APPLY
:
5793 if (!validate_arglist (arglist
, POINTER_TYPE
,
5794 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5795 && !validate_arglist (arglist
, REFERENCE_TYPE
,
5796 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5804 for (t
= arglist
, i
= 0; t
; t
= TREE_CHAIN (t
), i
++)
5805 ops
[i
] = expand_expr (TREE_VALUE (t
), NULL_RTX
, VOIDmode
, 0);
5807 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
5810 /* __builtin_return (RESULT) causes the function to return the
5811 value described by RESULT. RESULT is address of the block of
5812 memory returned by __builtin_apply. */
5813 case BUILT_IN_RETURN
:
5814 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5815 expand_builtin_return (expand_expr (TREE_VALUE (arglist
),
5816 NULL_RTX
, VOIDmode
, 0));
5819 case BUILT_IN_SAVEREGS
:
5820 return expand_builtin_saveregs ();
5822 case BUILT_IN_ARGS_INFO
:
5823 return expand_builtin_args_info (arglist
);
5825 /* Return the address of the first anonymous stack arg. */
5826 case BUILT_IN_NEXT_ARG
:
5827 if (fold_builtin_next_arg (arglist
))
5829 return expand_builtin_next_arg ();
5831 case BUILT_IN_CLASSIFY_TYPE
:
5832 return expand_builtin_classify_type (arglist
);
5834 case BUILT_IN_CONSTANT_P
:
5837 case BUILT_IN_FRAME_ADDRESS
:
5838 case BUILT_IN_RETURN_ADDRESS
:
5839 return expand_builtin_frame_address (fndecl
, arglist
);
5841 /* Returns the address of the area where the structure is returned.
5843 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
5845 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
5846 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
5849 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
5851 case BUILT_IN_ALLOCA
:
5852 target
= expand_builtin_alloca (arglist
, target
);
5857 case BUILT_IN_STACK_SAVE
:
5858 return expand_stack_save ();
5860 case BUILT_IN_STACK_RESTORE
:
5861 expand_stack_restore (TREE_VALUE (arglist
));
5866 case BUILT_IN_FFSLL
:
5867 case BUILT_IN_FFSIMAX
:
5868 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5869 subtarget
, ffs_optab
);
5876 case BUILT_IN_CLZLL
:
5877 case BUILT_IN_CLZIMAX
:
5878 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5879 subtarget
, clz_optab
);
5886 case BUILT_IN_CTZLL
:
5887 case BUILT_IN_CTZIMAX
:
5888 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5889 subtarget
, ctz_optab
);
5894 case BUILT_IN_POPCOUNT
:
5895 case BUILT_IN_POPCOUNTL
:
5896 case BUILT_IN_POPCOUNTLL
:
5897 case BUILT_IN_POPCOUNTIMAX
:
5898 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5899 subtarget
, popcount_optab
);
5904 case BUILT_IN_PARITY
:
5905 case BUILT_IN_PARITYL
:
5906 case BUILT_IN_PARITYLL
:
5907 case BUILT_IN_PARITYIMAX
:
5908 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5909 subtarget
, parity_optab
);
5914 case BUILT_IN_STRLEN
:
5915 target
= expand_builtin_strlen (arglist
, target
, target_mode
);
5920 case BUILT_IN_STRCPY
:
5921 target
= expand_builtin_strcpy (fndecl
, arglist
, target
, mode
);
5926 case BUILT_IN_STRNCPY
:
5927 target
= expand_builtin_strncpy (exp
, target
, mode
);
5932 case BUILT_IN_STPCPY
:
5933 target
= expand_builtin_stpcpy (exp
, target
, mode
);
5938 case BUILT_IN_STRCAT
:
5939 target
= expand_builtin_strcat (fndecl
, arglist
, target
, mode
);
5944 case BUILT_IN_STRNCAT
:
5945 target
= expand_builtin_strncat (arglist
, target
, mode
);
5950 case BUILT_IN_STRSPN
:
5951 target
= expand_builtin_strspn (arglist
, target
, mode
);
5956 case BUILT_IN_STRCSPN
:
5957 target
= expand_builtin_strcspn (arglist
, target
, mode
);
5962 case BUILT_IN_STRSTR
:
5963 target
= expand_builtin_strstr (arglist
, TREE_TYPE (exp
), target
, mode
);
5968 case BUILT_IN_STRPBRK
:
5969 target
= expand_builtin_strpbrk (arglist
, TREE_TYPE (exp
), target
, mode
);
5974 case BUILT_IN_INDEX
:
5975 case BUILT_IN_STRCHR
:
5976 target
= expand_builtin_strchr (arglist
, TREE_TYPE (exp
), target
, mode
);
5981 case BUILT_IN_RINDEX
:
5982 case BUILT_IN_STRRCHR
:
5983 target
= expand_builtin_strrchr (arglist
, TREE_TYPE (exp
), target
, mode
);
5988 case BUILT_IN_MEMCPY
:
5989 target
= expand_builtin_memcpy (exp
, target
, mode
);
5994 case BUILT_IN_MEMPCPY
:
5995 target
= expand_builtin_mempcpy (arglist
, TREE_TYPE (exp
), target
, mode
, /*endp=*/ 1);
6000 case BUILT_IN_MEMMOVE
:
6001 target
= expand_builtin_memmove (arglist
, TREE_TYPE (exp
), target
,
6007 case BUILT_IN_BCOPY
:
6008 target
= expand_builtin_bcopy (exp
);
6013 case BUILT_IN_MEMSET
:
6014 target
= expand_builtin_memset (arglist
, target
, mode
, exp
);
6019 case BUILT_IN_BZERO
:
6020 target
= expand_builtin_bzero (exp
);
6025 case BUILT_IN_STRCMP
:
6026 target
= expand_builtin_strcmp (exp
, target
, mode
);
6031 case BUILT_IN_STRNCMP
:
6032 target
= expand_builtin_strncmp (exp
, target
, mode
);
6038 case BUILT_IN_MEMCMP
:
6039 target
= expand_builtin_memcmp (exp
, arglist
, target
, mode
);
6044 case BUILT_IN_SETJMP
:
6045 target
= expand_builtin_setjmp (arglist
, target
);
6050 /* __builtin_longjmp is passed a pointer to an array of five words.
6051 It's similar to the C library longjmp function but works with
6052 __builtin_setjmp above. */
6053 case BUILT_IN_LONGJMP
:
6054 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6058 rtx buf_addr
= expand_expr (TREE_VALUE (arglist
), subtarget
,
6060 rtx value
= expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)),
6061 NULL_RTX
, VOIDmode
, 0);
6063 if (value
!= const1_rtx
)
6065 error ("%<__builtin_longjmp%> second argument must be 1");
6069 expand_builtin_longjmp (buf_addr
, value
);
6073 case BUILT_IN_NONLOCAL_GOTO
:
6074 target
= expand_builtin_nonlocal_goto (arglist
);
6079 /* This updates the setjmp buffer that is its argument with the value
6080 of the current stack pointer. */
6081 case BUILT_IN_UPDATE_SETJMP_BUF
:
6082 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6085 = expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
6087 expand_builtin_update_setjmp_buf (buf_addr
);
6093 expand_builtin_trap ();
6096 case BUILT_IN_PRINTF
:
6097 target
= expand_builtin_printf (exp
, target
, mode
, false);
6102 case BUILT_IN_PRINTF_UNLOCKED
:
6103 target
= expand_builtin_printf (exp
, target
, mode
, true);
6108 case BUILT_IN_FPUTS
:
6109 target
= expand_builtin_fputs (arglist
, target
, false);
6113 case BUILT_IN_FPUTS_UNLOCKED
:
6114 target
= expand_builtin_fputs (arglist
, target
, true);
6119 case BUILT_IN_FPRINTF
:
6120 target
= expand_builtin_fprintf (exp
, target
, mode
, false);
6125 case BUILT_IN_FPRINTF_UNLOCKED
:
6126 target
= expand_builtin_fprintf (exp
, target
, mode
, true);
6131 case BUILT_IN_SPRINTF
:
6132 target
= expand_builtin_sprintf (arglist
, target
, mode
);
6137 case BUILT_IN_SIGNBIT
:
6138 case BUILT_IN_SIGNBITF
:
6139 case BUILT_IN_SIGNBITL
:
6140 target
= expand_builtin_signbit (exp
, target
);
6145 /* Various hooks for the DWARF 2 __throw routine. */
6146 case BUILT_IN_UNWIND_INIT
:
6147 expand_builtin_unwind_init ();
6149 case BUILT_IN_DWARF_CFA
:
6150 return virtual_cfa_rtx
;
6151 #ifdef DWARF2_UNWIND_INFO
6152 case BUILT_IN_DWARF_SP_COLUMN
:
6153 return expand_builtin_dwarf_sp_column ();
6154 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6155 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist
));
6158 case BUILT_IN_FROB_RETURN_ADDR
:
6159 return expand_builtin_frob_return_addr (TREE_VALUE (arglist
));
6160 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6161 return expand_builtin_extract_return_addr (TREE_VALUE (arglist
));
6162 case BUILT_IN_EH_RETURN
:
6163 expand_builtin_eh_return (TREE_VALUE (arglist
),
6164 TREE_VALUE (TREE_CHAIN (arglist
)));
6166 #ifdef EH_RETURN_DATA_REGNO
6167 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6168 return expand_builtin_eh_return_data_regno (arglist
);
6170 case BUILT_IN_EXTEND_POINTER
:
6171 return expand_builtin_extend_pointer (TREE_VALUE (arglist
));
6173 case BUILT_IN_VA_START
:
6174 case BUILT_IN_STDARG_START
:
6175 return expand_builtin_va_start (arglist
);
6176 case BUILT_IN_VA_END
:
6177 return expand_builtin_va_end (arglist
);
6178 case BUILT_IN_VA_COPY
:
6179 return expand_builtin_va_copy (arglist
);
6180 case BUILT_IN_EXPECT
:
6181 return expand_builtin_expect (arglist
, target
);
6182 case BUILT_IN_PREFETCH
:
6183 expand_builtin_prefetch (arglist
);
6186 case BUILT_IN_PROFILE_FUNC_ENTER
:
6187 return expand_builtin_profile_func (false);
6188 case BUILT_IN_PROFILE_FUNC_EXIT
:
6189 return expand_builtin_profile_func (true);
6191 case BUILT_IN_INIT_TRAMPOLINE
:
6192 return expand_builtin_init_trampoline (arglist
);
6193 case BUILT_IN_ADJUST_TRAMPOLINE
:
6194 return expand_builtin_adjust_trampoline (arglist
);
6197 case BUILT_IN_EXECL
:
6198 case BUILT_IN_EXECV
:
6199 case BUILT_IN_EXECLP
:
6200 case BUILT_IN_EXECLE
:
6201 case BUILT_IN_EXECVP
:
6202 case BUILT_IN_EXECVE
:
6203 target
= expand_builtin_fork_or_exec (fndecl
, arglist
, target
, ignore
);
6208 case BUILT_IN_FETCH_AND_ADD_1
:
6209 case BUILT_IN_FETCH_AND_ADD_2
:
6210 case BUILT_IN_FETCH_AND_ADD_4
:
6211 case BUILT_IN_FETCH_AND_ADD_8
:
6212 target
= expand_builtin_sync_operation (arglist
, PLUS
,
6213 false, target
, ignore
);
6218 case BUILT_IN_FETCH_AND_SUB_1
:
6219 case BUILT_IN_FETCH_AND_SUB_2
:
6220 case BUILT_IN_FETCH_AND_SUB_4
:
6221 case BUILT_IN_FETCH_AND_SUB_8
:
6222 target
= expand_builtin_sync_operation (arglist
, MINUS
,
6223 false, target
, ignore
);
6228 case BUILT_IN_FETCH_AND_OR_1
:
6229 case BUILT_IN_FETCH_AND_OR_2
:
6230 case BUILT_IN_FETCH_AND_OR_4
:
6231 case BUILT_IN_FETCH_AND_OR_8
:
6232 target
= expand_builtin_sync_operation (arglist
, IOR
,
6233 false, target
, ignore
);
6238 case BUILT_IN_FETCH_AND_AND_1
:
6239 case BUILT_IN_FETCH_AND_AND_2
:
6240 case BUILT_IN_FETCH_AND_AND_4
:
6241 case BUILT_IN_FETCH_AND_AND_8
:
6242 target
= expand_builtin_sync_operation (arglist
, AND
,
6243 false, target
, ignore
);
6248 case BUILT_IN_FETCH_AND_XOR_1
:
6249 case BUILT_IN_FETCH_AND_XOR_2
:
6250 case BUILT_IN_FETCH_AND_XOR_4
:
6251 case BUILT_IN_FETCH_AND_XOR_8
:
6252 target
= expand_builtin_sync_operation (arglist
, XOR
,
6253 false, target
, ignore
);
6258 case BUILT_IN_FETCH_AND_NAND_1
:
6259 case BUILT_IN_FETCH_AND_NAND_2
:
6260 case BUILT_IN_FETCH_AND_NAND_4
:
6261 case BUILT_IN_FETCH_AND_NAND_8
:
6262 target
= expand_builtin_sync_operation (arglist
, NOT
,
6263 false, target
, ignore
);
6268 case BUILT_IN_ADD_AND_FETCH_1
:
6269 case BUILT_IN_ADD_AND_FETCH_2
:
6270 case BUILT_IN_ADD_AND_FETCH_4
:
6271 case BUILT_IN_ADD_AND_FETCH_8
:
6272 target
= expand_builtin_sync_operation (arglist
, PLUS
,
6273 true, target
, ignore
);
6278 case BUILT_IN_SUB_AND_FETCH_1
:
6279 case BUILT_IN_SUB_AND_FETCH_2
:
6280 case BUILT_IN_SUB_AND_FETCH_4
:
6281 case BUILT_IN_SUB_AND_FETCH_8
:
6282 target
= expand_builtin_sync_operation (arglist
, MINUS
,
6283 true, target
, ignore
);
6288 case BUILT_IN_OR_AND_FETCH_1
:
6289 case BUILT_IN_OR_AND_FETCH_2
:
6290 case BUILT_IN_OR_AND_FETCH_4
:
6291 case BUILT_IN_OR_AND_FETCH_8
:
6292 target
= expand_builtin_sync_operation (arglist
, IOR
,
6293 true, target
, ignore
);
6298 case BUILT_IN_AND_AND_FETCH_1
:
6299 case BUILT_IN_AND_AND_FETCH_2
:
6300 case BUILT_IN_AND_AND_FETCH_4
:
6301 case BUILT_IN_AND_AND_FETCH_8
:
6302 target
= expand_builtin_sync_operation (arglist
, AND
,
6303 true, target
, ignore
);
6308 case BUILT_IN_XOR_AND_FETCH_1
:
6309 case BUILT_IN_XOR_AND_FETCH_2
:
6310 case BUILT_IN_XOR_AND_FETCH_4
:
6311 case BUILT_IN_XOR_AND_FETCH_8
:
6312 target
= expand_builtin_sync_operation (arglist
, XOR
,
6313 true, target
, ignore
);
6318 case BUILT_IN_NAND_AND_FETCH_1
:
6319 case BUILT_IN_NAND_AND_FETCH_2
:
6320 case BUILT_IN_NAND_AND_FETCH_4
:
6321 case BUILT_IN_NAND_AND_FETCH_8
:
6322 target
= expand_builtin_sync_operation (arglist
, NOT
,
6323 true, target
, ignore
);
6328 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1
:
6329 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2
:
6330 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4
:
6331 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8
:
6332 if (mode
== VOIDmode
)
6333 mode
= TYPE_MODE (boolean_type_node
);
6334 if (!target
|| !register_operand (target
, mode
))
6335 target
= gen_reg_rtx (mode
);
6336 target
= expand_builtin_compare_and_swap (arglist
, true, target
);
6341 case BUILT_IN_VAL_COMPARE_AND_SWAP_1
:
6342 case BUILT_IN_VAL_COMPARE_AND_SWAP_2
:
6343 case BUILT_IN_VAL_COMPARE_AND_SWAP_4
:
6344 case BUILT_IN_VAL_COMPARE_AND_SWAP_8
:
6345 target
= expand_builtin_compare_and_swap (arglist
, false, target
);
6350 case BUILT_IN_LOCK_TEST_AND_SET_1
:
6351 case BUILT_IN_LOCK_TEST_AND_SET_2
:
6352 case BUILT_IN_LOCK_TEST_AND_SET_4
:
6353 case BUILT_IN_LOCK_TEST_AND_SET_8
:
6354 target
= expand_builtin_lock_test_and_set (arglist
, target
);
6359 case BUILT_IN_LOCK_RELEASE_1
:
6360 case BUILT_IN_LOCK_RELEASE_2
:
6361 case BUILT_IN_LOCK_RELEASE_4
:
6362 case BUILT_IN_LOCK_RELEASE_8
:
6363 expand_builtin_lock_release (arglist
);
6366 case BUILT_IN_SYNCHRONIZE
:
6367 expand_builtin_synchronize ();
6370 case BUILT_IN_OBJECT_SIZE
:
6371 return expand_builtin_object_size (exp
);
6373 case BUILT_IN_MEMCPY_CHK
:
6374 case BUILT_IN_MEMPCPY_CHK
:
6375 case BUILT_IN_MEMMOVE_CHK
:
6376 case BUILT_IN_MEMSET_CHK
:
6377 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
6382 case BUILT_IN_STRCPY_CHK
:
6383 case BUILT_IN_STPCPY_CHK
:
6384 case BUILT_IN_STRNCPY_CHK
:
6385 case BUILT_IN_STRCAT_CHK
:
6386 case BUILT_IN_SNPRINTF_CHK
:
6387 case BUILT_IN_VSNPRINTF_CHK
:
6388 maybe_emit_chk_warning (exp
, fcode
);
6391 case BUILT_IN_SPRINTF_CHK
:
6392 case BUILT_IN_VSPRINTF_CHK
:
6393 maybe_emit_sprintf_chk_warning (exp
, fcode
);
6396 default: /* just do library call, if unknown builtin */
6400 /* The switch statement above can drop through to cause the function
6401 to be called normally. */
6402 return expand_call (exp
, target
, ignore
);
6405 /* Determine whether a tree node represents a call to a built-in
6406 function. If the tree T is a call to a built-in function with
6407 the right number of arguments of the appropriate types, return
6408 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6409 Otherwise the return value is END_BUILTINS. */
6411 enum built_in_function
6412 builtin_mathfn_code (tree t
)
6414 tree fndecl
, arglist
, parmlist
;
6415 tree argtype
, parmtype
;
6417 if (TREE_CODE (t
) != CALL_EXPR
6418 || TREE_CODE (TREE_OPERAND (t
, 0)) != ADDR_EXPR
)
6419 return END_BUILTINS
;
6421 fndecl
= get_callee_fndecl (t
);
6422 if (fndecl
== NULL_TREE
6423 || TREE_CODE (fndecl
) != FUNCTION_DECL
6424 || ! DECL_BUILT_IN (fndecl
)
6425 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6426 return END_BUILTINS
;
6428 arglist
= TREE_OPERAND (t
, 1);
6429 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6430 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
6432 /* If a function doesn't take a variable number of arguments,
6433 the last element in the list will have type `void'. */
6434 parmtype
= TREE_VALUE (parmlist
);
6435 if (VOID_TYPE_P (parmtype
))
6438 return END_BUILTINS
;
6439 return DECL_FUNCTION_CODE (fndecl
);
6443 return END_BUILTINS
;
6445 argtype
= TREE_TYPE (TREE_VALUE (arglist
));
6447 if (SCALAR_FLOAT_TYPE_P (parmtype
))
6449 if (! SCALAR_FLOAT_TYPE_P (argtype
))
6450 return END_BUILTINS
;
6452 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
6454 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
6455 return END_BUILTINS
;
6457 else if (POINTER_TYPE_P (parmtype
))
6459 if (! POINTER_TYPE_P (argtype
))
6460 return END_BUILTINS
;
6462 else if (INTEGRAL_TYPE_P (parmtype
))
6464 if (! INTEGRAL_TYPE_P (argtype
))
6465 return END_BUILTINS
;
6468 return END_BUILTINS
;
6470 arglist
= TREE_CHAIN (arglist
);
6473 /* Variable-length argument list. */
6474 return DECL_FUNCTION_CODE (fndecl
);
6477 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
6478 constant. ARGLIST is the argument list of the call. */
6481 fold_builtin_constant_p (tree arglist
)
6486 arglist
= TREE_VALUE (arglist
);
6488 /* We return 1 for a numeric type that's known to be a constant
6489 value at compile-time or for an aggregate type that's a
6490 literal constant. */
6491 STRIP_NOPS (arglist
);
6493 /* If we know this is a constant, emit the constant of one. */
6494 if (CONSTANT_CLASS_P (arglist
)
6495 || (TREE_CODE (arglist
) == CONSTRUCTOR
6496 && TREE_CONSTANT (arglist
)))
6497 return integer_one_node
;
6498 if (TREE_CODE (arglist
) == ADDR_EXPR
)
6500 tree op
= TREE_OPERAND (arglist
, 0);
6501 if (TREE_CODE (op
) == STRING_CST
6502 || (TREE_CODE (op
) == ARRAY_REF
6503 && integer_zerop (TREE_OPERAND (op
, 1))
6504 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
6505 return integer_one_node
;
6508 /* If this expression has side effects, show we don't know it to be a
6509 constant. Likewise if it's a pointer or aggregate type since in
6510 those case we only want literals, since those are only optimized
6511 when generating RTL, not later.
6512 And finally, if we are compiling an initializer, not code, we
6513 need to return a definite result now; there's not going to be any
6514 more optimization done. */
6515 if (TREE_SIDE_EFFECTS (arglist
)
6516 || AGGREGATE_TYPE_P (TREE_TYPE (arglist
))
6517 || POINTER_TYPE_P (TREE_TYPE (arglist
))
6519 return integer_zero_node
;
6524 /* Fold a call to __builtin_expect, if we expect that a comparison against
6525 the argument will fold to a constant. In practice, this means a true
6526 constant or the address of a non-weak symbol. ARGLIST is the argument
6527 list of the call. */
6530 fold_builtin_expect (tree arglist
)
6537 arg
= TREE_VALUE (arglist
);
6539 /* If the argument isn't invariant, then there's nothing we can do. */
6540 if (!TREE_INVARIANT (arg
))
6543 /* If we're looking at an address of a weak decl, then do not fold. */
6546 if (TREE_CODE (inner
) == ADDR_EXPR
)
6550 inner
= TREE_OPERAND (inner
, 0);
6552 while (TREE_CODE (inner
) == COMPONENT_REF
6553 || TREE_CODE (inner
) == ARRAY_REF
);
6554 if (DECL_P (inner
) && DECL_WEAK (inner
))
6558 /* Otherwise, ARG already has the proper type for the return value. */
6562 /* Fold a call to __builtin_classify_type. */
6565 fold_builtin_classify_type (tree arglist
)
6568 return build_int_cst (NULL_TREE
, no_type_class
);
6570 return build_int_cst (NULL_TREE
,
6571 type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
6574 /* Fold a call to __builtin_strlen. */
6577 fold_builtin_strlen (tree arglist
)
6579 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6583 tree len
= c_strlen (TREE_VALUE (arglist
), 0);
6587 /* Convert from the internal "sizetype" type to "size_t". */
6589 len
= fold_convert (size_type_node
, len
);
6597 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6600 fold_builtin_inf (tree type
, int warn
)
6602 REAL_VALUE_TYPE real
;
6604 /* __builtin_inff is intended to be usable to define INFINITY on all
6605 targets. If an infinity is not available, INFINITY expands "to a
6606 positive constant of type float that overflows at translation
6607 time", footnote "In this case, using INFINITY will violate the
6608 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6609 Thus we pedwarn to ensure this constraint violation is
6611 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
6612 pedwarn ("target format does not support infinity");
6615 return build_real (type
, real
);
6618 /* Fold a call to __builtin_nan or __builtin_nans. */
6621 fold_builtin_nan (tree arglist
, tree type
, int quiet
)
6623 REAL_VALUE_TYPE real
;
6626 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6628 str
= c_getstr (TREE_VALUE (arglist
));
6632 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
6635 return build_real (type
, real
);
6638 /* Return true if the floating point expression T has an integer value.
6639 We also allow +Inf, -Inf and NaN to be considered integer values. */
6642 integer_valued_real_p (tree t
)
6644 switch (TREE_CODE (t
))
6651 case NON_LVALUE_EXPR
:
6652 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6657 return integer_valued_real_p (TREE_OPERAND (t
, 1));
6664 return integer_valued_real_p (TREE_OPERAND (t
, 0))
6665 && integer_valued_real_p (TREE_OPERAND (t
, 1));
6668 return integer_valued_real_p (TREE_OPERAND (t
, 1))
6669 && integer_valued_real_p (TREE_OPERAND (t
, 2));
6672 if (! TREE_CONSTANT_OVERFLOW (t
))
6674 REAL_VALUE_TYPE c
, cint
;
6676 c
= TREE_REAL_CST (t
);
6677 real_trunc (&cint
, TYPE_MODE (TREE_TYPE (t
)), &c
);
6678 return real_identical (&c
, &cint
);
6683 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6684 if (TREE_CODE (type
) == INTEGER_TYPE
)
6686 if (TREE_CODE (type
) == REAL_TYPE
)
6687 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6692 switch (builtin_mathfn_code (t
))
6695 case BUILT_IN_CEILF
:
6696 case BUILT_IN_CEILL
:
6697 case BUILT_IN_FLOOR
:
6698 case BUILT_IN_FLOORF
:
6699 case BUILT_IN_FLOORL
:
6700 case BUILT_IN_NEARBYINT
:
6701 case BUILT_IN_NEARBYINTF
:
6702 case BUILT_IN_NEARBYINTL
:
6704 case BUILT_IN_RINTF
:
6705 case BUILT_IN_RINTL
:
6706 case BUILT_IN_ROUND
:
6707 case BUILT_IN_ROUNDF
:
6708 case BUILT_IN_ROUNDL
:
6709 case BUILT_IN_TRUNC
:
6710 case BUILT_IN_TRUNCF
:
6711 case BUILT_IN_TRUNCL
:
6725 /* EXP is assumed to be builtin call where truncation can be propagated
6726 across (for instance floor((double)f) == (double)floorf (f).
6727 Do the transformation. */
6730 fold_trunc_transparent_mathfn (tree fndecl
, tree arglist
)
6732 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6735 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6738 arg
= TREE_VALUE (arglist
);
6739 /* Integer rounding functions are idempotent. */
6740 if (fcode
== builtin_mathfn_code (arg
))
6743 /* If argument is already integer valued, and we don't need to worry
6744 about setting errno, there's no need to perform rounding. */
6745 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6750 tree arg0
= strip_float_extensions (arg
);
6751 tree ftype
= TREE_TYPE (TREE_TYPE (fndecl
));
6752 tree newtype
= TREE_TYPE (arg0
);
6755 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6756 && (decl
= mathfn_built_in (newtype
, fcode
)))
6759 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6760 return fold_convert (ftype
,
6761 build_function_call_expr (decl
, arglist
));
6767 /* EXP is assumed to be builtin call which can narrow the FP type of
6768 the argument, for instance lround((double)f) -> lroundf (f). */
6771 fold_fixed_mathfn (tree fndecl
, tree arglist
)
6773 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6776 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6779 arg
= TREE_VALUE (arglist
);
6781 /* If argument is already integer valued, and we don't need to worry
6782 about setting errno, there's no need to perform rounding. */
6783 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6784 return fold_build1 (FIX_TRUNC_EXPR
, TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
6788 tree ftype
= TREE_TYPE (arg
);
6789 tree arg0
= strip_float_extensions (arg
);
6790 tree newtype
= TREE_TYPE (arg0
);
6793 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6794 && (decl
= mathfn_built_in (newtype
, fcode
)))
6797 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6798 return build_function_call_expr (decl
, arglist
);
6804 /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
6805 is the argument list and TYPE is the return type. Return
6806 NULL_TREE if no if no simplification can be made. */
6809 fold_builtin_cabs (tree arglist
, tree type
)
6813 if (!arglist
|| TREE_CHAIN (arglist
))
6816 arg
= TREE_VALUE (arglist
);
6817 if (TREE_CODE (TREE_TYPE (arg
)) != COMPLEX_TYPE
6818 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
6821 /* Evaluate cabs of a constant at compile-time. */
6822 if (flag_unsafe_math_optimizations
6823 && TREE_CODE (arg
) == COMPLEX_CST
6824 && TREE_CODE (TREE_REALPART (arg
)) == REAL_CST
6825 && TREE_CODE (TREE_IMAGPART (arg
)) == REAL_CST
6826 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg
))
6827 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg
)))
6829 REAL_VALUE_TYPE r
, i
;
6831 r
= TREE_REAL_CST (TREE_REALPART (arg
));
6832 i
= TREE_REAL_CST (TREE_IMAGPART (arg
));
6834 real_arithmetic (&r
, MULT_EXPR
, &r
, &r
);
6835 real_arithmetic (&i
, MULT_EXPR
, &i
, &i
);
6836 real_arithmetic (&r
, PLUS_EXPR
, &r
, &i
);
6837 if (real_sqrt (&r
, TYPE_MODE (type
), &r
)
6838 || ! flag_trapping_math
)
6839 return build_real (type
, r
);
6842 /* If either part is zero, cabs is fabs of the other. */
6843 if (TREE_CODE (arg
) == COMPLEX_EXPR
6844 && real_zerop (TREE_OPERAND (arg
, 0)))
6845 return fold_build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 1));
6846 if (TREE_CODE (arg
) == COMPLEX_EXPR
6847 && real_zerop (TREE_OPERAND (arg
, 1)))
6848 return fold_build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 0));
6850 /* Don't do this when optimizing for size. */
6851 if (flag_unsafe_math_optimizations
6852 && optimize
&& !optimize_size
)
6854 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
6856 if (sqrtfn
!= NULL_TREE
)
6858 tree rpart
, ipart
, result
, arglist
;
6860 arg
= builtin_save_expr (arg
);
6862 rpart
= fold_build1 (REALPART_EXPR
, type
, arg
);
6863 ipart
= fold_build1 (IMAGPART_EXPR
, type
, arg
);
6865 rpart
= builtin_save_expr (rpart
);
6866 ipart
= builtin_save_expr (ipart
);
6868 result
= fold_build2 (PLUS_EXPR
, type
,
6869 fold_build2 (MULT_EXPR
, type
,
6871 fold_build2 (MULT_EXPR
, type
,
6874 arglist
= build_tree_list (NULL_TREE
, result
);
6875 return build_function_call_expr (sqrtfn
, arglist
);
6882 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl. Return
6883 NULL_TREE if no simplification can be made. */
6886 fold_builtin_sqrt (tree arglist
, tree type
)
6889 enum built_in_function fcode
;
6890 tree arg
= TREE_VALUE (arglist
);
6892 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6895 /* Optimize sqrt of constant value. */
6896 if (TREE_CODE (arg
) == REAL_CST
6897 && ! TREE_CONSTANT_OVERFLOW (arg
))
6899 REAL_VALUE_TYPE r
, x
;
6901 x
= TREE_REAL_CST (arg
);
6902 if (real_sqrt (&r
, TYPE_MODE (type
), &x
)
6903 || (!flag_trapping_math
&& !flag_errno_math
))
6904 return build_real (type
, r
);
6907 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
6908 fcode
= builtin_mathfn_code (arg
);
6909 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6911 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6912 arg
= fold_build2 (MULT_EXPR
, type
,
6913 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6914 build_real (type
, dconsthalf
));
6915 arglist
= build_tree_list (NULL_TREE
, arg
);
6916 return build_function_call_expr (expfn
, arglist
);
6919 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
6920 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
6922 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6926 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6928 /* The inner root was either sqrt or cbrt. */
6929 REAL_VALUE_TYPE dconstroot
=
6930 BUILTIN_SQRT_P (fcode
) ? dconsthalf
: dconstthird
;
6932 /* Adjust for the outer root. */
6933 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6934 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6935 tree_root
= build_real (type
, dconstroot
);
6936 arglist
= tree_cons (NULL_TREE
, arg0
,
6937 build_tree_list (NULL_TREE
, tree_root
));
6938 return build_function_call_expr (powfn
, arglist
);
6942 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
6943 if (flag_unsafe_math_optimizations
6944 && (fcode
== BUILT_IN_POW
6945 || fcode
== BUILT_IN_POWF
6946 || fcode
== BUILT_IN_POWL
))
6948 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6949 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6950 tree arg1
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
6952 if (!tree_expr_nonnegative_p (arg0
))
6953 arg0
= build1 (ABS_EXPR
, type
, arg0
);
6954 narg1
= fold_build2 (MULT_EXPR
, type
, arg1
,
6955 build_real (type
, dconsthalf
));
6956 arglist
= tree_cons (NULL_TREE
, arg0
,
6957 build_tree_list (NULL_TREE
, narg1
));
6958 return build_function_call_expr (powfn
, arglist
);
6964 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl. Return
6965 NULL_TREE if no simplification can be made. */
6967 fold_builtin_cbrt (tree arglist
, tree type
)
6969 tree arg
= TREE_VALUE (arglist
);
6970 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
6972 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6975 /* Optimize cbrt of constant value. */
6976 if (real_zerop (arg
) || real_onep (arg
) || real_minus_onep (arg
))
6979 if (flag_unsafe_math_optimizations
)
6981 /* Optimize cbrt(expN(x)) -> expN(x/3). */
6982 if (BUILTIN_EXPONENT_P (fcode
))
6984 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6985 const REAL_VALUE_TYPE third_trunc
=
6986 real_value_truncate (TYPE_MODE (type
), dconstthird
);
6987 arg
= fold_build2 (MULT_EXPR
, type
,
6988 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6989 build_real (type
, third_trunc
));
6990 arglist
= build_tree_list (NULL_TREE
, arg
);
6991 return build_function_call_expr (expfn
, arglist
);
6994 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
6995 if (BUILTIN_SQRT_P (fcode
))
6997 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7001 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7003 REAL_VALUE_TYPE dconstroot
= dconstthird
;
7005 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
7006 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7007 tree_root
= build_real (type
, dconstroot
);
7008 arglist
= tree_cons (NULL_TREE
, arg0
,
7009 build_tree_list (NULL_TREE
, tree_root
));
7010 return build_function_call_expr (powfn
, arglist
);
7014 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7015 if (BUILTIN_CBRT_P (fcode
))
7017 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7018 if (tree_expr_nonnegative_p (arg0
))
7020 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
7025 REAL_VALUE_TYPE dconstroot
;
7027 real_arithmetic (&dconstroot
, MULT_EXPR
, &dconstthird
, &dconstthird
);
7028 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
7029 tree_root
= build_real (type
, dconstroot
);
7030 arglist
= tree_cons (NULL_TREE
, arg0
,
7031 build_tree_list (NULL_TREE
, tree_root
));
7032 return build_function_call_expr (powfn
, arglist
);
7037 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7038 if (fcode
== BUILT_IN_POW
|| fcode
== BUILT_IN_POWF
7039 || fcode
== BUILT_IN_POWL
)
7041 tree arg00
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7042 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
7043 if (tree_expr_nonnegative_p (arg00
))
7045 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
7046 const REAL_VALUE_TYPE dconstroot
7047 = real_value_truncate (TYPE_MODE (type
), dconstthird
);
7048 tree narg01
= fold_build2 (MULT_EXPR
, type
, arg01
,
7049 build_real (type
, dconstroot
));
7050 arglist
= tree_cons (NULL_TREE
, arg00
,
7051 build_tree_list (NULL_TREE
, narg01
));
7052 return build_function_call_expr (powfn
, arglist
);
7059 /* Fold function call to builtin sin, sinf, or sinl. Return
7060 NULL_TREE if no simplification can be made. */
7062 fold_builtin_sin (tree arglist
)
7064 tree arg
= TREE_VALUE (arglist
);
7066 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7069 /* Optimize sin (0.0) = 0.0. */
7070 if (real_zerop (arg
))
7076 /* Fold function call to builtin cos, cosf, or cosl. Return
7077 NULL_TREE if no simplification can be made. */
7079 fold_builtin_cos (tree arglist
, tree type
, tree fndecl
)
7081 tree arg
= TREE_VALUE (arglist
);
7083 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7086 /* Optimize cos (0.0) = 1.0. */
7087 if (real_zerop (arg
))
7088 return build_real (type
, dconst1
);
7090 /* Optimize cos(-x) into cos (x). */
7091 if (TREE_CODE (arg
) == NEGATE_EXPR
)
7093 tree args
= build_tree_list (NULL_TREE
,
7094 TREE_OPERAND (arg
, 0));
7095 return build_function_call_expr (fndecl
, args
);
7101 /* Fold function call to builtin tan, tanf, or tanl. Return
7102 NULL_TREE if no simplification can be made. */
7104 fold_builtin_tan (tree arglist
)
7106 enum built_in_function fcode
;
7107 tree arg
= TREE_VALUE (arglist
);
7109 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7112 /* Optimize tan(0.0) = 0.0. */
7113 if (real_zerop (arg
))
7116 /* Optimize tan(atan(x)) = x. */
7117 fcode
= builtin_mathfn_code (arg
);
7118 if (flag_unsafe_math_optimizations
7119 && (fcode
== BUILT_IN_ATAN
7120 || fcode
== BUILT_IN_ATANF
7121 || fcode
== BUILT_IN_ATANL
))
7122 return TREE_VALUE (TREE_OPERAND (arg
, 1));
7127 /* Fold function call to builtin atan, atanf, or atanl. Return
7128 NULL_TREE if no simplification can be made. */
7131 fold_builtin_atan (tree arglist
, tree type
)
7134 tree arg
= TREE_VALUE (arglist
);
7136 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7139 /* Optimize atan(0.0) = 0.0. */
7140 if (real_zerop (arg
))
7143 /* Optimize atan(1.0) = pi/4. */
7144 if (real_onep (arg
))
7146 REAL_VALUE_TYPE cst
;
7148 real_convert (&cst
, TYPE_MODE (type
), &dconstpi
);
7149 SET_REAL_EXP (&cst
, REAL_EXP (&cst
) - 2);
7150 return build_real (type
, cst
);
7156 /* Fold function call to builtin trunc, truncf or truncl. Return
7157 NULL_TREE if no simplification can be made. */
7160 fold_builtin_trunc (tree fndecl
, tree arglist
)
7164 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7167 /* Optimize trunc of constant value. */
7168 arg
= TREE_VALUE (arglist
);
7169 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7171 REAL_VALUE_TYPE r
, x
;
7172 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7174 x
= TREE_REAL_CST (arg
);
7175 real_trunc (&r
, TYPE_MODE (type
), &x
);
7176 return build_real (type
, r
);
7179 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7182 /* Fold function call to builtin floor, floorf or floorl. Return
7183 NULL_TREE if no simplification can be made. */
7186 fold_builtin_floor (tree fndecl
, tree arglist
)
7190 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7193 /* Optimize floor of constant value. */
7194 arg
= TREE_VALUE (arglist
);
7195 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7199 x
= TREE_REAL_CST (arg
);
7200 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7202 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7205 real_floor (&r
, TYPE_MODE (type
), &x
);
7206 return build_real (type
, r
);
7210 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7213 /* Fold function call to builtin ceil, ceilf or ceill. Return
7214 NULL_TREE if no simplification can be made. */
7217 fold_builtin_ceil (tree fndecl
, tree arglist
)
7221 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7224 /* Optimize ceil of constant value. */
7225 arg
= TREE_VALUE (arglist
);
7226 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7230 x
= TREE_REAL_CST (arg
);
7231 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7233 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7236 real_ceil (&r
, TYPE_MODE (type
), &x
);
7237 return build_real (type
, r
);
7241 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7244 /* Fold function call to builtin round, roundf or roundl. Return
7245 NULL_TREE if no simplification can be made. */
7248 fold_builtin_round (tree fndecl
, tree arglist
)
7252 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7255 /* Optimize round of constant value. */
7256 arg
= TREE_VALUE (arglist
);
7257 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7261 x
= TREE_REAL_CST (arg
);
7262 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7264 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7267 real_round (&r
, TYPE_MODE (type
), &x
);
7268 return build_real (type
, r
);
7272 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7275 /* Fold function call to builtin lround, lroundf or lroundl (or the
7276 corresponding long long versions) and other rounding functions.
7277 Return NULL_TREE if no simplification can be made. */
7280 fold_builtin_int_roundingfn (tree fndecl
, tree arglist
)
7284 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7287 /* Optimize lround of constant value. */
7288 arg
= TREE_VALUE (arglist
);
7289 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7291 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
7293 if (! REAL_VALUE_ISNAN (x
) && ! REAL_VALUE_ISINF (x
))
7295 tree itype
= TREE_TYPE (TREE_TYPE (fndecl
));
7296 tree ftype
= TREE_TYPE (arg
), result
;
7297 HOST_WIDE_INT hi
, lo
;
7300 switch (DECL_FUNCTION_CODE (fndecl
))
7302 case BUILT_IN_LFLOOR
:
7303 case BUILT_IN_LFLOORF
:
7304 case BUILT_IN_LFLOORL
:
7305 case BUILT_IN_LLFLOOR
:
7306 case BUILT_IN_LLFLOORF
:
7307 case BUILT_IN_LLFLOORL
:
7308 real_floor (&r
, TYPE_MODE (ftype
), &x
);
7311 case BUILT_IN_LCEIL
:
7312 case BUILT_IN_LCEILF
:
7313 case BUILT_IN_LCEILL
:
7314 case BUILT_IN_LLCEIL
:
7315 case BUILT_IN_LLCEILF
:
7316 case BUILT_IN_LLCEILL
:
7317 real_ceil (&r
, TYPE_MODE (ftype
), &x
);
7320 case BUILT_IN_LROUND
:
7321 case BUILT_IN_LROUNDF
:
7322 case BUILT_IN_LROUNDL
:
7323 case BUILT_IN_LLROUND
:
7324 case BUILT_IN_LLROUNDF
:
7325 case BUILT_IN_LLROUNDL
:
7326 real_round (&r
, TYPE_MODE (ftype
), &x
);
7333 REAL_VALUE_TO_INT (&lo
, &hi
, r
);
7334 result
= build_int_cst_wide (NULL_TREE
, lo
, hi
);
7335 if (int_fits_type_p (result
, itype
))
7336 return fold_convert (itype
, result
);
7340 return fold_fixed_mathfn (fndecl
, arglist
);
7343 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7344 and their long and long long variants (i.e. ffsl and ffsll).
7345 Return NULL_TREE if no simplification can be made. */
7348 fold_builtin_bitop (tree fndecl
, tree arglist
)
7352 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7355 /* Optimize for constant argument. */
7356 arg
= TREE_VALUE (arglist
);
7357 if (TREE_CODE (arg
) == INTEGER_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7359 HOST_WIDE_INT hi
, width
, result
;
7360 unsigned HOST_WIDE_INT lo
;
7363 type
= TREE_TYPE (arg
);
7364 width
= TYPE_PRECISION (type
);
7365 lo
= TREE_INT_CST_LOW (arg
);
7367 /* Clear all the bits that are beyond the type's precision. */
7368 if (width
> HOST_BITS_PER_WIDE_INT
)
7370 hi
= TREE_INT_CST_HIGH (arg
);
7371 if (width
< 2 * HOST_BITS_PER_WIDE_INT
)
7372 hi
&= ~((HOST_WIDE_INT
) (-1) >> (width
- HOST_BITS_PER_WIDE_INT
));
7377 if (width
< HOST_BITS_PER_WIDE_INT
)
7378 lo
&= ~((unsigned HOST_WIDE_INT
) (-1) << width
);
7381 switch (DECL_FUNCTION_CODE (fndecl
))
7385 case BUILT_IN_FFSLL
:
7387 result
= exact_log2 (lo
& -lo
) + 1;
7389 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
) + 1;
7396 case BUILT_IN_CLZLL
:
7398 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
7400 result
= width
- floor_log2 (lo
) - 1;
7401 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7407 case BUILT_IN_CTZLL
:
7409 result
= exact_log2 (lo
& -lo
);
7411 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
);
7412 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7416 case BUILT_IN_POPCOUNT
:
7417 case BUILT_IN_POPCOUNTL
:
7418 case BUILT_IN_POPCOUNTLL
:
7421 result
++, lo
&= lo
- 1;
7423 result
++, hi
&= hi
- 1;
7426 case BUILT_IN_PARITY
:
7427 case BUILT_IN_PARITYL
:
7428 case BUILT_IN_PARITYLL
:
7431 result
++, lo
&= lo
- 1;
7433 result
++, hi
&= hi
- 1;
7441 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), result
);
7447 /* Return true if EXPR is the real constant contained in VALUE. */
7450 real_dconstp (tree expr
, const REAL_VALUE_TYPE
*value
)
7454 return ((TREE_CODE (expr
) == REAL_CST
7455 && ! TREE_CONSTANT_OVERFLOW (expr
)
7456 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), *value
))
7457 || (TREE_CODE (expr
) == COMPLEX_CST
7458 && real_dconstp (TREE_REALPART (expr
), value
)
7459 && real_zerop (TREE_IMAGPART (expr
))));
7462 /* A subroutine of fold_builtin to fold the various logarithmic
7463 functions. EXP is the CALL_EXPR of a call to a builtin logN
7464 function. VALUE is the base of the logN function. */
7467 fold_builtin_logarithm (tree fndecl
, tree arglist
,
7468 const REAL_VALUE_TYPE
*value
)
7470 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7472 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7473 tree arg
= TREE_VALUE (arglist
);
7474 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7476 /* Optimize logN(1.0) = 0.0. */
7477 if (real_onep (arg
))
7478 return build_real (type
, dconst0
);
7480 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
7481 exactly, then only do this if flag_unsafe_math_optimizations. */
7482 if (exact_real_truncate (TYPE_MODE (type
), value
)
7483 || flag_unsafe_math_optimizations
)
7485 const REAL_VALUE_TYPE value_truncate
=
7486 real_value_truncate (TYPE_MODE (type
), *value
);
7487 if (real_dconstp (arg
, &value_truncate
))
7488 return build_real (type
, dconst1
);
7491 /* Special case, optimize logN(expN(x)) = x. */
7492 if (flag_unsafe_math_optimizations
7493 && ((value
== &dconste
7494 && (fcode
== BUILT_IN_EXP
7495 || fcode
== BUILT_IN_EXPF
7496 || fcode
== BUILT_IN_EXPL
))
7497 || (value
== &dconst2
7498 && (fcode
== BUILT_IN_EXP2
7499 || fcode
== BUILT_IN_EXP2F
7500 || fcode
== BUILT_IN_EXP2L
))
7501 || (value
== &dconst10
&& (BUILTIN_EXP10_P (fcode
)))))
7502 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7504 /* Optimize logN(func()) for various exponential functions. We
7505 want to determine the value "x" and the power "exponent" in
7506 order to transform logN(x**exponent) into exponent*logN(x). */
7507 if (flag_unsafe_math_optimizations
)
7509 tree exponent
= 0, x
= 0;
7516 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7517 x
= build_real (type
,
7518 real_value_truncate (TYPE_MODE (type
), dconste
));
7519 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7522 case BUILT_IN_EXP2F
:
7523 case BUILT_IN_EXP2L
:
7524 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7525 x
= build_real (type
, dconst2
);
7526 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7528 case BUILT_IN_EXP10
:
7529 case BUILT_IN_EXP10F
:
7530 case BUILT_IN_EXP10L
:
7531 case BUILT_IN_POW10
:
7532 case BUILT_IN_POW10F
:
7533 case BUILT_IN_POW10L
:
7534 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7535 x
= build_real (type
, dconst10
);
7536 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7539 case BUILT_IN_SQRTF
:
7540 case BUILT_IN_SQRTL
:
7541 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7542 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7543 exponent
= build_real (type
, dconsthalf
);
7546 case BUILT_IN_CBRTF
:
7547 case BUILT_IN_CBRTL
:
7548 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7549 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7550 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
7556 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7557 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7558 exponent
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
7564 /* Now perform the optimization. */
7568 arglist
= build_tree_list (NULL_TREE
, x
);
7569 logfn
= build_function_call_expr (fndecl
, arglist
);
7570 return fold_build2 (MULT_EXPR
, type
, exponent
, logfn
);
7578 /* Fold a builtin function call to pow, powf, or powl. Return
7579 NULL_TREE if no simplification can be made. */
7581 fold_builtin_pow (tree fndecl
, tree arglist
, tree type
)
7583 tree arg0
= TREE_VALUE (arglist
);
7584 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7586 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7589 /* Optimize pow(1.0,y) = 1.0. */
7590 if (real_onep (arg0
))
7591 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
7593 if (TREE_CODE (arg1
) == REAL_CST
7594 && ! TREE_CONSTANT_OVERFLOW (arg1
))
7596 REAL_VALUE_TYPE cint
;
7600 c
= TREE_REAL_CST (arg1
);
7602 /* Optimize pow(x,0.0) = 1.0. */
7603 if (REAL_VALUES_EQUAL (c
, dconst0
))
7604 return omit_one_operand (type
, build_real (type
, dconst1
),
7607 /* Optimize pow(x,1.0) = x. */
7608 if (REAL_VALUES_EQUAL (c
, dconst1
))
7611 /* Optimize pow(x,-1.0) = 1.0/x. */
7612 if (REAL_VALUES_EQUAL (c
, dconstm1
))
7613 return fold_build2 (RDIV_EXPR
, type
,
7614 build_real (type
, dconst1
), arg0
);
7616 /* Optimize pow(x,0.5) = sqrt(x). */
7617 if (flag_unsafe_math_optimizations
7618 && REAL_VALUES_EQUAL (c
, dconsthalf
))
7620 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7622 if (sqrtfn
!= NULL_TREE
)
7624 tree arglist
= build_tree_list (NULL_TREE
, arg0
);
7625 return build_function_call_expr (sqrtfn
, arglist
);
7629 /* Check for an integer exponent. */
7630 n
= real_to_integer (&c
);
7631 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
7632 if (real_identical (&c
, &cint
))
7634 /* Attempt to evaluate pow at compile-time. */
7635 if (TREE_CODE (arg0
) == REAL_CST
7636 && ! TREE_CONSTANT_OVERFLOW (arg0
))
7641 x
= TREE_REAL_CST (arg0
);
7642 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
7643 if (flag_unsafe_math_optimizations
|| !inexact
)
7644 return build_real (type
, x
);
7647 /* Strip sign ops from even integer powers. */
7648 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
7650 tree narg0
= fold_strip_sign_ops (arg0
);
7653 arglist
= build_tree_list (NULL_TREE
, arg1
);
7654 arglist
= tree_cons (NULL_TREE
, narg0
, arglist
);
7655 return build_function_call_expr (fndecl
, arglist
);
7661 if (flag_unsafe_math_optimizations
)
7663 const enum built_in_function fcode
= builtin_mathfn_code (arg0
);
7665 /* Optimize pow(expN(x),y) = expN(x*y). */
7666 if (BUILTIN_EXPONENT_P (fcode
))
7668 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
7669 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7670 arg
= fold_build2 (MULT_EXPR
, type
, arg
, arg1
);
7671 arglist
= build_tree_list (NULL_TREE
, arg
);
7672 return build_function_call_expr (expfn
, arglist
);
7675 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
7676 if (BUILTIN_SQRT_P (fcode
))
7678 tree narg0
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7679 tree narg1
= fold_build2 (MULT_EXPR
, type
, arg1
,
7680 build_real (type
, dconsthalf
));
7682 arglist
= tree_cons (NULL_TREE
, narg0
,
7683 build_tree_list (NULL_TREE
, narg1
));
7684 return build_function_call_expr (fndecl
, arglist
);
7687 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
7688 if (BUILTIN_CBRT_P (fcode
))
7690 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7691 if (tree_expr_nonnegative_p (arg
))
7693 const REAL_VALUE_TYPE dconstroot
7694 = real_value_truncate (TYPE_MODE (type
), dconstthird
);
7695 tree narg1
= fold_build2 (MULT_EXPR
, type
, arg1
,
7696 build_real (type
, dconstroot
));
7697 arglist
= tree_cons (NULL_TREE
, arg
,
7698 build_tree_list (NULL_TREE
, narg1
));
7699 return build_function_call_expr (fndecl
, arglist
);
7703 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
7704 if (fcode
== BUILT_IN_POW
|| fcode
== BUILT_IN_POWF
7705 || fcode
== BUILT_IN_POWL
)
7707 tree arg00
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7708 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0
, 1)));
7709 tree narg1
= fold_build2 (MULT_EXPR
, type
, arg01
, arg1
);
7710 arglist
= tree_cons (NULL_TREE
, arg00
,
7711 build_tree_list (NULL_TREE
, narg1
));
7712 return build_function_call_expr (fndecl
, arglist
);
7719 /* Fold a builtin function call to powi, powif, or powil. Return
7720 NULL_TREE if no simplification can be made. */
7722 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED
, tree arglist
, tree type
)
7724 tree arg0
= TREE_VALUE (arglist
);
7725 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7727 if (!validate_arglist (arglist
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7730 /* Optimize pow(1.0,y) = 1.0. */
7731 if (real_onep (arg0
))
7732 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
7734 if (host_integerp (arg1
, 0))
7736 HOST_WIDE_INT c
= TREE_INT_CST_LOW (arg1
);
7738 /* Evaluate powi at compile-time. */
7739 if (TREE_CODE (arg0
) == REAL_CST
7740 && ! TREE_CONSTANT_OVERFLOW (arg0
))
7743 x
= TREE_REAL_CST (arg0
);
7744 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
7745 return build_real (type
, x
);
7748 /* Optimize pow(x,0) = 1.0. */
7750 return omit_one_operand (type
, build_real (type
, dconst1
),
7753 /* Optimize pow(x,1) = x. */
7757 /* Optimize pow(x,-1) = 1.0/x. */
7759 return fold_build2 (RDIV_EXPR
, type
,
7760 build_real (type
, dconst1
), arg0
);
7766 /* A subroutine of fold_builtin to fold the various exponent
7767 functions. EXP is the CALL_EXPR of a call to a builtin function.
7768 VALUE is the value which will be raised to a power. */
7771 fold_builtin_exponent (tree fndecl
, tree arglist
,
7772 const REAL_VALUE_TYPE
*value
)
7774 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7776 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7777 tree arg
= TREE_VALUE (arglist
);
7779 /* Optimize exp*(0.0) = 1.0. */
7780 if (real_zerop (arg
))
7781 return build_real (type
, dconst1
);
7783 /* Optimize expN(1.0) = N. */
7784 if (real_onep (arg
))
7786 REAL_VALUE_TYPE cst
;
7788 real_convert (&cst
, TYPE_MODE (type
), value
);
7789 return build_real (type
, cst
);
7792 /* Attempt to evaluate expN(integer) at compile-time. */
7793 if (flag_unsafe_math_optimizations
7794 && TREE_CODE (arg
) == REAL_CST
7795 && ! TREE_CONSTANT_OVERFLOW (arg
))
7797 REAL_VALUE_TYPE cint
;
7801 c
= TREE_REAL_CST (arg
);
7802 n
= real_to_integer (&c
);
7803 real_from_integer (&cint
, VOIDmode
, n
,
7805 if (real_identical (&c
, &cint
))
7809 real_powi (&x
, TYPE_MODE (type
), value
, n
);
7810 return build_real (type
, x
);
7814 /* Optimize expN(logN(x)) = x. */
7815 if (flag_unsafe_math_optimizations
)
7817 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7819 if ((value
== &dconste
7820 && (fcode
== BUILT_IN_LOG
7821 || fcode
== BUILT_IN_LOGF
7822 || fcode
== BUILT_IN_LOGL
))
7823 || (value
== &dconst2
7824 && (fcode
== BUILT_IN_LOG2
7825 || fcode
== BUILT_IN_LOG2F
7826 || fcode
== BUILT_IN_LOG2L
))
7827 || (value
== &dconst10
7828 && (fcode
== BUILT_IN_LOG10
7829 || fcode
== BUILT_IN_LOG10F
7830 || fcode
== BUILT_IN_LOG10L
)))
7831 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7838 /* Fold function call to builtin memcpy. Return
7839 NULL_TREE if no simplification can be made. */
7842 fold_builtin_memcpy (tree fndecl
, tree arglist
)
7844 tree dest
, src
, len
;
7846 if (!validate_arglist (arglist
,
7847 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7850 dest
= TREE_VALUE (arglist
);
7851 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7852 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7854 /* If the LEN parameter is zero, return DEST. */
7855 if (integer_zerop (len
))
7856 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
7858 /* If SRC and DEST are the same (and not volatile), return DEST. */
7859 if (operand_equal_p (src
, dest
, 0))
7860 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
7865 /* Fold function call to builtin mempcpy. Return
7866 NULL_TREE if no simplification can be made. */
7869 fold_builtin_mempcpy (tree arglist
, tree type
, int endp
)
7871 if (validate_arglist (arglist
,
7872 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7874 tree dest
= TREE_VALUE (arglist
);
7875 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
7876 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7878 /* If the LEN parameter is zero, return DEST. */
7879 if (integer_zerop (len
))
7880 return omit_one_operand (type
, dest
, src
);
7882 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
7883 if (operand_equal_p (src
, dest
, 0))
7886 return omit_one_operand (type
, dest
, len
);
7889 len
= fold_build2 (MINUS_EXPR
, TREE_TYPE (len
), len
,
7892 len
= fold_convert (TREE_TYPE (dest
), len
);
7893 len
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
7894 return fold_convert (type
, len
);
7900 /* Fold function call to builtin memmove. Return
7901 NULL_TREE if no simplification can be made. */
7904 fold_builtin_memmove (tree arglist
, tree type
)
7906 tree dest
, src
, len
;
7908 if (!validate_arglist (arglist
,
7909 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7912 dest
= TREE_VALUE (arglist
);
7913 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7914 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7916 /* If the LEN parameter is zero, return DEST. */
7917 if (integer_zerop (len
))
7918 return omit_one_operand (type
, dest
, src
);
7920 /* If SRC and DEST are the same (and not volatile), return DEST. */
7921 if (operand_equal_p (src
, dest
, 0))
7922 return omit_one_operand (type
, dest
, len
);
7927 /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
7928 the length of the string to be copied. Return NULL_TREE if no
7929 simplification can be made. */
7932 fold_builtin_strcpy (tree fndecl
, tree arglist
, tree len
)
7936 if (!validate_arglist (arglist
,
7937 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7940 dest
= TREE_VALUE (arglist
);
7941 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7943 /* If SRC and DEST are the same (and not volatile), return DEST. */
7944 if (operand_equal_p (src
, dest
, 0))
7945 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
7950 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7956 len
= c_strlen (src
, 1);
7957 if (! len
|| TREE_SIDE_EFFECTS (len
))
7961 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
7962 arglist
= build_tree_list (NULL_TREE
, len
);
7963 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
7964 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
7965 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)),
7966 build_function_call_expr (fn
, arglist
));
7969 /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
7970 the length of the source string. Return NULL_TREE if no simplification
7974 fold_builtin_strncpy (tree fndecl
, tree arglist
, tree slen
)
7976 tree dest
, src
, len
, fn
;
7978 if (!validate_arglist (arglist
,
7979 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7982 dest
= TREE_VALUE (arglist
);
7983 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7984 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7986 /* If the LEN parameter is zero, return DEST. */
7987 if (integer_zerop (len
))
7988 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
7990 /* We can't compare slen with len as constants below if len is not a
7992 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
7996 slen
= c_strlen (src
, 1);
7998 /* Now, we must be passed a constant src ptr parameter. */
7999 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
8002 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
8004 /* We do not support simplification of this case, though we do
8005 support it when expanding trees into RTL. */
8006 /* FIXME: generate a call to __builtin_memset. */
8007 if (tree_int_cst_lt (slen
, len
))
8010 /* OK transform into builtin memcpy. */
8011 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
8014 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)),
8015 build_function_call_expr (fn
, arglist
));
8018 /* Fold function call to builtin memcmp. Return
8019 NULL_TREE if no simplification can be made. */
8022 fold_builtin_memcmp (tree arglist
)
8024 tree arg1
, arg2
, len
;
8025 const char *p1
, *p2
;
8027 if (!validate_arglist (arglist
,
8028 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8031 arg1
= TREE_VALUE (arglist
);
8032 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
8033 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
8035 /* If the LEN parameter is zero, return zero. */
8036 if (integer_zerop (len
))
8037 return omit_two_operands (integer_type_node
, integer_zero_node
,
8040 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8041 if (operand_equal_p (arg1
, arg2
, 0))
8042 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
8044 p1
= c_getstr (arg1
);
8045 p2
= c_getstr (arg2
);
8047 /* If all arguments are constant, and the value of len is not greater
8048 than the lengths of arg1 and arg2, evaluate at compile-time. */
8049 if (host_integerp (len
, 1) && p1
&& p2
8050 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
8051 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
8053 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
8056 return integer_one_node
;
8058 return integer_minus_one_node
;
8060 return integer_zero_node
;
8063 /* If len parameter is one, return an expression corresponding to
8064 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8065 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
8067 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8068 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
8069 tree ind1
= fold_convert (integer_type_node
,
8070 build1 (INDIRECT_REF
, cst_uchar_node
,
8071 fold_convert (cst_uchar_ptr_node
,
8073 tree ind2
= fold_convert (integer_type_node
,
8074 build1 (INDIRECT_REF
, cst_uchar_node
,
8075 fold_convert (cst_uchar_ptr_node
,
8077 return fold_build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8083 /* Fold function call to builtin strcmp. Return
8084 NULL_TREE if no simplification can be made. */
8087 fold_builtin_strcmp (tree arglist
)
8090 const char *p1
, *p2
;
8092 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8095 arg1
= TREE_VALUE (arglist
);
8096 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
8098 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8099 if (operand_equal_p (arg1
, arg2
, 0))
8100 return integer_zero_node
;
8102 p1
= c_getstr (arg1
);
8103 p2
= c_getstr (arg2
);
8107 const int i
= strcmp (p1
, p2
);
8109 return integer_minus_one_node
;
8111 return integer_one_node
;
8113 return integer_zero_node
;
8116 /* If the second arg is "", return *(const unsigned char*)arg1. */
8117 if (p2
&& *p2
== '\0')
8119 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8120 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
8121 return fold_convert (integer_type_node
,
8122 build1 (INDIRECT_REF
, cst_uchar_node
,
8123 fold_convert (cst_uchar_ptr_node
,
8127 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8128 if (p1
&& *p1
== '\0')
8130 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8131 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
8132 tree temp
= fold_convert (integer_type_node
,
8133 build1 (INDIRECT_REF
, cst_uchar_node
,
8134 fold_convert (cst_uchar_ptr_node
,
8136 return fold_build1 (NEGATE_EXPR
, integer_type_node
, temp
);
8142 /* Fold function call to builtin strncmp. Return
8143 NULL_TREE if no simplification can be made. */
8146 fold_builtin_strncmp (tree arglist
)
8148 tree arg1
, arg2
, len
;
8149 const char *p1
, *p2
;
8151 if (!validate_arglist (arglist
,
8152 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8155 arg1
= TREE_VALUE (arglist
);
8156 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
8157 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
8159 /* If the LEN parameter is zero, return zero. */
8160 if (integer_zerop (len
))
8161 return omit_two_operands (integer_type_node
, integer_zero_node
,
8164 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8165 if (operand_equal_p (arg1
, arg2
, 0))
8166 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
8168 p1
= c_getstr (arg1
);
8169 p2
= c_getstr (arg2
);
8171 if (host_integerp (len
, 1) && p1
&& p2
)
8173 const int i
= strncmp (p1
, p2
, tree_low_cst (len
, 1));
8175 return integer_one_node
;
8177 return integer_minus_one_node
;
8179 return integer_zero_node
;
8182 /* If the second arg is "", and the length is greater than zero,
8183 return *(const unsigned char*)arg1. */
8184 if (p2
&& *p2
== '\0'
8185 && TREE_CODE (len
) == INTEGER_CST
8186 && tree_int_cst_sgn (len
) == 1)
8188 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8189 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
8190 return fold_convert (integer_type_node
,
8191 build1 (INDIRECT_REF
, cst_uchar_node
,
8192 fold_convert (cst_uchar_ptr_node
,
8196 /* If the first arg is "", and the length is greater than zero,
8197 return -*(const unsigned char*)arg2. */
8198 if (p1
&& *p1
== '\0'
8199 && TREE_CODE (len
) == INTEGER_CST
8200 && tree_int_cst_sgn (len
) == 1)
8202 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8203 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
8204 tree temp
= fold_convert (integer_type_node
,
8205 build1 (INDIRECT_REF
, cst_uchar_node
,
8206 fold_convert (cst_uchar_ptr_node
,
8208 return fold_build1 (NEGATE_EXPR
, integer_type_node
, temp
);
8211 /* If len parameter is one, return an expression corresponding to
8212 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8213 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
8215 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8216 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
8217 tree ind1
= fold_convert (integer_type_node
,
8218 build1 (INDIRECT_REF
, cst_uchar_node
,
8219 fold_convert (cst_uchar_ptr_node
,
8221 tree ind2
= fold_convert (integer_type_node
,
8222 build1 (INDIRECT_REF
, cst_uchar_node
,
8223 fold_convert (cst_uchar_ptr_node
,
8225 return fold_build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8231 /* Fold function call to builtin signbit, signbitf or signbitl. Return
8232 NULL_TREE if no simplification can be made. */
8235 fold_builtin_signbit (tree fndecl
, tree arglist
)
8237 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8240 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8243 arg
= TREE_VALUE (arglist
);
8245 /* If ARG is a compile-time constant, determine the result. */
8246 if (TREE_CODE (arg
) == REAL_CST
8247 && !TREE_CONSTANT_OVERFLOW (arg
))
8251 c
= TREE_REAL_CST (arg
);
8252 temp
= REAL_VALUE_NEGATIVE (c
) ? integer_one_node
: integer_zero_node
;
8253 return fold_convert (type
, temp
);
8256 /* If ARG is non-negative, the result is always zero. */
8257 if (tree_expr_nonnegative_p (arg
))
8258 return omit_one_operand (type
, integer_zero_node
, arg
);
8260 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
8261 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
8262 return fold_build2 (LT_EXPR
, type
, arg
,
8263 build_real (TREE_TYPE (arg
), dconst0
));
8268 /* Fold function call to builtin copysign, copysignf or copysignl.
8269 Return NULL_TREE if no simplification can be made. */
8272 fold_builtin_copysign (tree fndecl
, tree arglist
, tree type
)
8274 tree arg1
, arg2
, tem
;
8276 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
8279 arg1
= TREE_VALUE (arglist
);
8280 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
8282 /* copysign(X,X) is X. */
8283 if (operand_equal_p (arg1
, arg2
, 0))
8284 return fold_convert (type
, arg1
);
8286 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
8287 if (TREE_CODE (arg1
) == REAL_CST
8288 && TREE_CODE (arg2
) == REAL_CST
8289 && !TREE_CONSTANT_OVERFLOW (arg1
)
8290 && !TREE_CONSTANT_OVERFLOW (arg2
))
8292 REAL_VALUE_TYPE c1
, c2
;
8294 c1
= TREE_REAL_CST (arg1
);
8295 c2
= TREE_REAL_CST (arg2
);
8296 real_copysign (&c1
, &c2
);
8297 return build_real (type
, c1
);
8301 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
8302 Remember to evaluate Y for side-effects. */
8303 if (tree_expr_nonnegative_p (arg2
))
8304 return omit_one_operand (type
,
8305 fold_build1 (ABS_EXPR
, type
, arg1
),
8308 /* Strip sign changing operations for the first argument. */
8309 tem
= fold_strip_sign_ops (arg1
);
8312 arglist
= tree_cons (NULL_TREE
, tem
, TREE_CHAIN (arglist
));
8313 return build_function_call_expr (fndecl
, arglist
);
8319 /* Fold a call to builtin isascii. */
8322 fold_builtin_isascii (tree arglist
)
8324 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8328 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
8329 tree arg
= TREE_VALUE (arglist
);
8331 arg
= build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
8332 build_int_cst (NULL_TREE
,
8333 ~ (unsigned HOST_WIDE_INT
) 0x7f));
8334 arg
= fold_build2 (EQ_EXPR
, integer_type_node
,
8335 arg
, integer_zero_node
);
8337 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
8344 /* Fold a call to builtin toascii. */
8347 fold_builtin_toascii (tree arglist
)
8349 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8353 /* Transform toascii(c) -> (c & 0x7f). */
8354 tree arg
= TREE_VALUE (arglist
);
8356 return fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
8357 build_int_cst (NULL_TREE
, 0x7f));
8361 /* Fold a call to builtin isdigit. */
8364 fold_builtin_isdigit (tree arglist
)
8366 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8370 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
8371 /* According to the C standard, isdigit is unaffected by locale.
8372 However, it definitely is affected by the target character set. */
8374 unsigned HOST_WIDE_INT target_digit0
8375 = lang_hooks
.to_target_charset ('0');
8377 if (target_digit0
== 0)
8380 arg
= fold_convert (unsigned_type_node
, TREE_VALUE (arglist
));
8381 arg
= build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
8382 build_int_cst (unsigned_type_node
, target_digit0
));
8383 arg
= fold_build2 (LE_EXPR
, integer_type_node
, arg
,
8384 build_int_cst (unsigned_type_node
, 9));
8385 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
8392 /* Fold a call to fabs, fabsf or fabsl. */
8395 fold_builtin_fabs (tree arglist
, tree type
)
8399 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8402 arg
= TREE_VALUE (arglist
);
8403 arg
= fold_convert (type
, arg
);
8404 if (TREE_CODE (arg
) == REAL_CST
)
8405 return fold_abs_const (arg
, type
);
8406 return fold_build1 (ABS_EXPR
, type
, arg
);
8409 /* Fold a call to abs, labs, llabs or imaxabs. */
8412 fold_builtin_abs (tree arglist
, tree type
)
8416 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8419 arg
= TREE_VALUE (arglist
);
8420 arg
= fold_convert (type
, arg
);
8421 if (TREE_CODE (arg
) == INTEGER_CST
)
8422 return fold_abs_const (arg
, type
);
8423 return fold_build1 (ABS_EXPR
, type
, arg
);
8426 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8427 EXP is the CALL_EXPR for the call. */
8430 fold_builtin_classify (tree fndecl
, tree arglist
, int builtin_index
)
8432 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8436 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8438 /* Check that we have exactly one argument. */
8441 error ("too few arguments to function %qs",
8442 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8443 return error_mark_node
;
8445 else if (TREE_CHAIN (arglist
) != 0)
8447 error ("too many arguments to function %qs",
8448 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8449 return error_mark_node
;
8453 error ("non-floating-point argument to function %qs",
8454 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8455 return error_mark_node
;
8459 arg
= TREE_VALUE (arglist
);
8460 switch (builtin_index
)
8462 case BUILT_IN_ISINF
:
8463 if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
8464 return omit_one_operand (type
, integer_zero_node
, arg
);
8466 if (TREE_CODE (arg
) == REAL_CST
)
8468 r
= TREE_REAL_CST (arg
);
8469 if (real_isinf (&r
))
8470 return real_compare (GT_EXPR
, &r
, &dconst0
)
8471 ? integer_one_node
: integer_minus_one_node
;
8473 return integer_zero_node
;
8478 case BUILT_IN_FINITE
:
8479 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
)))
8480 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
8481 return omit_one_operand (type
, integer_zero_node
, arg
);
8483 if (TREE_CODE (arg
) == REAL_CST
)
8485 r
= TREE_REAL_CST (arg
);
8486 return real_isinf (&r
) || real_isnan (&r
)
8487 ? integer_zero_node
: integer_one_node
;
8492 case BUILT_IN_ISNAN
:
8493 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
))))
8494 return omit_one_operand (type
, integer_zero_node
, arg
);
8496 if (TREE_CODE (arg
) == REAL_CST
)
8498 r
= TREE_REAL_CST (arg
);
8499 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
8502 arg
= builtin_save_expr (arg
);
8503 return fold_build2 (UNORDERED_EXPR
, type
, arg
, arg
);
8510 /* Fold a call to an unordered comparison function such as
8511 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
8512 being called and ARGLIST is the argument list for the call.
8513 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
8514 the opposite of the desired result. UNORDERED_CODE is used
8515 for modes that can hold NaNs and ORDERED_CODE is used for
8519 fold_builtin_unordered_cmp (tree fndecl
, tree arglist
,
8520 enum tree_code unordered_code
,
8521 enum tree_code ordered_code
)
8523 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8524 enum tree_code code
;
8527 enum tree_code code0
, code1
;
8528 tree cmp_type
= NULL_TREE
;
8530 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
8532 /* Check that we have exactly two arguments. */
8533 if (arglist
== 0 || TREE_CHAIN (arglist
) == 0)
8535 error ("too few arguments to function %qs",
8536 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8537 return error_mark_node
;
8539 else if (TREE_CHAIN (TREE_CHAIN (arglist
)) != 0)
8541 error ("too many arguments to function %qs",
8542 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8543 return error_mark_node
;
8547 arg0
= TREE_VALUE (arglist
);
8548 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
8550 type0
= TREE_TYPE (arg0
);
8551 type1
= TREE_TYPE (arg1
);
8553 code0
= TREE_CODE (type0
);
8554 code1
= TREE_CODE (type1
);
8556 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
8557 /* Choose the wider of two real types. */
8558 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
8560 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
8562 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
8566 error ("non-floating-point argument to function %qs",
8567 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8568 return error_mark_node
;
8571 arg0
= fold_convert (cmp_type
, arg0
);
8572 arg1
= fold_convert (cmp_type
, arg1
);
8574 if (unordered_code
== UNORDERED_EXPR
)
8576 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
8577 return omit_two_operands (type
, integer_zero_node
, arg0
, arg1
);
8578 return fold_build2 (UNORDERED_EXPR
, type
, arg0
, arg1
);
8581 code
= MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
8583 return fold_build1 (TRUTH_NOT_EXPR
, type
,
8584 fold_build2 (code
, type
, arg0
, arg1
));
8587 /* Used by constant folding to simplify calls to builtin functions. EXP is
8588 the CALL_EXPR of a call to a builtin function. IGNORE is true if the
8589 result of the function call is ignored. This function returns NULL_TREE
8590 if no simplification was possible. */
8593 fold_builtin_1 (tree fndecl
, tree arglist
, bool ignore
)
8595 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8596 enum built_in_function fcode
;
8598 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
8599 return targetm
.fold_builtin (fndecl
, arglist
, ignore
);
8601 fcode
= DECL_FUNCTION_CODE (fndecl
);
8604 case BUILT_IN_FPUTS
:
8605 return fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
8607 case BUILT_IN_FPUTS_UNLOCKED
:
8608 return fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
8610 case BUILT_IN_STRSTR
:
8611 return fold_builtin_strstr (arglist
, type
);
8613 case BUILT_IN_STRCAT
:
8614 return fold_builtin_strcat (arglist
);
8616 case BUILT_IN_STRNCAT
:
8617 return fold_builtin_strncat (arglist
);
8619 case BUILT_IN_STRSPN
:
8620 return fold_builtin_strspn (arglist
);
8622 case BUILT_IN_STRCSPN
:
8623 return fold_builtin_strcspn (arglist
);
8625 case BUILT_IN_STRCHR
:
8626 case BUILT_IN_INDEX
:
8627 return fold_builtin_strchr (arglist
, type
);
8629 case BUILT_IN_STRRCHR
:
8630 case BUILT_IN_RINDEX
:
8631 return fold_builtin_strrchr (arglist
, type
);
8633 case BUILT_IN_STRCPY
:
8634 return fold_builtin_strcpy (fndecl
, arglist
, NULL_TREE
);
8636 case BUILT_IN_STRNCPY
:
8637 return fold_builtin_strncpy (fndecl
, arglist
, NULL_TREE
);
8639 case BUILT_IN_STRCMP
:
8640 return fold_builtin_strcmp (arglist
);
8642 case BUILT_IN_STRNCMP
:
8643 return fold_builtin_strncmp (arglist
);
8645 case BUILT_IN_STRPBRK
:
8646 return fold_builtin_strpbrk (arglist
, type
);
8649 case BUILT_IN_MEMCMP
:
8650 return fold_builtin_memcmp (arglist
);
8652 case BUILT_IN_SPRINTF
:
8653 return fold_builtin_sprintf (arglist
, ignore
);
8655 case BUILT_IN_CONSTANT_P
:
8659 val
= fold_builtin_constant_p (arglist
);
8660 /* Gimplification will pull the CALL_EXPR for the builtin out of
8661 an if condition. When not optimizing, we'll not CSE it back.
8662 To avoid link error types of regressions, return false now. */
8663 if (!val
&& !optimize
)
8664 val
= integer_zero_node
;
8669 case BUILT_IN_EXPECT
:
8670 return fold_builtin_expect (arglist
);
8672 case BUILT_IN_CLASSIFY_TYPE
:
8673 return fold_builtin_classify_type (arglist
);
8675 case BUILT_IN_STRLEN
:
8676 return fold_builtin_strlen (arglist
);
8679 case BUILT_IN_FABSF
:
8680 case BUILT_IN_FABSL
:
8681 return fold_builtin_fabs (arglist
, type
);
8685 case BUILT_IN_LLABS
:
8686 case BUILT_IN_IMAXABS
:
8687 return fold_builtin_abs (arglist
, type
);
8690 case BUILT_IN_CONJF
:
8691 case BUILT_IN_CONJL
:
8692 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8693 return fold_build1 (CONJ_EXPR
, type
, TREE_VALUE (arglist
));
8696 case BUILT_IN_CREAL
:
8697 case BUILT_IN_CREALF
:
8698 case BUILT_IN_CREALL
:
8699 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8700 return non_lvalue (fold_build1 (REALPART_EXPR
, type
,
8701 TREE_VALUE (arglist
)));
8704 case BUILT_IN_CIMAG
:
8705 case BUILT_IN_CIMAGF
:
8706 case BUILT_IN_CIMAGL
:
8707 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8708 return non_lvalue (fold_build1 (IMAGPART_EXPR
, type
,
8709 TREE_VALUE (arglist
)));
8713 case BUILT_IN_CABSF
:
8714 case BUILT_IN_CABSL
:
8715 return fold_builtin_cabs (arglist
, type
);
8718 case BUILT_IN_SQRTF
:
8719 case BUILT_IN_SQRTL
:
8720 return fold_builtin_sqrt (arglist
, type
);
8723 case BUILT_IN_CBRTF
:
8724 case BUILT_IN_CBRTL
:
8725 return fold_builtin_cbrt (arglist
, type
);
8730 return fold_builtin_sin (arglist
);
8735 return fold_builtin_cos (arglist
, type
, fndecl
);
8740 return fold_builtin_exponent (fndecl
, arglist
, &dconste
);
8743 case BUILT_IN_EXP2F
:
8744 case BUILT_IN_EXP2L
:
8745 return fold_builtin_exponent (fndecl
, arglist
, &dconst2
);
8747 case BUILT_IN_EXP10
:
8748 case BUILT_IN_EXP10F
:
8749 case BUILT_IN_EXP10L
:
8750 case BUILT_IN_POW10
:
8751 case BUILT_IN_POW10F
:
8752 case BUILT_IN_POW10L
:
8753 return fold_builtin_exponent (fndecl
, arglist
, &dconst10
);
8758 return fold_builtin_logarithm (fndecl
, arglist
, &dconste
);
8761 case BUILT_IN_LOG2F
:
8762 case BUILT_IN_LOG2L
:
8763 return fold_builtin_logarithm (fndecl
, arglist
, &dconst2
);
8765 case BUILT_IN_LOG10
:
8766 case BUILT_IN_LOG10F
:
8767 case BUILT_IN_LOG10L
:
8768 return fold_builtin_logarithm (fndecl
, arglist
, &dconst10
);
8773 return fold_builtin_tan (arglist
);
8776 case BUILT_IN_ATANF
:
8777 case BUILT_IN_ATANL
:
8778 return fold_builtin_atan (arglist
, type
);
8783 return fold_builtin_pow (fndecl
, arglist
, type
);
8786 case BUILT_IN_POWIF
:
8787 case BUILT_IN_POWIL
:
8788 return fold_builtin_powi (fndecl
, arglist
, type
);
8793 return fold_builtin_inf (type
, true);
8795 case BUILT_IN_HUGE_VAL
:
8796 case BUILT_IN_HUGE_VALF
:
8797 case BUILT_IN_HUGE_VALL
:
8798 return fold_builtin_inf (type
, false);
8803 return fold_builtin_nan (arglist
, type
, true);
8806 case BUILT_IN_NANSF
:
8807 case BUILT_IN_NANSL
:
8808 return fold_builtin_nan (arglist
, type
, false);
8810 case BUILT_IN_FLOOR
:
8811 case BUILT_IN_FLOORF
:
8812 case BUILT_IN_FLOORL
:
8813 return fold_builtin_floor (fndecl
, arglist
);
8816 case BUILT_IN_CEILF
:
8817 case BUILT_IN_CEILL
:
8818 return fold_builtin_ceil (fndecl
, arglist
);
8820 case BUILT_IN_TRUNC
:
8821 case BUILT_IN_TRUNCF
:
8822 case BUILT_IN_TRUNCL
:
8823 return fold_builtin_trunc (fndecl
, arglist
);
8825 case BUILT_IN_ROUND
:
8826 case BUILT_IN_ROUNDF
:
8827 case BUILT_IN_ROUNDL
:
8828 return fold_builtin_round (fndecl
, arglist
);
8830 case BUILT_IN_NEARBYINT
:
8831 case BUILT_IN_NEARBYINTF
:
8832 case BUILT_IN_NEARBYINTL
:
8834 case BUILT_IN_RINTF
:
8835 case BUILT_IN_RINTL
:
8836 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
8838 case BUILT_IN_LCEIL
:
8839 case BUILT_IN_LCEILF
:
8840 case BUILT_IN_LCEILL
:
8841 case BUILT_IN_LLCEIL
:
8842 case BUILT_IN_LLCEILF
:
8843 case BUILT_IN_LLCEILL
:
8844 case BUILT_IN_LFLOOR
:
8845 case BUILT_IN_LFLOORF
:
8846 case BUILT_IN_LFLOORL
:
8847 case BUILT_IN_LLFLOOR
:
8848 case BUILT_IN_LLFLOORF
:
8849 case BUILT_IN_LLFLOORL
:
8850 case BUILT_IN_LROUND
:
8851 case BUILT_IN_LROUNDF
:
8852 case BUILT_IN_LROUNDL
:
8853 case BUILT_IN_LLROUND
:
8854 case BUILT_IN_LLROUNDF
:
8855 case BUILT_IN_LLROUNDL
:
8856 return fold_builtin_int_roundingfn (fndecl
, arglist
);
8858 case BUILT_IN_LRINT
:
8859 case BUILT_IN_LRINTF
:
8860 case BUILT_IN_LRINTL
:
8861 case BUILT_IN_LLRINT
:
8862 case BUILT_IN_LLRINTF
:
8863 case BUILT_IN_LLRINTL
:
8864 return fold_fixed_mathfn (fndecl
, arglist
);
8868 case BUILT_IN_FFSLL
:
8871 case BUILT_IN_CLZLL
:
8874 case BUILT_IN_CTZLL
:
8875 case BUILT_IN_POPCOUNT
:
8876 case BUILT_IN_POPCOUNTL
:
8877 case BUILT_IN_POPCOUNTLL
:
8878 case BUILT_IN_PARITY
:
8879 case BUILT_IN_PARITYL
:
8880 case BUILT_IN_PARITYLL
:
8881 return fold_builtin_bitop (fndecl
, arglist
);
8883 case BUILT_IN_MEMCPY
:
8884 return fold_builtin_memcpy (fndecl
, arglist
);
8886 case BUILT_IN_MEMPCPY
:
8887 return fold_builtin_mempcpy (arglist
, type
, /*endp=*/1);
8889 case BUILT_IN_MEMMOVE
:
8890 return fold_builtin_memmove (arglist
, type
);
8892 case BUILT_IN_SIGNBIT
:
8893 case BUILT_IN_SIGNBITF
:
8894 case BUILT_IN_SIGNBITL
:
8895 return fold_builtin_signbit (fndecl
, arglist
);
8897 case BUILT_IN_ISASCII
:
8898 return fold_builtin_isascii (arglist
);
8900 case BUILT_IN_TOASCII
:
8901 return fold_builtin_toascii (arglist
);
8903 case BUILT_IN_ISDIGIT
:
8904 return fold_builtin_isdigit (arglist
);
8906 case BUILT_IN_COPYSIGN
:
8907 case BUILT_IN_COPYSIGNF
:
8908 case BUILT_IN_COPYSIGNL
:
8909 return fold_builtin_copysign (fndecl
, arglist
, type
);
8911 case BUILT_IN_FINITE
:
8912 case BUILT_IN_FINITEF
:
8913 case BUILT_IN_FINITEL
:
8914 return fold_builtin_classify (fndecl
, arglist
, BUILT_IN_FINITE
);
8916 case BUILT_IN_ISINF
:
8917 case BUILT_IN_ISINFF
:
8918 case BUILT_IN_ISINFL
:
8919 return fold_builtin_classify (fndecl
, arglist
, BUILT_IN_ISINF
);
8921 case BUILT_IN_ISNAN
:
8922 case BUILT_IN_ISNANF
:
8923 case BUILT_IN_ISNANL
:
8924 return fold_builtin_classify (fndecl
, arglist
, BUILT_IN_ISNAN
);
8926 case BUILT_IN_ISGREATER
:
8927 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNLE_EXPR
, LE_EXPR
);
8928 case BUILT_IN_ISGREATEREQUAL
:
8929 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNLT_EXPR
, LT_EXPR
);
8930 case BUILT_IN_ISLESS
:
8931 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNGE_EXPR
, GE_EXPR
);
8932 case BUILT_IN_ISLESSEQUAL
:
8933 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNGT_EXPR
, GT_EXPR
);
8934 case BUILT_IN_ISLESSGREATER
:
8935 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNEQ_EXPR
, EQ_EXPR
);
8936 case BUILT_IN_ISUNORDERED
:
8937 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNORDERED_EXPR
,
8940 /* We do the folding for va_start in the expander. */
8941 case BUILT_IN_VA_START
:
8944 case BUILT_IN_OBJECT_SIZE
:
8945 return fold_builtin_object_size (arglist
);
8946 case BUILT_IN_MEMCPY_CHK
:
8947 case BUILT_IN_MEMPCPY_CHK
:
8948 case BUILT_IN_MEMMOVE_CHK
:
8949 case BUILT_IN_MEMSET_CHK
:
8950 return fold_builtin_memory_chk (fndecl
, arglist
, NULL_TREE
, ignore
,
8951 DECL_FUNCTION_CODE (fndecl
));
8952 case BUILT_IN_STRCPY_CHK
:
8953 case BUILT_IN_STPCPY_CHK
:
8954 return fold_builtin_stxcpy_chk (fndecl
, arglist
, NULL_TREE
, ignore
,
8955 DECL_FUNCTION_CODE (fndecl
));
8956 case BUILT_IN_STRNCPY_CHK
:
8957 return fold_builtin_strncpy_chk (arglist
, NULL_TREE
);
8958 case BUILT_IN_STRCAT_CHK
:
8959 return fold_builtin_strcat_chk (fndecl
, arglist
);
8960 case BUILT_IN_STRNCAT_CHK
:
8961 return fold_builtin_strncat_chk (fndecl
, arglist
);
8962 case BUILT_IN_SPRINTF_CHK
:
8963 case BUILT_IN_VSPRINTF_CHK
:
8964 return fold_builtin_sprintf_chk (arglist
, DECL_FUNCTION_CODE (fndecl
));
8965 case BUILT_IN_SNPRINTF_CHK
:
8966 case BUILT_IN_VSNPRINTF_CHK
:
8967 return fold_builtin_snprintf_chk (arglist
, NULL_TREE
,
8968 DECL_FUNCTION_CODE (fndecl
));
8970 case BUILT_IN_PRINTF
:
8971 case BUILT_IN_PRINTF_UNLOCKED
:
8972 case BUILT_IN_VPRINTF
:
8973 case BUILT_IN_PRINTF_CHK
:
8974 case BUILT_IN_VPRINTF_CHK
:
8975 return fold_builtin_printf (fndecl
, arglist
, ignore
,
8976 DECL_FUNCTION_CODE (fndecl
));
8978 case BUILT_IN_FPRINTF
:
8979 case BUILT_IN_FPRINTF_UNLOCKED
:
8980 case BUILT_IN_VFPRINTF
:
8981 case BUILT_IN_FPRINTF_CHK
:
8982 case BUILT_IN_VFPRINTF_CHK
:
8983 return fold_builtin_fprintf (fndecl
, arglist
, ignore
,
8984 DECL_FUNCTION_CODE (fndecl
));
8993 /* A wrapper function for builtin folding that prevents warnings for
8994 "statement without effect" and the like, caused by removing the
8995 call node earlier than the warning is generated. */
8998 fold_builtin (tree fndecl
, tree arglist
, bool ignore
)
9000 tree exp
= fold_builtin_1 (fndecl
, arglist
, ignore
);
9003 exp
= build1 (NOP_EXPR
, TREE_TYPE (exp
), exp
);
9004 TREE_NO_WARNING (exp
) = 1;
9010 /* Conveniently construct a function call expression. */
9013 build_function_call_expr (tree fn
, tree arglist
)
9017 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
9018 return fold_build3 (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
9019 call_expr
, arglist
, NULL_TREE
);
9022 /* This function validates the types of a function call argument list
9023 represented as a tree chain of parameters against a specified list
9024 of tree_codes. If the last specifier is a 0, that represents an
9025 ellipses, otherwise the last specifier must be a VOID_TYPE. */
9028 validate_arglist (tree arglist
, ...)
9030 enum tree_code code
;
9034 va_start (ap
, arglist
);
9038 code
= va_arg (ap
, enum tree_code
);
9042 /* This signifies an ellipses, any further arguments are all ok. */
9046 /* This signifies an endlink, if no arguments remain, return
9047 true, otherwise return false. */
9051 /* If no parameters remain or the parameter's code does not
9052 match the specified code, return false. Otherwise continue
9053 checking any remaining arguments. */
9056 if (code
== POINTER_TYPE
)
9058 if (! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
))))
9061 else if (code
!= TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))))
9065 arglist
= TREE_CHAIN (arglist
);
9069 /* We need gotos here since we can only have one VA_CLOSE in a
9077 /* Default target-specific builtin expander that does nothing. */
9080 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
9081 rtx target ATTRIBUTE_UNUSED
,
9082 rtx subtarget ATTRIBUTE_UNUSED
,
9083 enum machine_mode mode ATTRIBUTE_UNUSED
,
9084 int ignore ATTRIBUTE_UNUSED
)
9089 /* Returns true is EXP represents data that would potentially reside
9090 in a readonly section. */
9093 readonly_data_expr (tree exp
)
9097 if (TREE_CODE (exp
) != ADDR_EXPR
)
9100 exp
= get_base_address (TREE_OPERAND (exp
, 0));
9104 /* Make sure we call decl_readonly_section only for trees it
9105 can handle (since it returns true for everything it doesn't
9107 if (TREE_CODE (exp
) == STRING_CST
9108 || TREE_CODE (exp
) == CONSTRUCTOR
9109 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
9110 return decl_readonly_section (exp
, 0);
9115 /* Simplify a call to the strstr builtin.
9117 Return 0 if no simplification was possible, otherwise return the
9118 simplified form of the call as a tree.
9120 The simplified form may be a constant or other expression which
9121 computes the same value, but in a more efficient manner (including
9122 calls to other builtin functions).
9124 The call may contain arguments which need to be evaluated, but
9125 which are not useful to determine the result of the call. In
9126 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9127 COMPOUND_EXPR will be an argument which must be evaluated.
9128 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9129 COMPOUND_EXPR in the chain will contain the tree for the simplified
9130 form of the builtin function call. */
9133 fold_builtin_strstr (tree arglist
, tree type
)
9135 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9139 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9141 const char *p1
, *p2
;
9150 const char *r
= strstr (p1
, p2
);
9154 return build_int_cst (TREE_TYPE (s1
), 0);
9156 /* Return an offset into the constant string argument. */
9157 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9158 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9159 return fold_convert (type
, tem
);
9168 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
9172 /* New argument list transforming strstr(s1, s2) to
9173 strchr(s1, s2[0]). */
9174 arglist
= build_tree_list (NULL_TREE
,
9175 build_int_cst (NULL_TREE
, p2
[0]));
9176 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
9177 return build_function_call_expr (fn
, arglist
);
9181 /* Simplify a call to the strchr builtin.
9183 Return 0 if no simplification was possible, otherwise return the
9184 simplified form of the call as a tree.
9186 The simplified form may be a constant or other expression which
9187 computes the same value, but in a more efficient manner (including
9188 calls to other builtin functions).
9190 The call may contain arguments which need to be evaluated, but
9191 which are not useful to determine the result of the call. In
9192 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9193 COMPOUND_EXPR will be an argument which must be evaluated.
9194 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9195 COMPOUND_EXPR in the chain will contain the tree for the simplified
9196 form of the builtin function call. */
9199 fold_builtin_strchr (tree arglist
, tree type
)
9201 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9205 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9208 if (TREE_CODE (s2
) != INTEGER_CST
)
9218 if (target_char_cast (s2
, &c
))
9224 return build_int_cst (TREE_TYPE (s1
), 0);
9226 /* Return an offset into the constant string argument. */
9227 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9228 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9229 return fold_convert (type
, tem
);
9235 /* Simplify a call to the strrchr builtin.
9237 Return 0 if no simplification was possible, otherwise return the
9238 simplified form of the call as a tree.
9240 The simplified form may be a constant or other expression which
9241 computes the same value, but in a more efficient manner (including
9242 calls to other builtin functions).
9244 The call may contain arguments which need to be evaluated, but
9245 which are not useful to determine the result of the call. In
9246 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9247 COMPOUND_EXPR will be an argument which must be evaluated.
9248 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9249 COMPOUND_EXPR in the chain will contain the tree for the simplified
9250 form of the builtin function call. */
9253 fold_builtin_strrchr (tree arglist
, tree type
)
9255 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9259 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9263 if (TREE_CODE (s2
) != INTEGER_CST
)
9273 if (target_char_cast (s2
, &c
))
9276 r
= strrchr (p1
, c
);
9279 return build_int_cst (TREE_TYPE (s1
), 0);
9281 /* Return an offset into the constant string argument. */
9282 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9283 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9284 return fold_convert (type
, tem
);
9287 if (! integer_zerop (s2
))
9290 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
9294 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
9295 return build_function_call_expr (fn
, arglist
);
9299 /* Simplify a call to the strpbrk builtin.
9301 Return 0 if no simplification was possible, otherwise return the
9302 simplified form of the call as a tree.
9304 The simplified form may be a constant or other expression which
9305 computes the same value, but in a more efficient manner (including
9306 calls to other builtin functions).
9308 The call may contain arguments which need to be evaluated, but
9309 which are not useful to determine the result of the call. In
9310 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9311 COMPOUND_EXPR will be an argument which must be evaluated.
9312 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9313 COMPOUND_EXPR in the chain will contain the tree for the simplified
9314 form of the builtin function call. */
9317 fold_builtin_strpbrk (tree arglist
, tree type
)
9319 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9323 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9325 const char *p1
, *p2
;
9334 const char *r
= strpbrk (p1
, p2
);
9338 return build_int_cst (TREE_TYPE (s1
), 0);
9340 /* Return an offset into the constant string argument. */
9341 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9342 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9343 return fold_convert (type
, tem
);
9347 /* strpbrk(x, "") == NULL.
9348 Evaluate and ignore s1 in case it had side-effects. */
9349 return omit_one_operand (TREE_TYPE (s1
), integer_zero_node
, s1
);
9352 return 0; /* Really call strpbrk. */
9354 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
9358 /* New argument list transforming strpbrk(s1, s2) to
9359 strchr(s1, s2[0]). */
9360 arglist
= build_tree_list (NULL_TREE
,
9361 build_int_cst (NULL_TREE
, p2
[0]));
9362 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
9363 return build_function_call_expr (fn
, arglist
);
9367 /* Simplify a call to the strcat builtin.
9369 Return 0 if no simplification was possible, otherwise return the
9370 simplified form of the call as a tree.
9372 The simplified form may be a constant or other expression which
9373 computes the same value, but in a more efficient manner (including
9374 calls to other builtin functions).
9376 The call may contain arguments which need to be evaluated, but
9377 which are not useful to determine the result of the call. In
9378 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9379 COMPOUND_EXPR will be an argument which must be evaluated.
9380 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9381 COMPOUND_EXPR in the chain will contain the tree for the simplified
9382 form of the builtin function call. */
9385 fold_builtin_strcat (tree arglist
)
9387 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9391 tree dst
= TREE_VALUE (arglist
),
9392 src
= TREE_VALUE (TREE_CHAIN (arglist
));
9393 const char *p
= c_getstr (src
);
9395 /* If the string length is zero, return the dst parameter. */
9396 if (p
&& *p
== '\0')
9403 /* Simplify a call to the strncat builtin.
9405 Return 0 if no simplification was possible, otherwise return the
9406 simplified form of the call as a tree.
9408 The simplified form may be a constant or other expression which
9409 computes the same value, but in a more efficient manner (including
9410 calls to other builtin functions).
9412 The call may contain arguments which need to be evaluated, but
9413 which are not useful to determine the result of the call. In
9414 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9415 COMPOUND_EXPR will be an argument which must be evaluated.
9416 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9417 COMPOUND_EXPR in the chain will contain the tree for the simplified
9418 form of the builtin function call. */
9421 fold_builtin_strncat (tree arglist
)
9423 if (!validate_arglist (arglist
,
9424 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9428 tree dst
= TREE_VALUE (arglist
);
9429 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
9430 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9431 const char *p
= c_getstr (src
);
9433 /* If the requested length is zero, or the src parameter string
9434 length is zero, return the dst parameter. */
9435 if (integer_zerop (len
) || (p
&& *p
== '\0'))
9436 return omit_two_operands (TREE_TYPE (dst
), dst
, src
, len
);
9438 /* If the requested len is greater than or equal to the string
9439 length, call strcat. */
9440 if (TREE_CODE (len
) == INTEGER_CST
&& p
9441 && compare_tree_int (len
, strlen (p
)) >= 0)
9444 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
9445 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
9447 /* If the replacement _DECL isn't initialized, don't do the
9452 return build_function_call_expr (fn
, newarglist
);
9458 /* Simplify a call to the strspn builtin.
9460 Return 0 if no simplification was possible, otherwise return the
9461 simplified form of the call as a tree.
9463 The simplified form may be a constant or other expression which
9464 computes the same value, but in a more efficient manner (including
9465 calls to other builtin functions).
9467 The call may contain arguments which need to be evaluated, but
9468 which are not useful to determine the result of the call. In
9469 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9470 COMPOUND_EXPR will be an argument which must be evaluated.
9471 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9472 COMPOUND_EXPR in the chain will contain the tree for the simplified
9473 form of the builtin function call. */
9476 fold_builtin_strspn (tree arglist
)
9478 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9482 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9483 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9485 /* If both arguments are constants, evaluate at compile-time. */
9488 const size_t r
= strspn (p1
, p2
);
9489 return size_int (r
);
9492 /* If either argument is "", return 0. */
9493 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
9494 /* Evaluate and ignore both arguments in case either one has
9496 return omit_two_operands (integer_type_node
, integer_zero_node
,
9502 /* Simplify a call to the strcspn builtin.
9504 Return 0 if no simplification was possible, otherwise return the
9505 simplified form of the call as a tree.
9507 The simplified form may be a constant or other expression which
9508 computes the same value, but in a more efficient manner (including
9509 calls to other builtin functions).
9511 The call may contain arguments which need to be evaluated, but
9512 which are not useful to determine the result of the call. In
9513 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9514 COMPOUND_EXPR will be an argument which must be evaluated.
9515 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9516 COMPOUND_EXPR in the chain will contain the tree for the simplified
9517 form of the builtin function call. */
9520 fold_builtin_strcspn (tree arglist
)
9522 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9526 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9527 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9529 /* If both arguments are constants, evaluate at compile-time. */
9532 const size_t r
= strcspn (p1
, p2
);
9533 return size_int (r
);
9536 /* If the first argument is "", return 0. */
9537 if (p1
&& *p1
== '\0')
9539 /* Evaluate and ignore argument s2 in case it has
9541 return omit_one_operand (integer_type_node
,
9542 integer_zero_node
, s2
);
9545 /* If the second argument is "", return __builtin_strlen(s1). */
9546 if (p2
&& *p2
== '\0')
9548 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
9549 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
9551 /* If the replacement _DECL isn't initialized, don't do the
9556 return build_function_call_expr (fn
, newarglist
);
9562 /* Fold a call to the fputs builtin. IGNORE is true if the value returned
9563 by the builtin will be ignored. UNLOCKED is true is true if this
9564 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
9565 the known length of the string. Return NULL_TREE if no simplification
9569 fold_builtin_fputs (tree arglist
, bool ignore
, bool unlocked
, tree len
)
9572 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
9573 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
9574 tree fn_fwrite
= unlocked
? implicit_built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
9575 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
9577 /* If the return value is used, or the replacement _DECL isn't
9578 initialized, don't do the transformation. */
9579 if (!ignore
|| !fn_fputc
|| !fn_fwrite
)
9582 /* Verify the arguments in the original call. */
9583 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9587 len
= c_strlen (TREE_VALUE (arglist
), 0);
9589 /* Get the length of the string passed to fputs. If the length
9590 can't be determined, punt. */
9592 || TREE_CODE (len
) != INTEGER_CST
)
9595 switch (compare_tree_int (len
, 1))
9597 case -1: /* length is 0, delete the call entirely . */
9598 return omit_one_operand (integer_type_node
, integer_zero_node
,
9599 TREE_VALUE (TREE_CHAIN (arglist
)));
9601 case 0: /* length is 1, call fputc. */
9603 const char *p
= c_getstr (TREE_VALUE (arglist
));
9607 /* New argument list transforming fputs(string, stream) to
9608 fputc(string[0], stream). */
9609 arglist
= build_tree_list (NULL_TREE
,
9610 TREE_VALUE (TREE_CHAIN (arglist
)));
9611 arglist
= tree_cons (NULL_TREE
,
9612 build_int_cst (NULL_TREE
, p
[0]),
9619 case 1: /* length is greater than 1, call fwrite. */
9623 /* If optimizing for size keep fputs. */
9626 string_arg
= TREE_VALUE (arglist
);
9627 /* New argument list transforming fputs(string, stream) to
9628 fwrite(string, 1, len, stream). */
9629 arglist
= build_tree_list (NULL_TREE
,
9630 TREE_VALUE (TREE_CHAIN (arglist
)));
9631 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
9632 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
9633 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
9641 /* These optimizations are only performed when the result is ignored,
9642 hence there's no need to cast the result to integer_type_node. */
9643 return build_function_call_expr (fn
, arglist
);
9646 /* Fold the new_arg's arguments (ARGLIST). Returns true if there was an error
9647 produced. False otherwise. This is done so that we don't output the error
9648 or warning twice or three times. */
9650 fold_builtin_next_arg (tree arglist
)
9652 tree fntype
= TREE_TYPE (current_function_decl
);
9654 if (TYPE_ARG_TYPES (fntype
) == 0
9655 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
9658 error ("%<va_start%> used in function with fixed args");
9663 /* Evidently an out of date version of <stdarg.h>; can't validate
9664 va_start's second argument, but can still work as intended. */
9665 warning (0, "%<__builtin_next_arg%> called without an argument");
9668 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
9669 when we checked the arguments and if needed issued a warning. */
9670 else if (!TREE_CHAIN (arglist
)
9671 || !integer_zerop (TREE_VALUE (arglist
))
9672 || !integer_zerop (TREE_VALUE (TREE_CHAIN (arglist
)))
9673 || TREE_CHAIN (TREE_CHAIN (arglist
)))
9675 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
9676 tree arg
= TREE_VALUE (arglist
);
9678 if (TREE_CHAIN (arglist
))
9680 error ("%<va_start%> used with too many arguments");
9684 /* Strip off all nops for the sake of the comparison. This
9685 is not quite the same as STRIP_NOPS. It does more.
9686 We must also strip off INDIRECT_EXPR for C++ reference
9688 while (TREE_CODE (arg
) == NOP_EXPR
9689 || TREE_CODE (arg
) == CONVERT_EXPR
9690 || TREE_CODE (arg
) == NON_LVALUE_EXPR
9691 || TREE_CODE (arg
) == INDIRECT_REF
)
9692 arg
= TREE_OPERAND (arg
, 0);
9693 if (arg
!= last_parm
)
9695 /* FIXME: Sometimes with the tree optimizers we can get the
9696 not the last argument even though the user used the last
9697 argument. We just warn and set the arg to be the last
9698 argument so that we will get wrong-code because of
9700 warning (0, "second parameter of %<va_start%> not last named argument");
9702 /* We want to verify the second parameter just once before the tree
9703 optimizers are run and then avoid keeping it in the tree,
9704 as otherwise we could warn even for correct code like:
9705 void foo (int i, ...)
9706 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
9707 TREE_VALUE (arglist
) = integer_zero_node
;
9708 TREE_CHAIN (arglist
) = build_tree_list (NULL
, integer_zero_node
);
9714 /* Simplify a call to the sprintf builtin.
9716 Return 0 if no simplification was possible, otherwise return the
9717 simplified form of the call as a tree. If IGNORED is true, it means that
9718 the caller does not use the returned value of the function. */
9721 fold_builtin_sprintf (tree arglist
, int ignored
)
9723 tree call
, retval
, dest
, fmt
;
9724 const char *fmt_str
= NULL
;
9726 /* Verify the required arguments in the original call. We deal with two
9727 types of sprintf() calls: 'sprintf (str, fmt)' and
9728 'sprintf (dest, "%s", orig)'. */
9729 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
)
9730 && !validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, POINTER_TYPE
,
9734 /* Get the destination string and the format specifier. */
9735 dest
= TREE_VALUE (arglist
);
9736 fmt
= TREE_VALUE (TREE_CHAIN (arglist
));
9738 /* Check whether the format is a literal string constant. */
9739 fmt_str
= c_getstr (fmt
);
9740 if (fmt_str
== NULL
)
9746 /* If the format doesn't contain % args or %%, use strcpy. */
9747 if (strchr (fmt_str
, '%') == NULL
)
9749 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9754 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
9755 'format' is known to contain no % formats. */
9756 arglist
= build_tree_list (NULL_TREE
, fmt
);
9757 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9758 call
= build_function_call_expr (fn
, arglist
);
9760 retval
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
9763 /* If the format is "%s", use strcpy if the result isn't used. */
9764 else if (fmt_str
&& strcmp (fmt_str
, "%s") == 0)
9767 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9772 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
9773 orig
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9774 arglist
= build_tree_list (NULL_TREE
, orig
);
9775 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9778 retval
= c_strlen (orig
, 1);
9779 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
9782 call
= build_function_call_expr (fn
, arglist
);
9788 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls
[BUILT_IN_SPRINTF
])),
9790 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);
9796 /* Expand a call to __builtin_object_size. */
9799 expand_builtin_object_size (tree exp
)
9802 int object_size_type
;
9803 tree fndecl
= get_callee_fndecl (exp
);
9804 tree arglist
= TREE_OPERAND (exp
, 1);
9805 location_t locus
= EXPR_LOCATION (exp
);
9807 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9809 error ("%Hfirst argument of %D must be a pointer, second integer constant",
9811 expand_builtin_trap ();
9815 ost
= TREE_VALUE (TREE_CHAIN (arglist
));
9818 if (TREE_CODE (ost
) != INTEGER_CST
9819 || tree_int_cst_sgn (ost
) < 0
9820 || compare_tree_int (ost
, 3) > 0)
9822 error ("%Hlast argument of %D is not integer constant between 0 and 3",
9824 expand_builtin_trap ();
9828 object_size_type
= tree_low_cst (ost
, 0);
9830 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
9833 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9834 FCODE is the BUILT_IN_* to use.
9835 Return 0 if we failed; the caller should emit a normal call,
9836 otherwise try to get the result in TARGET, if convenient (and in
9837 mode MODE if that's convenient). */
9840 expand_builtin_memory_chk (tree exp
, rtx target
, enum machine_mode mode
,
9841 enum built_in_function fcode
)
9843 tree arglist
= TREE_OPERAND (exp
, 1);
9844 tree dest
, src
, len
, size
;
9846 if (!validate_arglist (arglist
,
9848 fcode
== BUILT_IN_MEMSET_CHK
9849 ? INTEGER_TYPE
: POINTER_TYPE
,
9850 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9853 dest
= TREE_VALUE (arglist
);
9854 src
= TREE_VALUE (TREE_CHAIN (arglist
));
9855 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9856 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
9858 if (! host_integerp (size
, 1))
9861 if (host_integerp (len
, 1) || integer_all_onesp (size
))
9865 if (! integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
9867 location_t locus
= EXPR_LOCATION (exp
);
9868 warning (0, "%Hcall to %D will always overflow destination buffer",
9869 &locus
, get_callee_fndecl (exp
));
9873 arglist
= build_tree_list (NULL_TREE
, len
);
9874 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
9875 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9878 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9879 mem{cpy,pcpy,move,set} is available. */
9882 case BUILT_IN_MEMCPY_CHK
:
9883 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
9885 case BUILT_IN_MEMPCPY_CHK
:
9886 fn
= built_in_decls
[BUILT_IN_MEMPCPY
];
9888 case BUILT_IN_MEMMOVE_CHK
:
9889 fn
= built_in_decls
[BUILT_IN_MEMMOVE
];
9891 case BUILT_IN_MEMSET_CHK
:
9892 fn
= built_in_decls
[BUILT_IN_MEMSET
];
9901 fn
= build_function_call_expr (fn
, arglist
);
9902 if (TREE_CODE (fn
) == CALL_EXPR
)
9903 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
9904 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
9906 else if (fcode
== BUILT_IN_MEMSET_CHK
)
9910 unsigned int dest_align
9911 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
9913 /* If DEST is not a pointer type, call the normal function. */
9914 if (dest_align
== 0)
9917 /* If SRC and DEST are the same (and not volatile), do nothing. */
9918 if (operand_equal_p (src
, dest
, 0))
9922 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
9924 /* Evaluate and ignore LEN in case it has side-effects. */
9925 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
9926 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
9929 len
= fold_convert (TREE_TYPE (dest
), len
);
9930 expr
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
9931 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
9934 /* __memmove_chk special case. */
9935 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
9937 unsigned int src_align
9938 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
9943 /* If src is categorized for a readonly section we can use
9944 normal __memcpy_chk. */
9945 if (readonly_data_expr (src
))
9947 tree fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
9950 fn
= build_function_call_expr (fn
, arglist
);
9951 if (TREE_CODE (fn
) == CALL_EXPR
)
9952 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
9953 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
9960 /* Emit warning if a buffer overflow is detected at compile time. */
9963 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
9965 int arg_mask
, is_strlen
= 0;
9966 tree arglist
= TREE_OPERAND (exp
, 1), a
;
9972 case BUILT_IN_STRCPY_CHK
:
9973 case BUILT_IN_STPCPY_CHK
:
9974 /* For __strcat_chk the warning will be emitted only if overflowing
9975 by at least strlen (dest) + 1 bytes. */
9976 case BUILT_IN_STRCAT_CHK
:
9980 case BUILT_IN_STRNCPY_CHK
:
9983 case BUILT_IN_SNPRINTF_CHK
:
9984 case BUILT_IN_VSNPRINTF_CHK
:
9993 for (a
= arglist
; a
&& arg_mask
; a
= TREE_CHAIN (a
), arg_mask
>>= 1)
10005 len
= TREE_VALUE (len
);
10006 size
= TREE_VALUE (size
);
10008 if (! host_integerp (size
, 1) || integer_all_onesp (size
))
10013 len
= c_strlen (len
, 1);
10014 if (! len
|| ! host_integerp (len
, 1) || tree_int_cst_lt (len
, size
))
10017 else if (! host_integerp (len
, 1) || ! tree_int_cst_lt (size
, len
))
10020 locus
= EXPR_LOCATION (exp
);
10021 warning (0, "%Hcall to %D will always overflow destination buffer",
10022 &locus
, get_callee_fndecl (exp
));
10025 /* Emit warning if a buffer overflow is detected at compile time
10026 in __sprintf_chk/__vsprintf_chk calls. */
10029 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
10031 tree arglist
= TREE_OPERAND (exp
, 1);
10032 tree dest
, size
, len
, fmt
, flag
;
10033 const char *fmt_str
;
10035 /* Verify the required arguments in the original call. */
10038 dest
= TREE_VALUE (arglist
);
10039 arglist
= TREE_CHAIN (arglist
);
10042 flag
= TREE_VALUE (arglist
);
10043 arglist
= TREE_CHAIN (arglist
);
10046 size
= TREE_VALUE (arglist
);
10047 arglist
= TREE_CHAIN (arglist
);
10050 fmt
= TREE_VALUE (arglist
);
10051 arglist
= TREE_CHAIN (arglist
);
10053 if (! host_integerp (size
, 1) || integer_all_onesp (size
))
10056 /* Check whether the format is a literal string constant. */
10057 fmt_str
= c_getstr (fmt
);
10058 if (fmt_str
== NULL
)
10061 /* If the format doesn't contain % args or %%, we know its size. */
10062 if (strchr (fmt_str
, '%') == 0)
10063 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
10064 /* If the format is "%s" and first ... argument is a string literal,
10066 else if (fcode
== BUILT_IN_SPRINTF_CHK
&& strcmp (fmt_str
, "%s") == 0)
10072 arg
= TREE_VALUE (arglist
);
10073 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
10076 len
= c_strlen (arg
, 1);
10077 if (!len
|| ! host_integerp (len
, 1))
10083 if (! tree_int_cst_lt (len
, size
))
10085 location_t locus
= EXPR_LOCATION (exp
);
10086 warning (0, "%Hcall to %D will always overflow destination buffer",
10087 &locus
, get_callee_fndecl (exp
));
10091 /* Fold a call to __builtin_object_size, if possible. */
10094 fold_builtin_object_size (tree arglist
)
10096 tree ptr
, ost
, ret
= 0;
10097 int object_size_type
;
10099 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
10102 ptr
= TREE_VALUE (arglist
);
10103 ost
= TREE_VALUE (TREE_CHAIN (arglist
));
10106 if (TREE_CODE (ost
) != INTEGER_CST
10107 || tree_int_cst_sgn (ost
) < 0
10108 || compare_tree_int (ost
, 3) > 0)
10111 object_size_type
= tree_low_cst (ost
, 0);
10113 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
10114 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
10115 and (size_t) 0 for types 2 and 3. */
10116 if (TREE_SIDE_EFFECTS (ptr
))
10117 return fold_convert (size_type_node
,
10118 object_size_type
< 2
10119 ? integer_minus_one_node
: integer_zero_node
);
10121 if (TREE_CODE (ptr
) == ADDR_EXPR
)
10122 ret
= build_int_cstu (size_type_node
,
10123 compute_builtin_object_size (ptr
, object_size_type
));
10125 else if (TREE_CODE (ptr
) == SSA_NAME
)
10127 unsigned HOST_WIDE_INT bytes
;
10129 /* If object size is not known yet, delay folding until
10130 later. Maybe subsequent passes will help determining
10132 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
10133 if (bytes
!= (unsigned HOST_WIDE_INT
) (object_size_type
< 2
10135 ret
= build_int_cstu (size_type_node
, bytes
);
10140 ret
= force_fit_type (ret
, -1, false, false);
10141 if (TREE_CONSTANT_OVERFLOW (ret
))
10148 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
10149 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
10150 code of the builtin. If MAXLEN is not NULL, it is maximum length
10151 passed as third argument. */
10154 fold_builtin_memory_chk (tree fndecl
, tree arglist
, tree maxlen
, bool ignore
,
10155 enum built_in_function fcode
)
10157 tree dest
, src
, len
, size
, fn
;
10159 if (!validate_arglist (arglist
,
10161 fcode
== BUILT_IN_MEMSET_CHK
10162 ? INTEGER_TYPE
: POINTER_TYPE
,
10163 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
10166 dest
= TREE_VALUE (arglist
);
10167 /* Actually val for __memset_chk, but it doesn't matter. */
10168 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10169 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10170 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
10172 /* If SRC and DEST are the same (and not volatile), return DEST
10173 (resp. DEST+LEN for __mempcpy_chk). */
10174 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
10176 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
10177 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
10180 tree temp
= fold_convert (TREE_TYPE (dest
), len
);
10181 temp
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, temp
);
10182 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), temp
);
10186 if (! host_integerp (size
, 1))
10189 if (! integer_all_onesp (size
))
10191 if (! host_integerp (len
, 1))
10193 /* If LEN is not constant, try MAXLEN too.
10194 For MAXLEN only allow optimizing into non-_ocs function
10195 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10196 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10198 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
10200 /* (void) __mempcpy_chk () can be optimized into
10201 (void) __memcpy_chk (). */
10202 fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
10206 return build_function_call_expr (fn
, arglist
);
10214 if (tree_int_cst_lt (size
, maxlen
))
10218 arglist
= build_tree_list (NULL_TREE
, len
);
10219 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10220 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10223 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
10224 mem{cpy,pcpy,move,set} is available. */
10227 case BUILT_IN_MEMCPY_CHK
:
10228 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
10230 case BUILT_IN_MEMPCPY_CHK
:
10231 fn
= built_in_decls
[BUILT_IN_MEMPCPY
];
10233 case BUILT_IN_MEMMOVE_CHK
:
10234 fn
= built_in_decls
[BUILT_IN_MEMMOVE
];
10236 case BUILT_IN_MEMSET_CHK
:
10237 fn
= built_in_decls
[BUILT_IN_MEMSET
];
10246 return build_function_call_expr (fn
, arglist
);
10249 /* Fold a call to the __st[rp]cpy_chk builtin.
10250 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
10251 code of the builtin. If MAXLEN is not NULL, it is maximum length of
10252 strings passed as second argument. */
10255 fold_builtin_stxcpy_chk (tree fndecl
, tree arglist
, tree maxlen
, bool ignore
,
10256 enum built_in_function fcode
)
10258 tree dest
, src
, size
, len
, fn
;
10260 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10264 dest
= TREE_VALUE (arglist
);
10265 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10266 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10268 /* If SRC and DEST are the same (and not volatile), return DEST. */
10269 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
10270 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
10272 if (! host_integerp (size
, 1))
10275 if (! integer_all_onesp (size
))
10277 len
= c_strlen (src
, 1);
10278 if (! len
|| ! host_integerp (len
, 1))
10280 /* If LEN is not constant, try MAXLEN too.
10281 For MAXLEN only allow optimizing into non-_ocs function
10282 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10283 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10285 if (fcode
== BUILT_IN_STPCPY_CHK
)
10290 /* If return value of __stpcpy_chk is ignored,
10291 optimize into __strcpy_chk. */
10292 fn
= built_in_decls
[BUILT_IN_STRCPY_CHK
];
10296 return build_function_call_expr (fn
, arglist
);
10299 if (! len
|| TREE_SIDE_EFFECTS (len
))
10302 /* If c_strlen returned something, but not a constant,
10303 transform __strcpy_chk into __memcpy_chk. */
10304 fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
10308 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
10309 arglist
= build_tree_list (NULL_TREE
, size
);
10310 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
10311 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10312 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10313 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)),
10314 build_function_call_expr (fn
, arglist
));
10320 if (! tree_int_cst_lt (maxlen
, size
))
10324 arglist
= build_tree_list (NULL_TREE
, src
);
10325 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10327 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
10328 fn
= built_in_decls
[fcode
== BUILT_IN_STPCPY_CHK
10329 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
];
10333 return build_function_call_expr (fn
, arglist
);
10336 /* Fold a call to the __strncpy_chk builtin.
10337 If MAXLEN is not NULL, it is maximum length passed as third argument. */
10340 fold_builtin_strncpy_chk (tree arglist
, tree maxlen
)
10342 tree dest
, src
, size
, len
, fn
;
10344 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10345 INTEGER_TYPE
, VOID_TYPE
))
10348 dest
= TREE_VALUE (arglist
);
10349 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10350 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10351 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
10353 if (! host_integerp (size
, 1))
10356 if (! integer_all_onesp (size
))
10358 if (! host_integerp (len
, 1))
10360 /* If LEN is not constant, try MAXLEN too.
10361 For MAXLEN only allow optimizing into non-_ocs function
10362 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10363 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10369 if (tree_int_cst_lt (size
, maxlen
))
10373 arglist
= build_tree_list (NULL_TREE
, len
);
10374 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10375 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10377 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
10378 fn
= built_in_decls
[BUILT_IN_STRNCPY
];
10382 return build_function_call_expr (fn
, arglist
);
10385 /* Fold a call to the __strcat_chk builtin FNDECL with ARGLIST. */
10388 fold_builtin_strcat_chk (tree fndecl
, tree arglist
)
10390 tree dest
, src
, size
, fn
;
10393 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10397 dest
= TREE_VALUE (arglist
);
10398 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10399 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10401 p
= c_getstr (src
);
10402 /* If the SRC parameter is "", return DEST. */
10403 if (p
&& *p
== '\0')
10404 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
10406 if (! host_integerp (size
, 1) || ! integer_all_onesp (size
))
10409 arglist
= build_tree_list (NULL_TREE
, src
);
10410 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10412 /* If __builtin_strcat_chk is used, assume strcat is available. */
10413 fn
= built_in_decls
[BUILT_IN_STRCAT
];
10417 return build_function_call_expr (fn
, arglist
);
10420 /* Fold a call to the __strncat_chk builtin EXP. */
10423 fold_builtin_strncat_chk (tree fndecl
, tree arglist
)
10425 tree dest
, src
, size
, len
, fn
;
10428 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10429 INTEGER_TYPE
, VOID_TYPE
))
10432 dest
= TREE_VALUE (arglist
);
10433 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10434 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10435 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
10437 p
= c_getstr (src
);
10438 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
10439 if (p
&& *p
== '\0')
10440 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
10441 else if (integer_zerop (len
))
10442 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
10444 if (! host_integerp (size
, 1))
10447 if (! integer_all_onesp (size
))
10449 tree src_len
= c_strlen (src
, 1);
10451 && host_integerp (src_len
, 1)
10452 && host_integerp (len
, 1)
10453 && ! tree_int_cst_lt (len
, src_len
))
10455 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
10456 fn
= built_in_decls
[BUILT_IN_STRCAT_CHK
];
10460 arglist
= build_tree_list (NULL_TREE
, size
);
10461 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10462 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10463 return build_function_call_expr (fn
, arglist
);
10468 arglist
= build_tree_list (NULL_TREE
, len
);
10469 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10470 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10472 /* If __builtin_strncat_chk is used, assume strncat is available. */
10473 fn
= built_in_decls
[BUILT_IN_STRNCAT
];
10477 return build_function_call_expr (fn
, arglist
);
10480 /* Fold a call to __{,v}sprintf_chk with argument list ARGLIST. Return 0 if
10481 a normal call should be emitted rather than expanding the function
10482 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
10485 fold_builtin_sprintf_chk (tree arglist
, enum built_in_function fcode
)
10487 tree dest
, size
, len
, fn
, fmt
, flag
;
10488 const char *fmt_str
;
10490 /* Verify the required arguments in the original call. */
10493 dest
= TREE_VALUE (arglist
);
10494 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
10496 arglist
= TREE_CHAIN (arglist
);
10499 flag
= TREE_VALUE (arglist
);
10500 if (TREE_CODE (TREE_TYPE (flag
)) != INTEGER_TYPE
)
10502 arglist
= TREE_CHAIN (arglist
);
10505 size
= TREE_VALUE (arglist
);
10506 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
)
10508 arglist
= TREE_CHAIN (arglist
);
10511 fmt
= TREE_VALUE (arglist
);
10512 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10514 arglist
= TREE_CHAIN (arglist
);
10516 if (! host_integerp (size
, 1))
10521 /* Check whether the format is a literal string constant. */
10522 fmt_str
= c_getstr (fmt
);
10523 if (fmt_str
!= NULL
)
10525 /* If the format doesn't contain % args or %%, we know the size. */
10526 if (strchr (fmt_str
, '%') == 0)
10528 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| arglist
== NULL_TREE
)
10529 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
10531 /* If the format is "%s" and first ... argument is a string literal,
10532 we know the size too. */
10533 else if (fcode
== BUILT_IN_SPRINTF_CHK
&& strcmp (fmt_str
, "%s") == 0)
10537 if (arglist
&& !TREE_CHAIN (arglist
))
10539 arg
= TREE_VALUE (arglist
);
10540 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
10542 len
= c_strlen (arg
, 1);
10543 if (! len
|| ! host_integerp (len
, 1))
10550 if (! integer_all_onesp (size
))
10552 if (! len
|| ! tree_int_cst_lt (len
, size
))
10556 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
10557 or if format doesn't contain % chars or is "%s". */
10558 if (! integer_zerop (flag
))
10560 if (fmt_str
== NULL
)
10562 if (strchr (fmt_str
, '%') != NULL
&& strcmp (fmt_str
, "%s"))
10566 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
10567 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10569 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
10570 fn
= built_in_decls
[fcode
== BUILT_IN_VSPRINTF_CHK
10571 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
];
10575 return build_function_call_expr (fn
, arglist
);
10578 /* Fold a call to {,v}snprintf with argument list ARGLIST. Return 0 if
10579 a normal call should be emitted rather than expanding the function
10580 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
10581 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
10582 passed as second argument. */
10585 fold_builtin_snprintf_chk (tree arglist
, tree maxlen
,
10586 enum built_in_function fcode
)
10588 tree dest
, size
, len
, fn
, fmt
, flag
;
10589 const char *fmt_str
;
10591 /* Verify the required arguments in the original call. */
10594 dest
= TREE_VALUE (arglist
);
10595 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
10597 arglist
= TREE_CHAIN (arglist
);
10600 len
= TREE_VALUE (arglist
);
10601 if (TREE_CODE (TREE_TYPE (len
)) != INTEGER_TYPE
)
10603 arglist
= TREE_CHAIN (arglist
);
10606 flag
= TREE_VALUE (arglist
);
10607 if (TREE_CODE (TREE_TYPE (len
)) != INTEGER_TYPE
)
10609 arglist
= TREE_CHAIN (arglist
);
10612 size
= TREE_VALUE (arglist
);
10613 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
)
10615 arglist
= TREE_CHAIN (arglist
);
10618 fmt
= TREE_VALUE (arglist
);
10619 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10621 arglist
= TREE_CHAIN (arglist
);
10623 if (! host_integerp (size
, 1))
10626 if (! integer_all_onesp (size
))
10628 if (! host_integerp (len
, 1))
10630 /* If LEN is not constant, try MAXLEN too.
10631 For MAXLEN only allow optimizing into non-_ocs function
10632 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10633 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10639 if (tree_int_cst_lt (size
, maxlen
))
10643 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
10644 or if format doesn't contain % chars or is "%s". */
10645 if (! integer_zerop (flag
))
10647 fmt_str
= c_getstr (fmt
);
10648 if (fmt_str
== NULL
)
10650 if (strchr (fmt_str
, '%') != NULL
&& strcmp (fmt_str
, "%s"))
10654 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
10655 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
10656 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10658 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
10660 fn
= built_in_decls
[fcode
== BUILT_IN_VSNPRINTF_CHK
10661 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
];
10665 return build_function_call_expr (fn
, arglist
);
10668 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
10670 Return 0 if no simplification was possible, otherwise return the
10671 simplified form of the call as a tree. FCODE is the BUILT_IN_*
10672 code of the function to be simplified. */
10675 fold_builtin_printf (tree fndecl
, tree arglist
, bool ignore
,
10676 enum built_in_function fcode
)
10678 tree fmt
, fn
= NULL_TREE
, fn_putchar
, fn_puts
, arg
, call
;
10679 const char *fmt_str
= NULL
;
10681 /* If the return value is used, don't do the transformation. */
10685 /* Verify the required arguments in the original call. */
10686 if (fcode
== BUILT_IN_PRINTF_CHK
|| fcode
== BUILT_IN_VPRINTF_CHK
)
10692 flag
= TREE_VALUE (arglist
);
10693 if (TREE_CODE (TREE_TYPE (flag
)) != INTEGER_TYPE
10694 || TREE_SIDE_EFFECTS (flag
))
10696 arglist
= TREE_CHAIN (arglist
);
10701 fmt
= TREE_VALUE (arglist
);
10702 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10704 arglist
= TREE_CHAIN (arglist
);
10706 /* Check whether the format is a literal string constant. */
10707 fmt_str
= c_getstr (fmt
);
10708 if (fmt_str
== NULL
)
10711 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
10713 fn_putchar
= implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
];
10714 fn_puts
= implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
];
10718 fn_putchar
= implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
10719 fn_puts
= implicit_built_in_decls
[BUILT_IN_PUTS
];
10722 if (strcmp (fmt_str
, "%s") == 0 || strchr (fmt_str
, '%') == NULL
)
10726 if (strcmp (fmt_str
, "%s") == 0)
10728 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
10732 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
10733 || TREE_CHAIN (arglist
))
10736 str
= c_getstr (TREE_VALUE (arglist
));
10742 /* The format specifier doesn't contain any '%' characters. */
10743 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
10749 /* If the string was "", printf does nothing. */
10750 if (str
[0] == '\0')
10751 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
10753 /* If the string has length of 1, call putchar. */
10754 if (str
[1] == '\0')
10756 /* Given printf("c"), (where c is any one character,)
10757 convert "c"[0] to an int and pass that to the replacement
10759 arg
= build_int_cst (NULL_TREE
, str
[0]);
10760 arglist
= build_tree_list (NULL_TREE
, arg
);
10765 /* If the string was "string\n", call puts("string"). */
10766 size_t len
= strlen (str
);
10767 if (str
[len
- 1] == '\n')
10769 /* Create a NUL-terminated string that's one char shorter
10770 than the original, stripping off the trailing '\n'. */
10771 char *newstr
= alloca (len
);
10772 memcpy (newstr
, str
, len
- 1);
10773 newstr
[len
- 1] = 0;
10775 arg
= build_string_literal (len
, newstr
);
10776 arglist
= build_tree_list (NULL_TREE
, arg
);
10780 /* We'd like to arrange to call fputs(string,stdout) here,
10781 but we need stdout and don't have a way to get it yet. */
10786 /* The other optimizations can be done only on the non-va_list variants. */
10787 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
10790 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
10791 else if (strcmp (fmt_str
, "%s\n") == 0)
10794 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
10795 || TREE_CHAIN (arglist
))
10800 /* If the format specifier was "%c", call __builtin_putchar(arg). */
10801 else if (strcmp (fmt_str
, "%c") == 0)
10804 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
10805 || TREE_CHAIN (arglist
))
10813 call
= build_function_call_expr (fn
, arglist
);
10814 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), call
);
10817 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
10819 Return 0 if no simplification was possible, otherwise return the
10820 simplified form of the call as a tree. FCODE is the BUILT_IN_*
10821 code of the function to be simplified. */
10824 fold_builtin_fprintf (tree fndecl
, tree arglist
, bool ignore
,
10825 enum built_in_function fcode
)
10827 tree fp
, fmt
, fn
= NULL_TREE
, fn_fputc
, fn_fputs
, arg
, call
;
10828 const char *fmt_str
= NULL
;
10830 /* If the return value is used, don't do the transformation. */
10834 /* Verify the required arguments in the original call. */
10837 fp
= TREE_VALUE (arglist
);
10838 if (! POINTER_TYPE_P (TREE_TYPE (fp
)))
10840 arglist
= TREE_CHAIN (arglist
);
10842 if (fcode
== BUILT_IN_FPRINTF_CHK
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
10848 flag
= TREE_VALUE (arglist
);
10849 if (TREE_CODE (TREE_TYPE (flag
)) != INTEGER_TYPE
10850 || TREE_SIDE_EFFECTS (flag
))
10852 arglist
= TREE_CHAIN (arglist
);
10857 fmt
= TREE_VALUE (arglist
);
10858 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10860 arglist
= TREE_CHAIN (arglist
);
10862 /* Check whether the format is a literal string constant. */
10863 fmt_str
= c_getstr (fmt
);
10864 if (fmt_str
== NULL
)
10867 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
10869 fn_fputc
= implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
];
10870 fn_fputs
= implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
];
10874 fn_fputc
= implicit_built_in_decls
[BUILT_IN_FPUTC
];
10875 fn_fputs
= implicit_built_in_decls
[BUILT_IN_FPUTS
];
10878 /* If the format doesn't contain % args or %%, use strcpy. */
10879 if (strchr (fmt_str
, '%') == NULL
)
10881 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
10885 /* If the format specifier was "", fprintf does nothing. */
10886 if (fmt_str
[0] == '\0')
10888 /* If FP has side-effects, just wait until gimplification is
10890 if (TREE_SIDE_EFFECTS (fp
))
10893 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
10896 /* When "string" doesn't contain %, replace all cases of
10897 fprintf (fp, string) with fputs (string, fp). The fputs
10898 builtin will take care of special cases like length == 1. */
10899 arglist
= build_tree_list (NULL_TREE
, fp
);
10900 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
10904 /* The other optimizations can be done only on the non-va_list variants. */
10905 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
10908 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
10909 else if (strcmp (fmt_str
, "%s") == 0)
10912 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
10913 || TREE_CHAIN (arglist
))
10915 arg
= TREE_VALUE (arglist
);
10916 arglist
= build_tree_list (NULL_TREE
, fp
);
10917 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
10921 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
10922 else if (strcmp (fmt_str
, "%c") == 0)
10925 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
10926 || TREE_CHAIN (arglist
))
10928 arg
= TREE_VALUE (arglist
);
10929 arglist
= build_tree_list (NULL_TREE
, fp
);
10930 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
10937 call
= build_function_call_expr (fn
, arglist
);
10938 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), call
);