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 int apply_args_size (void);
80 static int apply_result_size (void);
81 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
82 static rtx
result_vector (int, rtx
);
84 static rtx
expand_builtin_setjmp (tree
, rtx
);
85 static void expand_builtin_update_setjmp_buf (rtx
);
86 static void expand_builtin_prefetch (tree
);
87 static rtx
expand_builtin_apply_args (void);
88 static rtx
expand_builtin_apply_args_1 (void);
89 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
90 static void expand_builtin_return (rtx
);
91 static enum type_class
type_to_class (tree
);
92 static rtx
expand_builtin_classify_type (tree
);
93 static void expand_errno_check (tree
, rtx
);
94 static rtx
expand_builtin_mathfn (tree
, rtx
, rtx
);
95 static rtx
expand_builtin_mathfn_2 (tree
, rtx
, rtx
);
96 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
97 static rtx
expand_builtin_sincos (tree
);
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
);
202 static bool init_target_chars (void);
204 static unsigned HOST_WIDE_INT target_newline
;
205 static unsigned HOST_WIDE_INT target_percent
;
206 static unsigned HOST_WIDE_INT target_c
;
207 static unsigned HOST_WIDE_INT target_s
;
208 static char target_percent_c
[3];
209 static char target_percent_s
[3];
210 static char target_percent_s_newline
[4];
212 /* Return true if NODE should be considered for inline expansion regardless
213 of the optimization level. This means whenever a function is invoked with
214 its "internal" name, which normally contains the prefix "__builtin". */
216 static bool called_as_built_in (tree node
)
218 const char *name
= IDENTIFIER_POINTER (DECL_NAME (node
));
219 if (strncmp (name
, "__builtin_", 10) == 0)
221 if (strncmp (name
, "__sync_", 7) == 0)
226 /* Return the alignment in bits of EXP, a pointer valued expression.
227 But don't return more than MAX_ALIGN no matter what.
228 The alignment returned is, by default, the alignment of the thing that
229 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
231 Otherwise, look at the expression to see if we can do better, i.e., if the
232 expression is actually pointing at an object whose alignment is tighter. */
235 get_pointer_alignment (tree exp
, unsigned int max_align
)
237 unsigned int align
, inner
;
239 if (! POINTER_TYPE_P (TREE_TYPE (exp
)))
242 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
243 align
= MIN (align
, max_align
);
247 switch (TREE_CODE (exp
))
251 case NON_LVALUE_EXPR
:
252 exp
= TREE_OPERAND (exp
, 0);
253 if (! POINTER_TYPE_P (TREE_TYPE (exp
)))
256 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
257 align
= MIN (inner
, max_align
);
261 /* If sum of pointer + int, restrict our maximum alignment to that
262 imposed by the integer. If not, we can't do any better than
264 if (! host_integerp (TREE_OPERAND (exp
, 1), 1))
267 while (((tree_low_cst (TREE_OPERAND (exp
, 1), 1))
268 & (max_align
/ BITS_PER_UNIT
- 1))
272 exp
= TREE_OPERAND (exp
, 0);
276 /* See what we are pointing at and look at its alignment. */
277 exp
= TREE_OPERAND (exp
, 0);
278 if (TREE_CODE (exp
) == FUNCTION_DECL
)
279 align
= FUNCTION_BOUNDARY
;
280 else if (DECL_P (exp
))
281 align
= DECL_ALIGN (exp
);
282 #ifdef CONSTANT_ALIGNMENT
283 else if (CONSTANT_CLASS_P (exp
))
284 align
= CONSTANT_ALIGNMENT (exp
, align
);
286 return MIN (align
, max_align
);
294 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
295 way, because it could contain a zero byte in the middle.
296 TREE_STRING_LENGTH is the size of the character array, not the string.
298 ONLY_VALUE should be nonzero if the result is not going to be emitted
299 into the instruction stream and zero if it is going to be expanded.
300 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
301 is returned, otherwise NULL, since
302 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
303 evaluate the side-effects.
305 The value returned is of type `ssizetype'.
307 Unfortunately, string_constant can't access the values of const char
308 arrays with initializers, so neither can we do so here. */
311 c_strlen (tree src
, int only_value
)
314 HOST_WIDE_INT offset
;
319 if (TREE_CODE (src
) == COND_EXPR
320 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
324 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
325 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
326 if (tree_int_cst_equal (len1
, len2
))
330 if (TREE_CODE (src
) == COMPOUND_EXPR
331 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
332 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
334 src
= string_constant (src
, &offset_node
);
338 max
= TREE_STRING_LENGTH (src
) - 1;
339 ptr
= TREE_STRING_POINTER (src
);
341 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
343 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
344 compute the offset to the following null if we don't know where to
345 start searching for it. */
348 for (i
= 0; i
< max
; i
++)
352 /* We don't know the starting offset, but we do know that the string
353 has no internal zero bytes. We can assume that the offset falls
354 within the bounds of the string; otherwise, the programmer deserves
355 what he gets. Subtract the offset from the length of the string,
356 and return that. This would perhaps not be valid if we were dealing
357 with named arrays in addition to literal string constants. */
359 return size_diffop (size_int (max
), offset_node
);
362 /* We have a known offset into the string. Start searching there for
363 a null character if we can represent it as a single HOST_WIDE_INT. */
364 if (offset_node
== 0)
366 else if (! host_integerp (offset_node
, 0))
369 offset
= tree_low_cst (offset_node
, 0);
371 /* If the offset is known to be out of bounds, warn, and call strlen at
373 if (offset
< 0 || offset
> max
)
375 warning (0, "offset outside bounds of constant string");
379 /* Use strlen to search for the first zero byte. Since any strings
380 constructed with build_string will have nulls appended, we win even
381 if we get handed something like (char[4])"abcd".
383 Since OFFSET is our starting index into the string, no further
384 calculation is needed. */
385 return ssize_int (strlen (ptr
+ offset
));
388 /* Return a char pointer for a C string if it is a string constant
389 or sum of string constant and integer constant. */
396 src
= string_constant (src
, &offset_node
);
400 if (offset_node
== 0)
401 return TREE_STRING_POINTER (src
);
402 else if (!host_integerp (offset_node
, 1)
403 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
406 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
409 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
410 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
413 c_readstr (const char *str
, enum machine_mode mode
)
419 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
424 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
427 if (WORDS_BIG_ENDIAN
)
428 j
= GET_MODE_SIZE (mode
) - i
- 1;
429 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
430 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
431 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
433 gcc_assert (j
<= 2 * HOST_BITS_PER_WIDE_INT
);
436 ch
= (unsigned char) str
[i
];
437 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
439 return immed_double_const (c
[0], c
[1], mode
);
442 /* Cast a target constant CST to target CHAR and if that value fits into
443 host char type, return zero and put that value into variable pointed to by
447 target_char_cast (tree cst
, char *p
)
449 unsigned HOST_WIDE_INT val
, hostval
;
451 if (!host_integerp (cst
, 1)
452 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
455 val
= tree_low_cst (cst
, 1);
456 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
457 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
460 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
461 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
470 /* Similar to save_expr, but assumes that arbitrary code is not executed
471 in between the multiple evaluations. In particular, we assume that a
472 non-addressable local variable will not be modified. */
475 builtin_save_expr (tree exp
)
477 if (TREE_ADDRESSABLE (exp
) == 0
478 && (TREE_CODE (exp
) == PARM_DECL
479 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
))))
482 return save_expr (exp
);
485 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
486 times to get the address of either a higher stack frame, or a return
487 address located within it (depending on FNDECL_CODE). */
490 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
494 #ifdef INITIAL_FRAME_ADDRESS_RTX
495 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
499 /* For a zero count, we don't care what frame address we return, so frame
500 pointer elimination is OK, and using the soft frame pointer is OK.
501 For a non-zero count, we require a stable offset from the current frame
502 pointer to the previous one, so we must use the hard frame pointer, and
503 we must disable frame pointer elimination. */
505 tem
= frame_pointer_rtx
;
508 tem
= hard_frame_pointer_rtx
;
510 /* Tell reload not to eliminate the frame pointer. */
511 current_function_accesses_prior_frames
= 1;
515 /* Some machines need special handling before we can access
516 arbitrary frames. For example, on the sparc, we must first flush
517 all register windows to the stack. */
518 #ifdef SETUP_FRAME_ADDRESSES
520 SETUP_FRAME_ADDRESSES ();
523 /* On the sparc, the return address is not in the frame, it is in a
524 register. There is no way to access it off of the current frame
525 pointer, but it can be accessed off the previous frame pointer by
526 reading the value from the register window save area. */
527 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
528 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
532 /* Scan back COUNT frames to the specified frame. */
533 for (i
= 0; i
< count
; i
++)
535 /* Assume the dynamic chain pointer is in the word that the
536 frame address points to, unless otherwise specified. */
537 #ifdef DYNAMIC_CHAIN_ADDRESS
538 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
540 tem
= memory_address (Pmode
, tem
);
541 tem
= gen_frame_mem (Pmode
, tem
);
542 tem
= copy_to_reg (tem
);
545 /* For __builtin_frame_address, return what we've got. */
546 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
549 /* For __builtin_return_address, Get the return address from that
551 #ifdef RETURN_ADDR_RTX
552 tem
= RETURN_ADDR_RTX (count
, tem
);
554 tem
= memory_address (Pmode
,
555 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
556 tem
= gen_frame_mem (Pmode
, tem
);
561 /* Alias set used for setjmp buffer. */
562 static HOST_WIDE_INT setjmp_alias_set
= -1;
564 /* Construct the leading half of a __builtin_setjmp call. Control will
565 return to RECEIVER_LABEL. This is used directly by sjlj exception
569 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
571 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
575 if (setjmp_alias_set
== -1)
576 setjmp_alias_set
= new_alias_set ();
578 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
580 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
582 /* We store the frame pointer and the address of receiver_label in
583 the buffer and use the rest of it for the stack save area, which
584 is machine-dependent. */
586 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
587 set_mem_alias_set (mem
, setjmp_alias_set
);
588 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
590 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
591 set_mem_alias_set (mem
, setjmp_alias_set
);
593 emit_move_insn (validize_mem (mem
),
594 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
596 stack_save
= gen_rtx_MEM (sa_mode
,
597 plus_constant (buf_addr
,
598 2 * GET_MODE_SIZE (Pmode
)));
599 set_mem_alias_set (stack_save
, setjmp_alias_set
);
600 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
602 /* If there is further processing to do, do it. */
603 #ifdef HAVE_builtin_setjmp_setup
604 if (HAVE_builtin_setjmp_setup
)
605 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
608 /* Tell optimize_save_area_alloca that extra work is going to
609 need to go on during alloca. */
610 current_function_calls_setjmp
= 1;
612 /* Set this so all the registers get saved in our frame; we need to be
613 able to copy the saved values for any registers from frames we unwind. */
614 current_function_has_nonlocal_label
= 1;
617 /* Construct the trailing part of a __builtin_setjmp call.
618 This is used directly by sjlj exception handling code. */
621 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
623 /* Clobber the FP when we get here, so we have to make sure it's
624 marked as used by this function. */
625 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
627 /* Mark the static chain as clobbered here so life information
628 doesn't get messed up for it. */
629 emit_insn (gen_rtx_CLOBBER (VOIDmode
, static_chain_rtx
));
631 /* Now put in the code to restore the frame pointer, and argument
632 pointer, if needed. */
633 #ifdef HAVE_nonlocal_goto
634 if (! HAVE_nonlocal_goto
)
636 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
638 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
639 if (fixed_regs
[ARG_POINTER_REGNUM
])
641 #ifdef ELIMINABLE_REGS
643 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
645 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
646 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
647 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
650 if (i
== ARRAY_SIZE (elim_regs
))
653 /* Now restore our arg pointer from the address at which it
654 was saved in our stack frame. */
655 emit_move_insn (virtual_incoming_args_rtx
,
656 copy_to_reg (get_arg_pointer_save_area (cfun
)));
661 #ifdef HAVE_builtin_setjmp_receiver
662 if (HAVE_builtin_setjmp_receiver
)
663 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
666 #ifdef HAVE_nonlocal_goto_receiver
667 if (HAVE_nonlocal_goto_receiver
)
668 emit_insn (gen_nonlocal_goto_receiver ());
673 /* @@@ This is a kludge. Not all machine descriptions define a blockage
674 insn, but we must not allow the code we just generated to be reordered
675 by scheduling. Specifically, the update of the frame pointer must
676 happen immediately, not later. So emit an ASM_INPUT to act as blockage
678 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
681 /* __builtin_setjmp is passed a pointer to an array of five words (not
682 all will be used on all machines). It operates similarly to the C
683 library function of the same name, but is more efficient. Much of
684 the code below (and for longjmp) is copied from the handling of
687 NOTE: This is intended for use by GNAT and the exception handling
688 scheme in the compiler and will only work in the method used by
692 expand_builtin_setjmp (tree arglist
, rtx target
)
694 rtx buf_addr
, next_lab
, cont_lab
;
696 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
699 if (target
== 0 || !REG_P (target
)
700 || REGNO (target
) < FIRST_PSEUDO_REGISTER
)
701 target
= gen_reg_rtx (TYPE_MODE (integer_type_node
));
703 buf_addr
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
705 next_lab
= gen_label_rtx ();
706 cont_lab
= gen_label_rtx ();
708 expand_builtin_setjmp_setup (buf_addr
, next_lab
);
710 /* Set TARGET to zero and branch to the continue label. Use emit_jump to
711 ensure that pending stack adjustments are flushed. */
712 emit_move_insn (target
, const0_rtx
);
713 emit_jump (cont_lab
);
715 emit_label (next_lab
);
717 expand_builtin_setjmp_receiver (next_lab
);
719 /* Set TARGET to one. */
720 emit_move_insn (target
, const1_rtx
);
721 emit_label (cont_lab
);
723 /* Tell flow about the strange goings on. Putting `next_lab' on
724 `nonlocal_goto_handler_labels' to indicates that function
725 calls may traverse the arc back to this label. */
727 current_function_has_nonlocal_label
= 1;
728 nonlocal_goto_handler_labels
729 = gen_rtx_EXPR_LIST (VOIDmode
, next_lab
, nonlocal_goto_handler_labels
);
734 /* __builtin_longjmp is passed a pointer to an array of five words (not
735 all will be used on all machines). It operates similarly to the C
736 library function of the same name, but is more efficient. Much of
737 the code below is copied from the handling of non-local gotos.
739 NOTE: This is intended for use by GNAT and the exception handling
740 scheme in the compiler and will only work in the method used by
744 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
746 rtx fp
, lab
, stack
, insn
, last
;
747 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
749 if (setjmp_alias_set
== -1)
750 setjmp_alias_set
= new_alias_set ();
752 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
754 buf_addr
= force_reg (Pmode
, buf_addr
);
756 /* We used to store value in static_chain_rtx, but that fails if pointers
757 are smaller than integers. We instead require that the user must pass
758 a second argument of 1, because that is what builtin_setjmp will
759 return. This also makes EH slightly more efficient, since we are no
760 longer copying around a value that we don't care about. */
761 gcc_assert (value
== const1_rtx
);
763 last
= get_last_insn ();
764 #ifdef HAVE_builtin_longjmp
765 if (HAVE_builtin_longjmp
)
766 emit_insn (gen_builtin_longjmp (buf_addr
));
770 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
771 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
772 GET_MODE_SIZE (Pmode
)));
774 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
775 2 * GET_MODE_SIZE (Pmode
)));
776 set_mem_alias_set (fp
, setjmp_alias_set
);
777 set_mem_alias_set (lab
, setjmp_alias_set
);
778 set_mem_alias_set (stack
, setjmp_alias_set
);
780 /* Pick up FP, label, and SP from the block and jump. This code is
781 from expand_goto in stmt.c; see there for detailed comments. */
782 #if HAVE_nonlocal_goto
783 if (HAVE_nonlocal_goto
)
784 /* We have to pass a value to the nonlocal_goto pattern that will
785 get copied into the static_chain pointer, but it does not matter
786 what that value is, because builtin_setjmp does not use it. */
787 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
791 lab
= copy_to_reg (lab
);
793 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
794 gen_rtx_MEM (BLKmode
,
795 gen_rtx_SCRATCH (VOIDmode
))));
796 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
797 gen_rtx_MEM (BLKmode
,
798 hard_frame_pointer_rtx
)));
800 emit_move_insn (hard_frame_pointer_rtx
, fp
);
801 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
803 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
804 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
805 emit_indirect_jump (lab
);
809 /* Search backwards and mark the jump insn as a non-local goto.
810 Note that this precludes the use of __builtin_longjmp to a
811 __builtin_setjmp target in the same function. However, we've
812 already cautioned the user that these functions are for
813 internal exception handling use only. */
814 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
816 gcc_assert (insn
!= last
);
820 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
, const0_rtx
,
824 else if (CALL_P (insn
))
829 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
830 and the address of the save area. */
833 expand_builtin_nonlocal_goto (tree arglist
)
835 tree t_label
, t_save_area
;
836 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
838 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
841 t_label
= TREE_VALUE (arglist
);
842 arglist
= TREE_CHAIN (arglist
);
843 t_save_area
= TREE_VALUE (arglist
);
845 r_label
= expand_expr (t_label
, NULL_RTX
, VOIDmode
, 0);
846 r_label
= convert_memory_address (Pmode
, r_label
);
847 r_save_area
= expand_expr (t_save_area
, NULL_RTX
, VOIDmode
, 0);
848 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
849 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
850 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
851 plus_constant (r_save_area
, GET_MODE_SIZE (Pmode
)));
853 current_function_has_nonlocal_goto
= 1;
855 #if HAVE_nonlocal_goto
856 /* ??? We no longer need to pass the static chain value, afaik. */
857 if (HAVE_nonlocal_goto
)
858 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
862 r_label
= copy_to_reg (r_label
);
864 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
865 gen_rtx_MEM (BLKmode
,
866 gen_rtx_SCRATCH (VOIDmode
))));
868 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
869 gen_rtx_MEM (BLKmode
,
870 hard_frame_pointer_rtx
)));
872 /* Restore frame pointer for containing function.
873 This sets the actual hard register used for the frame pointer
874 to the location of the function's incoming static chain info.
875 The non-local goto handler will then adjust it to contain the
876 proper value and reload the argument pointer, if needed. */
877 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
878 emit_stack_restore (SAVE_NONLOCAL
, r_sp
, NULL_RTX
);
880 /* USE of hard_frame_pointer_rtx added for consistency;
881 not clear if really needed. */
882 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
883 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
884 emit_indirect_jump (r_label
);
887 /* Search backwards to the jump insn and mark it as a
889 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
893 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
,
894 const0_rtx
, REG_NOTES (insn
));
897 else if (CALL_P (insn
))
904 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
905 (not all will be used on all machines) that was passed to __builtin_setjmp.
906 It updates the stack pointer in that block to correspond to the current
910 expand_builtin_update_setjmp_buf (rtx buf_addr
)
912 enum machine_mode sa_mode
= Pmode
;
916 #ifdef HAVE_save_stack_nonlocal
917 if (HAVE_save_stack_nonlocal
)
918 sa_mode
= insn_data
[(int) CODE_FOR_save_stack_nonlocal
].operand
[0].mode
;
920 #ifdef STACK_SAVEAREA_MODE
921 sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
925 = gen_rtx_MEM (sa_mode
,
928 plus_constant (buf_addr
, 2 * GET_MODE_SIZE (Pmode
))));
932 emit_insn (gen_setjmp ());
935 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
938 /* Expand a call to __builtin_prefetch. For a target that does not support
939 data prefetch, evaluate the memory address argument in case it has side
943 expand_builtin_prefetch (tree arglist
)
945 tree arg0
, arg1
, arg2
;
948 if (!validate_arglist (arglist
, POINTER_TYPE
, 0))
951 arg0
= TREE_VALUE (arglist
);
952 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
953 zero (read) and argument 2 (locality) defaults to 3 (high degree of
955 if (TREE_CHAIN (arglist
))
957 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
958 if (TREE_CHAIN (TREE_CHAIN (arglist
)))
959 arg2
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
961 arg2
= build_int_cst (NULL_TREE
, 3);
965 arg1
= integer_zero_node
;
966 arg2
= build_int_cst (NULL_TREE
, 3);
969 /* Argument 0 is an address. */
970 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
972 /* Argument 1 (read/write flag) must be a compile-time constant int. */
973 if (TREE_CODE (arg1
) != INTEGER_CST
)
975 error ("second argument to %<__builtin_prefetch%> must be a constant");
976 arg1
= integer_zero_node
;
978 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
979 /* Argument 1 must be either zero or one. */
980 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
982 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
987 /* Argument 2 (locality) must be a compile-time constant int. */
988 if (TREE_CODE (arg2
) != INTEGER_CST
)
990 error ("third argument to %<__builtin_prefetch%> must be a constant");
991 arg2
= integer_zero_node
;
993 op2
= expand_expr (arg2
, NULL_RTX
, VOIDmode
, 0);
994 /* Argument 2 must be 0, 1, 2, or 3. */
995 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
997 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1001 #ifdef HAVE_prefetch
1004 if ((! (*insn_data
[(int) CODE_FOR_prefetch
].operand
[0].predicate
)
1006 insn_data
[(int) CODE_FOR_prefetch
].operand
[0].mode
))
1007 || (GET_MODE (op0
) != Pmode
))
1009 op0
= convert_memory_address (Pmode
, op0
);
1010 op0
= force_reg (Pmode
, op0
);
1012 emit_insn (gen_prefetch (op0
, op1
, op2
));
1016 /* Don't do anything with direct references to volatile memory, but
1017 generate code to handle other side effects. */
1018 if (!MEM_P (op0
) && side_effects_p (op0
))
1022 /* Get a MEM rtx for expression EXP which is the address of an operand
1023 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1024 the maximum length of the block of memory that might be accessed or
1028 get_memory_rtx (tree exp
, tree len
)
1030 rtx addr
= expand_expr (exp
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
1031 rtx mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
1033 /* Get an expression we can use to find the attributes to assign to MEM.
1034 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1035 we can. First remove any nops. */
1036 while ((TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
1037 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1038 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
1039 exp
= TREE_OPERAND (exp
, 0);
1041 if (TREE_CODE (exp
) == ADDR_EXPR
)
1042 exp
= TREE_OPERAND (exp
, 0);
1043 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
1044 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
1048 /* Honor attributes derived from exp, except for the alias set
1049 (as builtin stringops may alias with anything) and the size
1050 (as stringops may access multiple array elements). */
1053 set_mem_attributes (mem
, exp
, 0);
1055 /* Allow the string and memory builtins to overflow from one
1056 field into another, see http://gcc.gnu.org/PR23561.
1057 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1058 memory accessed by the string or memory builtin will fit
1059 within the field. */
1060 if (MEM_EXPR (mem
) && TREE_CODE (MEM_EXPR (mem
)) == COMPONENT_REF
)
1062 tree mem_expr
= MEM_EXPR (mem
);
1063 HOST_WIDE_INT offset
= -1, length
= -1;
1066 while (TREE_CODE (inner
) == ARRAY_REF
1067 || TREE_CODE (inner
) == NOP_EXPR
1068 || TREE_CODE (inner
) == CONVERT_EXPR
1069 || TREE_CODE (inner
) == NON_LVALUE_EXPR
1070 || TREE_CODE (inner
) == VIEW_CONVERT_EXPR
1071 || TREE_CODE (inner
) == SAVE_EXPR
)
1072 inner
= TREE_OPERAND (inner
, 0);
1074 gcc_assert (TREE_CODE (inner
) == COMPONENT_REF
);
1076 if (MEM_OFFSET (mem
)
1077 && GET_CODE (MEM_OFFSET (mem
)) == CONST_INT
)
1078 offset
= INTVAL (MEM_OFFSET (mem
));
1080 if (offset
>= 0 && len
&& host_integerp (len
, 0))
1081 length
= tree_low_cst (len
, 0);
1083 while (TREE_CODE (inner
) == COMPONENT_REF
)
1085 tree field
= TREE_OPERAND (inner
, 1);
1086 gcc_assert (! DECL_BIT_FIELD (field
));
1087 gcc_assert (TREE_CODE (mem_expr
) == COMPONENT_REF
);
1088 gcc_assert (field
== TREE_OPERAND (mem_expr
, 1));
1091 && TYPE_SIZE_UNIT (TREE_TYPE (inner
))
1092 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner
)), 0))
1095 = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner
)), 0);
1096 /* If we can prove the memory starting at XEXP (mem, 0)
1097 and ending at XEXP (mem, 0) + LENGTH will fit into
1098 this field, we can keep that COMPONENT_REF in MEM_EXPR. */
1101 && offset
+ length
<= size
)
1106 && host_integerp (DECL_FIELD_OFFSET (field
), 0))
1107 offset
+= tree_low_cst (DECL_FIELD_OFFSET (field
), 0)
1108 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1116 mem_expr
= TREE_OPERAND (mem_expr
, 0);
1117 inner
= TREE_OPERAND (inner
, 0);
1120 if (mem_expr
== NULL
)
1122 if (mem_expr
!= MEM_EXPR (mem
))
1124 set_mem_expr (mem
, mem_expr
);
1125 set_mem_offset (mem
, offset
>= 0 ? GEN_INT (offset
) : NULL_RTX
);
1128 set_mem_alias_set (mem
, 0);
1129 set_mem_size (mem
, NULL_RTX
);
1135 /* Built-in functions to perform an untyped call and return. */
1137 /* For each register that may be used for calling a function, this
1138 gives a mode used to copy the register's value. VOIDmode indicates
1139 the register is not used for calling a function. If the machine
1140 has register windows, this gives only the outbound registers.
1141 INCOMING_REGNO gives the corresponding inbound register. */
1142 static enum machine_mode apply_args_mode
[FIRST_PSEUDO_REGISTER
];
1144 /* For each register that may be used for returning values, this gives
1145 a mode used to copy the register's value. VOIDmode indicates the
1146 register is not used for returning values. If the machine has
1147 register windows, this gives only the outbound registers.
1148 INCOMING_REGNO gives the corresponding inbound register. */
1149 static enum machine_mode apply_result_mode
[FIRST_PSEUDO_REGISTER
];
1151 /* For each register that may be used for calling a function, this
1152 gives the offset of that register into the block returned by
1153 __builtin_apply_args. 0 indicates that the register is not
1154 used for calling a function. */
1155 static int apply_args_reg_offset
[FIRST_PSEUDO_REGISTER
];
1157 /* Return the size required for the block returned by __builtin_apply_args,
1158 and initialize apply_args_mode. */
1161 apply_args_size (void)
1163 static int size
= -1;
1166 enum machine_mode mode
;
1168 /* The values computed by this function never change. */
1171 /* The first value is the incoming arg-pointer. */
1172 size
= GET_MODE_SIZE (Pmode
);
1174 /* The second value is the structure value address unless this is
1175 passed as an "invisible" first argument. */
1176 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1177 size
+= GET_MODE_SIZE (Pmode
);
1179 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1180 if (FUNCTION_ARG_REGNO_P (regno
))
1182 mode
= reg_raw_mode
[regno
];
1184 gcc_assert (mode
!= VOIDmode
);
1186 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1187 if (size
% align
!= 0)
1188 size
= CEIL (size
, align
) * align
;
1189 apply_args_reg_offset
[regno
] = size
;
1190 size
+= GET_MODE_SIZE (mode
);
1191 apply_args_mode
[regno
] = mode
;
1195 apply_args_mode
[regno
] = VOIDmode
;
1196 apply_args_reg_offset
[regno
] = 0;
1202 /* Return the size required for the block returned by __builtin_apply,
1203 and initialize apply_result_mode. */
1206 apply_result_size (void)
1208 static int size
= -1;
1210 enum machine_mode mode
;
1212 /* The values computed by this function never change. */
1217 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1218 if (FUNCTION_VALUE_REGNO_P (regno
))
1220 mode
= reg_raw_mode
[regno
];
1222 gcc_assert (mode
!= VOIDmode
);
1224 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1225 if (size
% align
!= 0)
1226 size
= CEIL (size
, align
) * align
;
1227 size
+= GET_MODE_SIZE (mode
);
1228 apply_result_mode
[regno
] = mode
;
1231 apply_result_mode
[regno
] = VOIDmode
;
1233 /* Allow targets that use untyped_call and untyped_return to override
1234 the size so that machine-specific information can be stored here. */
1235 #ifdef APPLY_RESULT_SIZE
1236 size
= APPLY_RESULT_SIZE
;
1242 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1243 /* Create a vector describing the result block RESULT. If SAVEP is true,
1244 the result block is used to save the values; otherwise it is used to
1245 restore the values. */
1248 result_vector (int savep
, rtx result
)
1250 int regno
, size
, align
, nelts
;
1251 enum machine_mode mode
;
1253 rtx
*savevec
= alloca (FIRST_PSEUDO_REGISTER
* sizeof (rtx
));
1256 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1257 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1259 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1260 if (size
% align
!= 0)
1261 size
= CEIL (size
, align
) * align
;
1262 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1263 mem
= adjust_address (result
, mode
, size
);
1264 savevec
[nelts
++] = (savep
1265 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1266 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1267 size
+= GET_MODE_SIZE (mode
);
1269 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1271 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1273 /* Save the state required to perform an untyped call with the same
1274 arguments as were passed to the current function. */
1277 expand_builtin_apply_args_1 (void)
1280 int size
, align
, regno
;
1281 enum machine_mode mode
;
1282 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1284 /* Create a block where the arg-pointer, structure value address,
1285 and argument registers can be saved. */
1286 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1288 /* Walk past the arg-pointer and structure value address. */
1289 size
= GET_MODE_SIZE (Pmode
);
1290 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1291 size
+= GET_MODE_SIZE (Pmode
);
1293 /* Save each register used in calling a function to the block. */
1294 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1295 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1297 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1298 if (size
% align
!= 0)
1299 size
= CEIL (size
, align
) * align
;
1301 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1303 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1304 size
+= GET_MODE_SIZE (mode
);
1307 /* Save the arg pointer to the block. */
1308 tem
= copy_to_reg (virtual_incoming_args_rtx
);
1309 #ifdef STACK_GROWS_DOWNWARD
1310 /* We need the pointer as the caller actually passed them to us, not
1311 as we might have pretended they were passed. Make sure it's a valid
1312 operand, as emit_move_insn isn't expected to handle a PLUS. */
1314 = force_operand (plus_constant (tem
, current_function_pretend_args_size
),
1317 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1319 size
= GET_MODE_SIZE (Pmode
);
1321 /* Save the structure value address unless this is passed as an
1322 "invisible" first argument. */
1323 if (struct_incoming_value
)
1325 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1326 copy_to_reg (struct_incoming_value
));
1327 size
+= GET_MODE_SIZE (Pmode
);
1330 /* Return the address of the block. */
1331 return copy_addr_to_reg (XEXP (registers
, 0));
1334 /* __builtin_apply_args returns block of memory allocated on
1335 the stack into which is stored the arg pointer, structure
1336 value address, static chain, and all the registers that might
1337 possibly be used in performing a function call. The code is
1338 moved to the start of the function so the incoming values are
1342 expand_builtin_apply_args (void)
1344 /* Don't do __builtin_apply_args more than once in a function.
1345 Save the result of the first call and reuse it. */
1346 if (apply_args_value
!= 0)
1347 return apply_args_value
;
1349 /* When this function is called, it means that registers must be
1350 saved on entry to this function. So we migrate the
1351 call to the first insn of this function. */
1356 temp
= expand_builtin_apply_args_1 ();
1360 apply_args_value
= temp
;
1362 /* Put the insns after the NOTE that starts the function.
1363 If this is inside a start_sequence, make the outer-level insn
1364 chain current, so the code is placed at the start of the
1366 push_topmost_sequence ();
1367 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1368 pop_topmost_sequence ();
1373 /* Perform an untyped call and save the state required to perform an
1374 untyped return of whatever value was returned by the given function. */
1377 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1379 int size
, align
, regno
;
1380 enum machine_mode mode
;
1381 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1382 rtx old_stack_level
= 0;
1383 rtx call_fusage
= 0;
1384 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1386 arguments
= convert_memory_address (Pmode
, arguments
);
1388 /* Create a block where the return registers can be saved. */
1389 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1391 /* Fetch the arg pointer from the ARGUMENTS block. */
1392 incoming_args
= gen_reg_rtx (Pmode
);
1393 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1394 #ifndef STACK_GROWS_DOWNWARD
1395 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1396 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1399 /* Push a new argument block and copy the arguments. Do not allow
1400 the (potential) memcpy call below to interfere with our stack
1402 do_pending_stack_adjust ();
1405 /* Save the stack with nonlocal if available. */
1406 #ifdef HAVE_save_stack_nonlocal
1407 if (HAVE_save_stack_nonlocal
)
1408 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1411 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1413 /* Allocate a block of memory onto the stack and copy the memory
1414 arguments to the outgoing arguments address. */
1415 allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
);
1416 dest
= virtual_outgoing_args_rtx
;
1417 #ifndef STACK_GROWS_DOWNWARD
1418 if (GET_CODE (argsize
) == CONST_INT
)
1419 dest
= plus_constant (dest
, -INTVAL (argsize
));
1421 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1423 dest
= gen_rtx_MEM (BLKmode
, dest
);
1424 set_mem_align (dest
, PARM_BOUNDARY
);
1425 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1426 set_mem_align (src
, PARM_BOUNDARY
);
1427 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1429 /* Refer to the argument block. */
1431 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1432 set_mem_align (arguments
, PARM_BOUNDARY
);
1434 /* Walk past the arg-pointer and structure value address. */
1435 size
= GET_MODE_SIZE (Pmode
);
1437 size
+= GET_MODE_SIZE (Pmode
);
1439 /* Restore each of the registers previously saved. Make USE insns
1440 for each of these registers for use in making the call. */
1441 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1442 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1444 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1445 if (size
% align
!= 0)
1446 size
= CEIL (size
, align
) * align
;
1447 reg
= gen_rtx_REG (mode
, regno
);
1448 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1449 use_reg (&call_fusage
, reg
);
1450 size
+= GET_MODE_SIZE (mode
);
1453 /* Restore the structure value address unless this is passed as an
1454 "invisible" first argument. */
1455 size
= GET_MODE_SIZE (Pmode
);
1458 rtx value
= gen_reg_rtx (Pmode
);
1459 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1460 emit_move_insn (struct_value
, value
);
1461 if (REG_P (struct_value
))
1462 use_reg (&call_fusage
, struct_value
);
1463 size
+= GET_MODE_SIZE (Pmode
);
1466 /* All arguments and registers used for the call are set up by now! */
1467 function
= prepare_call_address (function
, NULL
, &call_fusage
, 0, 0);
1469 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1470 and we don't want to load it into a register as an optimization,
1471 because prepare_call_address already did it if it should be done. */
1472 if (GET_CODE (function
) != SYMBOL_REF
)
1473 function
= memory_address (FUNCTION_MODE
, function
);
1475 /* Generate the actual call instruction and save the return value. */
1476 #ifdef HAVE_untyped_call
1477 if (HAVE_untyped_call
)
1478 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1479 result
, result_vector (1, result
)));
1482 #ifdef HAVE_call_value
1483 if (HAVE_call_value
)
1487 /* Locate the unique return register. It is not possible to
1488 express a call that sets more than one return register using
1489 call_value; use untyped_call for that. In fact, untyped_call
1490 only needs to save the return registers in the given block. */
1491 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1492 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1494 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1496 valreg
= gen_rtx_REG (mode
, regno
);
1499 emit_call_insn (GEN_CALL_VALUE (valreg
,
1500 gen_rtx_MEM (FUNCTION_MODE
, function
),
1501 const0_rtx
, NULL_RTX
, const0_rtx
));
1503 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1509 /* Find the CALL insn we just emitted, and attach the register usage
1511 call_insn
= last_call_insn ();
1512 add_function_usage_to (call_insn
, call_fusage
);
1514 /* Restore the stack. */
1515 #ifdef HAVE_save_stack_nonlocal
1516 if (HAVE_save_stack_nonlocal
)
1517 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1520 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1524 /* Return the address of the result block. */
1525 result
= copy_addr_to_reg (XEXP (result
, 0));
1526 return convert_memory_address (ptr_mode
, result
);
1529 /* Perform an untyped return. */
1532 expand_builtin_return (rtx result
)
1534 int size
, align
, regno
;
1535 enum machine_mode mode
;
1537 rtx call_fusage
= 0;
1539 result
= convert_memory_address (Pmode
, result
);
1541 apply_result_size ();
1542 result
= gen_rtx_MEM (BLKmode
, result
);
1544 #ifdef HAVE_untyped_return
1545 if (HAVE_untyped_return
)
1547 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1553 /* Restore the return value and note that each value is used. */
1555 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1556 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1558 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1559 if (size
% align
!= 0)
1560 size
= CEIL (size
, align
) * align
;
1561 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1562 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1564 push_to_sequence (call_fusage
);
1565 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1566 call_fusage
= get_insns ();
1568 size
+= GET_MODE_SIZE (mode
);
1571 /* Put the USE insns before the return. */
1572 emit_insn (call_fusage
);
1574 /* Return whatever values was restored by jumping directly to the end
1576 expand_naked_return ();
1579 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1581 static enum type_class
1582 type_to_class (tree type
)
1584 switch (TREE_CODE (type
))
1586 case VOID_TYPE
: return void_type_class
;
1587 case INTEGER_TYPE
: return integer_type_class
;
1588 case CHAR_TYPE
: return char_type_class
;
1589 case ENUMERAL_TYPE
: return enumeral_type_class
;
1590 case BOOLEAN_TYPE
: return boolean_type_class
;
1591 case POINTER_TYPE
: return pointer_type_class
;
1592 case REFERENCE_TYPE
: return reference_type_class
;
1593 case OFFSET_TYPE
: return offset_type_class
;
1594 case REAL_TYPE
: return real_type_class
;
1595 case COMPLEX_TYPE
: return complex_type_class
;
1596 case FUNCTION_TYPE
: return function_type_class
;
1597 case METHOD_TYPE
: return method_type_class
;
1598 case RECORD_TYPE
: return record_type_class
;
1600 case QUAL_UNION_TYPE
: return union_type_class
;
1601 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1602 ? string_type_class
: array_type_class
);
1603 case LANG_TYPE
: return lang_type_class
;
1604 default: return no_type_class
;
1608 /* Expand a call to __builtin_classify_type with arguments found in
1612 expand_builtin_classify_type (tree arglist
)
1615 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
1616 return GEN_INT (no_type_class
);
1619 /* This helper macro, meant to be used in mathfn_built_in below,
1620 determines which among a set of three builtin math functions is
1621 appropriate for a given type mode. The `F' and `L' cases are
1622 automatically generated from the `double' case. */
1623 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1624 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1625 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1626 fcodel = BUILT_IN_MATHFN##L ; break;
1628 /* Return mathematic function equivalent to FN but operating directly
1629 on TYPE, if available. If we can't do the conversion, return zero. */
1631 mathfn_built_in (tree type
, enum built_in_function fn
)
1633 enum built_in_function fcode
, fcodef
, fcodel
;
1637 CASE_MATHFN (BUILT_IN_ACOS
)
1638 CASE_MATHFN (BUILT_IN_ACOSH
)
1639 CASE_MATHFN (BUILT_IN_ASIN
)
1640 CASE_MATHFN (BUILT_IN_ASINH
)
1641 CASE_MATHFN (BUILT_IN_ATAN
)
1642 CASE_MATHFN (BUILT_IN_ATAN2
)
1643 CASE_MATHFN (BUILT_IN_ATANH
)
1644 CASE_MATHFN (BUILT_IN_CBRT
)
1645 CASE_MATHFN (BUILT_IN_CEIL
)
1646 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1647 CASE_MATHFN (BUILT_IN_COS
)
1648 CASE_MATHFN (BUILT_IN_COSH
)
1649 CASE_MATHFN (BUILT_IN_DREM
)
1650 CASE_MATHFN (BUILT_IN_ERF
)
1651 CASE_MATHFN (BUILT_IN_ERFC
)
1652 CASE_MATHFN (BUILT_IN_EXP
)
1653 CASE_MATHFN (BUILT_IN_EXP10
)
1654 CASE_MATHFN (BUILT_IN_EXP2
)
1655 CASE_MATHFN (BUILT_IN_EXPM1
)
1656 CASE_MATHFN (BUILT_IN_FABS
)
1657 CASE_MATHFN (BUILT_IN_FDIM
)
1658 CASE_MATHFN (BUILT_IN_FLOOR
)
1659 CASE_MATHFN (BUILT_IN_FMA
)
1660 CASE_MATHFN (BUILT_IN_FMAX
)
1661 CASE_MATHFN (BUILT_IN_FMIN
)
1662 CASE_MATHFN (BUILT_IN_FMOD
)
1663 CASE_MATHFN (BUILT_IN_FREXP
)
1664 CASE_MATHFN (BUILT_IN_GAMMA
)
1665 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1666 CASE_MATHFN (BUILT_IN_HYPOT
)
1667 CASE_MATHFN (BUILT_IN_ILOGB
)
1668 CASE_MATHFN (BUILT_IN_INF
)
1669 CASE_MATHFN (BUILT_IN_J0
)
1670 CASE_MATHFN (BUILT_IN_J1
)
1671 CASE_MATHFN (BUILT_IN_JN
)
1672 CASE_MATHFN (BUILT_IN_LCEIL
)
1673 CASE_MATHFN (BUILT_IN_LDEXP
)
1674 CASE_MATHFN (BUILT_IN_LFLOOR
)
1675 CASE_MATHFN (BUILT_IN_LGAMMA
)
1676 CASE_MATHFN (BUILT_IN_LLCEIL
)
1677 CASE_MATHFN (BUILT_IN_LLFLOOR
)
1678 CASE_MATHFN (BUILT_IN_LLRINT
)
1679 CASE_MATHFN (BUILT_IN_LLROUND
)
1680 CASE_MATHFN (BUILT_IN_LOG
)
1681 CASE_MATHFN (BUILT_IN_LOG10
)
1682 CASE_MATHFN (BUILT_IN_LOG1P
)
1683 CASE_MATHFN (BUILT_IN_LOG2
)
1684 CASE_MATHFN (BUILT_IN_LOGB
)
1685 CASE_MATHFN (BUILT_IN_LRINT
)
1686 CASE_MATHFN (BUILT_IN_LROUND
)
1687 CASE_MATHFN (BUILT_IN_MODF
)
1688 CASE_MATHFN (BUILT_IN_NAN
)
1689 CASE_MATHFN (BUILT_IN_NANS
)
1690 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1691 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1692 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1693 CASE_MATHFN (BUILT_IN_POW
)
1694 CASE_MATHFN (BUILT_IN_POWI
)
1695 CASE_MATHFN (BUILT_IN_POW10
)
1696 CASE_MATHFN (BUILT_IN_REMAINDER
)
1697 CASE_MATHFN (BUILT_IN_REMQUO
)
1698 CASE_MATHFN (BUILT_IN_RINT
)
1699 CASE_MATHFN (BUILT_IN_ROUND
)
1700 CASE_MATHFN (BUILT_IN_SCALB
)
1701 CASE_MATHFN (BUILT_IN_SCALBLN
)
1702 CASE_MATHFN (BUILT_IN_SCALBN
)
1703 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1704 CASE_MATHFN (BUILT_IN_SIN
)
1705 CASE_MATHFN (BUILT_IN_SINCOS
)
1706 CASE_MATHFN (BUILT_IN_SINH
)
1707 CASE_MATHFN (BUILT_IN_SQRT
)
1708 CASE_MATHFN (BUILT_IN_TAN
)
1709 CASE_MATHFN (BUILT_IN_TANH
)
1710 CASE_MATHFN (BUILT_IN_TGAMMA
)
1711 CASE_MATHFN (BUILT_IN_TRUNC
)
1712 CASE_MATHFN (BUILT_IN_Y0
)
1713 CASE_MATHFN (BUILT_IN_Y1
)
1714 CASE_MATHFN (BUILT_IN_YN
)
1720 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1721 return implicit_built_in_decls
[fcode
];
1722 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1723 return implicit_built_in_decls
[fcodef
];
1724 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1725 return implicit_built_in_decls
[fcodel
];
1730 /* If errno must be maintained, expand the RTL to check if the result,
1731 TARGET, of a built-in function call, EXP, is NaN, and if so set
1735 expand_errno_check (tree exp
, rtx target
)
1737 rtx lab
= gen_label_rtx ();
1739 /* Test the result; if it is NaN, set errno=EDOM because
1740 the argument was not in the domain. */
1741 emit_cmp_and_jump_insns (target
, target
, EQ
, 0, GET_MODE (target
),
1745 /* If this built-in doesn't throw an exception, set errno directly. */
1746 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
1748 #ifdef GEN_ERRNO_RTX
1749 rtx errno_rtx
= GEN_ERRNO_RTX
;
1752 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1754 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1760 /* We can't set errno=EDOM directly; let the library call do it.
1761 Pop the arguments right away in case the call gets deleted. */
1763 expand_call (exp
, target
, 0);
1769 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1770 Return 0 if a normal call should be emitted rather than expanding the
1771 function in-line. EXP is the expression that is a call to the builtin
1772 function; if convenient, the result should be placed in TARGET.
1773 SUBTARGET may be used as the target for computing one of EXP's operands. */
1776 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
1778 optab builtin_optab
;
1779 rtx op0
, insns
, before_call
;
1780 tree fndecl
= get_callee_fndecl (exp
);
1781 tree arglist
= TREE_OPERAND (exp
, 1);
1782 enum machine_mode mode
;
1783 bool errno_set
= false;
1786 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1789 arg
= TREE_VALUE (arglist
);
1791 switch (DECL_FUNCTION_CODE (fndecl
))
1793 CASE_FLT_FN (BUILT_IN_SQRT
):
1794 errno_set
= ! tree_expr_nonnegative_p (arg
);
1795 builtin_optab
= sqrt_optab
;
1797 CASE_FLT_FN (BUILT_IN_EXP
):
1798 errno_set
= true; builtin_optab
= exp_optab
; break;
1799 CASE_FLT_FN (BUILT_IN_EXP10
):
1800 CASE_FLT_FN (BUILT_IN_POW10
):
1801 errno_set
= true; builtin_optab
= exp10_optab
; break;
1802 CASE_FLT_FN (BUILT_IN_EXP2
):
1803 errno_set
= true; builtin_optab
= exp2_optab
; break;
1804 CASE_FLT_FN (BUILT_IN_EXPM1
):
1805 errno_set
= true; builtin_optab
= expm1_optab
; break;
1806 CASE_FLT_FN (BUILT_IN_LOGB
):
1807 errno_set
= true; builtin_optab
= logb_optab
; break;
1808 CASE_FLT_FN (BUILT_IN_ILOGB
):
1809 errno_set
= true; builtin_optab
= ilogb_optab
; break;
1810 CASE_FLT_FN (BUILT_IN_LOG
):
1811 errno_set
= true; builtin_optab
= log_optab
; break;
1812 CASE_FLT_FN (BUILT_IN_LOG10
):
1813 errno_set
= true; builtin_optab
= log10_optab
; break;
1814 CASE_FLT_FN (BUILT_IN_LOG2
):
1815 errno_set
= true; builtin_optab
= log2_optab
; break;
1816 CASE_FLT_FN (BUILT_IN_LOG1P
):
1817 errno_set
= true; builtin_optab
= log1p_optab
; break;
1818 CASE_FLT_FN (BUILT_IN_ASIN
):
1819 builtin_optab
= asin_optab
; break;
1820 CASE_FLT_FN (BUILT_IN_ACOS
):
1821 builtin_optab
= acos_optab
; break;
1822 CASE_FLT_FN (BUILT_IN_TAN
):
1823 builtin_optab
= tan_optab
; break;
1824 CASE_FLT_FN (BUILT_IN_ATAN
):
1825 builtin_optab
= atan_optab
; break;
1826 CASE_FLT_FN (BUILT_IN_FLOOR
):
1827 builtin_optab
= floor_optab
; break;
1828 CASE_FLT_FN (BUILT_IN_CEIL
):
1829 builtin_optab
= ceil_optab
; break;
1830 CASE_FLT_FN (BUILT_IN_TRUNC
):
1831 builtin_optab
= btrunc_optab
; break;
1832 CASE_FLT_FN (BUILT_IN_ROUND
):
1833 builtin_optab
= round_optab
; break;
1834 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
1835 builtin_optab
= nearbyint_optab
; break;
1836 CASE_FLT_FN (BUILT_IN_RINT
):
1837 builtin_optab
= rint_optab
; break;
1838 CASE_FLT_FN (BUILT_IN_LRINT
):
1839 CASE_FLT_FN (BUILT_IN_LLRINT
):
1840 builtin_optab
= lrint_optab
; break;
1845 /* Make a suitable register to place result in. */
1846 mode
= TYPE_MODE (TREE_TYPE (exp
));
1848 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1851 /* Before working hard, check whether the instruction is available. */
1852 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
1854 target
= gen_reg_rtx (mode
);
1856 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1857 need to expand the argument again. This way, we will not perform
1858 side-effects more the once. */
1859 narg
= builtin_save_expr (arg
);
1863 arglist
= build_tree_list (NULL_TREE
, arg
);
1864 exp
= build_function_call_expr (fndecl
, arglist
);
1867 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
1871 /* Compute into TARGET.
1872 Set TARGET to wherever the result comes back. */
1873 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
1878 expand_errno_check (exp
, target
);
1880 /* Output the entire sequence. */
1881 insns
= get_insns ();
1887 /* If we were unable to expand via the builtin, stop the sequence
1888 (without outputting the insns) and call to the library function
1889 with the stabilized argument list. */
1893 before_call
= get_last_insn ();
1895 target
= expand_call (exp
, target
, target
== const0_rtx
);
1897 /* If this is a sqrt operation and we don't care about errno, try to
1898 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1899 This allows the semantics of the libcall to be visible to the RTL
1901 if (builtin_optab
== sqrt_optab
&& !errno_set
)
1903 /* Search backwards through the insns emitted by expand_call looking
1904 for the instruction with the REG_RETVAL note. */
1905 rtx last
= get_last_insn ();
1906 while (last
!= before_call
)
1908 if (find_reg_note (last
, REG_RETVAL
, NULL
))
1910 rtx note
= find_reg_note (last
, REG_EQUAL
, NULL
);
1911 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1912 two elements, i.e. symbol_ref(sqrt) and the operand. */
1914 && GET_CODE (note
) == EXPR_LIST
1915 && GET_CODE (XEXP (note
, 0)) == EXPR_LIST
1916 && XEXP (XEXP (note
, 0), 1) != NULL_RTX
1917 && XEXP (XEXP (XEXP (note
, 0), 1), 1) == NULL_RTX
)
1919 rtx operand
= XEXP (XEXP (XEXP (note
, 0), 1), 0);
1920 /* Check operand is a register with expected mode. */
1923 && GET_MODE (operand
) == mode
)
1925 /* Replace the REG_EQUAL note with a SQRT rtx. */
1926 rtx equiv
= gen_rtx_SQRT (mode
, operand
);
1927 set_unique_reg_note (last
, REG_EQUAL
, equiv
);
1932 last
= PREV_INSN (last
);
1939 /* Expand a call to the builtin binary math functions (pow and atan2).
1940 Return 0 if a normal call should be emitted rather than expanding the
1941 function in-line. EXP is the expression that is a call to the builtin
1942 function; if convenient, the result should be placed in TARGET.
1943 SUBTARGET may be used as the target for computing one of EXP's
1947 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
1949 optab builtin_optab
;
1950 rtx op0
, op1
, insns
;
1951 int op1_type
= REAL_TYPE
;
1952 tree fndecl
= get_callee_fndecl (exp
);
1953 tree arglist
= TREE_OPERAND (exp
, 1);
1954 tree arg0
, arg1
, temp
, narg
;
1955 enum machine_mode mode
;
1956 bool errno_set
= true;
1959 if ((DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXP
)
1960 || (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXPF
)
1961 || (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXPL
))
1962 op1_type
= INTEGER_TYPE
;
1964 if (!validate_arglist (arglist
, REAL_TYPE
, op1_type
, VOID_TYPE
))
1967 arg0
= TREE_VALUE (arglist
);
1968 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
1970 switch (DECL_FUNCTION_CODE (fndecl
))
1972 CASE_FLT_FN (BUILT_IN_POW
):
1973 builtin_optab
= pow_optab
; break;
1974 CASE_FLT_FN (BUILT_IN_ATAN2
):
1975 builtin_optab
= atan2_optab
; break;
1976 CASE_FLT_FN (BUILT_IN_LDEXP
):
1977 builtin_optab
= ldexp_optab
; break;
1978 CASE_FLT_FN (BUILT_IN_FMOD
):
1979 builtin_optab
= fmod_optab
; break;
1980 CASE_FLT_FN (BUILT_IN_DREM
):
1981 builtin_optab
= drem_optab
; break;
1986 /* Make a suitable register to place result in. */
1987 mode
= TYPE_MODE (TREE_TYPE (exp
));
1989 /* Before working hard, check whether the instruction is available. */
1990 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
1993 target
= gen_reg_rtx (mode
);
1995 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1998 /* Always stabilize the argument list. */
1999 narg
= builtin_save_expr (arg1
);
2003 temp
= build_tree_list (NULL_TREE
, narg
);
2007 temp
= TREE_CHAIN (arglist
);
2009 narg
= builtin_save_expr (arg0
);
2013 arglist
= tree_cons (NULL_TREE
, narg
, temp
);
2017 arglist
= tree_cons (NULL_TREE
, arg0
, temp
);
2020 exp
= build_function_call_expr (fndecl
, arglist
);
2022 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2023 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
2027 /* Compute into TARGET.
2028 Set TARGET to wherever the result comes back. */
2029 target
= expand_binop (mode
, builtin_optab
, op0
, op1
,
2030 target
, 0, OPTAB_DIRECT
);
2032 /* If we were unable to expand via the builtin, stop the sequence
2033 (without outputting the insns) and call to the library function
2034 with the stabilized argument list. */
2038 return expand_call (exp
, target
, target
== const0_rtx
);
2042 expand_errno_check (exp
, target
);
2044 /* Output the entire sequence. */
2045 insns
= get_insns ();
2052 /* Expand a call to the builtin sin and cos math functions.
2053 Return 0 if a normal call should be emitted rather than expanding the
2054 function in-line. EXP is the expression that is a call to the builtin
2055 function; if convenient, the result should be placed in TARGET.
2056 SUBTARGET may be used as the target for computing one of EXP's
2060 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
2062 optab builtin_optab
;
2064 tree fndecl
= get_callee_fndecl (exp
);
2065 tree arglist
= TREE_OPERAND (exp
, 1);
2066 enum machine_mode mode
;
2069 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
2072 arg
= TREE_VALUE (arglist
);
2074 switch (DECL_FUNCTION_CODE (fndecl
))
2076 CASE_FLT_FN (BUILT_IN_SIN
):
2077 CASE_FLT_FN (BUILT_IN_COS
):
2078 builtin_optab
= sincos_optab
; break;
2083 /* Make a suitable register to place result in. */
2084 mode
= TYPE_MODE (TREE_TYPE (exp
));
2086 /* Check if sincos insn is available, otherwise fallback
2087 to sin or cos insn. */
2088 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
) {
2089 switch (DECL_FUNCTION_CODE (fndecl
))
2091 CASE_FLT_FN (BUILT_IN_SIN
):
2092 builtin_optab
= sin_optab
; break;
2093 CASE_FLT_FN (BUILT_IN_COS
):
2094 builtin_optab
= cos_optab
; break;
2100 /* Before working hard, check whether the instruction is available. */
2101 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2103 target
= gen_reg_rtx (mode
);
2105 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2106 need to expand the argument again. This way, we will not perform
2107 side-effects more the once. */
2108 narg
= save_expr (arg
);
2112 arglist
= build_tree_list (NULL_TREE
, arg
);
2113 exp
= build_function_call_expr (fndecl
, arglist
);
2116 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2120 /* Compute into TARGET.
2121 Set TARGET to wherever the result comes back. */
2122 if (builtin_optab
== sincos_optab
)
2126 switch (DECL_FUNCTION_CODE (fndecl
))
2128 CASE_FLT_FN (BUILT_IN_SIN
):
2129 result
= expand_twoval_unop (builtin_optab
, op0
, 0, target
, 0);
2131 CASE_FLT_FN (BUILT_IN_COS
):
2132 result
= expand_twoval_unop (builtin_optab
, op0
, target
, 0, 0);
2137 gcc_assert (result
);
2141 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2146 /* Output the entire sequence. */
2147 insns
= get_insns ();
2153 /* If we were unable to expand via the builtin, stop the sequence
2154 (without outputting the insns) and call to the library function
2155 with the stabilized argument list. */
2159 target
= expand_call (exp
, target
, target
== const0_rtx
);
2164 /* Expand a call to the builtin sincos math function.
2165 Return 0 if a normal call should be emitted rather than expanding the
2166 function in-line. EXP is the expression that is a call to the builtin
2170 expand_builtin_sincos (tree exp
)
2172 rtx op0
, op1
, op2
, target1
, target2
;
2173 tree arglist
= TREE_OPERAND (exp
, 1);
2174 enum machine_mode mode
;
2175 tree arg
, sinp
, cosp
;
2178 if (!validate_arglist (arglist
, REAL_TYPE
,
2179 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2182 arg
= TREE_VALUE (arglist
);
2183 sinp
= TREE_VALUE (TREE_CHAIN (arglist
));
2184 cosp
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2186 /* Make a suitable register to place result in. */
2187 mode
= TYPE_MODE (TREE_TYPE (arg
));
2189 /* Check if sincos insn is available, otherwise emit the call. */
2190 if (sincos_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
2193 target1
= gen_reg_rtx (mode
);
2194 target2
= gen_reg_rtx (mode
);
2196 op0
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
2197 op1
= expand_expr (build_fold_indirect_ref (sinp
), NULL_RTX
, VOIDmode
, 0);
2198 op2
= expand_expr (build_fold_indirect_ref (cosp
), NULL_RTX
, VOIDmode
, 0);
2200 /* Compute into target1 and target2.
2201 Set TARGET to wherever the result comes back. */
2202 result
= expand_twoval_unop (sincos_optab
, op0
, target2
, target1
, 0);
2203 gcc_assert (result
);
2205 /* Move target1 and target2 to the memory locations indicated
2207 emit_move_insn (op1
, target1
);
2208 emit_move_insn (op2
, target2
);
2213 /* Expand a call to one of the builtin rounding functions (lfloor).
2214 If expanding via optab fails, lower expression to (int)(floor(x)).
2215 EXP is the expression that is a call to the builtin function;
2216 if convenient, the result should be placed in TARGET. SUBTARGET may
2217 be used as the target for computing one of EXP's operands. */
2220 expand_builtin_int_roundingfn (tree exp
, rtx target
, rtx subtarget
)
2222 optab builtin_optab
;
2223 rtx op0
, insns
, tmp
;
2224 tree fndecl
= get_callee_fndecl (exp
);
2225 tree arglist
= TREE_OPERAND (exp
, 1);
2226 enum built_in_function fallback_fn
;
2227 tree fallback_fndecl
;
2228 enum machine_mode mode
;
2231 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
2234 arg
= TREE_VALUE (arglist
);
2236 switch (DECL_FUNCTION_CODE (fndecl
))
2238 CASE_FLT_FN (BUILT_IN_LCEIL
):
2239 CASE_FLT_FN (BUILT_IN_LLCEIL
):
2240 builtin_optab
= lceil_optab
;
2241 fallback_fn
= BUILT_IN_CEIL
;
2244 CASE_FLT_FN (BUILT_IN_LFLOOR
):
2245 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
2246 builtin_optab
= lfloor_optab
;
2247 fallback_fn
= BUILT_IN_FLOOR
;
2254 /* Make a suitable register to place result in. */
2255 mode
= TYPE_MODE (TREE_TYPE (exp
));
2257 /* Before working hard, check whether the instruction is available. */
2258 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2260 target
= gen_reg_rtx (mode
);
2262 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2263 need to expand the argument again. This way, we will not perform
2264 side-effects more the once. */
2265 narg
= builtin_save_expr (arg
);
2269 arglist
= build_tree_list (NULL_TREE
, arg
);
2270 exp
= build_function_call_expr (fndecl
, arglist
);
2273 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2277 /* Compute into TARGET.
2278 Set TARGET to wherever the result comes back. */
2279 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2283 /* Output the entire sequence. */
2284 insns
= get_insns ();
2290 /* If we were unable to expand via the builtin, stop the sequence
2291 (without outputting the insns). */
2295 /* Fall back to floating point rounding optab. */
2296 fallback_fndecl
= mathfn_built_in (TREE_TYPE (arg
), fallback_fn
);
2297 /* We shouldn't get here on targets without TARGET_C99_FUNCTIONS.
2298 ??? Perhaps convert (int)floorf(x) into (int)floor((double)x). */
2299 gcc_assert (fallback_fndecl
!= NULL_TREE
);
2300 exp
= build_function_call_expr (fallback_fndecl
, arglist
);
2302 tmp
= expand_builtin_mathfn (exp
, NULL_RTX
, NULL_RTX
);
2304 /* Truncate the result of floating point optab to integer
2305 via expand_fix (). */
2306 target
= gen_reg_rtx (mode
);
2307 expand_fix (target
, tmp
, 0);
2312 /* To evaluate powi(x,n), the floating point value x raised to the
2313 constant integer exponent n, we use a hybrid algorithm that
2314 combines the "window method" with look-up tables. For an
2315 introduction to exponentiation algorithms and "addition chains",
2316 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2317 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2318 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2319 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2321 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2322 multiplications to inline before calling the system library's pow
2323 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2324 so this default never requires calling pow, powf or powl. */
2326 #ifndef POWI_MAX_MULTS
2327 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2330 /* The size of the "optimal power tree" lookup table. All
2331 exponents less than this value are simply looked up in the
2332 powi_table below. This threshold is also used to size the
2333 cache of pseudo registers that hold intermediate results. */
2334 #define POWI_TABLE_SIZE 256
2336 /* The size, in bits of the window, used in the "window method"
2337 exponentiation algorithm. This is equivalent to a radix of
2338 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2339 #define POWI_WINDOW_SIZE 3
2341 /* The following table is an efficient representation of an
2342 "optimal power tree". For each value, i, the corresponding
2343 value, j, in the table states than an optimal evaluation
2344 sequence for calculating pow(x,i) can be found by evaluating
2345 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2346 100 integers is given in Knuth's "Seminumerical algorithms". */
2348 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
2350 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2351 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2352 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2353 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2354 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2355 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2356 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2357 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2358 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2359 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2360 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2361 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2362 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2363 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2364 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2365 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2366 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2367 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2368 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2369 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2370 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2371 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2372 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2373 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2374 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2375 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2376 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2377 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2378 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2379 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2380 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2381 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2385 /* Return the number of multiplications required to calculate
2386 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2387 subroutine of powi_cost. CACHE is an array indicating
2388 which exponents have already been calculated. */
2391 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
2393 /* If we've already calculated this exponent, then this evaluation
2394 doesn't require any additional multiplications. */
2399 return powi_lookup_cost (n
- powi_table
[n
], cache
)
2400 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
2403 /* Return the number of multiplications required to calculate
2404 powi(x,n) for an arbitrary x, given the exponent N. This
2405 function needs to be kept in sync with expand_powi below. */
2408 powi_cost (HOST_WIDE_INT n
)
2410 bool cache
[POWI_TABLE_SIZE
];
2411 unsigned HOST_WIDE_INT digit
;
2412 unsigned HOST_WIDE_INT val
;
2418 /* Ignore the reciprocal when calculating the cost. */
2419 val
= (n
< 0) ? -n
: n
;
2421 /* Initialize the exponent cache. */
2422 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
2427 while (val
>= POWI_TABLE_SIZE
)
2431 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
2432 result
+= powi_lookup_cost (digit
, cache
)
2433 + POWI_WINDOW_SIZE
+ 1;
2434 val
>>= POWI_WINDOW_SIZE
;
2443 return result
+ powi_lookup_cost (val
, cache
);
2446 /* Recursive subroutine of expand_powi. This function takes the array,
2447 CACHE, of already calculated exponents and an exponent N and returns
2448 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2451 expand_powi_1 (enum machine_mode mode
, unsigned HOST_WIDE_INT n
, rtx
*cache
)
2453 unsigned HOST_WIDE_INT digit
;
2457 if (n
< POWI_TABLE_SIZE
)
2462 target
= gen_reg_rtx (mode
);
2465 op0
= expand_powi_1 (mode
, n
- powi_table
[n
], cache
);
2466 op1
= expand_powi_1 (mode
, powi_table
[n
], cache
);
2470 target
= gen_reg_rtx (mode
);
2471 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
2472 op0
= expand_powi_1 (mode
, n
- digit
, cache
);
2473 op1
= expand_powi_1 (mode
, digit
, cache
);
2477 target
= gen_reg_rtx (mode
);
2478 op0
= expand_powi_1 (mode
, n
>> 1, cache
);
2482 result
= expand_mult (mode
, op0
, op1
, target
, 0);
2483 if (result
!= target
)
2484 emit_move_insn (target
, result
);
2488 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2489 floating point operand in mode MODE, and N is the exponent. This
2490 function needs to be kept in sync with powi_cost above. */
2493 expand_powi (rtx x
, enum machine_mode mode
, HOST_WIDE_INT n
)
2495 unsigned HOST_WIDE_INT val
;
2496 rtx cache
[POWI_TABLE_SIZE
];
2500 return CONST1_RTX (mode
);
2502 val
= (n
< 0) ? -n
: n
;
2504 memset (cache
, 0, sizeof (cache
));
2507 result
= expand_powi_1 (mode
, (n
< 0) ? -n
: n
, cache
);
2509 /* If the original exponent was negative, reciprocate the result. */
2511 result
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
2512 result
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2517 /* Expand a call to the pow built-in mathematical function. Return 0 if
2518 a normal call should be emitted rather than expanding the function
2519 in-line. EXP is the expression that is a call to the builtin
2520 function; if convenient, the result should be placed in TARGET. */
2523 expand_builtin_pow (tree exp
, rtx target
, rtx subtarget
)
2525 tree arglist
= TREE_OPERAND (exp
, 1);
2528 if (! validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2531 arg0
= TREE_VALUE (arglist
);
2532 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2534 if (TREE_CODE (arg1
) == REAL_CST
2535 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2537 REAL_VALUE_TYPE cint
;
2541 c
= TREE_REAL_CST (arg1
);
2542 n
= real_to_integer (&c
);
2543 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
2544 if (real_identical (&c
, &cint
))
2546 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2547 Otherwise, check the number of multiplications required.
2548 Note that pow never sets errno for an integer exponent. */
2549 if ((n
>= -1 && n
<= 2)
2550 || (flag_unsafe_math_optimizations
2552 && powi_cost (n
) <= POWI_MAX_MULTS
))
2554 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2555 rtx op
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2556 op
= force_reg (mode
, op
);
2557 return expand_powi (op
, mode
, n
);
2562 if (! flag_unsafe_math_optimizations
)
2564 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
2567 /* Expand a call to the powi built-in mathematical function. Return 0 if
2568 a normal call should be emitted rather than expanding the function
2569 in-line. EXP is the expression that is a call to the builtin
2570 function; if convenient, the result should be placed in TARGET. */
2573 expand_builtin_powi (tree exp
, rtx target
, rtx subtarget
)
2575 tree arglist
= TREE_OPERAND (exp
, 1);
2578 enum machine_mode mode
;
2579 enum machine_mode mode2
;
2581 if (! validate_arglist (arglist
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2584 arg0
= TREE_VALUE (arglist
);
2585 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2586 mode
= TYPE_MODE (TREE_TYPE (exp
));
2588 /* Handle constant power. */
2590 if (TREE_CODE (arg1
) == INTEGER_CST
2591 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2593 HOST_WIDE_INT n
= TREE_INT_CST_LOW (arg1
);
2595 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2596 Otherwise, check the number of multiplications required. */
2597 if ((TREE_INT_CST_HIGH (arg1
) == 0
2598 || TREE_INT_CST_HIGH (arg1
) == -1)
2599 && ((n
>= -1 && n
<= 2)
2601 && powi_cost (n
) <= POWI_MAX_MULTS
)))
2603 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2604 op0
= force_reg (mode
, op0
);
2605 return expand_powi (op0
, mode
, n
);
2609 /* Emit a libcall to libgcc. */
2611 /* Mode of the 2nd argument must match that of an int. */
2612 mode2
= mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0);
2614 if (target
== NULL_RTX
)
2615 target
= gen_reg_rtx (mode
);
2617 op0
= expand_expr (arg0
, subtarget
, mode
, 0);
2618 if (GET_MODE (op0
) != mode
)
2619 op0
= convert_to_mode (mode
, op0
, 0);
2620 op1
= expand_expr (arg1
, 0, mode2
, 0);
2621 if (GET_MODE (op1
) != mode2
)
2622 op1
= convert_to_mode (mode2
, op1
, 0);
2624 target
= emit_library_call_value (powi_optab
->handlers
[(int) mode
].libfunc
,
2625 target
, LCT_CONST_MAKE_BLOCK
, mode
, 2,
2626 op0
, mode
, op1
, mode2
);
2631 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2632 if we failed the caller should emit a normal call, otherwise
2633 try to get the result in TARGET, if convenient. */
2636 expand_builtin_strlen (tree arglist
, rtx target
,
2637 enum machine_mode target_mode
)
2639 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
2644 tree len
, src
= TREE_VALUE (arglist
);
2645 rtx result
, src_reg
, char_rtx
, before_strlen
;
2646 enum machine_mode insn_mode
= target_mode
, char_mode
;
2647 enum insn_code icode
= CODE_FOR_nothing
;
2650 /* If the length can be computed at compile-time, return it. */
2651 len
= c_strlen (src
, 0);
2653 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2655 /* If the length can be computed at compile-time and is constant
2656 integer, but there are side-effects in src, evaluate
2657 src for side-effects, then return len.
2658 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2659 can be optimized into: i++; x = 3; */
2660 len
= c_strlen (src
, 1);
2661 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
2663 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2664 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2667 align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2669 /* If SRC is not a pointer type, don't do this operation inline. */
2673 /* Bail out if we can't compute strlen in the right mode. */
2674 while (insn_mode
!= VOIDmode
)
2676 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
2677 if (icode
!= CODE_FOR_nothing
)
2680 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
2682 if (insn_mode
== VOIDmode
)
2685 /* Make a place to write the result of the instruction. */
2689 && GET_MODE (result
) == insn_mode
2690 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
2691 result
= gen_reg_rtx (insn_mode
);
2693 /* Make a place to hold the source address. We will not expand
2694 the actual source until we are sure that the expansion will
2695 not fail -- there are trees that cannot be expanded twice. */
2696 src_reg
= gen_reg_rtx (Pmode
);
2698 /* Mark the beginning of the strlen sequence so we can emit the
2699 source operand later. */
2700 before_strlen
= get_last_insn ();
2702 char_rtx
= const0_rtx
;
2703 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
2704 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
2706 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
2708 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
2709 char_rtx
, GEN_INT (align
));
2714 /* Now that we are assured of success, expand the source. */
2716 pat
= expand_expr (src
, src_reg
, ptr_mode
, EXPAND_NORMAL
);
2718 emit_move_insn (src_reg
, pat
);
2723 emit_insn_after (pat
, before_strlen
);
2725 emit_insn_before (pat
, get_insns ());
2727 /* Return the value in the proper mode for this function. */
2728 if (GET_MODE (result
) == target_mode
)
2730 else if (target
!= 0)
2731 convert_move (target
, result
, 0);
2733 target
= convert_to_mode (target_mode
, result
, 0);
2739 /* Expand a call to the strstr builtin. Return 0 if we failed the
2740 caller should emit a normal call, otherwise try to get the result
2741 in TARGET, if convenient (and in mode MODE if that's convenient). */
2744 expand_builtin_strstr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2746 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2748 tree result
= fold_builtin_strstr (arglist
, type
);
2750 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2755 /* Expand a call to the strchr builtin. Return 0 if we failed the
2756 caller should emit a normal call, otherwise try to get the result
2757 in TARGET, if convenient (and in mode MODE if that's convenient). */
2760 expand_builtin_strchr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2762 if (validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2764 tree result
= fold_builtin_strchr (arglist
, type
);
2766 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2768 /* FIXME: Should use strchrM optab so that ports can optimize this. */
2773 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2774 caller should emit a normal call, otherwise try to get the result
2775 in TARGET, if convenient (and in mode MODE if that's convenient). */
2778 expand_builtin_strrchr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2780 if (validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2782 tree result
= fold_builtin_strrchr (arglist
, type
);
2784 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2789 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2790 caller should emit a normal call, otherwise try to get the result
2791 in TARGET, if convenient (and in mode MODE if that's convenient). */
2794 expand_builtin_strpbrk (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2796 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2798 tree result
= fold_builtin_strpbrk (arglist
, type
);
2800 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2805 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2806 bytes from constant string DATA + OFFSET and return it as target
2810 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
2811 enum machine_mode mode
)
2813 const char *str
= (const char *) data
;
2815 gcc_assert (offset
>= 0
2816 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
2817 <= strlen (str
) + 1));
2819 return c_readstr (str
+ offset
, mode
);
2822 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2823 Return 0 if we failed, the caller should emit a normal call,
2824 otherwise try to get the result in TARGET, if convenient (and in
2825 mode MODE if that's convenient). */
2827 expand_builtin_memcpy (tree exp
, rtx target
, enum machine_mode mode
)
2829 tree fndecl
= get_callee_fndecl (exp
);
2830 tree arglist
= TREE_OPERAND (exp
, 1);
2831 if (!validate_arglist (arglist
,
2832 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2836 tree dest
= TREE_VALUE (arglist
);
2837 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2838 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2839 const char *src_str
;
2840 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2841 unsigned int dest_align
2842 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2843 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
2844 tree result
= fold_builtin_memcpy (fndecl
, arglist
);
2847 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2849 /* If DEST is not a pointer type, call the normal function. */
2850 if (dest_align
== 0)
2853 /* If either SRC is not a pointer type, don't do this
2854 operation in-line. */
2858 dest_mem
= get_memory_rtx (dest
, len
);
2859 set_mem_align (dest_mem
, dest_align
);
2860 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2861 src_str
= c_getstr (src
);
2863 /* If SRC is a string constant and block move would be done
2864 by pieces, we can avoid loading the string from memory
2865 and only stored the computed constants. */
2867 && GET_CODE (len_rtx
) == CONST_INT
2868 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2869 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2870 (void *) src_str
, dest_align
))
2872 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2873 builtin_memcpy_read_str
,
2874 (void *) src_str
, dest_align
, 0);
2875 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2876 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2880 src_mem
= get_memory_rtx (src
, len
);
2881 set_mem_align (src_mem
, src_align
);
2883 /* Copy word part most expediently. */
2884 dest_addr
= emit_block_move (dest_mem
, src_mem
, len_rtx
,
2885 CALL_EXPR_TAILCALL (exp
)
2886 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
);
2890 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2891 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
2897 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2898 Return 0 if we failed; the caller should emit a normal call,
2899 otherwise try to get the result in TARGET, if convenient (and in
2900 mode MODE if that's convenient). If ENDP is 0 return the
2901 destination pointer, if ENDP is 1 return the end pointer ala
2902 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2906 expand_builtin_mempcpy (tree arglist
, tree type
, rtx target
, enum machine_mode mode
,
2909 if (!validate_arglist (arglist
,
2910 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2912 /* If return value is ignored, transform mempcpy into memcpy. */
2913 else if (target
== const0_rtx
)
2915 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2920 return expand_expr (build_function_call_expr (fn
, arglist
),
2921 target
, mode
, EXPAND_NORMAL
);
2925 tree dest
= TREE_VALUE (arglist
);
2926 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2927 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2928 const char *src_str
;
2929 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2930 unsigned int dest_align
2931 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2932 rtx dest_mem
, src_mem
, len_rtx
;
2933 tree result
= fold_builtin_mempcpy (arglist
, type
, endp
);
2936 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2938 /* If either SRC or DEST is not a pointer type, don't do this
2939 operation in-line. */
2940 if (dest_align
== 0 || src_align
== 0)
2943 /* If LEN is not constant, call the normal function. */
2944 if (! host_integerp (len
, 1))
2947 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2948 src_str
= c_getstr (src
);
2950 /* If SRC is a string constant and block move would be done
2951 by pieces, we can avoid loading the string from memory
2952 and only stored the computed constants. */
2954 && GET_CODE (len_rtx
) == CONST_INT
2955 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2956 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2957 (void *) src_str
, dest_align
))
2959 dest_mem
= get_memory_rtx (dest
, len
);
2960 set_mem_align (dest_mem
, dest_align
);
2961 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2962 builtin_memcpy_read_str
,
2963 (void *) src_str
, dest_align
, endp
);
2964 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2965 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2969 if (GET_CODE (len_rtx
) == CONST_INT
2970 && can_move_by_pieces (INTVAL (len_rtx
),
2971 MIN (dest_align
, src_align
)))
2973 dest_mem
= get_memory_rtx (dest
, len
);
2974 set_mem_align (dest_mem
, dest_align
);
2975 src_mem
= get_memory_rtx (src
, len
);
2976 set_mem_align (src_mem
, src_align
);
2977 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
2978 MIN (dest_align
, src_align
), endp
);
2979 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2980 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2988 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2989 if we failed; the caller should emit a normal call. */
2992 expand_builtin_memmove (tree arglist
, tree type
, rtx target
,
2993 enum machine_mode mode
, tree orig_exp
)
2995 if (!validate_arglist (arglist
,
2996 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3000 tree dest
= TREE_VALUE (arglist
);
3001 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
3002 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3004 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
3005 unsigned int dest_align
3006 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3007 tree result
= fold_builtin_memmove (arglist
, type
);
3010 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3012 /* If DEST is not a pointer type, call the normal function. */
3013 if (dest_align
== 0)
3016 /* If either SRC is not a pointer type, don't do this
3017 operation in-line. */
3021 /* If src is categorized for a readonly section we can use
3023 if (readonly_data_expr (src
))
3025 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3028 fn
= build_function_call_expr (fn
, arglist
);
3029 if (TREE_CODE (fn
) == CALL_EXPR
)
3030 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (orig_exp
);
3031 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
3034 /* If length is 1 and we can expand memcpy call inline,
3035 it is ok to use memcpy as well. */
3036 if (integer_onep (len
))
3038 rtx ret
= expand_builtin_mempcpy (arglist
, type
, target
, mode
,
3044 /* Otherwise, call the normal function. */
3049 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
3050 if we failed the caller should emit a normal call. */
3053 expand_builtin_bcopy (tree exp
)
3055 tree arglist
= TREE_OPERAND (exp
, 1);
3056 tree type
= TREE_TYPE (exp
);
3057 tree src
, dest
, size
, newarglist
;
3059 if (!validate_arglist (arglist
,
3060 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3063 src
= TREE_VALUE (arglist
);
3064 dest
= TREE_VALUE (TREE_CHAIN (arglist
));
3065 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3067 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
3068 memmove(ptr y, ptr x, size_t z). This is done this way
3069 so that if it isn't expanded inline, we fallback to
3070 calling bcopy instead of memmove. */
3072 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3073 newarglist
= tree_cons (NULL_TREE
, src
, newarglist
);
3074 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3076 return expand_builtin_memmove (newarglist
, type
, const0_rtx
, VOIDmode
, exp
);
3080 # define HAVE_movstr 0
3081 # define CODE_FOR_movstr CODE_FOR_nothing
3084 /* Expand into a movstr instruction, if one is available. Return 0 if
3085 we failed, the caller should emit a normal call, otherwise try to
3086 get the result in TARGET, if convenient. If ENDP is 0 return the
3087 destination pointer, if ENDP is 1 return the end pointer ala
3088 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3092 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
3098 const struct insn_data
* data
;
3103 dest_mem
= get_memory_rtx (dest
, NULL
);
3104 src_mem
= get_memory_rtx (src
, NULL
);
3107 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
3108 dest_mem
= replace_equiv_address (dest_mem
, target
);
3109 end
= gen_reg_rtx (Pmode
);
3113 if (target
== 0 || target
== const0_rtx
)
3115 end
= gen_reg_rtx (Pmode
);
3123 data
= insn_data
+ CODE_FOR_movstr
;
3125 if (data
->operand
[0].mode
!= VOIDmode
)
3126 end
= gen_lowpart (data
->operand
[0].mode
, end
);
3128 insn
= data
->genfun (end
, dest_mem
, src_mem
);
3134 /* movstr is supposed to set end to the address of the NUL
3135 terminator. If the caller requested a mempcpy-like return value,
3137 if (endp
== 1 && target
!= const0_rtx
)
3139 rtx tem
= plus_constant (gen_lowpart (GET_MODE (target
), end
), 1);
3140 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
3146 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
3147 if we failed the caller should emit a normal call, otherwise try to get
3148 the result in TARGET, if convenient (and in mode MODE if that's
3152 expand_builtin_strcpy (tree fndecl
, tree arglist
, rtx target
, enum machine_mode mode
)
3154 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3156 tree result
= fold_builtin_strcpy (fndecl
, arglist
, 0);
3158 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3160 return expand_movstr (TREE_VALUE (arglist
),
3161 TREE_VALUE (TREE_CHAIN (arglist
)),
3162 target
, /*endp=*/0);
3167 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3168 Return 0 if we failed the caller should emit a normal call,
3169 otherwise try to get the result in TARGET, if convenient (and in
3170 mode MODE if that's convenient). */
3173 expand_builtin_stpcpy (tree exp
, rtx target
, enum machine_mode mode
)
3175 tree arglist
= TREE_OPERAND (exp
, 1);
3176 /* If return value is ignored, transform stpcpy into strcpy. */
3177 if (target
== const0_rtx
)
3179 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
3183 return expand_expr (build_function_call_expr (fn
, arglist
),
3184 target
, mode
, EXPAND_NORMAL
);
3187 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3191 tree dst
, src
, len
, lenp1
;
3195 /* Ensure we get an actual string whose length can be evaluated at
3196 compile-time, not an expression containing a string. This is
3197 because the latter will potentially produce pessimized code
3198 when used to produce the return value. */
3199 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3200 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
3201 return expand_movstr (TREE_VALUE (arglist
),
3202 TREE_VALUE (TREE_CHAIN (arglist
)),
3203 target
, /*endp=*/2);
3205 dst
= TREE_VALUE (arglist
);
3206 lenp1
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3207 narglist
= build_tree_list (NULL_TREE
, lenp1
);
3208 narglist
= tree_cons (NULL_TREE
, src
, narglist
);
3209 narglist
= tree_cons (NULL_TREE
, dst
, narglist
);
3210 ret
= expand_builtin_mempcpy (narglist
, TREE_TYPE (exp
),
3211 target
, mode
, /*endp=*/2);
3216 if (TREE_CODE (len
) == INTEGER_CST
)
3218 rtx len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3220 if (GET_CODE (len_rtx
) == CONST_INT
)
3222 ret
= expand_builtin_strcpy (get_callee_fndecl (exp
),
3223 arglist
, target
, mode
);
3229 if (mode
!= VOIDmode
)
3230 target
= gen_reg_rtx (mode
);
3232 target
= gen_reg_rtx (GET_MODE (ret
));
3234 if (GET_MODE (target
) != GET_MODE (ret
))
3235 ret
= gen_lowpart (GET_MODE (target
), ret
);
3237 ret
= plus_constant (ret
, INTVAL (len_rtx
));
3238 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3246 return expand_movstr (TREE_VALUE (arglist
),
3247 TREE_VALUE (TREE_CHAIN (arglist
)),
3248 target
, /*endp=*/2);
3252 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3253 bytes from constant string DATA + OFFSET and return it as target
3257 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3258 enum machine_mode mode
)
3260 const char *str
= (const char *) data
;
3262 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3265 return c_readstr (str
+ offset
, mode
);
3268 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
3269 if we failed the caller should emit a normal call. */
3272 expand_builtin_strncpy (tree exp
, rtx target
, enum machine_mode mode
)
3274 tree fndecl
= get_callee_fndecl (exp
);
3275 tree arglist
= TREE_OPERAND (exp
, 1);
3276 if (validate_arglist (arglist
,
3277 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3279 tree slen
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)), 1);
3280 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3281 tree result
= fold_builtin_strncpy (fndecl
, arglist
, slen
);
3284 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3286 /* We must be passed a constant len and src parameter. */
3287 if (!host_integerp (len
, 1) || !slen
|| !host_integerp (slen
, 1))
3290 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
3292 /* We're required to pad with trailing zeros if the requested
3293 len is greater than strlen(s2)+1. In that case try to
3294 use store_by_pieces, if it fails, punt. */
3295 if (tree_int_cst_lt (slen
, len
))
3297 tree dest
= TREE_VALUE (arglist
);
3298 unsigned int dest_align
3299 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3300 const char *p
= c_getstr (TREE_VALUE (TREE_CHAIN (arglist
)));
3303 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
3304 || !can_store_by_pieces (tree_low_cst (len
, 1),
3305 builtin_strncpy_read_str
,
3306 (void *) p
, dest_align
))
3309 dest_mem
= get_memory_rtx (dest
, len
);
3310 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3311 builtin_strncpy_read_str
,
3312 (void *) p
, dest_align
, 0);
3313 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3314 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3321 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3322 bytes from constant string DATA + OFFSET and return it as target
3326 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3327 enum machine_mode mode
)
3329 const char *c
= (const char *) data
;
3330 char *p
= alloca (GET_MODE_SIZE (mode
));
3332 memset (p
, *c
, GET_MODE_SIZE (mode
));
3334 return c_readstr (p
, mode
);
3337 /* Callback routine for store_by_pieces. Return the RTL of a register
3338 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3339 char value given in the RTL register data. For example, if mode is
3340 4 bytes wide, return the RTL for 0x01010101*data. */
3343 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3344 enum machine_mode mode
)
3350 size
= GET_MODE_SIZE (mode
);
3355 memset (p
, 1, size
);
3356 coeff
= c_readstr (p
, mode
);
3358 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3359 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3360 return force_reg (mode
, target
);
3363 /* Expand expression EXP, which is a call to the memset builtin. Return 0
3364 if we failed the caller should emit a normal call, otherwise try to get
3365 the result in TARGET, if convenient (and in mode MODE if that's
3369 expand_builtin_memset (tree arglist
, rtx target
, enum machine_mode mode
,
3372 if (!validate_arglist (arglist
,
3373 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3377 tree dest
= TREE_VALUE (arglist
);
3378 tree val
= TREE_VALUE (TREE_CHAIN (arglist
));
3379 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3382 unsigned int dest_align
3383 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3384 rtx dest_mem
, dest_addr
, len_rtx
;
3386 /* If DEST is not a pointer type, don't do this
3387 operation in-line. */
3388 if (dest_align
== 0)
3391 /* If the LEN parameter is zero, return DEST. */
3392 if (integer_zerop (len
))
3394 /* Evaluate and ignore VAL in case it has side-effects. */
3395 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3396 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3399 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3400 dest_mem
= get_memory_rtx (dest
, len
);
3402 if (TREE_CODE (val
) != INTEGER_CST
)
3406 val
= fold_build1 (CONVERT_EXPR
, unsigned_char_type_node
, val
);
3407 val_rtx
= expand_expr (val
, NULL_RTX
, VOIDmode
, 0);
3409 /* Assume that we can memset by pieces if we can store the
3410 * the coefficients by pieces (in the required modes).
3411 * We can't pass builtin_memset_gen_str as that emits RTL. */
3413 if (host_integerp (len
, 1)
3414 && !(optimize_size
&& tree_low_cst (len
, 1) > 1)
3415 && can_store_by_pieces (tree_low_cst (len
, 1),
3416 builtin_memset_read_str
, &c
, dest_align
))
3418 val_rtx
= force_reg (TYPE_MODE (unsigned_char_type_node
),
3420 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3421 builtin_memset_gen_str
, val_rtx
, dest_align
, 0);
3423 else if (!set_storage_via_setmem(dest_mem
, len_rtx
, val_rtx
,
3427 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3428 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3432 if (target_char_cast (val
, &c
))
3437 if (host_integerp (len
, 1)
3438 && !(optimize_size
&& tree_low_cst (len
, 1) > 1)
3439 && can_store_by_pieces (tree_low_cst (len
, 1),
3440 builtin_memset_read_str
, &c
, dest_align
))
3441 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3442 builtin_memset_read_str
, &c
, dest_align
, 0);
3443 else if (!set_storage_via_setmem (dest_mem
, len_rtx
, GEN_INT (c
),
3447 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3448 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3452 set_mem_align (dest_mem
, dest_align
);
3453 dest_addr
= clear_storage (dest_mem
, len_rtx
,
3454 CALL_EXPR_TAILCALL (orig_exp
)
3455 ? BLOCK_OP_TAILCALL
: BLOCK_OP_NORMAL
);
3459 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3460 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3467 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3468 if we failed the caller should emit a normal call. */
3471 expand_builtin_bzero (tree exp
)
3473 tree arglist
= TREE_OPERAND (exp
, 1);
3474 tree dest
, size
, newarglist
;
3476 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3479 dest
= TREE_VALUE (arglist
);
3480 size
= TREE_VALUE (TREE_CHAIN (arglist
));
3482 /* New argument list transforming bzero(ptr x, int y) to
3483 memset(ptr x, int 0, size_t y). This is done this way
3484 so that if it isn't expanded inline, we fallback to
3485 calling bzero instead of memset. */
3487 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3488 newarglist
= tree_cons (NULL_TREE
, integer_zero_node
, newarglist
);
3489 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3491 return expand_builtin_memset (newarglist
, const0_rtx
, VOIDmode
, exp
);
3494 /* Expand expression EXP, which is a call to the memcmp built-in function.
3495 ARGLIST is the argument list for this call. Return 0 if we failed and the
3496 caller should emit a normal call, otherwise try to get the result in
3497 TARGET, if convenient (and in mode MODE, if that's convenient). */
3500 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED
, tree arglist
, rtx target
,
3501 enum machine_mode mode
)
3503 if (!validate_arglist (arglist
,
3504 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3508 tree result
= fold_builtin_memcmp (arglist
);
3510 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3513 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3515 tree arg1
= TREE_VALUE (arglist
);
3516 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3517 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3518 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3523 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3525 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3526 enum machine_mode insn_mode
;
3528 #ifdef HAVE_cmpmemsi
3530 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3533 #ifdef HAVE_cmpstrnsi
3535 insn_mode
= insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3540 /* If we don't have POINTER_TYPE, call the function. */
3541 if (arg1_align
== 0 || arg2_align
== 0)
3544 /* Make a place to write the result of the instruction. */
3547 && REG_P (result
) && GET_MODE (result
) == insn_mode
3548 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3549 result
= gen_reg_rtx (insn_mode
);
3551 arg1_rtx
= get_memory_rtx (arg1
, len
);
3552 arg2_rtx
= get_memory_rtx (arg2
, len
);
3553 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3555 /* Set MEM_SIZE as appropriate. */
3556 if (GET_CODE (arg3_rtx
) == CONST_INT
)
3558 set_mem_size (arg1_rtx
, arg3_rtx
);
3559 set_mem_size (arg2_rtx
, arg3_rtx
);
3562 #ifdef HAVE_cmpmemsi
3564 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3565 GEN_INT (MIN (arg1_align
, arg2_align
)));
3568 #ifdef HAVE_cmpstrnsi
3570 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3571 GEN_INT (MIN (arg1_align
, arg2_align
)));
3579 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE_MAKE_BLOCK
,
3580 TYPE_MODE (integer_type_node
), 3,
3581 XEXP (arg1_rtx
, 0), Pmode
,
3582 XEXP (arg2_rtx
, 0), Pmode
,
3583 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
3584 TYPE_UNSIGNED (sizetype
)),
3585 TYPE_MODE (sizetype
));
3587 /* Return the value in the proper mode for this function. */
3588 mode
= TYPE_MODE (TREE_TYPE (exp
));
3589 if (GET_MODE (result
) == mode
)
3591 else if (target
!= 0)
3593 convert_move (target
, result
, 0);
3597 return convert_to_mode (mode
, result
, 0);
3604 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3605 if we failed the caller should emit a normal call, otherwise try to get
3606 the result in TARGET, if convenient. */
3609 expand_builtin_strcmp (tree exp
, rtx target
, enum machine_mode mode
)
3611 tree arglist
= TREE_OPERAND (exp
, 1);
3613 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3617 tree result
= fold_builtin_strcmp (arglist
);
3619 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3622 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3623 if (cmpstr_optab
[SImode
] != CODE_FOR_nothing
3624 || cmpstrn_optab
[SImode
] != CODE_FOR_nothing
)
3626 rtx arg1_rtx
, arg2_rtx
;
3627 rtx result
, insn
= NULL_RTX
;
3630 tree arg1
= TREE_VALUE (arglist
);
3631 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3633 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3635 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3637 /* If we don't have POINTER_TYPE, call the function. */
3638 if (arg1_align
== 0 || arg2_align
== 0)
3641 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
3642 arg1
= builtin_save_expr (arg1
);
3643 arg2
= builtin_save_expr (arg2
);
3645 arg1_rtx
= get_memory_rtx (arg1
, NULL
);
3646 arg2_rtx
= get_memory_rtx (arg2
, NULL
);
3648 #ifdef HAVE_cmpstrsi
3649 /* Try to call cmpstrsi. */
3652 enum machine_mode insn_mode
3653 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3655 /* Make a place to write the result of the instruction. */
3658 && REG_P (result
) && GET_MODE (result
) == insn_mode
3659 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3660 result
= gen_reg_rtx (insn_mode
);
3662 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
,
3663 GEN_INT (MIN (arg1_align
, arg2_align
)));
3667 /* Try to determine at least one length and call cmpstrnsi. */
3668 if (!insn
&& HAVE_cmpstrnsi
)
3673 enum machine_mode insn_mode
3674 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3675 tree len1
= c_strlen (arg1
, 1);
3676 tree len2
= c_strlen (arg2
, 1);
3679 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3681 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3683 /* If we don't have a constant length for the first, use the length
3684 of the second, if we know it. We don't require a constant for
3685 this case; some cost analysis could be done if both are available
3686 but neither is constant. For now, assume they're equally cheap,
3687 unless one has side effects. If both strings have constant lengths,
3694 else if (TREE_SIDE_EFFECTS (len1
))
3696 else if (TREE_SIDE_EFFECTS (len2
))
3698 else if (TREE_CODE (len1
) != INTEGER_CST
)
3700 else if (TREE_CODE (len2
) != INTEGER_CST
)
3702 else if (tree_int_cst_lt (len1
, len2
))
3707 /* If both arguments have side effects, we cannot optimize. */
3708 if (!len
|| TREE_SIDE_EFFECTS (len
))
3711 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
3712 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3714 /* Make a place to write the result of the instruction. */
3717 && REG_P (result
) && GET_MODE (result
) == insn_mode
3718 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3719 result
= gen_reg_rtx (insn_mode
);
3721 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3722 GEN_INT (MIN (arg1_align
, arg2_align
)));
3730 /* Return the value in the proper mode for this function. */
3731 mode
= TYPE_MODE (TREE_TYPE (exp
));
3732 if (GET_MODE (result
) == mode
)
3735 return convert_to_mode (mode
, result
, 0);
3736 convert_move (target
, result
, 0);
3740 /* Expand the library call ourselves using a stabilized argument
3741 list to avoid re-evaluating the function's arguments twice. */
3742 arglist
= build_tree_list (NULL_TREE
, arg2
);
3743 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3744 fndecl
= get_callee_fndecl (exp
);
3745 fn
= build_function_call_expr (fndecl
, arglist
);
3746 if (TREE_CODE (fn
) == CALL_EXPR
)
3747 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
3748 return expand_call (fn
, target
, target
== const0_rtx
);
3754 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3755 if we failed the caller should emit a normal call, otherwise try to get
3756 the result in TARGET, if convenient. */
3759 expand_builtin_strncmp (tree exp
, rtx target
, enum machine_mode mode
)
3761 tree arglist
= TREE_OPERAND (exp
, 1);
3763 if (!validate_arglist (arglist
,
3764 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3768 tree result
= fold_builtin_strncmp (arglist
);
3770 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3773 /* If c_strlen can determine an expression for one of the string
3774 lengths, and it doesn't have side effects, then emit cmpstrnsi
3775 using length MIN(strlen(string)+1, arg3). */
3776 #ifdef HAVE_cmpstrnsi
3779 tree arg1
= TREE_VALUE (arglist
);
3780 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3781 tree arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3782 tree len
, len1
, len2
;
3783 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3788 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3790 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3791 enum machine_mode insn_mode
3792 = insn_data
[(int) CODE_FOR_cmpstrnsi
].operand
[0].mode
;
3794 len1
= c_strlen (arg1
, 1);
3795 len2
= c_strlen (arg2
, 1);
3798 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3800 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3802 /* If we don't have a constant length for the first, use the length
3803 of the second, if we know it. We don't require a constant for
3804 this case; some cost analysis could be done if both are available
3805 but neither is constant. For now, assume they're equally cheap,
3806 unless one has side effects. If both strings have constant lengths,
3813 else if (TREE_SIDE_EFFECTS (len1
))
3815 else if (TREE_SIDE_EFFECTS (len2
))
3817 else if (TREE_CODE (len1
) != INTEGER_CST
)
3819 else if (TREE_CODE (len2
) != INTEGER_CST
)
3821 else if (tree_int_cst_lt (len1
, len2
))
3826 /* If both arguments have side effects, we cannot optimize. */
3827 if (!len
|| TREE_SIDE_EFFECTS (len
))
3830 /* The actual new length parameter is MIN(len,arg3). */
3831 len
= fold_build2 (MIN_EXPR
, TREE_TYPE (len
), len
,
3832 fold_convert (TREE_TYPE (len
), arg3
));
3834 /* If we don't have POINTER_TYPE, call the function. */
3835 if (arg1_align
== 0 || arg2_align
== 0)
3838 /* Make a place to write the result of the instruction. */
3841 && REG_P (result
) && GET_MODE (result
) == insn_mode
3842 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3843 result
= gen_reg_rtx (insn_mode
);
3845 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
3846 arg1
= builtin_save_expr (arg1
);
3847 arg2
= builtin_save_expr (arg2
);
3848 len
= builtin_save_expr (len
);
3850 arg1_rtx
= get_memory_rtx (arg1
, len
);
3851 arg2_rtx
= get_memory_rtx (arg2
, len
);
3852 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3853 insn
= gen_cmpstrnsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3854 GEN_INT (MIN (arg1_align
, arg2_align
)));
3859 /* Return the value in the proper mode for this function. */
3860 mode
= TYPE_MODE (TREE_TYPE (exp
));
3861 if (GET_MODE (result
) == mode
)
3864 return convert_to_mode (mode
, result
, 0);
3865 convert_move (target
, result
, 0);
3869 /* Expand the library call ourselves using a stabilized argument
3870 list to avoid re-evaluating the function's arguments twice. */
3871 arglist
= build_tree_list (NULL_TREE
, len
);
3872 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3873 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3874 fndecl
= get_callee_fndecl (exp
);
3875 fn
= build_function_call_expr (fndecl
, arglist
);
3876 if (TREE_CODE (fn
) == CALL_EXPR
)
3877 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
3878 return expand_call (fn
, target
, target
== const0_rtx
);
3884 /* Expand expression EXP, which is a call to the strcat builtin.
3885 Return 0 if we failed the caller should emit a normal call,
3886 otherwise try to get the result in TARGET, if convenient. */
3889 expand_builtin_strcat (tree fndecl
, tree arglist
, rtx target
, enum machine_mode mode
)
3891 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3895 tree dst
= TREE_VALUE (arglist
),
3896 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3897 const char *p
= c_getstr (src
);
3899 /* If the string length is zero, return the dst parameter. */
3900 if (p
&& *p
== '\0')
3901 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3905 /* See if we can store by pieces into (dst + strlen(dst)). */
3906 tree newsrc
, newdst
,
3907 strlen_fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
3910 /* Stabilize the argument list. */
3911 newsrc
= builtin_save_expr (src
);
3913 arglist
= build_tree_list (NULL_TREE
, newsrc
);
3915 arglist
= TREE_CHAIN (arglist
); /* Reusing arglist if safe. */
3917 dst
= builtin_save_expr (dst
);
3921 /* Create strlen (dst). */
3923 build_function_call_expr (strlen_fn
,
3924 build_tree_list (NULL_TREE
, dst
));
3925 /* Create (dst + (cast) strlen (dst)). */
3926 newdst
= fold_convert (TREE_TYPE (dst
), newdst
);
3927 newdst
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dst
), dst
, newdst
);
3929 newdst
= builtin_save_expr (newdst
);
3930 arglist
= tree_cons (NULL_TREE
, newdst
, arglist
);
3932 if (!expand_builtin_strcpy (fndecl
, arglist
, target
, mode
))
3934 end_sequence (); /* Stop sequence. */
3938 /* Output the entire sequence. */
3939 insns
= get_insns ();
3943 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3950 /* Expand expression EXP, which is a call to the strncat builtin.
3951 Return 0 if we failed the caller should emit a normal call,
3952 otherwise try to get the result in TARGET, if convenient. */
3955 expand_builtin_strncat (tree arglist
, rtx target
, enum machine_mode mode
)
3957 if (validate_arglist (arglist
,
3958 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3960 tree result
= fold_builtin_strncat (arglist
);
3962 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3967 /* Expand expression EXP, which is a call to the strspn builtin.
3968 Return 0 if we failed the caller should emit a normal call,
3969 otherwise try to get the result in TARGET, if convenient. */
3972 expand_builtin_strspn (tree arglist
, rtx target
, enum machine_mode mode
)
3974 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3976 tree result
= fold_builtin_strspn (arglist
);
3978 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3983 /* Expand expression EXP, which is a call to the strcspn builtin.
3984 Return 0 if we failed the caller should emit a normal call,
3985 otherwise try to get the result in TARGET, if convenient. */
3988 expand_builtin_strcspn (tree arglist
, rtx target
, enum machine_mode mode
)
3990 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3992 tree result
= fold_builtin_strcspn (arglist
);
3994 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3999 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4000 if that's convenient. */
4003 expand_builtin_saveregs (void)
4007 /* Don't do __builtin_saveregs more than once in a function.
4008 Save the result of the first call and reuse it. */
4009 if (saveregs_value
!= 0)
4010 return saveregs_value
;
4012 /* When this function is called, it means that registers must be
4013 saved on entry to this function. So we migrate the call to the
4014 first insn of this function. */
4018 /* Do whatever the machine needs done in this case. */
4019 val
= targetm
.calls
.expand_builtin_saveregs ();
4024 saveregs_value
= val
;
4026 /* Put the insns after the NOTE that starts the function. If this
4027 is inside a start_sequence, make the outer-level insn chain current, so
4028 the code is placed at the start of the function. */
4029 push_topmost_sequence ();
4030 emit_insn_after (seq
, entry_of_function ());
4031 pop_topmost_sequence ();
4036 /* __builtin_args_info (N) returns word N of the arg space info
4037 for the current function. The number and meanings of words
4038 is controlled by the definition of CUMULATIVE_ARGS. */
4041 expand_builtin_args_info (tree arglist
)
4043 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
4044 int *word_ptr
= (int *) ¤t_function_args_info
;
4046 gcc_assert (sizeof (CUMULATIVE_ARGS
) % sizeof (int) == 0);
4050 if (!host_integerp (TREE_VALUE (arglist
), 0))
4051 error ("argument of %<__builtin_args_info%> must be constant");
4054 HOST_WIDE_INT wordnum
= tree_low_cst (TREE_VALUE (arglist
), 0);
4056 if (wordnum
< 0 || wordnum
>= nwords
)
4057 error ("argument of %<__builtin_args_info%> out of range");
4059 return GEN_INT (word_ptr
[wordnum
]);
4063 error ("missing argument in %<__builtin_args_info%>");
4068 /* Expand a call to __builtin_next_arg. */
4071 expand_builtin_next_arg (void)
4073 /* Checking arguments is already done in fold_builtin_next_arg
4074 that must be called before this function. */
4075 return expand_binop (Pmode
, add_optab
,
4076 current_function_internal_arg_pointer
,
4077 current_function_arg_offset_rtx
,
4078 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
4081 /* Make it easier for the backends by protecting the valist argument
4082 from multiple evaluations. */
4085 stabilize_va_list (tree valist
, int needs_lvalue
)
4087 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4089 if (TREE_SIDE_EFFECTS (valist
))
4090 valist
= save_expr (valist
);
4092 /* For this case, the backends will be expecting a pointer to
4093 TREE_TYPE (va_list_type_node), but it's possible we've
4094 actually been given an array (an actual va_list_type_node).
4096 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4098 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4099 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4108 if (! TREE_SIDE_EFFECTS (valist
))
4111 pt
= build_pointer_type (va_list_type_node
);
4112 valist
= fold_build1 (ADDR_EXPR
, pt
, valist
);
4113 TREE_SIDE_EFFECTS (valist
) = 1;
4116 if (TREE_SIDE_EFFECTS (valist
))
4117 valist
= save_expr (valist
);
4118 valist
= build_fold_indirect_ref (valist
);
4124 /* The "standard" definition of va_list is void*. */
4127 std_build_builtin_va_list (void)
4129 return ptr_type_node
;
4132 /* The "standard" implementation of va_start: just assign `nextarg' to
4136 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
4140 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
4141 make_tree (ptr_type_node
, nextarg
));
4142 TREE_SIDE_EFFECTS (t
) = 1;
4144 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4147 /* Expand ARGLIST, from a call to __builtin_va_start. */
4150 expand_builtin_va_start (tree arglist
)
4155 chain
= TREE_CHAIN (arglist
);
4159 error ("too few arguments to function %<va_start%>");
4163 if (fold_builtin_next_arg (chain
))
4166 nextarg
= expand_builtin_next_arg ();
4167 valist
= stabilize_va_list (TREE_VALUE (arglist
), 1);
4169 #ifdef EXPAND_BUILTIN_VA_START
4170 EXPAND_BUILTIN_VA_START (valist
, nextarg
);
4172 std_expand_builtin_va_start (valist
, nextarg
);
4178 /* The "standard" implementation of va_arg: read the value from the
4179 current (padded) address and increment by the (padded) size. */
4182 std_gimplify_va_arg_expr (tree valist
, tree type
, tree
*pre_p
, tree
*post_p
)
4184 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
4185 unsigned HOST_WIDE_INT align
, boundary
;
4188 #ifdef ARGS_GROW_DOWNWARD
4189 /* All of the alignment and movement below is for args-grow-up machines.
4190 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4191 implement their own specialized gimplify_va_arg_expr routines. */
4195 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
4197 type
= build_pointer_type (type
);
4199 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
4200 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
) / BITS_PER_UNIT
;
4202 /* Hoist the valist value into a temporary for the moment. */
4203 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
4205 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4206 requires greater alignment, we must perform dynamic alignment. */
4207 if (boundary
> align
4208 && !integer_zerop (TYPE_SIZE (type
)))
4210 t
= fold_convert (TREE_TYPE (valist
), size_int (boundary
- 1));
4211 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4212 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4213 gimplify_and_add (t
, pre_p
);
4215 t
= fold_convert (TREE_TYPE (valist
), size_int (-boundary
));
4216 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
4217 build2 (BIT_AND_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
4218 gimplify_and_add (t
, pre_p
);
4223 /* If the actual alignment is less than the alignment of the type,
4224 adjust the type accordingly so that we don't assume strict alignment
4225 when deferencing the pointer. */
4226 boundary
*= BITS_PER_UNIT
;
4227 if (boundary
< TYPE_ALIGN (type
))
4229 type
= build_variant_type_copy (type
);
4230 TYPE_ALIGN (type
) = boundary
;
4233 /* Compute the rounded size of the type. */
4234 type_size
= size_in_bytes (type
);
4235 rounded_size
= round_up (type_size
, align
);
4237 /* Reduce rounded_size so it's sharable with the postqueue. */
4238 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4242 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
4244 /* Small args are padded downward. */
4245 t
= fold_build2 (GT_EXPR
, sizetype
, rounded_size
, size_int (align
));
4246 t
= fold_build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
4247 size_binop (MINUS_EXPR
, rounded_size
, type_size
));
4248 t
= fold_convert (TREE_TYPE (addr
), t
);
4249 addr
= fold_build2 (PLUS_EXPR
, TREE_TYPE (addr
), addr
, t
);
4252 /* Compute new value for AP. */
4253 t
= fold_convert (TREE_TYPE (valist
), rounded_size
);
4254 t
= build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
);
4255 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
4256 gimplify_and_add (t
, pre_p
);
4258 addr
= fold_convert (build_pointer_type (type
), addr
);
4261 addr
= build_va_arg_indirect_ref (addr
);
4263 return build_va_arg_indirect_ref (addr
);
4266 /* Build an indirect-ref expression over the given TREE, which represents a
4267 piece of a va_arg() expansion. */
4269 build_va_arg_indirect_ref (tree addr
)
4271 addr
= build_fold_indirect_ref (addr
);
4273 if (flag_mudflap
) /* Don't instrument va_arg INDIRECT_REF. */
4279 /* Return a dummy expression of type TYPE in order to keep going after an
4283 dummy_object (tree type
)
4285 tree t
= convert (build_pointer_type (type
), null_pointer_node
);
4286 return build1 (INDIRECT_REF
, type
, t
);
4289 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4290 builtin function, but a very special sort of operator. */
4292 enum gimplify_status
4293 gimplify_va_arg_expr (tree
*expr_p
, tree
*pre_p
, tree
*post_p
)
4295 tree promoted_type
, want_va_type
, have_va_type
;
4296 tree valist
= TREE_OPERAND (*expr_p
, 0);
4297 tree type
= TREE_TYPE (*expr_p
);
4300 /* Verify that valist is of the proper type. */
4301 want_va_type
= va_list_type_node
;
4302 have_va_type
= TREE_TYPE (valist
);
4304 if (have_va_type
== error_mark_node
)
4307 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
4309 /* If va_list is an array type, the argument may have decayed
4310 to a pointer type, e.g. by being passed to another function.
4311 In that case, unwrap both types so that we can compare the
4312 underlying records. */
4313 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
4314 || POINTER_TYPE_P (have_va_type
))
4316 want_va_type
= TREE_TYPE (want_va_type
);
4317 have_va_type
= TREE_TYPE (have_va_type
);
4321 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
4323 error ("first argument to %<va_arg%> not of type %<va_list%>");
4327 /* Generate a diagnostic for requesting data of a type that cannot
4328 be passed through `...' due to type promotion at the call site. */
4329 else if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4332 static bool gave_help
;
4334 /* Unfortunately, this is merely undefined, rather than a constraint
4335 violation, so we cannot make this an error. If this call is never
4336 executed, the program is still strictly conforming. */
4337 warning (0, "%qT is promoted to %qT when passed through %<...%>",
4338 type
, promoted_type
);
4342 warning (0, "(so you should pass %qT not %qT to %<va_arg%>)",
4343 promoted_type
, type
);
4346 /* We can, however, treat "undefined" any way we please.
4347 Call abort to encourage the user to fix the program. */
4348 inform ("if this code is reached, the program will abort");
4349 t
= build_function_call_expr (implicit_built_in_decls
[BUILT_IN_TRAP
],
4351 append_to_statement_list (t
, pre_p
);
4353 /* This is dead code, but go ahead and finish so that the
4354 mode of the result comes out right. */
4355 *expr_p
= dummy_object (type
);
4360 /* Make it easier for the backends by protecting the valist argument
4361 from multiple evaluations. */
4362 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4364 /* For this case, the backends will be expecting a pointer to
4365 TREE_TYPE (va_list_type_node), but it's possible we've
4366 actually been given an array (an actual va_list_type_node).
4368 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4370 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4371 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4373 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4376 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
4378 if (!targetm
.gimplify_va_arg_expr
)
4379 /* FIXME:Once most targets are converted we should merely
4380 assert this is non-null. */
4383 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
4388 /* Expand ARGLIST, from a call to __builtin_va_end. */
4391 expand_builtin_va_end (tree arglist
)
4393 tree valist
= TREE_VALUE (arglist
);
4395 /* Evaluate for side effects, if needed. I hate macros that don't
4397 if (TREE_SIDE_EFFECTS (valist
))
4398 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4403 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4404 builtin rather than just as an assignment in stdarg.h because of the
4405 nastiness of array-type va_list types. */
4408 expand_builtin_va_copy (tree arglist
)
4412 dst
= TREE_VALUE (arglist
);
4413 src
= TREE_VALUE (TREE_CHAIN (arglist
));
4415 dst
= stabilize_va_list (dst
, 1);
4416 src
= stabilize_va_list (src
, 0);
4418 if (TREE_CODE (va_list_type_node
) != ARRAY_TYPE
)
4420 t
= build2 (MODIFY_EXPR
, va_list_type_node
, dst
, src
);
4421 TREE_SIDE_EFFECTS (t
) = 1;
4422 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4426 rtx dstb
, srcb
, size
;
4428 /* Evaluate to pointers. */
4429 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4430 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4431 size
= expand_expr (TYPE_SIZE_UNIT (va_list_type_node
), NULL_RTX
,
4432 VOIDmode
, EXPAND_NORMAL
);
4434 dstb
= convert_memory_address (Pmode
, dstb
);
4435 srcb
= convert_memory_address (Pmode
, srcb
);
4437 /* "Dereference" to BLKmode memories. */
4438 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4439 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4440 set_mem_align (dstb
, TYPE_ALIGN (va_list_type_node
));
4441 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4442 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4443 set_mem_align (srcb
, TYPE_ALIGN (va_list_type_node
));
4446 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4452 /* Expand a call to one of the builtin functions __builtin_frame_address or
4453 __builtin_return_address. */
4456 expand_builtin_frame_address (tree fndecl
, tree arglist
)
4458 /* The argument must be a nonnegative integer constant.
4459 It counts the number of frames to scan up the stack.
4460 The value is the return address saved in that frame. */
4462 /* Warning about missing arg was already issued. */
4464 else if (! host_integerp (TREE_VALUE (arglist
), 1))
4466 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4467 error ("invalid argument to %<__builtin_frame_address%>");
4469 error ("invalid argument to %<__builtin_return_address%>");
4475 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4476 tree_low_cst (TREE_VALUE (arglist
), 1));
4478 /* Some ports cannot access arbitrary stack frames. */
4481 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4482 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4484 warning (0, "unsupported argument to %<__builtin_return_address%>");
4488 /* For __builtin_frame_address, return what we've got. */
4489 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4493 && ! CONSTANT_P (tem
))
4494 tem
= copy_to_mode_reg (Pmode
, tem
);
4499 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4500 we failed and the caller should emit a normal call, otherwise try to get
4501 the result in TARGET, if convenient. */
4504 expand_builtin_alloca (tree arglist
, rtx target
)
4509 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4510 should always expand to function calls. These can be intercepted
4515 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4518 /* Compute the argument. */
4519 op0
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
4521 /* Allocate the desired space. */
4522 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
4523 result
= convert_memory_address (ptr_mode
, result
);
4528 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4529 Return 0 if a normal call should be emitted rather than expanding the
4530 function in-line. If convenient, the result should be placed in TARGET.
4531 SUBTARGET may be used as the target for computing one of EXP's operands. */
4534 expand_builtin_unop (enum machine_mode target_mode
, tree arglist
, rtx target
,
4535 rtx subtarget
, optab op_optab
)
4538 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4541 /* Compute the argument. */
4542 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4543 /* Compute op, into TARGET if possible.
4544 Set TARGET to wherever the result comes back. */
4545 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4546 op_optab
, op0
, target
, 1);
4547 gcc_assert (target
);
4549 return convert_to_mode (target_mode
, target
, 0);
4552 /* If the string passed to fputs is a constant and is one character
4553 long, we attempt to transform this call into __builtin_fputc(). */
4556 expand_builtin_fputs (tree arglist
, rtx target
, bool unlocked
)
4558 /* Verify the arguments in the original call. */
4559 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4561 tree result
= fold_builtin_fputs (arglist
, (target
== const0_rtx
),
4562 unlocked
, NULL_TREE
);
4564 return expand_expr (result
, target
, VOIDmode
, EXPAND_NORMAL
);
4569 /* Expand a call to __builtin_expect. We return our argument and emit a
4570 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4571 a non-jump context. */
4574 expand_builtin_expect (tree arglist
, rtx target
)
4579 if (arglist
== NULL_TREE
4580 || TREE_CHAIN (arglist
) == NULL_TREE
)
4582 exp
= TREE_VALUE (arglist
);
4583 c
= TREE_VALUE (TREE_CHAIN (arglist
));
4585 if (TREE_CODE (c
) != INTEGER_CST
)
4587 error ("second argument to %<__builtin_expect%> must be a constant");
4588 c
= integer_zero_node
;
4591 target
= expand_expr (exp
, target
, VOIDmode
, EXPAND_NORMAL
);
4593 /* Don't bother with expected value notes for integral constants. */
4594 if (flag_guess_branch_prob
&& GET_CODE (target
) != CONST_INT
)
4596 /* We do need to force this into a register so that we can be
4597 moderately sure to be able to correctly interpret the branch
4599 target
= force_reg (GET_MODE (target
), target
);
4601 rtx_c
= expand_expr (c
, NULL_RTX
, GET_MODE (target
), EXPAND_NORMAL
);
4603 note
= emit_note (NOTE_INSN_EXPECTED_VALUE
);
4604 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, target
, rtx_c
);
4610 /* Like expand_builtin_expect, except do this in a jump context. This is
4611 called from do_jump if the conditional is a __builtin_expect. Return either
4612 a list of insns to emit the jump or NULL if we cannot optimize
4613 __builtin_expect. We need to optimize this at jump time so that machines
4614 like the PowerPC don't turn the test into a SCC operation, and then jump
4615 based on the test being 0/1. */
4618 expand_builtin_expect_jump (tree exp
, rtx if_false_label
, rtx if_true_label
)
4620 tree arglist
= TREE_OPERAND (exp
, 1);
4621 tree arg0
= TREE_VALUE (arglist
);
4622 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
4625 /* Only handle __builtin_expect (test, 0) and
4626 __builtin_expect (test, 1). */
4627 if (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
4628 && (integer_zerop (arg1
) || integer_onep (arg1
)))
4630 rtx insn
, drop_through_label
, temp
;
4632 /* Expand the jump insns. */
4634 do_jump (arg0
, if_false_label
, if_true_label
);
4637 drop_through_label
= get_last_insn ();
4638 if (drop_through_label
&& NOTE_P (drop_through_label
))
4639 drop_through_label
= prev_nonnote_insn (drop_through_label
);
4640 if (drop_through_label
&& !LABEL_P (drop_through_label
))
4641 drop_through_label
= NULL_RTX
;
4644 if (! if_true_label
)
4645 if_true_label
= drop_through_label
;
4646 if (! if_false_label
)
4647 if_false_label
= drop_through_label
;
4649 /* Go through and add the expect's to each of the conditional jumps. */
4651 while (insn
!= NULL_RTX
)
4653 rtx next
= NEXT_INSN (insn
);
4655 if (JUMP_P (insn
) && any_condjump_p (insn
))
4657 rtx ifelse
= SET_SRC (pc_set (insn
));
4658 rtx then_dest
= XEXP (ifelse
, 1);
4659 rtx else_dest
= XEXP (ifelse
, 2);
4662 /* First check if we recognize any of the labels. */
4663 if (GET_CODE (then_dest
) == LABEL_REF
4664 && XEXP (then_dest
, 0) == if_true_label
)
4666 else if (GET_CODE (then_dest
) == LABEL_REF
4667 && XEXP (then_dest
, 0) == if_false_label
)
4669 else if (GET_CODE (else_dest
) == LABEL_REF
4670 && XEXP (else_dest
, 0) == if_false_label
)
4672 else if (GET_CODE (else_dest
) == LABEL_REF
4673 && XEXP (else_dest
, 0) == if_true_label
)
4675 /* Otherwise check where we drop through. */
4676 else if (else_dest
== pc_rtx
)
4678 if (next
&& NOTE_P (next
))
4679 next
= next_nonnote_insn (next
);
4681 if (next
&& JUMP_P (next
)
4682 && any_uncondjump_p (next
))
4683 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4687 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4688 else that can't possibly match either target label. */
4689 if (temp
== if_false_label
)
4691 else if (temp
== if_true_label
)
4694 else if (then_dest
== pc_rtx
)
4696 if (next
&& NOTE_P (next
))
4697 next
= next_nonnote_insn (next
);
4699 if (next
&& JUMP_P (next
)
4700 && any_uncondjump_p (next
))
4701 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4705 if (temp
== if_false_label
)
4707 else if (temp
== if_true_label
)
4713 /* If the test is expected to fail, reverse the
4715 if (integer_zerop (arg1
))
4717 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, taken
);
4729 expand_builtin_trap (void)
4733 emit_insn (gen_trap ());
4736 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4740 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4741 Return 0 if a normal call should be emitted rather than expanding
4742 the function inline. If convenient, the result should be placed
4743 in TARGET. SUBTARGET may be used as the target for computing
4747 expand_builtin_fabs (tree arglist
, rtx target
, rtx subtarget
)
4749 enum machine_mode mode
;
4753 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
4756 arg
= TREE_VALUE (arglist
);
4757 mode
= TYPE_MODE (TREE_TYPE (arg
));
4758 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4759 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4762 /* Expand a call to copysign, copysignf, or copysignl with arguments ARGLIST.
4763 Return NULL is a normal call should be emitted rather than expanding the
4764 function inline. If convenient, the result should be placed in TARGET.
4765 SUBTARGET may be used as the target for computing the operand. */
4768 expand_builtin_copysign (tree arglist
, rtx target
, rtx subtarget
)
4773 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
4776 arg
= TREE_VALUE (arglist
);
4777 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4779 arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4780 op1
= expand_expr (arg
, NULL
, VOIDmode
, 0);
4782 return expand_copysign (op0
, op1
, target
);
4785 /* Create a new constant string literal and return a char* pointer to it.
4786 The STRING_CST value is the LEN characters at STR. */
4788 build_string_literal (int len
, const char *str
)
4790 tree t
, elem
, index
, type
;
4792 t
= build_string (len
, str
);
4793 elem
= build_type_variant (char_type_node
, 1, 0);
4794 index
= build_index_type (build_int_cst (NULL_TREE
, len
- 1));
4795 type
= build_array_type (elem
, index
);
4796 TREE_TYPE (t
) = type
;
4797 TREE_CONSTANT (t
) = 1;
4798 TREE_INVARIANT (t
) = 1;
4799 TREE_READONLY (t
) = 1;
4800 TREE_STATIC (t
) = 1;
4802 type
= build_pointer_type (type
);
4803 t
= build1 (ADDR_EXPR
, type
, t
);
4805 type
= build_pointer_type (elem
);
4806 t
= build1 (NOP_EXPR
, type
, t
);
4810 /* Expand EXP, a call to printf or printf_unlocked.
4811 Return 0 if a normal call should be emitted rather than transforming
4812 the function inline. If convenient, the result should be placed in
4813 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4816 expand_builtin_printf (tree exp
, rtx target
, enum machine_mode mode
,
4819 tree arglist
= TREE_OPERAND (exp
, 1);
4820 /* If we're using an unlocked function, assume the other unlocked
4821 functions exist explicitly. */
4822 tree
const fn_putchar
= unlocked
? built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
]
4823 : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4824 tree
const fn_puts
= unlocked
? built_in_decls
[BUILT_IN_PUTS_UNLOCKED
]
4825 : implicit_built_in_decls
[BUILT_IN_PUTS
];
4826 const char *fmt_str
;
4829 /* If the return value is used, don't do the transformation. */
4830 if (target
!= const0_rtx
)
4833 /* Verify the required arguments in the original call. */
4836 fmt
= TREE_VALUE (arglist
);
4837 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4839 arglist
= TREE_CHAIN (arglist
);
4841 /* Check whether the format is a literal string constant. */
4842 fmt_str
= c_getstr (fmt
);
4843 if (fmt_str
== NULL
)
4846 if (!init_target_chars())
4849 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4850 if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
4853 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
4854 || TREE_CHAIN (arglist
))
4858 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4859 else if (strcmp (fmt_str
, target_percent_c
) == 0)
4862 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
4863 || TREE_CHAIN (arglist
))
4869 /* We can't handle anything else with % args or %% ... yet. */
4870 if (strchr (fmt_str
, target_percent
))
4876 /* If the format specifier was "", printf does nothing. */
4877 if (fmt_str
[0] == '\0')
4879 /* If the format specifier has length of 1, call putchar. */
4880 if (fmt_str
[1] == '\0')
4882 /* Given printf("c"), (where c is any one character,)
4883 convert "c"[0] to an int and pass that to the replacement
4885 arg
= build_int_cst (NULL_TREE
, fmt_str
[0]);
4886 arglist
= build_tree_list (NULL_TREE
, arg
);
4891 /* If the format specifier was "string\n", call puts("string"). */
4892 size_t len
= strlen (fmt_str
);
4893 if ((unsigned char)fmt_str
[len
- 1] == target_newline
)
4895 /* Create a NUL-terminated string that's one char shorter
4896 than the original, stripping off the trailing '\n'. */
4897 char *newstr
= alloca (len
);
4898 memcpy (newstr
, fmt_str
, len
- 1);
4899 newstr
[len
- 1] = 0;
4901 arg
= build_string_literal (len
, newstr
);
4902 arglist
= build_tree_list (NULL_TREE
, arg
);
4906 /* We'd like to arrange to call fputs(string,stdout) here,
4907 but we need stdout and don't have a way to get it yet. */
4914 fn
= build_function_call_expr (fn
, arglist
);
4915 if (TREE_CODE (fn
) == CALL_EXPR
)
4916 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
4917 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
4920 /* Expand EXP, a call to fprintf or fprintf_unlocked.
4921 Return 0 if a normal call should be emitted rather than transforming
4922 the function inline. If convenient, the result should be placed in
4923 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4926 expand_builtin_fprintf (tree exp
, rtx target
, enum machine_mode mode
,
4929 tree arglist
= TREE_OPERAND (exp
, 1);
4930 /* If we're using an unlocked function, assume the other unlocked
4931 functions exist explicitly. */
4932 tree
const fn_fputc
= unlocked
? built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
4933 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4934 tree
const fn_fputs
= unlocked
? built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
]
4935 : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4936 const char *fmt_str
;
4937 tree fn
, fmt
, fp
, arg
;
4939 /* If the return value is used, don't do the transformation. */
4940 if (target
!= const0_rtx
)
4943 /* Verify the required arguments in the original call. */
4946 fp
= TREE_VALUE (arglist
);
4947 if (! POINTER_TYPE_P (TREE_TYPE (fp
)))
4949 arglist
= TREE_CHAIN (arglist
);
4952 fmt
= TREE_VALUE (arglist
);
4953 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4955 arglist
= TREE_CHAIN (arglist
);
4957 /* Check whether the format is a literal string constant. */
4958 fmt_str
= c_getstr (fmt
);
4959 if (fmt_str
== NULL
)
4962 if (!init_target_chars())
4965 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
4966 if (strcmp (fmt_str
, target_percent_s
) == 0)
4969 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
4970 || TREE_CHAIN (arglist
))
4972 arg
= TREE_VALUE (arglist
);
4973 arglist
= build_tree_list (NULL_TREE
, fp
);
4974 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
4977 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
4978 else if (strcmp (fmt_str
, target_percent_c
) == 0)
4981 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
4982 || TREE_CHAIN (arglist
))
4984 arg
= TREE_VALUE (arglist
);
4985 arglist
= build_tree_list (NULL_TREE
, fp
);
4986 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
4991 /* We can't handle anything else with % args or %% ... yet. */
4992 if (strchr (fmt_str
, target_percent
))
4998 /* If the format specifier was "", fprintf does nothing. */
4999 if (fmt_str
[0] == '\0')
5001 /* Evaluate and ignore FILE* argument for side-effects. */
5002 expand_expr (fp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5006 /* When "string" doesn't contain %, replace all cases of
5007 fprintf(stream,string) with fputs(string,stream). The fputs
5008 builtin will take care of special cases like length == 1. */
5009 arglist
= build_tree_list (NULL_TREE
, fp
);
5010 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
5016 fn
= build_function_call_expr (fn
, arglist
);
5017 if (TREE_CODE (fn
) == CALL_EXPR
)
5018 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
5019 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
5022 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
5023 a normal call should be emitted rather than expanding the function
5024 inline. If convenient, the result should be placed in TARGET with
5028 expand_builtin_sprintf (tree arglist
, rtx target
, enum machine_mode mode
)
5030 tree orig_arglist
, dest
, fmt
;
5031 const char *fmt_str
;
5033 orig_arglist
= arglist
;
5035 /* Verify the required arguments in the original call. */
5038 dest
= TREE_VALUE (arglist
);
5039 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
5041 arglist
= TREE_CHAIN (arglist
);
5044 fmt
= TREE_VALUE (arglist
);
5045 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
5047 arglist
= TREE_CHAIN (arglist
);
5049 /* Check whether the format is a literal string constant. */
5050 fmt_str
= c_getstr (fmt
);
5051 if (fmt_str
== NULL
)
5054 if (!init_target_chars())
5057 /* If the format doesn't contain % args or %%, use strcpy. */
5058 if (strchr (fmt_str
, target_percent
) == 0)
5060 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5063 if (arglist
|| ! fn
)
5065 expand_expr (build_function_call_expr (fn
, orig_arglist
),
5066 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5067 if (target
== const0_rtx
)
5069 exp
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
5070 return expand_expr (exp
, target
, mode
, EXPAND_NORMAL
);
5072 /* If the format is "%s", use strcpy if the result isn't used. */
5073 else if (strcmp (fmt_str
, target_percent_s
) == 0)
5076 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
5081 if (! arglist
|| TREE_CHAIN (arglist
))
5083 arg
= TREE_VALUE (arglist
);
5084 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
5087 if (target
!= const0_rtx
)
5089 len
= c_strlen (arg
, 1);
5090 if (! len
|| TREE_CODE (len
) != INTEGER_CST
)
5096 arglist
= build_tree_list (NULL_TREE
, arg
);
5097 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
5098 expand_expr (build_function_call_expr (fn
, arglist
),
5099 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
5101 if (target
== const0_rtx
)
5103 return expand_expr (len
, target
, mode
, EXPAND_NORMAL
);
5109 /* Expand a call to either the entry or exit function profiler. */
5112 expand_builtin_profile_func (bool exitp
)
5116 this = DECL_RTL (current_function_decl
);
5117 gcc_assert (MEM_P (this));
5118 this = XEXP (this, 0);
5121 which
= profile_function_exit_libfunc
;
5123 which
= profile_function_entry_libfunc
;
5125 emit_library_call (which
, LCT_NORMAL
, VOIDmode
, 2, this, Pmode
,
5126 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
5133 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5136 round_trampoline_addr (rtx tramp
)
5138 rtx temp
, addend
, mask
;
5140 /* If we don't need too much alignment, we'll have been guaranteed
5141 proper alignment by get_trampoline_type. */
5142 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
5145 /* Round address up to desired boundary. */
5146 temp
= gen_reg_rtx (Pmode
);
5147 addend
= GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1);
5148 mask
= GEN_INT (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
5150 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
5151 temp
, 0, OPTAB_LIB_WIDEN
);
5152 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
5153 temp
, 0, OPTAB_LIB_WIDEN
);
5159 expand_builtin_init_trampoline (tree arglist
)
5161 tree t_tramp
, t_func
, t_chain
;
5162 rtx r_tramp
, r_func
, r_chain
;
5163 #ifdef TRAMPOLINE_TEMPLATE
5167 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
,
5168 POINTER_TYPE
, VOID_TYPE
))
5171 t_tramp
= TREE_VALUE (arglist
);
5172 arglist
= TREE_CHAIN (arglist
);
5173 t_func
= TREE_VALUE (arglist
);
5174 arglist
= TREE_CHAIN (arglist
);
5175 t_chain
= TREE_VALUE (arglist
);
5177 r_tramp
= expand_expr (t_tramp
, NULL_RTX
, VOIDmode
, 0);
5178 r_func
= expand_expr (t_func
, NULL_RTX
, VOIDmode
, 0);
5179 r_chain
= expand_expr (t_chain
, NULL_RTX
, VOIDmode
, 0);
5181 /* Generate insns to initialize the trampoline. */
5182 r_tramp
= round_trampoline_addr (r_tramp
);
5183 #ifdef TRAMPOLINE_TEMPLATE
5184 blktramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
5185 set_mem_align (blktramp
, TRAMPOLINE_ALIGNMENT
);
5186 emit_block_move (blktramp
, assemble_trampoline_template (),
5187 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
5189 trampolines_created
= 1;
5190 INITIALIZE_TRAMPOLINE (r_tramp
, r_func
, r_chain
);
5196 expand_builtin_adjust_trampoline (tree arglist
)
5200 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5203 tramp
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
5204 tramp
= round_trampoline_addr (tramp
);
5205 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5206 TRAMPOLINE_ADJUST_ADDRESS (tramp
);
5212 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5213 Return NULL_RTX if a normal call should be emitted rather than expanding
5214 the function in-line. EXP is the expression that is a call to the builtin
5215 function; if convenient, the result should be placed in TARGET. */
5218 expand_builtin_signbit (tree exp
, rtx target
)
5220 const struct real_format
*fmt
;
5221 enum machine_mode fmode
, imode
, rmode
;
5222 HOST_WIDE_INT hi
, lo
;
5227 arglist
= TREE_OPERAND (exp
, 1);
5228 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
5231 arg
= TREE_VALUE (arglist
);
5232 fmode
= TYPE_MODE (TREE_TYPE (arg
));
5233 rmode
= TYPE_MODE (TREE_TYPE (exp
));
5234 fmt
= REAL_MODE_FORMAT (fmode
);
5236 /* For floating point formats without a sign bit, implement signbit
5238 bitpos
= fmt
->signbit_ro
;
5241 /* But we can't do this if the format supports signed zero. */
5242 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
5245 arg
= fold_build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
5246 build_real (TREE_TYPE (arg
), dconst0
));
5247 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
5250 temp
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
5251 if (GET_MODE_SIZE (fmode
) <= UNITS_PER_WORD
)
5253 imode
= int_mode_for_mode (fmode
);
5254 if (imode
== BLKmode
)
5256 temp
= gen_lowpart (imode
, temp
);
5261 /* Handle targets with different FP word orders. */
5262 if (FLOAT_WORDS_BIG_ENDIAN
)
5263 word
= (GET_MODE_BITSIZE (fmode
) - bitpos
) / BITS_PER_WORD
;
5265 word
= bitpos
/ BITS_PER_WORD
;
5266 temp
= operand_subword_force (temp
, word
, fmode
);
5267 bitpos
= bitpos
% BITS_PER_WORD
;
5270 /* Force the intermediate word_mode (or narrower) result into a
5271 register. This avoids attempting to create paradoxical SUBREGs
5272 of floating point modes below. */
5273 temp
= force_reg (imode
, temp
);
5275 /* If the bitpos is within the "result mode" lowpart, the operation
5276 can be implement with a single bitwise AND. Otherwise, we need
5277 a right shift and an AND. */
5279 if (bitpos
< GET_MODE_BITSIZE (rmode
))
5281 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5284 lo
= (HOST_WIDE_INT
) 1 << bitpos
;
5288 hi
= (HOST_WIDE_INT
) 1 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5293 temp
= gen_lowpart (rmode
, temp
);
5294 temp
= expand_binop (rmode
, and_optab
, temp
,
5295 immed_double_const (lo
, hi
, rmode
),
5296 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5300 /* Perform a logical right shift to place the signbit in the least
5301 significant bit, then truncate the result to the desired mode
5302 and mask just this bit. */
5303 temp
= expand_shift (RSHIFT_EXPR
, imode
, temp
,
5304 build_int_cst (NULL_TREE
, bitpos
), NULL_RTX
, 1);
5305 temp
= gen_lowpart (rmode
, temp
);
5306 temp
= expand_binop (rmode
, and_optab
, temp
, const1_rtx
,
5307 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5313 /* Expand fork or exec calls. TARGET is the desired target of the
5314 call. ARGLIST is the list of arguments of the call. FN is the
5315 identificator of the actual function. IGNORE is nonzero if the
5316 value is to be ignored. */
5319 expand_builtin_fork_or_exec (tree fn
, tree arglist
, rtx target
, int ignore
)
5324 /* If we are not profiling, just call the function. */
5325 if (!profile_arc_flag
)
5328 /* Otherwise call the wrapper. This should be equivalent for the rest of
5329 compiler, so the code does not diverge, and the wrapper may run the
5330 code necessary for keeping the profiling sane. */
5332 switch (DECL_FUNCTION_CODE (fn
))
5335 id
= get_identifier ("__gcov_fork");
5338 case BUILT_IN_EXECL
:
5339 id
= get_identifier ("__gcov_execl");
5342 case BUILT_IN_EXECV
:
5343 id
= get_identifier ("__gcov_execv");
5346 case BUILT_IN_EXECLP
:
5347 id
= get_identifier ("__gcov_execlp");
5350 case BUILT_IN_EXECLE
:
5351 id
= get_identifier ("__gcov_execle");
5354 case BUILT_IN_EXECVP
:
5355 id
= get_identifier ("__gcov_execvp");
5358 case BUILT_IN_EXECVE
:
5359 id
= get_identifier ("__gcov_execve");
5366 decl
= build_decl (FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5367 DECL_EXTERNAL (decl
) = 1;
5368 TREE_PUBLIC (decl
) = 1;
5369 DECL_ARTIFICIAL (decl
) = 1;
5370 TREE_NOTHROW (decl
) = 1;
5371 call
= build_function_call_expr (decl
, arglist
);
5373 return expand_call (call
, target
, ignore
);
5377 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5378 the pointer in these functions is void*, the tree optimizers may remove
5379 casts. The mode computed in expand_builtin isn't reliable either, due
5380 to __sync_bool_compare_and_swap.
5382 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5383 group of builtins. This gives us log2 of the mode size. */
5385 static inline enum machine_mode
5386 get_builtin_sync_mode (int fcode_diff
)
5388 /* The size is not negotiable, so ask not to get BLKmode in return
5389 if the target indicates that a smaller size would be better. */
5390 return mode_for_size (BITS_PER_UNIT
<< fcode_diff
, MODE_INT
, 0);
5393 /* Expand the memory expression LOC and return the appropriate memory operand
5394 for the builtin_sync operations. */
5397 get_builtin_sync_mem (tree loc
, enum machine_mode mode
)
5401 addr
= expand_expr (loc
, NULL
, Pmode
, EXPAND_SUM
);
5403 /* Note that we explicitly do not want any alias information for this
5404 memory, so that we kill all other live memories. Otherwise we don't
5405 satisfy the full barrier semantics of the intrinsic. */
5406 mem
= validize_mem (gen_rtx_MEM (mode
, addr
));
5408 set_mem_align (mem
, get_pointer_alignment (loc
, BIGGEST_ALIGNMENT
));
5409 MEM_VOLATILE_P (mem
) = 1;
5414 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5415 ARGLIST is the operands list to the function. CODE is the rtx code
5416 that corresponds to the arithmetic or logical operation from the name;
5417 an exception here is that NOT actually means NAND. TARGET is an optional
5418 place for us to store the results; AFTER is true if this is the
5419 fetch_and_xxx form. IGNORE is true if we don't actually care about
5420 the result of the operation at all. */
5423 expand_builtin_sync_operation (enum machine_mode mode
, tree arglist
,
5424 enum rtx_code code
, bool after
,
5425 rtx target
, bool ignore
)
5429 /* Expand the operands. */
5430 mem
= get_builtin_sync_mem (TREE_VALUE (arglist
), mode
);
5432 arglist
= TREE_CHAIN (arglist
);
5433 val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5436 return expand_sync_operation (mem
, val
, code
);
5438 return expand_sync_fetch_operation (mem
, val
, code
, after
, target
);
5441 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5442 intrinsics. ARGLIST is the operands list to the function. IS_BOOL is
5443 true if this is the boolean form. TARGET is a place for us to store the
5444 results; this is NOT optional if IS_BOOL is true. */
5447 expand_builtin_compare_and_swap (enum machine_mode mode
, tree arglist
,
5448 bool is_bool
, rtx target
)
5450 rtx old_val
, new_val
, mem
;
5452 /* Expand the operands. */
5453 mem
= get_builtin_sync_mem (TREE_VALUE (arglist
), mode
);
5455 arglist
= TREE_CHAIN (arglist
);
5456 old_val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5458 arglist
= TREE_CHAIN (arglist
);
5459 new_val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
5462 return expand_bool_compare_and_swap (mem
, old_val
, new_val
, target
);
5464 return expand_val_compare_and_swap (mem
, old_val
, new_val
, target
);
5467 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5468 general form is actually an atomic exchange, and some targets only
5469 support a reduced form with the second argument being a constant 1.
5470 ARGLIST is the operands list to the function; TARGET is an optional
5471 place for us to store the results. */
5474 expand_builtin_lock_test_and_set (enum machine_mode mode
, tree arglist
,
5479 /* Expand the operands. */
5480 mem
= get_builtin_sync_mem (TREE_VALUE (arglist
), mode
);
5482 arglist
= TREE_CHAIN (arglist
);
5483 val
= expand_expr (TREE_VALUE (arglist
), NULL
, mode
, EXPAND_NORMAL
);
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
5504 empty asm stmt with a memory clobber. */
5505 x
= build4 (ASM_EXPR
, void_type_node
, build_string (0, ""), NULL
, NULL
,
5506 tree_cons (NULL
, build_string (6, "memory"), NULL
));
5507 ASM_VOLATILE_P (x
) = 1;
5508 expand_asm_expr (x
);
5511 /* Expand the __sync_lock_release intrinsic. ARGLIST is the operands list
5515 expand_builtin_lock_release (enum machine_mode mode
, tree arglist
)
5517 enum insn_code icode
;
5519 rtx val
= const0_rtx
;
5521 /* Expand the operands. */
5522 mem
= get_builtin_sync_mem (TREE_VALUE (arglist
), mode
);
5524 /* If there is an explicit operation in the md file, use it. */
5525 icode
= sync_lock_release
[mode
];
5526 if (icode
!= CODE_FOR_nothing
)
5528 if (!insn_data
[icode
].operand
[1].predicate (val
, mode
))
5529 val
= force_reg (mode
, val
);
5531 insn
= GEN_FCN (icode
) (mem
, val
);
5539 /* Otherwise we can implement this operation by emitting a barrier
5540 followed by a store of zero. */
5541 expand_builtin_synchronize ();
5542 emit_move_insn (mem
, val
);
5545 /* Expand an expression EXP that calls a built-in function,
5546 with result going to TARGET if that's convenient
5547 (and in mode MODE if that's convenient).
5548 SUBTARGET may be used as the target for computing one of EXP's operands.
5549 IGNORE is nonzero if the value is to be ignored. */
5552 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5555 tree fndecl
= get_callee_fndecl (exp
);
5556 tree arglist
= TREE_OPERAND (exp
, 1);
5557 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5558 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5560 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5561 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5563 /* When not optimizing, generate calls to library functions for a certain
5566 && !called_as_built_in (fndecl
)
5567 && DECL_ASSEMBLER_NAME_SET_P (fndecl
)
5568 && fcode
!= BUILT_IN_ALLOCA
)
5569 return expand_call (exp
, target
, ignore
);
5571 /* The built-in function expanders test for target == const0_rtx
5572 to determine whether the function's result will be ignored. */
5574 target
= const0_rtx
;
5576 /* If the result of a pure or const built-in function is ignored, and
5577 none of its arguments are volatile, we can avoid expanding the
5578 built-in call and just evaluate the arguments for side-effects. */
5579 if (target
== const0_rtx
5580 && (DECL_IS_PURE (fndecl
) || TREE_READONLY (fndecl
)))
5582 bool volatilep
= false;
5585 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5586 if (TREE_THIS_VOLATILE (TREE_VALUE (arg
)))
5594 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5595 expand_expr (TREE_VALUE (arg
), const0_rtx
,
5596 VOIDmode
, EXPAND_NORMAL
);
5603 CASE_FLT_FN (BUILT_IN_FABS
):
5604 target
= expand_builtin_fabs (arglist
, target
, subtarget
);
5609 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
5610 target
= expand_builtin_copysign (arglist
, target
, subtarget
);
5615 /* Just do a normal library call if we were unable to fold
5617 CASE_FLT_FN (BUILT_IN_CABS
):
5620 CASE_FLT_FN (BUILT_IN_EXP
):
5621 CASE_FLT_FN (BUILT_IN_EXP10
):
5622 CASE_FLT_FN (BUILT_IN_POW10
):
5623 CASE_FLT_FN (BUILT_IN_EXP2
):
5624 CASE_FLT_FN (BUILT_IN_EXPM1
):
5625 CASE_FLT_FN (BUILT_IN_LOGB
):
5626 CASE_FLT_FN (BUILT_IN_ILOGB
):
5627 CASE_FLT_FN (BUILT_IN_LOG
):
5628 CASE_FLT_FN (BUILT_IN_LOG10
):
5629 CASE_FLT_FN (BUILT_IN_LOG2
):
5630 CASE_FLT_FN (BUILT_IN_LOG1P
):
5631 CASE_FLT_FN (BUILT_IN_TAN
):
5632 CASE_FLT_FN (BUILT_IN_ASIN
):
5633 CASE_FLT_FN (BUILT_IN_ACOS
):
5634 CASE_FLT_FN (BUILT_IN_ATAN
):
5635 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5636 because of possible accuracy problems. */
5637 if (! flag_unsafe_math_optimizations
)
5639 CASE_FLT_FN (BUILT_IN_SQRT
):
5640 CASE_FLT_FN (BUILT_IN_FLOOR
):
5641 CASE_FLT_FN (BUILT_IN_CEIL
):
5642 CASE_FLT_FN (BUILT_IN_TRUNC
):
5643 CASE_FLT_FN (BUILT_IN_ROUND
):
5644 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
5645 CASE_FLT_FN (BUILT_IN_RINT
):
5646 CASE_FLT_FN (BUILT_IN_LRINT
):
5647 CASE_FLT_FN (BUILT_IN_LLRINT
):
5648 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5653 CASE_FLT_FN (BUILT_IN_LCEIL
):
5654 CASE_FLT_FN (BUILT_IN_LLCEIL
):
5655 CASE_FLT_FN (BUILT_IN_LFLOOR
):
5656 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
5657 target
= expand_builtin_int_roundingfn (exp
, target
, subtarget
);
5662 CASE_FLT_FN (BUILT_IN_POW
):
5663 target
= expand_builtin_pow (exp
, target
, subtarget
);
5668 CASE_FLT_FN (BUILT_IN_POWI
):
5669 target
= expand_builtin_powi (exp
, target
, subtarget
);
5674 CASE_FLT_FN (BUILT_IN_ATAN2
):
5675 CASE_FLT_FN (BUILT_IN_LDEXP
):
5676 CASE_FLT_FN (BUILT_IN_FMOD
):
5677 CASE_FLT_FN (BUILT_IN_DREM
):
5678 if (! flag_unsafe_math_optimizations
)
5680 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5685 CASE_FLT_FN (BUILT_IN_SIN
):
5686 CASE_FLT_FN (BUILT_IN_COS
):
5687 if (! flag_unsafe_math_optimizations
)
5689 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5694 CASE_FLT_FN (BUILT_IN_SINCOS
):
5695 if (! flag_unsafe_math_optimizations
)
5697 target
= expand_builtin_sincos (exp
);
5702 case BUILT_IN_APPLY_ARGS
:
5703 return expand_builtin_apply_args ();
5705 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5706 FUNCTION with a copy of the parameters described by
5707 ARGUMENTS, and ARGSIZE. It returns a block of memory
5708 allocated on the stack into which is stored all the registers
5709 that might possibly be used for returning the result of a
5710 function. ARGUMENTS is the value returned by
5711 __builtin_apply_args. ARGSIZE is the number of bytes of
5712 arguments that must be copied. ??? How should this value be
5713 computed? We'll also need a safe worst case value for varargs
5715 case BUILT_IN_APPLY
:
5716 if (!validate_arglist (arglist
, POINTER_TYPE
,
5717 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5718 && !validate_arglist (arglist
, REFERENCE_TYPE
,
5719 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5727 for (t
= arglist
, i
= 0; t
; t
= TREE_CHAIN (t
), i
++)
5728 ops
[i
] = expand_expr (TREE_VALUE (t
), NULL_RTX
, VOIDmode
, 0);
5730 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
5733 /* __builtin_return (RESULT) causes the function to return the
5734 value described by RESULT. RESULT is address of the block of
5735 memory returned by __builtin_apply. */
5736 case BUILT_IN_RETURN
:
5737 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5738 expand_builtin_return (expand_expr (TREE_VALUE (arglist
),
5739 NULL_RTX
, VOIDmode
, 0));
5742 case BUILT_IN_SAVEREGS
:
5743 return expand_builtin_saveregs ();
5745 case BUILT_IN_ARGS_INFO
:
5746 return expand_builtin_args_info (arglist
);
5748 /* Return the address of the first anonymous stack arg. */
5749 case BUILT_IN_NEXT_ARG
:
5750 if (fold_builtin_next_arg (arglist
))
5752 return expand_builtin_next_arg ();
5754 case BUILT_IN_CLASSIFY_TYPE
:
5755 return expand_builtin_classify_type (arglist
);
5757 case BUILT_IN_CONSTANT_P
:
5760 case BUILT_IN_FRAME_ADDRESS
:
5761 case BUILT_IN_RETURN_ADDRESS
:
5762 return expand_builtin_frame_address (fndecl
, arglist
);
5764 /* Returns the address of the area where the structure is returned.
5766 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
5768 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
5769 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
5772 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
5774 case BUILT_IN_ALLOCA
:
5775 target
= expand_builtin_alloca (arglist
, target
);
5780 case BUILT_IN_STACK_SAVE
:
5781 return expand_stack_save ();
5783 case BUILT_IN_STACK_RESTORE
:
5784 expand_stack_restore (TREE_VALUE (arglist
));
5787 CASE_INT_FN (BUILT_IN_FFS
):
5788 case BUILT_IN_FFSIMAX
:
5789 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5790 subtarget
, ffs_optab
);
5795 CASE_INT_FN (BUILT_IN_CLZ
):
5796 case BUILT_IN_CLZIMAX
:
5797 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5798 subtarget
, clz_optab
);
5803 CASE_INT_FN (BUILT_IN_CTZ
):
5804 case BUILT_IN_CTZIMAX
:
5805 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5806 subtarget
, ctz_optab
);
5811 CASE_INT_FN (BUILT_IN_POPCOUNT
):
5812 case BUILT_IN_POPCOUNTIMAX
:
5813 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5814 subtarget
, popcount_optab
);
5819 CASE_INT_FN (BUILT_IN_PARITY
):
5820 case BUILT_IN_PARITYIMAX
:
5821 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5822 subtarget
, parity_optab
);
5827 case BUILT_IN_STRLEN
:
5828 target
= expand_builtin_strlen (arglist
, target
, target_mode
);
5833 case BUILT_IN_STRCPY
:
5834 target
= expand_builtin_strcpy (fndecl
, arglist
, target
, mode
);
5839 case BUILT_IN_STRNCPY
:
5840 target
= expand_builtin_strncpy (exp
, target
, mode
);
5845 case BUILT_IN_STPCPY
:
5846 target
= expand_builtin_stpcpy (exp
, target
, mode
);
5851 case BUILT_IN_STRCAT
:
5852 target
= expand_builtin_strcat (fndecl
, arglist
, target
, mode
);
5857 case BUILT_IN_STRNCAT
:
5858 target
= expand_builtin_strncat (arglist
, target
, mode
);
5863 case BUILT_IN_STRSPN
:
5864 target
= expand_builtin_strspn (arglist
, target
, mode
);
5869 case BUILT_IN_STRCSPN
:
5870 target
= expand_builtin_strcspn (arglist
, target
, mode
);
5875 case BUILT_IN_STRSTR
:
5876 target
= expand_builtin_strstr (arglist
, TREE_TYPE (exp
), target
, mode
);
5881 case BUILT_IN_STRPBRK
:
5882 target
= expand_builtin_strpbrk (arglist
, TREE_TYPE (exp
), target
, mode
);
5887 case BUILT_IN_INDEX
:
5888 case BUILT_IN_STRCHR
:
5889 target
= expand_builtin_strchr (arglist
, TREE_TYPE (exp
), target
, mode
);
5894 case BUILT_IN_RINDEX
:
5895 case BUILT_IN_STRRCHR
:
5896 target
= expand_builtin_strrchr (arglist
, TREE_TYPE (exp
), target
, mode
);
5901 case BUILT_IN_MEMCPY
:
5902 target
= expand_builtin_memcpy (exp
, target
, mode
);
5907 case BUILT_IN_MEMPCPY
:
5908 target
= expand_builtin_mempcpy (arglist
, TREE_TYPE (exp
), target
, mode
, /*endp=*/ 1);
5913 case BUILT_IN_MEMMOVE
:
5914 target
= expand_builtin_memmove (arglist
, TREE_TYPE (exp
), target
,
5920 case BUILT_IN_BCOPY
:
5921 target
= expand_builtin_bcopy (exp
);
5926 case BUILT_IN_MEMSET
:
5927 target
= expand_builtin_memset (arglist
, target
, mode
, exp
);
5932 case BUILT_IN_BZERO
:
5933 target
= expand_builtin_bzero (exp
);
5938 case BUILT_IN_STRCMP
:
5939 target
= expand_builtin_strcmp (exp
, target
, mode
);
5944 case BUILT_IN_STRNCMP
:
5945 target
= expand_builtin_strncmp (exp
, target
, mode
);
5951 case BUILT_IN_MEMCMP
:
5952 target
= expand_builtin_memcmp (exp
, arglist
, target
, mode
);
5957 case BUILT_IN_SETJMP
:
5958 target
= expand_builtin_setjmp (arglist
, target
);
5963 /* __builtin_longjmp is passed a pointer to an array of five words.
5964 It's similar to the C library longjmp function but works with
5965 __builtin_setjmp above. */
5966 case BUILT_IN_LONGJMP
:
5967 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5971 rtx buf_addr
= expand_expr (TREE_VALUE (arglist
), subtarget
,
5973 rtx value
= expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)),
5974 NULL_RTX
, VOIDmode
, 0);
5976 if (value
!= const1_rtx
)
5978 error ("%<__builtin_longjmp%> second argument must be 1");
5982 expand_builtin_longjmp (buf_addr
, value
);
5986 case BUILT_IN_NONLOCAL_GOTO
:
5987 target
= expand_builtin_nonlocal_goto (arglist
);
5992 /* This updates the setjmp buffer that is its argument with the value
5993 of the current stack pointer. */
5994 case BUILT_IN_UPDATE_SETJMP_BUF
:
5995 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5998 = expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
6000 expand_builtin_update_setjmp_buf (buf_addr
);
6006 expand_builtin_trap ();
6009 case BUILT_IN_PRINTF
:
6010 target
= expand_builtin_printf (exp
, target
, mode
, false);
6015 case BUILT_IN_PRINTF_UNLOCKED
:
6016 target
= expand_builtin_printf (exp
, target
, mode
, true);
6021 case BUILT_IN_FPUTS
:
6022 target
= expand_builtin_fputs (arglist
, target
, false);
6026 case BUILT_IN_FPUTS_UNLOCKED
:
6027 target
= expand_builtin_fputs (arglist
, target
, true);
6032 case BUILT_IN_FPRINTF
:
6033 target
= expand_builtin_fprintf (exp
, target
, mode
, false);
6038 case BUILT_IN_FPRINTF_UNLOCKED
:
6039 target
= expand_builtin_fprintf (exp
, target
, mode
, true);
6044 case BUILT_IN_SPRINTF
:
6045 target
= expand_builtin_sprintf (arglist
, target
, mode
);
6050 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
6051 target
= expand_builtin_signbit (exp
, target
);
6056 /* Various hooks for the DWARF 2 __throw routine. */
6057 case BUILT_IN_UNWIND_INIT
:
6058 expand_builtin_unwind_init ();
6060 case BUILT_IN_DWARF_CFA
:
6061 return virtual_cfa_rtx
;
6062 #ifdef DWARF2_UNWIND_INFO
6063 case BUILT_IN_DWARF_SP_COLUMN
:
6064 return expand_builtin_dwarf_sp_column ();
6065 case BUILT_IN_INIT_DWARF_REG_SIZES
:
6066 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist
));
6069 case BUILT_IN_FROB_RETURN_ADDR
:
6070 return expand_builtin_frob_return_addr (TREE_VALUE (arglist
));
6071 case BUILT_IN_EXTRACT_RETURN_ADDR
:
6072 return expand_builtin_extract_return_addr (TREE_VALUE (arglist
));
6073 case BUILT_IN_EH_RETURN
:
6074 expand_builtin_eh_return (TREE_VALUE (arglist
),
6075 TREE_VALUE (TREE_CHAIN (arglist
)));
6077 #ifdef EH_RETURN_DATA_REGNO
6078 case BUILT_IN_EH_RETURN_DATA_REGNO
:
6079 return expand_builtin_eh_return_data_regno (arglist
);
6081 case BUILT_IN_EXTEND_POINTER
:
6082 return expand_builtin_extend_pointer (TREE_VALUE (arglist
));
6084 case BUILT_IN_VA_START
:
6085 case BUILT_IN_STDARG_START
:
6086 return expand_builtin_va_start (arglist
);
6087 case BUILT_IN_VA_END
:
6088 return expand_builtin_va_end (arglist
);
6089 case BUILT_IN_VA_COPY
:
6090 return expand_builtin_va_copy (arglist
);
6091 case BUILT_IN_EXPECT
:
6092 return expand_builtin_expect (arglist
, target
);
6093 case BUILT_IN_PREFETCH
:
6094 expand_builtin_prefetch (arglist
);
6097 case BUILT_IN_PROFILE_FUNC_ENTER
:
6098 return expand_builtin_profile_func (false);
6099 case BUILT_IN_PROFILE_FUNC_EXIT
:
6100 return expand_builtin_profile_func (true);
6102 case BUILT_IN_INIT_TRAMPOLINE
:
6103 return expand_builtin_init_trampoline (arglist
);
6104 case BUILT_IN_ADJUST_TRAMPOLINE
:
6105 return expand_builtin_adjust_trampoline (arglist
);
6108 case BUILT_IN_EXECL
:
6109 case BUILT_IN_EXECV
:
6110 case BUILT_IN_EXECLP
:
6111 case BUILT_IN_EXECLE
:
6112 case BUILT_IN_EXECVP
:
6113 case BUILT_IN_EXECVE
:
6114 target
= expand_builtin_fork_or_exec (fndecl
, arglist
, target
, ignore
);
6119 case BUILT_IN_FETCH_AND_ADD_1
:
6120 case BUILT_IN_FETCH_AND_ADD_2
:
6121 case BUILT_IN_FETCH_AND_ADD_4
:
6122 case BUILT_IN_FETCH_AND_ADD_8
:
6123 case BUILT_IN_FETCH_AND_ADD_16
:
6124 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_ADD_1
);
6125 target
= expand_builtin_sync_operation (mode
, arglist
, PLUS
,
6126 false, target
, ignore
);
6131 case BUILT_IN_FETCH_AND_SUB_1
:
6132 case BUILT_IN_FETCH_AND_SUB_2
:
6133 case BUILT_IN_FETCH_AND_SUB_4
:
6134 case BUILT_IN_FETCH_AND_SUB_8
:
6135 case BUILT_IN_FETCH_AND_SUB_16
:
6136 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_SUB_1
);
6137 target
= expand_builtin_sync_operation (mode
, arglist
, MINUS
,
6138 false, target
, ignore
);
6143 case BUILT_IN_FETCH_AND_OR_1
:
6144 case BUILT_IN_FETCH_AND_OR_2
:
6145 case BUILT_IN_FETCH_AND_OR_4
:
6146 case BUILT_IN_FETCH_AND_OR_8
:
6147 case BUILT_IN_FETCH_AND_OR_16
:
6148 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_OR_1
);
6149 target
= expand_builtin_sync_operation (mode
, arglist
, IOR
,
6150 false, target
, ignore
);
6155 case BUILT_IN_FETCH_AND_AND_1
:
6156 case BUILT_IN_FETCH_AND_AND_2
:
6157 case BUILT_IN_FETCH_AND_AND_4
:
6158 case BUILT_IN_FETCH_AND_AND_8
:
6159 case BUILT_IN_FETCH_AND_AND_16
:
6160 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_AND_1
);
6161 target
= expand_builtin_sync_operation (mode
, arglist
, AND
,
6162 false, target
, ignore
);
6167 case BUILT_IN_FETCH_AND_XOR_1
:
6168 case BUILT_IN_FETCH_AND_XOR_2
:
6169 case BUILT_IN_FETCH_AND_XOR_4
:
6170 case BUILT_IN_FETCH_AND_XOR_8
:
6171 case BUILT_IN_FETCH_AND_XOR_16
:
6172 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_XOR_1
);
6173 target
= expand_builtin_sync_operation (mode
, arglist
, XOR
,
6174 false, target
, ignore
);
6179 case BUILT_IN_FETCH_AND_NAND_1
:
6180 case BUILT_IN_FETCH_AND_NAND_2
:
6181 case BUILT_IN_FETCH_AND_NAND_4
:
6182 case BUILT_IN_FETCH_AND_NAND_8
:
6183 case BUILT_IN_FETCH_AND_NAND_16
:
6184 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_FETCH_AND_NAND_1
);
6185 target
= expand_builtin_sync_operation (mode
, arglist
, NOT
,
6186 false, target
, ignore
);
6191 case BUILT_IN_ADD_AND_FETCH_1
:
6192 case BUILT_IN_ADD_AND_FETCH_2
:
6193 case BUILT_IN_ADD_AND_FETCH_4
:
6194 case BUILT_IN_ADD_AND_FETCH_8
:
6195 case BUILT_IN_ADD_AND_FETCH_16
:
6196 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_ADD_AND_FETCH_1
);
6197 target
= expand_builtin_sync_operation (mode
, arglist
, PLUS
,
6198 true, target
, ignore
);
6203 case BUILT_IN_SUB_AND_FETCH_1
:
6204 case BUILT_IN_SUB_AND_FETCH_2
:
6205 case BUILT_IN_SUB_AND_FETCH_4
:
6206 case BUILT_IN_SUB_AND_FETCH_8
:
6207 case BUILT_IN_SUB_AND_FETCH_16
:
6208 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_SUB_AND_FETCH_1
);
6209 target
= expand_builtin_sync_operation (mode
, arglist
, MINUS
,
6210 true, target
, ignore
);
6215 case BUILT_IN_OR_AND_FETCH_1
:
6216 case BUILT_IN_OR_AND_FETCH_2
:
6217 case BUILT_IN_OR_AND_FETCH_4
:
6218 case BUILT_IN_OR_AND_FETCH_8
:
6219 case BUILT_IN_OR_AND_FETCH_16
:
6220 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_OR_AND_FETCH_1
);
6221 target
= expand_builtin_sync_operation (mode
, arglist
, IOR
,
6222 true, target
, ignore
);
6227 case BUILT_IN_AND_AND_FETCH_1
:
6228 case BUILT_IN_AND_AND_FETCH_2
:
6229 case BUILT_IN_AND_AND_FETCH_4
:
6230 case BUILT_IN_AND_AND_FETCH_8
:
6231 case BUILT_IN_AND_AND_FETCH_16
:
6232 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_AND_AND_FETCH_1
);
6233 target
= expand_builtin_sync_operation (mode
, arglist
, AND
,
6234 true, target
, ignore
);
6239 case BUILT_IN_XOR_AND_FETCH_1
:
6240 case BUILT_IN_XOR_AND_FETCH_2
:
6241 case BUILT_IN_XOR_AND_FETCH_4
:
6242 case BUILT_IN_XOR_AND_FETCH_8
:
6243 case BUILT_IN_XOR_AND_FETCH_16
:
6244 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_XOR_AND_FETCH_1
);
6245 target
= expand_builtin_sync_operation (mode
, arglist
, XOR
,
6246 true, target
, ignore
);
6251 case BUILT_IN_NAND_AND_FETCH_1
:
6252 case BUILT_IN_NAND_AND_FETCH_2
:
6253 case BUILT_IN_NAND_AND_FETCH_4
:
6254 case BUILT_IN_NAND_AND_FETCH_8
:
6255 case BUILT_IN_NAND_AND_FETCH_16
:
6256 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_NAND_AND_FETCH_1
);
6257 target
= expand_builtin_sync_operation (mode
, arglist
, NOT
,
6258 true, target
, ignore
);
6263 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1
:
6264 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2
:
6265 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4
:
6266 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8
:
6267 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16
:
6268 if (mode
== VOIDmode
)
6269 mode
= TYPE_MODE (boolean_type_node
);
6270 if (!target
|| !register_operand (target
, mode
))
6271 target
= gen_reg_rtx (mode
);
6273 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_BOOL_COMPARE_AND_SWAP_1
);
6274 target
= expand_builtin_compare_and_swap (mode
, arglist
, true, target
);
6279 case BUILT_IN_VAL_COMPARE_AND_SWAP_1
:
6280 case BUILT_IN_VAL_COMPARE_AND_SWAP_2
:
6281 case BUILT_IN_VAL_COMPARE_AND_SWAP_4
:
6282 case BUILT_IN_VAL_COMPARE_AND_SWAP_8
:
6283 case BUILT_IN_VAL_COMPARE_AND_SWAP_16
:
6284 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_VAL_COMPARE_AND_SWAP_1
);
6285 target
= expand_builtin_compare_and_swap (mode
, arglist
, false, target
);
6290 case BUILT_IN_LOCK_TEST_AND_SET_1
:
6291 case BUILT_IN_LOCK_TEST_AND_SET_2
:
6292 case BUILT_IN_LOCK_TEST_AND_SET_4
:
6293 case BUILT_IN_LOCK_TEST_AND_SET_8
:
6294 case BUILT_IN_LOCK_TEST_AND_SET_16
:
6295 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_LOCK_TEST_AND_SET_1
);
6296 target
= expand_builtin_lock_test_and_set (mode
, arglist
, target
);
6301 case BUILT_IN_LOCK_RELEASE_1
:
6302 case BUILT_IN_LOCK_RELEASE_2
:
6303 case BUILT_IN_LOCK_RELEASE_4
:
6304 case BUILT_IN_LOCK_RELEASE_8
:
6305 case BUILT_IN_LOCK_RELEASE_16
:
6306 mode
= get_builtin_sync_mode (fcode
- BUILT_IN_LOCK_RELEASE_1
);
6307 expand_builtin_lock_release (mode
, arglist
);
6310 case BUILT_IN_SYNCHRONIZE
:
6311 expand_builtin_synchronize ();
6314 case BUILT_IN_OBJECT_SIZE
:
6315 return expand_builtin_object_size (exp
);
6317 case BUILT_IN_MEMCPY_CHK
:
6318 case BUILT_IN_MEMPCPY_CHK
:
6319 case BUILT_IN_MEMMOVE_CHK
:
6320 case BUILT_IN_MEMSET_CHK
:
6321 target
= expand_builtin_memory_chk (exp
, target
, mode
, fcode
);
6326 case BUILT_IN_STRCPY_CHK
:
6327 case BUILT_IN_STPCPY_CHK
:
6328 case BUILT_IN_STRNCPY_CHK
:
6329 case BUILT_IN_STRCAT_CHK
:
6330 case BUILT_IN_SNPRINTF_CHK
:
6331 case BUILT_IN_VSNPRINTF_CHK
:
6332 maybe_emit_chk_warning (exp
, fcode
);
6335 case BUILT_IN_SPRINTF_CHK
:
6336 case BUILT_IN_VSPRINTF_CHK
:
6337 maybe_emit_sprintf_chk_warning (exp
, fcode
);
6340 default: /* just do library call, if unknown builtin */
6344 /* The switch statement above can drop through to cause the function
6345 to be called normally. */
6346 return expand_call (exp
, target
, ignore
);
6349 /* Determine whether a tree node represents a call to a built-in
6350 function. If the tree T is a call to a built-in function with
6351 the right number of arguments of the appropriate types, return
6352 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6353 Otherwise the return value is END_BUILTINS. */
6355 enum built_in_function
6356 builtin_mathfn_code (tree t
)
6358 tree fndecl
, arglist
, parmlist
;
6359 tree argtype
, parmtype
;
6361 if (TREE_CODE (t
) != CALL_EXPR
6362 || TREE_CODE (TREE_OPERAND (t
, 0)) != ADDR_EXPR
)
6363 return END_BUILTINS
;
6365 fndecl
= get_callee_fndecl (t
);
6366 if (fndecl
== NULL_TREE
6367 || TREE_CODE (fndecl
) != FUNCTION_DECL
6368 || ! DECL_BUILT_IN (fndecl
)
6369 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6370 return END_BUILTINS
;
6372 arglist
= TREE_OPERAND (t
, 1);
6373 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6374 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
6376 /* If a function doesn't take a variable number of arguments,
6377 the last element in the list will have type `void'. */
6378 parmtype
= TREE_VALUE (parmlist
);
6379 if (VOID_TYPE_P (parmtype
))
6382 return END_BUILTINS
;
6383 return DECL_FUNCTION_CODE (fndecl
);
6387 return END_BUILTINS
;
6389 argtype
= TREE_TYPE (TREE_VALUE (arglist
));
6391 if (SCALAR_FLOAT_TYPE_P (parmtype
))
6393 if (! SCALAR_FLOAT_TYPE_P (argtype
))
6394 return END_BUILTINS
;
6396 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
6398 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
6399 return END_BUILTINS
;
6401 else if (POINTER_TYPE_P (parmtype
))
6403 if (! POINTER_TYPE_P (argtype
))
6404 return END_BUILTINS
;
6406 else if (INTEGRAL_TYPE_P (parmtype
))
6408 if (! INTEGRAL_TYPE_P (argtype
))
6409 return END_BUILTINS
;
6412 return END_BUILTINS
;
6414 arglist
= TREE_CHAIN (arglist
);
6417 /* Variable-length argument list. */
6418 return DECL_FUNCTION_CODE (fndecl
);
6421 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
6422 constant. ARGLIST is the argument list of the call. */
6425 fold_builtin_constant_p (tree arglist
)
6430 arglist
= TREE_VALUE (arglist
);
6432 /* We return 1 for a numeric type that's known to be a constant
6433 value at compile-time or for an aggregate type that's a
6434 literal constant. */
6435 STRIP_NOPS (arglist
);
6437 /* If we know this is a constant, emit the constant of one. */
6438 if (CONSTANT_CLASS_P (arglist
)
6439 || (TREE_CODE (arglist
) == CONSTRUCTOR
6440 && TREE_CONSTANT (arglist
)))
6441 return integer_one_node
;
6442 if (TREE_CODE (arglist
) == ADDR_EXPR
)
6444 tree op
= TREE_OPERAND (arglist
, 0);
6445 if (TREE_CODE (op
) == STRING_CST
6446 || (TREE_CODE (op
) == ARRAY_REF
6447 && integer_zerop (TREE_OPERAND (op
, 1))
6448 && TREE_CODE (TREE_OPERAND (op
, 0)) == STRING_CST
))
6449 return integer_one_node
;
6452 /* If this expression has side effects, show we don't know it to be a
6453 constant. Likewise if it's a pointer or aggregate type since in
6454 those case we only want literals, since those are only optimized
6455 when generating RTL, not later.
6456 And finally, if we are compiling an initializer, not code, we
6457 need to return a definite result now; there's not going to be any
6458 more optimization done. */
6459 if (TREE_SIDE_EFFECTS (arglist
)
6460 || AGGREGATE_TYPE_P (TREE_TYPE (arglist
))
6461 || POINTER_TYPE_P (TREE_TYPE (arglist
))
6463 return integer_zero_node
;
6468 /* Fold a call to __builtin_expect, if we expect that a comparison against
6469 the argument will fold to a constant. In practice, this means a true
6470 constant or the address of a non-weak symbol. ARGLIST is the argument
6471 list of the call. */
6474 fold_builtin_expect (tree arglist
)
6481 arg
= TREE_VALUE (arglist
);
6483 /* If the argument isn't invariant, then there's nothing we can do. */
6484 if (!TREE_INVARIANT (arg
))
6487 /* If we're looking at an address of a weak decl, then do not fold. */
6490 if (TREE_CODE (inner
) == ADDR_EXPR
)
6494 inner
= TREE_OPERAND (inner
, 0);
6496 while (TREE_CODE (inner
) == COMPONENT_REF
6497 || TREE_CODE (inner
) == ARRAY_REF
);
6498 if (DECL_P (inner
) && DECL_WEAK (inner
))
6502 /* Otherwise, ARG already has the proper type for the return value. */
6506 /* Fold a call to __builtin_classify_type. */
6509 fold_builtin_classify_type (tree arglist
)
6512 return build_int_cst (NULL_TREE
, no_type_class
);
6514 return build_int_cst (NULL_TREE
,
6515 type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
6518 /* Fold a call to __builtin_strlen. */
6521 fold_builtin_strlen (tree arglist
)
6523 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6527 tree len
= c_strlen (TREE_VALUE (arglist
), 0);
6531 /* Convert from the internal "sizetype" type to "size_t". */
6533 len
= fold_convert (size_type_node
, len
);
6541 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6544 fold_builtin_inf (tree type
, int warn
)
6546 REAL_VALUE_TYPE real
;
6548 /* __builtin_inff is intended to be usable to define INFINITY on all
6549 targets. If an infinity is not available, INFINITY expands "to a
6550 positive constant of type float that overflows at translation
6551 time", footnote "In this case, using INFINITY will violate the
6552 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6553 Thus we pedwarn to ensure this constraint violation is
6555 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
6556 pedwarn ("target format does not support infinity");
6559 return build_real (type
, real
);
6562 /* Fold a call to __builtin_nan or __builtin_nans. */
6565 fold_builtin_nan (tree arglist
, tree type
, int quiet
)
6567 REAL_VALUE_TYPE real
;
6570 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
6572 str
= c_getstr (TREE_VALUE (arglist
));
6576 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
6579 return build_real (type
, real
);
6582 /* Return true if the floating point expression T has an integer value.
6583 We also allow +Inf, -Inf and NaN to be considered integer values. */
6586 integer_valued_real_p (tree t
)
6588 switch (TREE_CODE (t
))
6595 case NON_LVALUE_EXPR
:
6596 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6601 return integer_valued_real_p (TREE_OPERAND (t
, 1));
6608 return integer_valued_real_p (TREE_OPERAND (t
, 0))
6609 && integer_valued_real_p (TREE_OPERAND (t
, 1));
6612 return integer_valued_real_p (TREE_OPERAND (t
, 1))
6613 && integer_valued_real_p (TREE_OPERAND (t
, 2));
6616 if (! TREE_CONSTANT_OVERFLOW (t
))
6618 REAL_VALUE_TYPE c
, cint
;
6620 c
= TREE_REAL_CST (t
);
6621 real_trunc (&cint
, TYPE_MODE (TREE_TYPE (t
)), &c
);
6622 return real_identical (&c
, &cint
);
6628 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6629 if (TREE_CODE (type
) == INTEGER_TYPE
)
6631 if (TREE_CODE (type
) == REAL_TYPE
)
6632 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6637 switch (builtin_mathfn_code (t
))
6639 CASE_FLT_FN (BUILT_IN_CEIL
):
6640 CASE_FLT_FN (BUILT_IN_FLOOR
):
6641 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
6642 CASE_FLT_FN (BUILT_IN_RINT
):
6643 CASE_FLT_FN (BUILT_IN_ROUND
):
6644 CASE_FLT_FN (BUILT_IN_TRUNC
):
6658 /* EXP is assumed to be builtin call where truncation can be propagated
6659 across (for instance floor((double)f) == (double)floorf (f).
6660 Do the transformation. */
6663 fold_trunc_transparent_mathfn (tree fndecl
, tree arglist
)
6665 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6668 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6671 arg
= TREE_VALUE (arglist
);
6672 /* Integer rounding functions are idempotent. */
6673 if (fcode
== builtin_mathfn_code (arg
))
6676 /* If argument is already integer valued, and we don't need to worry
6677 about setting errno, there's no need to perform rounding. */
6678 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6683 tree arg0
= strip_float_extensions (arg
);
6684 tree ftype
= TREE_TYPE (TREE_TYPE (fndecl
));
6685 tree newtype
= TREE_TYPE (arg0
);
6688 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6689 && (decl
= mathfn_built_in (newtype
, fcode
)))
6692 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6693 return fold_convert (ftype
,
6694 build_function_call_expr (decl
, arglist
));
6700 /* EXP is assumed to be builtin call which can narrow the FP type of
6701 the argument, for instance lround((double)f) -> lroundf (f). */
6704 fold_fixed_mathfn (tree fndecl
, tree arglist
)
6706 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6709 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6712 arg
= TREE_VALUE (arglist
);
6714 /* If argument is already integer valued, and we don't need to worry
6715 about setting errno, there's no need to perform rounding. */
6716 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6717 return fold_build1 (FIX_TRUNC_EXPR
, TREE_TYPE (TREE_TYPE (fndecl
)), arg
);
6721 tree ftype
= TREE_TYPE (arg
);
6722 tree arg0
= strip_float_extensions (arg
);
6723 tree newtype
= TREE_TYPE (arg0
);
6726 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6727 && (decl
= mathfn_built_in (newtype
, fcode
)))
6730 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6731 return build_function_call_expr (decl
, arglist
);
6737 /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
6738 is the argument list and TYPE is the return type. Return
6739 NULL_TREE if no if no simplification can be made. */
6742 fold_builtin_cabs (tree arglist
, tree type
)
6746 if (!arglist
|| TREE_CHAIN (arglist
))
6749 arg
= TREE_VALUE (arglist
);
6750 if (TREE_CODE (TREE_TYPE (arg
)) != COMPLEX_TYPE
6751 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
6754 /* Evaluate cabs of a constant at compile-time. */
6755 if (flag_unsafe_math_optimizations
6756 && TREE_CODE (arg
) == COMPLEX_CST
6757 && TREE_CODE (TREE_REALPART (arg
)) == REAL_CST
6758 && TREE_CODE (TREE_IMAGPART (arg
)) == REAL_CST
6759 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg
))
6760 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg
)))
6762 REAL_VALUE_TYPE r
, i
;
6764 r
= TREE_REAL_CST (TREE_REALPART (arg
));
6765 i
= TREE_REAL_CST (TREE_IMAGPART (arg
));
6767 real_arithmetic (&r
, MULT_EXPR
, &r
, &r
);
6768 real_arithmetic (&i
, MULT_EXPR
, &i
, &i
);
6769 real_arithmetic (&r
, PLUS_EXPR
, &r
, &i
);
6770 if (real_sqrt (&r
, TYPE_MODE (type
), &r
)
6771 || ! flag_trapping_math
)
6772 return build_real (type
, r
);
6775 /* If either part is zero, cabs is fabs of the other. */
6776 if (TREE_CODE (arg
) == COMPLEX_EXPR
6777 && real_zerop (TREE_OPERAND (arg
, 0)))
6778 return fold_build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 1));
6779 if (TREE_CODE (arg
) == COMPLEX_EXPR
6780 && real_zerop (TREE_OPERAND (arg
, 1)))
6781 return fold_build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 0));
6783 /* Don't do this when optimizing for size. */
6784 if (flag_unsafe_math_optimizations
6785 && optimize
&& !optimize_size
)
6787 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
6789 if (sqrtfn
!= NULL_TREE
)
6791 tree rpart
, ipart
, result
, arglist
;
6793 arg
= builtin_save_expr (arg
);
6795 rpart
= fold_build1 (REALPART_EXPR
, type
, arg
);
6796 ipart
= fold_build1 (IMAGPART_EXPR
, type
, arg
);
6798 rpart
= builtin_save_expr (rpart
);
6799 ipart
= builtin_save_expr (ipart
);
6801 result
= fold_build2 (PLUS_EXPR
, type
,
6802 fold_build2 (MULT_EXPR
, type
,
6804 fold_build2 (MULT_EXPR
, type
,
6807 arglist
= build_tree_list (NULL_TREE
, result
);
6808 return build_function_call_expr (sqrtfn
, arglist
);
6815 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl. Return
6816 NULL_TREE if no simplification can be made. */
6819 fold_builtin_sqrt (tree arglist
, tree type
)
6822 enum built_in_function fcode
;
6823 tree arg
= TREE_VALUE (arglist
);
6825 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6828 /* Optimize sqrt of constant value. */
6829 if (TREE_CODE (arg
) == REAL_CST
6830 && ! TREE_CONSTANT_OVERFLOW (arg
))
6832 REAL_VALUE_TYPE r
, x
;
6834 x
= TREE_REAL_CST (arg
);
6835 if (real_sqrt (&r
, TYPE_MODE (type
), &x
)
6836 || (!flag_trapping_math
&& !flag_errno_math
))
6837 return build_real (type
, r
);
6840 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
6841 fcode
= builtin_mathfn_code (arg
);
6842 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6844 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6845 arg
= fold_build2 (MULT_EXPR
, type
,
6846 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6847 build_real (type
, dconsthalf
));
6848 arglist
= build_tree_list (NULL_TREE
, arg
);
6849 return build_function_call_expr (expfn
, arglist
);
6852 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
6853 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
6855 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6859 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6861 /* The inner root was either sqrt or cbrt. */
6862 REAL_VALUE_TYPE dconstroot
=
6863 BUILTIN_SQRT_P (fcode
) ? dconsthalf
: dconstthird
;
6865 /* Adjust for the outer root. */
6866 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6867 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6868 tree_root
= build_real (type
, dconstroot
);
6869 arglist
= tree_cons (NULL_TREE
, arg0
,
6870 build_tree_list (NULL_TREE
, tree_root
));
6871 return build_function_call_expr (powfn
, arglist
);
6875 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
6876 if (flag_unsafe_math_optimizations
6877 && (fcode
== BUILT_IN_POW
6878 || fcode
== BUILT_IN_POWF
6879 || fcode
== BUILT_IN_POWL
))
6881 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6882 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6883 tree arg1
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
6885 if (!tree_expr_nonnegative_p (arg0
))
6886 arg0
= build1 (ABS_EXPR
, type
, arg0
);
6887 narg1
= fold_build2 (MULT_EXPR
, type
, arg1
,
6888 build_real (type
, dconsthalf
));
6889 arglist
= tree_cons (NULL_TREE
, arg0
,
6890 build_tree_list (NULL_TREE
, narg1
));
6891 return build_function_call_expr (powfn
, arglist
);
6897 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl. Return
6898 NULL_TREE if no simplification can be made. */
6900 fold_builtin_cbrt (tree arglist
, tree type
)
6902 tree arg
= TREE_VALUE (arglist
);
6903 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
6905 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6908 /* Optimize cbrt of constant value. */
6909 if (real_zerop (arg
) || real_onep (arg
) || real_minus_onep (arg
))
6912 if (flag_unsafe_math_optimizations
)
6914 /* Optimize cbrt(expN(x)) -> expN(x/3). */
6915 if (BUILTIN_EXPONENT_P (fcode
))
6917 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6918 const REAL_VALUE_TYPE third_trunc
=
6919 real_value_truncate (TYPE_MODE (type
), dconstthird
);
6920 arg
= fold_build2 (MULT_EXPR
, type
,
6921 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6922 build_real (type
, third_trunc
));
6923 arglist
= build_tree_list (NULL_TREE
, arg
);
6924 return build_function_call_expr (expfn
, arglist
);
6927 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
6928 if (BUILTIN_SQRT_P (fcode
))
6930 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6934 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6936 REAL_VALUE_TYPE dconstroot
= dconstthird
;
6938 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6939 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6940 tree_root
= build_real (type
, dconstroot
);
6941 arglist
= tree_cons (NULL_TREE
, arg0
,
6942 build_tree_list (NULL_TREE
, tree_root
));
6943 return build_function_call_expr (powfn
, arglist
);
6947 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
6948 if (BUILTIN_CBRT_P (fcode
))
6950 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6951 if (tree_expr_nonnegative_p (arg0
))
6953 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6958 REAL_VALUE_TYPE dconstroot
;
6960 real_arithmetic (&dconstroot
, MULT_EXPR
, &dconstthird
, &dconstthird
);
6961 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6962 tree_root
= build_real (type
, dconstroot
);
6963 arglist
= tree_cons (NULL_TREE
, arg0
,
6964 build_tree_list (NULL_TREE
, tree_root
));
6965 return build_function_call_expr (powfn
, arglist
);
6970 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
6971 if (fcode
== BUILT_IN_POW
|| fcode
== BUILT_IN_POWF
6972 || fcode
== BUILT_IN_POWL
)
6974 tree arg00
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6975 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
6976 if (tree_expr_nonnegative_p (arg00
))
6978 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6979 const REAL_VALUE_TYPE dconstroot
6980 = real_value_truncate (TYPE_MODE (type
), dconstthird
);
6981 tree narg01
= fold_build2 (MULT_EXPR
, type
, arg01
,
6982 build_real (type
, dconstroot
));
6983 arglist
= tree_cons (NULL_TREE
, arg00
,
6984 build_tree_list (NULL_TREE
, narg01
));
6985 return build_function_call_expr (powfn
, arglist
);
6992 /* Fold function call to builtin sin, sinf, or sinl. Return
6993 NULL_TREE if no simplification can be made. */
6995 fold_builtin_sin (tree arglist
)
6997 tree arg
= TREE_VALUE (arglist
);
6999 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7002 /* Optimize sin (0.0) = 0.0. */
7003 if (real_zerop (arg
))
7009 /* Fold function call to builtin cos, cosf, or cosl. Return
7010 NULL_TREE if no simplification can be made. */
7012 fold_builtin_cos (tree arglist
, tree type
, tree fndecl
)
7014 tree arg
= TREE_VALUE (arglist
);
7016 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7019 /* Optimize cos (0.0) = 1.0. */
7020 if (real_zerop (arg
))
7021 return build_real (type
, dconst1
);
7023 /* Optimize cos(-x) into cos (x). */
7024 if (TREE_CODE (arg
) == NEGATE_EXPR
)
7026 tree args
= build_tree_list (NULL_TREE
,
7027 TREE_OPERAND (arg
, 0));
7028 return build_function_call_expr (fndecl
, args
);
7034 /* Fold function call to builtin tan, tanf, or tanl. Return
7035 NULL_TREE if no simplification can be made. */
7037 fold_builtin_tan (tree arglist
)
7039 enum built_in_function fcode
;
7040 tree arg
= TREE_VALUE (arglist
);
7042 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7045 /* Optimize tan(0.0) = 0.0. */
7046 if (real_zerop (arg
))
7049 /* Optimize tan(atan(x)) = x. */
7050 fcode
= builtin_mathfn_code (arg
);
7051 if (flag_unsafe_math_optimizations
7052 && (fcode
== BUILT_IN_ATAN
7053 || fcode
== BUILT_IN_ATANF
7054 || fcode
== BUILT_IN_ATANL
))
7055 return TREE_VALUE (TREE_OPERAND (arg
, 1));
7060 /* Fold function call to builtin atan, atanf, or atanl. Return
7061 NULL_TREE if no simplification can be made. */
7064 fold_builtin_atan (tree arglist
, tree type
)
7067 tree arg
= TREE_VALUE (arglist
);
7069 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7072 /* Optimize atan(0.0) = 0.0. */
7073 if (real_zerop (arg
))
7076 /* Optimize atan(1.0) = pi/4. */
7077 if (real_onep (arg
))
7079 REAL_VALUE_TYPE cst
;
7081 real_convert (&cst
, TYPE_MODE (type
), &dconstpi
);
7082 SET_REAL_EXP (&cst
, REAL_EXP (&cst
) - 2);
7083 return build_real (type
, cst
);
7089 /* Fold function call to builtin trunc, truncf or truncl. Return
7090 NULL_TREE if no simplification can be made. */
7093 fold_builtin_trunc (tree fndecl
, tree arglist
)
7097 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7100 /* Optimize trunc of constant value. */
7101 arg
= TREE_VALUE (arglist
);
7102 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7104 REAL_VALUE_TYPE r
, x
;
7105 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7107 x
= TREE_REAL_CST (arg
);
7108 real_trunc (&r
, TYPE_MODE (type
), &x
);
7109 return build_real (type
, r
);
7112 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7115 /* Fold function call to builtin floor, floorf or floorl. Return
7116 NULL_TREE if no simplification can be made. */
7119 fold_builtin_floor (tree fndecl
, tree arglist
)
7123 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7126 /* Optimize floor of constant value. */
7127 arg
= TREE_VALUE (arglist
);
7128 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7132 x
= TREE_REAL_CST (arg
);
7133 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7135 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7138 real_floor (&r
, TYPE_MODE (type
), &x
);
7139 return build_real (type
, r
);
7143 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7146 /* Fold function call to builtin ceil, ceilf or ceill. Return
7147 NULL_TREE if no simplification can be made. */
7150 fold_builtin_ceil (tree fndecl
, tree arglist
)
7154 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7157 /* Optimize ceil of constant value. */
7158 arg
= TREE_VALUE (arglist
);
7159 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7163 x
= TREE_REAL_CST (arg
);
7164 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7166 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7169 real_ceil (&r
, TYPE_MODE (type
), &x
);
7170 return build_real (type
, r
);
7174 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7177 /* Fold function call to builtin round, roundf or roundl. Return
7178 NULL_TREE if no simplification can be made. */
7181 fold_builtin_round (tree fndecl
, tree arglist
)
7185 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7188 /* Optimize round of constant value. */
7189 arg
= TREE_VALUE (arglist
);
7190 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7194 x
= TREE_REAL_CST (arg
);
7195 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
7197 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7200 real_round (&r
, TYPE_MODE (type
), &x
);
7201 return build_real (type
, r
);
7205 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
7208 /* Fold function call to builtin lround, lroundf or lroundl (or the
7209 corresponding long long versions) and other rounding functions.
7210 Return NULL_TREE if no simplification can be made. */
7213 fold_builtin_int_roundingfn (tree fndecl
, tree arglist
)
7217 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7220 /* Optimize lround of constant value. */
7221 arg
= TREE_VALUE (arglist
);
7222 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7224 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
7226 if (! REAL_VALUE_ISNAN (x
) && ! REAL_VALUE_ISINF (x
))
7228 tree itype
= TREE_TYPE (TREE_TYPE (fndecl
));
7229 tree ftype
= TREE_TYPE (arg
), result
;
7230 HOST_WIDE_INT hi
, lo
;
7233 switch (DECL_FUNCTION_CODE (fndecl
))
7235 CASE_FLT_FN (BUILT_IN_LFLOOR
):
7236 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
7237 real_floor (&r
, TYPE_MODE (ftype
), &x
);
7240 CASE_FLT_FN (BUILT_IN_LCEIL
):
7241 CASE_FLT_FN (BUILT_IN_LLCEIL
):
7242 real_ceil (&r
, TYPE_MODE (ftype
), &x
);
7245 CASE_FLT_FN (BUILT_IN_LROUND
):
7246 CASE_FLT_FN (BUILT_IN_LLROUND
):
7247 real_round (&r
, TYPE_MODE (ftype
), &x
);
7254 REAL_VALUE_TO_INT (&lo
, &hi
, r
);
7255 result
= build_int_cst_wide (NULL_TREE
, lo
, hi
);
7256 if (int_fits_type_p (result
, itype
))
7257 return fold_convert (itype
, result
);
7261 return fold_fixed_mathfn (fndecl
, arglist
);
7264 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7265 and their long and long long variants (i.e. ffsl and ffsll).
7266 Return NULL_TREE if no simplification can be made. */
7269 fold_builtin_bitop (tree fndecl
, tree arglist
)
7273 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7276 /* Optimize for constant argument. */
7277 arg
= TREE_VALUE (arglist
);
7278 if (TREE_CODE (arg
) == INTEGER_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
7280 HOST_WIDE_INT hi
, width
, result
;
7281 unsigned HOST_WIDE_INT lo
;
7284 type
= TREE_TYPE (arg
);
7285 width
= TYPE_PRECISION (type
);
7286 lo
= TREE_INT_CST_LOW (arg
);
7288 /* Clear all the bits that are beyond the type's precision. */
7289 if (width
> HOST_BITS_PER_WIDE_INT
)
7291 hi
= TREE_INT_CST_HIGH (arg
);
7292 if (width
< 2 * HOST_BITS_PER_WIDE_INT
)
7293 hi
&= ~((HOST_WIDE_INT
) (-1) >> (width
- HOST_BITS_PER_WIDE_INT
));
7298 if (width
< HOST_BITS_PER_WIDE_INT
)
7299 lo
&= ~((unsigned HOST_WIDE_INT
) (-1) << width
);
7302 switch (DECL_FUNCTION_CODE (fndecl
))
7304 CASE_INT_FN (BUILT_IN_FFS
):
7306 result
= exact_log2 (lo
& -lo
) + 1;
7308 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
) + 1;
7313 CASE_INT_FN (BUILT_IN_CLZ
):
7315 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
7317 result
= width
- floor_log2 (lo
) - 1;
7318 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7322 CASE_INT_FN (BUILT_IN_CTZ
):
7324 result
= exact_log2 (lo
& -lo
);
7326 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
);
7327 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
7331 CASE_INT_FN (BUILT_IN_POPCOUNT
):
7334 result
++, lo
&= lo
- 1;
7336 result
++, hi
&= hi
- 1;
7339 CASE_INT_FN (BUILT_IN_PARITY
):
7342 result
++, lo
&= lo
- 1;
7344 result
++, hi
&= hi
- 1;
7352 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), result
);
7358 /* Return true if EXPR is the real constant contained in VALUE. */
7361 real_dconstp (tree expr
, const REAL_VALUE_TYPE
*value
)
7365 return ((TREE_CODE (expr
) == REAL_CST
7366 && ! TREE_CONSTANT_OVERFLOW (expr
)
7367 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), *value
))
7368 || (TREE_CODE (expr
) == COMPLEX_CST
7369 && real_dconstp (TREE_REALPART (expr
), value
)
7370 && real_zerop (TREE_IMAGPART (expr
))));
7373 /* A subroutine of fold_builtin to fold the various logarithmic
7374 functions. EXP is the CALL_EXPR of a call to a builtin logN
7375 function. VALUE is the base of the logN function. */
7378 fold_builtin_logarithm (tree fndecl
, tree arglist
,
7379 const REAL_VALUE_TYPE
*value
)
7381 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7383 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7384 tree arg
= TREE_VALUE (arglist
);
7385 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7387 /* Optimize logN(1.0) = 0.0. */
7388 if (real_onep (arg
))
7389 return build_real (type
, dconst0
);
7391 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
7392 exactly, then only do this if flag_unsafe_math_optimizations. */
7393 if (exact_real_truncate (TYPE_MODE (type
), value
)
7394 || flag_unsafe_math_optimizations
)
7396 const REAL_VALUE_TYPE value_truncate
=
7397 real_value_truncate (TYPE_MODE (type
), *value
);
7398 if (real_dconstp (arg
, &value_truncate
))
7399 return build_real (type
, dconst1
);
7402 /* Special case, optimize logN(expN(x)) = x. */
7403 if (flag_unsafe_math_optimizations
7404 && ((value
== &dconste
7405 && (fcode
== BUILT_IN_EXP
7406 || fcode
== BUILT_IN_EXPF
7407 || fcode
== BUILT_IN_EXPL
))
7408 || (value
== &dconst2
7409 && (fcode
== BUILT_IN_EXP2
7410 || fcode
== BUILT_IN_EXP2F
7411 || fcode
== BUILT_IN_EXP2L
))
7412 || (value
== &dconst10
&& (BUILTIN_EXP10_P (fcode
)))))
7413 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7415 /* Optimize logN(func()) for various exponential functions. We
7416 want to determine the value "x" and the power "exponent" in
7417 order to transform logN(x**exponent) into exponent*logN(x). */
7418 if (flag_unsafe_math_optimizations
)
7420 tree exponent
= 0, x
= 0;
7424 CASE_FLT_FN (BUILT_IN_EXP
):
7425 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7426 x
= build_real (type
,
7427 real_value_truncate (TYPE_MODE (type
), dconste
));
7428 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7430 CASE_FLT_FN (BUILT_IN_EXP2
):
7431 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7432 x
= build_real (type
, dconst2
);
7433 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7435 CASE_FLT_FN (BUILT_IN_EXP10
):
7436 CASE_FLT_FN (BUILT_IN_POW10
):
7437 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7438 x
= build_real (type
, dconst10
);
7439 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7441 CASE_FLT_FN (BUILT_IN_SQRT
):
7442 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7443 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7444 exponent
= build_real (type
, dconsthalf
);
7446 CASE_FLT_FN (BUILT_IN_CBRT
):
7447 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7448 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7449 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
7452 CASE_FLT_FN (BUILT_IN_POW
):
7453 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7454 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
7455 exponent
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
7461 /* Now perform the optimization. */
7465 arglist
= build_tree_list (NULL_TREE
, x
);
7466 logfn
= build_function_call_expr (fndecl
, arglist
);
7467 return fold_build2 (MULT_EXPR
, type
, exponent
, logfn
);
7475 /* Fold a builtin function call to pow, powf, or powl. Return
7476 NULL_TREE if no simplification can be made. */
7478 fold_builtin_pow (tree fndecl
, tree arglist
, tree type
)
7480 tree arg0
= TREE_VALUE (arglist
);
7481 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7483 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7486 /* Optimize pow(1.0,y) = 1.0. */
7487 if (real_onep (arg0
))
7488 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
7490 if (TREE_CODE (arg1
) == REAL_CST
7491 && ! TREE_CONSTANT_OVERFLOW (arg1
))
7493 REAL_VALUE_TYPE cint
;
7497 c
= TREE_REAL_CST (arg1
);
7499 /* Optimize pow(x,0.0) = 1.0. */
7500 if (REAL_VALUES_EQUAL (c
, dconst0
))
7501 return omit_one_operand (type
, build_real (type
, dconst1
),
7504 /* Optimize pow(x,1.0) = x. */
7505 if (REAL_VALUES_EQUAL (c
, dconst1
))
7508 /* Optimize pow(x,-1.0) = 1.0/x. */
7509 if (REAL_VALUES_EQUAL (c
, dconstm1
))
7510 return fold_build2 (RDIV_EXPR
, type
,
7511 build_real (type
, dconst1
), arg0
);
7513 /* Optimize pow(x,0.5) = sqrt(x). */
7514 if (flag_unsafe_math_optimizations
7515 && REAL_VALUES_EQUAL (c
, dconsthalf
))
7517 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
7519 if (sqrtfn
!= NULL_TREE
)
7521 tree arglist
= build_tree_list (NULL_TREE
, arg0
);
7522 return build_function_call_expr (sqrtfn
, arglist
);
7526 /* Check for an integer exponent. */
7527 n
= real_to_integer (&c
);
7528 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
7529 if (real_identical (&c
, &cint
))
7531 /* Attempt to evaluate pow at compile-time. */
7532 if (TREE_CODE (arg0
) == REAL_CST
7533 && ! TREE_CONSTANT_OVERFLOW (arg0
))
7538 x
= TREE_REAL_CST (arg0
);
7539 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
7540 if (flag_unsafe_math_optimizations
|| !inexact
)
7541 return build_real (type
, x
);
7544 /* Strip sign ops from even integer powers. */
7545 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
7547 tree narg0
= fold_strip_sign_ops (arg0
);
7550 arglist
= build_tree_list (NULL_TREE
, arg1
);
7551 arglist
= tree_cons (NULL_TREE
, narg0
, arglist
);
7552 return build_function_call_expr (fndecl
, arglist
);
7558 if (flag_unsafe_math_optimizations
)
7560 const enum built_in_function fcode
= builtin_mathfn_code (arg0
);
7562 /* Optimize pow(expN(x),y) = expN(x*y). */
7563 if (BUILTIN_EXPONENT_P (fcode
))
7565 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
7566 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7567 arg
= fold_build2 (MULT_EXPR
, type
, arg
, arg1
);
7568 arglist
= build_tree_list (NULL_TREE
, arg
);
7569 return build_function_call_expr (expfn
, arglist
);
7572 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
7573 if (BUILTIN_SQRT_P (fcode
))
7575 tree narg0
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7576 tree narg1
= fold_build2 (MULT_EXPR
, type
, arg1
,
7577 build_real (type
, dconsthalf
));
7579 arglist
= tree_cons (NULL_TREE
, narg0
,
7580 build_tree_list (NULL_TREE
, narg1
));
7581 return build_function_call_expr (fndecl
, arglist
);
7584 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
7585 if (BUILTIN_CBRT_P (fcode
))
7587 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7588 if (tree_expr_nonnegative_p (arg
))
7590 const REAL_VALUE_TYPE dconstroot
7591 = real_value_truncate (TYPE_MODE (type
), dconstthird
);
7592 tree narg1
= fold_build2 (MULT_EXPR
, type
, arg1
,
7593 build_real (type
, dconstroot
));
7594 arglist
= tree_cons (NULL_TREE
, arg
,
7595 build_tree_list (NULL_TREE
, narg1
));
7596 return build_function_call_expr (fndecl
, arglist
);
7600 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
7601 if (fcode
== BUILT_IN_POW
|| fcode
== BUILT_IN_POWF
7602 || fcode
== BUILT_IN_POWL
)
7604 tree arg00
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
7605 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0
, 1)));
7606 tree narg1
= fold_build2 (MULT_EXPR
, type
, arg01
, arg1
);
7607 arglist
= tree_cons (NULL_TREE
, arg00
,
7608 build_tree_list (NULL_TREE
, narg1
));
7609 return build_function_call_expr (fndecl
, arglist
);
7616 /* Fold a builtin function call to powi, powif, or powil. Return
7617 NULL_TREE if no simplification can be made. */
7619 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED
, tree arglist
, tree type
)
7621 tree arg0
= TREE_VALUE (arglist
);
7622 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7624 if (!validate_arglist (arglist
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7627 /* Optimize pow(1.0,y) = 1.0. */
7628 if (real_onep (arg0
))
7629 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
7631 if (host_integerp (arg1
, 0))
7633 HOST_WIDE_INT c
= TREE_INT_CST_LOW (arg1
);
7635 /* Evaluate powi at compile-time. */
7636 if (TREE_CODE (arg0
) == REAL_CST
7637 && ! TREE_CONSTANT_OVERFLOW (arg0
))
7640 x
= TREE_REAL_CST (arg0
);
7641 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
7642 return build_real (type
, x
);
7645 /* Optimize pow(x,0) = 1.0. */
7647 return omit_one_operand (type
, build_real (type
, dconst1
),
7650 /* Optimize pow(x,1) = x. */
7654 /* Optimize pow(x,-1) = 1.0/x. */
7656 return fold_build2 (RDIV_EXPR
, type
,
7657 build_real (type
, dconst1
), arg0
);
7663 /* A subroutine of fold_builtin to fold the various exponent
7664 functions. EXP is the CALL_EXPR of a call to a builtin function.
7665 VALUE is the value which will be raised to a power. */
7668 fold_builtin_exponent (tree fndecl
, tree arglist
,
7669 const REAL_VALUE_TYPE
*value
)
7671 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7673 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7674 tree arg
= TREE_VALUE (arglist
);
7676 /* Optimize exp*(0.0) = 1.0. */
7677 if (real_zerop (arg
))
7678 return build_real (type
, dconst1
);
7680 /* Optimize expN(1.0) = N. */
7681 if (real_onep (arg
))
7683 REAL_VALUE_TYPE cst
;
7685 real_convert (&cst
, TYPE_MODE (type
), value
);
7686 return build_real (type
, cst
);
7689 /* Attempt to evaluate expN(integer) at compile-time. */
7690 if (flag_unsafe_math_optimizations
7691 && TREE_CODE (arg
) == REAL_CST
7692 && ! TREE_CONSTANT_OVERFLOW (arg
))
7694 REAL_VALUE_TYPE cint
;
7698 c
= TREE_REAL_CST (arg
);
7699 n
= real_to_integer (&c
);
7700 real_from_integer (&cint
, VOIDmode
, n
,
7702 if (real_identical (&c
, &cint
))
7706 real_powi (&x
, TYPE_MODE (type
), value
, n
);
7707 return build_real (type
, x
);
7711 /* Optimize expN(logN(x)) = x. */
7712 if (flag_unsafe_math_optimizations
)
7714 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7716 if ((value
== &dconste
7717 && (fcode
== BUILT_IN_LOG
7718 || fcode
== BUILT_IN_LOGF
7719 || fcode
== BUILT_IN_LOGL
))
7720 || (value
== &dconst2
7721 && (fcode
== BUILT_IN_LOG2
7722 || fcode
== BUILT_IN_LOG2F
7723 || fcode
== BUILT_IN_LOG2L
))
7724 || (value
== &dconst10
7725 && (fcode
== BUILT_IN_LOG10
7726 || fcode
== BUILT_IN_LOG10F
7727 || fcode
== BUILT_IN_LOG10L
)))
7728 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7735 /* Fold function call to builtin memcpy. Return
7736 NULL_TREE if no simplification can be made. */
7739 fold_builtin_memcpy (tree fndecl
, tree arglist
)
7741 tree dest
, src
, len
;
7743 if (!validate_arglist (arglist
,
7744 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7747 dest
= TREE_VALUE (arglist
);
7748 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7749 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7751 /* If the LEN parameter is zero, return DEST. */
7752 if (integer_zerop (len
))
7753 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
7755 /* If SRC and DEST are the same (and not volatile), return DEST. */
7756 if (operand_equal_p (src
, dest
, 0))
7757 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
7762 /* Fold function call to builtin mempcpy. Return
7763 NULL_TREE if no simplification can be made. */
7766 fold_builtin_mempcpy (tree arglist
, tree type
, int endp
)
7768 if (validate_arglist (arglist
,
7769 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7771 tree dest
= TREE_VALUE (arglist
);
7772 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
7773 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7775 /* If the LEN parameter is zero, return DEST. */
7776 if (integer_zerop (len
))
7777 return omit_one_operand (type
, dest
, src
);
7779 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
7780 if (operand_equal_p (src
, dest
, 0))
7783 return omit_one_operand (type
, dest
, len
);
7786 len
= fold_build2 (MINUS_EXPR
, TREE_TYPE (len
), len
,
7789 len
= fold_convert (TREE_TYPE (dest
), len
);
7790 len
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
7791 return fold_convert (type
, len
);
7797 /* Fold function call to builtin memmove. Return
7798 NULL_TREE if no simplification can be made. */
7801 fold_builtin_memmove (tree arglist
, tree type
)
7803 tree dest
, src
, len
;
7805 if (!validate_arglist (arglist
,
7806 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7809 dest
= TREE_VALUE (arglist
);
7810 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7811 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7813 /* If the LEN parameter is zero, return DEST. */
7814 if (integer_zerop (len
))
7815 return omit_one_operand (type
, dest
, src
);
7817 /* If SRC and DEST are the same (and not volatile), return DEST. */
7818 if (operand_equal_p (src
, dest
, 0))
7819 return omit_one_operand (type
, dest
, len
);
7824 /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
7825 the length of the string to be copied. Return NULL_TREE if no
7826 simplification can be made. */
7829 fold_builtin_strcpy (tree fndecl
, tree arglist
, tree len
)
7833 if (!validate_arglist (arglist
,
7834 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7837 dest
= TREE_VALUE (arglist
);
7838 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7840 /* If SRC and DEST are the same (and not volatile), return DEST. */
7841 if (operand_equal_p (src
, dest
, 0))
7842 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
7847 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7853 len
= c_strlen (src
, 1);
7854 if (! len
|| TREE_SIDE_EFFECTS (len
))
7858 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
7859 arglist
= build_tree_list (NULL_TREE
, len
);
7860 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
7861 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
7862 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)),
7863 build_function_call_expr (fn
, arglist
));
7866 /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
7867 the length of the source string. Return NULL_TREE if no simplification
7871 fold_builtin_strncpy (tree fndecl
, tree arglist
, tree slen
)
7873 tree dest
, src
, len
, fn
;
7875 if (!validate_arglist (arglist
,
7876 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7879 dest
= TREE_VALUE (arglist
);
7880 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7881 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7883 /* If the LEN parameter is zero, return DEST. */
7884 if (integer_zerop (len
))
7885 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
7887 /* We can't compare slen with len as constants below if len is not a
7889 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
7893 slen
= c_strlen (src
, 1);
7895 /* Now, we must be passed a constant src ptr parameter. */
7896 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
7899 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
7901 /* We do not support simplification of this case, though we do
7902 support it when expanding trees into RTL. */
7903 /* FIXME: generate a call to __builtin_memset. */
7904 if (tree_int_cst_lt (slen
, len
))
7907 /* OK transform into builtin memcpy. */
7908 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7911 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)),
7912 build_function_call_expr (fn
, arglist
));
7915 /* Fold function call to builtin memcmp. Return
7916 NULL_TREE if no simplification can be made. */
7919 fold_builtin_memcmp (tree arglist
)
7921 tree arg1
, arg2
, len
;
7922 const char *p1
, *p2
;
7924 if (!validate_arglist (arglist
,
7925 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7928 arg1
= TREE_VALUE (arglist
);
7929 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7930 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7932 /* If the LEN parameter is zero, return zero. */
7933 if (integer_zerop (len
))
7934 return omit_two_operands (integer_type_node
, integer_zero_node
,
7937 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7938 if (operand_equal_p (arg1
, arg2
, 0))
7939 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
7941 p1
= c_getstr (arg1
);
7942 p2
= c_getstr (arg2
);
7944 /* If all arguments are constant, and the value of len is not greater
7945 than the lengths of arg1 and arg2, evaluate at compile-time. */
7946 if (host_integerp (len
, 1) && p1
&& p2
7947 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
7948 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
7950 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
7953 return integer_one_node
;
7955 return integer_minus_one_node
;
7957 return integer_zero_node
;
7960 /* If len parameter is one, return an expression corresponding to
7961 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7962 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
7964 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7965 tree cst_uchar_ptr_node
7966 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
7968 tree ind1
= fold_convert (integer_type_node
,
7969 build1 (INDIRECT_REF
, cst_uchar_node
,
7970 fold_convert (cst_uchar_ptr_node
,
7972 tree ind2
= fold_convert (integer_type_node
,
7973 build1 (INDIRECT_REF
, cst_uchar_node
,
7974 fold_convert (cst_uchar_ptr_node
,
7976 return fold_build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
7982 /* Fold function call to builtin strcmp. Return
7983 NULL_TREE if no simplification can be made. */
7986 fold_builtin_strcmp (tree arglist
)
7989 const char *p1
, *p2
;
7991 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7994 arg1
= TREE_VALUE (arglist
);
7995 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7997 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7998 if (operand_equal_p (arg1
, arg2
, 0))
7999 return integer_zero_node
;
8001 p1
= c_getstr (arg1
);
8002 p2
= c_getstr (arg2
);
8006 const int i
= strcmp (p1
, p2
);
8008 return integer_minus_one_node
;
8010 return integer_one_node
;
8012 return integer_zero_node
;
8015 /* If the second arg is "", return *(const unsigned char*)arg1. */
8016 if (p2
&& *p2
== '\0')
8018 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8019 tree cst_uchar_ptr_node
8020 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8022 return fold_convert (integer_type_node
,
8023 build1 (INDIRECT_REF
, cst_uchar_node
,
8024 fold_convert (cst_uchar_ptr_node
,
8028 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8029 if (p1
&& *p1
== '\0')
8031 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8032 tree cst_uchar_ptr_node
8033 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8035 tree temp
= fold_convert (integer_type_node
,
8036 build1 (INDIRECT_REF
, cst_uchar_node
,
8037 fold_convert (cst_uchar_ptr_node
,
8039 return fold_build1 (NEGATE_EXPR
, integer_type_node
, temp
);
8045 /* Fold function call to builtin strncmp. Return
8046 NULL_TREE if no simplification can be made. */
8049 fold_builtin_strncmp (tree arglist
)
8051 tree arg1
, arg2
, len
;
8052 const char *p1
, *p2
;
8054 if (!validate_arglist (arglist
,
8055 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8058 arg1
= TREE_VALUE (arglist
);
8059 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
8060 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
8062 /* If the LEN parameter is zero, return zero. */
8063 if (integer_zerop (len
))
8064 return omit_two_operands (integer_type_node
, integer_zero_node
,
8067 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8068 if (operand_equal_p (arg1
, arg2
, 0))
8069 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
8071 p1
= c_getstr (arg1
);
8072 p2
= c_getstr (arg2
);
8074 if (host_integerp (len
, 1) && p1
&& p2
)
8076 const int i
= strncmp (p1
, p2
, tree_low_cst (len
, 1));
8078 return integer_one_node
;
8080 return integer_minus_one_node
;
8082 return integer_zero_node
;
8085 /* If the second arg is "", and the length is greater than zero,
8086 return *(const unsigned char*)arg1. */
8087 if (p2
&& *p2
== '\0'
8088 && TREE_CODE (len
) == INTEGER_CST
8089 && tree_int_cst_sgn (len
) == 1)
8091 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8092 tree cst_uchar_ptr_node
8093 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8095 return fold_convert (integer_type_node
,
8096 build1 (INDIRECT_REF
, cst_uchar_node
,
8097 fold_convert (cst_uchar_ptr_node
,
8101 /* If the first arg is "", and the length is greater than zero,
8102 return -*(const unsigned char*)arg2. */
8103 if (p1
&& *p1
== '\0'
8104 && TREE_CODE (len
) == INTEGER_CST
8105 && tree_int_cst_sgn (len
) == 1)
8107 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8108 tree cst_uchar_ptr_node
8109 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8111 tree temp
= fold_convert (integer_type_node
,
8112 build1 (INDIRECT_REF
, cst_uchar_node
,
8113 fold_convert (cst_uchar_ptr_node
,
8115 return fold_build1 (NEGATE_EXPR
, integer_type_node
, temp
);
8118 /* If len parameter is one, return an expression corresponding to
8119 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8120 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
8122 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
8123 tree cst_uchar_ptr_node
8124 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
8126 tree ind1
= fold_convert (integer_type_node
,
8127 build1 (INDIRECT_REF
, cst_uchar_node
,
8128 fold_convert (cst_uchar_ptr_node
,
8130 tree ind2
= fold_convert (integer_type_node
,
8131 build1 (INDIRECT_REF
, cst_uchar_node
,
8132 fold_convert (cst_uchar_ptr_node
,
8134 return fold_build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
);
8140 /* Fold function call to builtin signbit, signbitf or signbitl. Return
8141 NULL_TREE if no simplification can be made. */
8144 fold_builtin_signbit (tree fndecl
, tree arglist
)
8146 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8149 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8152 arg
= TREE_VALUE (arglist
);
8154 /* If ARG is a compile-time constant, determine the result. */
8155 if (TREE_CODE (arg
) == REAL_CST
8156 && !TREE_CONSTANT_OVERFLOW (arg
))
8160 c
= TREE_REAL_CST (arg
);
8161 temp
= REAL_VALUE_NEGATIVE (c
) ? integer_one_node
: integer_zero_node
;
8162 return fold_convert (type
, temp
);
8165 /* If ARG is non-negative, the result is always zero. */
8166 if (tree_expr_nonnegative_p (arg
))
8167 return omit_one_operand (type
, integer_zero_node
, arg
);
8169 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
8170 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
8171 return fold_build2 (LT_EXPR
, type
, arg
,
8172 build_real (TREE_TYPE (arg
), dconst0
));
8177 /* Fold function call to builtin copysign, copysignf or copysignl.
8178 Return NULL_TREE if no simplification can be made. */
8181 fold_builtin_copysign (tree fndecl
, tree arglist
, tree type
)
8183 tree arg1
, arg2
, tem
;
8185 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
8188 arg1
= TREE_VALUE (arglist
);
8189 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
8191 /* copysign(X,X) is X. */
8192 if (operand_equal_p (arg1
, arg2
, 0))
8193 return fold_convert (type
, arg1
);
8195 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
8196 if (TREE_CODE (arg1
) == REAL_CST
8197 && TREE_CODE (arg2
) == REAL_CST
8198 && !TREE_CONSTANT_OVERFLOW (arg1
)
8199 && !TREE_CONSTANT_OVERFLOW (arg2
))
8201 REAL_VALUE_TYPE c1
, c2
;
8203 c1
= TREE_REAL_CST (arg1
);
8204 c2
= TREE_REAL_CST (arg2
);
8205 real_copysign (&c1
, &c2
);
8206 return build_real (type
, c1
);
8210 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
8211 Remember to evaluate Y for side-effects. */
8212 if (tree_expr_nonnegative_p (arg2
))
8213 return omit_one_operand (type
,
8214 fold_build1 (ABS_EXPR
, type
, arg1
),
8217 /* Strip sign changing operations for the first argument. */
8218 tem
= fold_strip_sign_ops (arg1
);
8221 arglist
= tree_cons (NULL_TREE
, tem
, TREE_CHAIN (arglist
));
8222 return build_function_call_expr (fndecl
, arglist
);
8228 /* Fold a call to builtin isascii. */
8231 fold_builtin_isascii (tree arglist
)
8233 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8237 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
8238 tree arg
= TREE_VALUE (arglist
);
8240 arg
= build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
8241 build_int_cst (NULL_TREE
,
8242 ~ (unsigned HOST_WIDE_INT
) 0x7f));
8243 arg
= fold_build2 (EQ_EXPR
, integer_type_node
,
8244 arg
, integer_zero_node
);
8246 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
8253 /* Fold a call to builtin toascii. */
8256 fold_builtin_toascii (tree arglist
)
8258 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8262 /* Transform toascii(c) -> (c & 0x7f). */
8263 tree arg
= TREE_VALUE (arglist
);
8265 return fold_build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
8266 build_int_cst (NULL_TREE
, 0x7f));
8270 /* Fold a call to builtin isdigit. */
8273 fold_builtin_isdigit (tree arglist
)
8275 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8279 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
8280 /* According to the C standard, isdigit is unaffected by locale.
8281 However, it definitely is affected by the target character set. */
8283 unsigned HOST_WIDE_INT target_digit0
8284 = lang_hooks
.to_target_charset ('0');
8286 if (target_digit0
== 0)
8289 arg
= fold_convert (unsigned_type_node
, TREE_VALUE (arglist
));
8290 arg
= build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
8291 build_int_cst (unsigned_type_node
, target_digit0
));
8292 arg
= fold_build2 (LE_EXPR
, integer_type_node
, arg
,
8293 build_int_cst (unsigned_type_node
, 9));
8294 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
8301 /* Fold a call to fabs, fabsf or fabsl. */
8304 fold_builtin_fabs (tree arglist
, tree type
)
8308 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8311 arg
= TREE_VALUE (arglist
);
8312 arg
= fold_convert (type
, arg
);
8313 if (TREE_CODE (arg
) == REAL_CST
)
8314 return fold_abs_const (arg
, type
);
8315 return fold_build1 (ABS_EXPR
, type
, arg
);
8318 /* Fold a call to abs, labs, llabs or imaxabs. */
8321 fold_builtin_abs (tree arglist
, tree type
)
8325 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
8328 arg
= TREE_VALUE (arglist
);
8329 arg
= fold_convert (type
, arg
);
8330 if (TREE_CODE (arg
) == INTEGER_CST
)
8331 return fold_abs_const (arg
, type
);
8332 return fold_build1 (ABS_EXPR
, type
, arg
);
8335 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8336 EXP is the CALL_EXPR for the call. */
8339 fold_builtin_classify (tree fndecl
, tree arglist
, int builtin_index
)
8341 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8345 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
8347 /* Check that we have exactly one argument. */
8350 error ("too few arguments to function %qs",
8351 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8352 return error_mark_node
;
8354 else if (TREE_CHAIN (arglist
) != 0)
8356 error ("too many arguments to function %qs",
8357 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8358 return error_mark_node
;
8362 error ("non-floating-point argument to function %qs",
8363 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8364 return error_mark_node
;
8368 arg
= TREE_VALUE (arglist
);
8369 switch (builtin_index
)
8371 case BUILT_IN_ISINF
:
8372 if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
8373 return omit_one_operand (type
, integer_zero_node
, arg
);
8375 if (TREE_CODE (arg
) == REAL_CST
)
8377 r
= TREE_REAL_CST (arg
);
8378 if (real_isinf (&r
))
8379 return real_compare (GT_EXPR
, &r
, &dconst0
)
8380 ? integer_one_node
: integer_minus_one_node
;
8382 return integer_zero_node
;
8387 case BUILT_IN_FINITE
:
8388 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
)))
8389 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
8390 return omit_one_operand (type
, integer_zero_node
, arg
);
8392 if (TREE_CODE (arg
) == REAL_CST
)
8394 r
= TREE_REAL_CST (arg
);
8395 return real_isinf (&r
) || real_isnan (&r
)
8396 ? integer_zero_node
: integer_one_node
;
8401 case BUILT_IN_ISNAN
:
8402 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
))))
8403 return omit_one_operand (type
, integer_zero_node
, arg
);
8405 if (TREE_CODE (arg
) == REAL_CST
)
8407 r
= TREE_REAL_CST (arg
);
8408 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
8411 arg
= builtin_save_expr (arg
);
8412 return fold_build2 (UNORDERED_EXPR
, type
, arg
, arg
);
8419 /* Fold a call to an unordered comparison function such as
8420 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
8421 being called and ARGLIST is the argument list for the call.
8422 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
8423 the opposite of the desired result. UNORDERED_CODE is used
8424 for modes that can hold NaNs and ORDERED_CODE is used for
8428 fold_builtin_unordered_cmp (tree fndecl
, tree arglist
,
8429 enum tree_code unordered_code
,
8430 enum tree_code ordered_code
)
8432 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8433 enum tree_code code
;
8436 enum tree_code code0
, code1
;
8437 tree cmp_type
= NULL_TREE
;
8439 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
8441 /* Check that we have exactly two arguments. */
8442 if (arglist
== 0 || TREE_CHAIN (arglist
) == 0)
8444 error ("too few arguments to function %qs",
8445 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8446 return error_mark_node
;
8448 else if (TREE_CHAIN (TREE_CHAIN (arglist
)) != 0)
8450 error ("too many arguments to function %qs",
8451 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8452 return error_mark_node
;
8456 arg0
= TREE_VALUE (arglist
);
8457 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
8459 type0
= TREE_TYPE (arg0
);
8460 type1
= TREE_TYPE (arg1
);
8462 code0
= TREE_CODE (type0
);
8463 code1
= TREE_CODE (type1
);
8465 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
8466 /* Choose the wider of two real types. */
8467 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
8469 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
8471 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
8475 error ("non-floating-point argument to function %qs",
8476 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
8477 return error_mark_node
;
8480 arg0
= fold_convert (cmp_type
, arg0
);
8481 arg1
= fold_convert (cmp_type
, arg1
);
8483 if (unordered_code
== UNORDERED_EXPR
)
8485 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
8486 return omit_two_operands (type
, integer_zero_node
, arg0
, arg1
);
8487 return fold_build2 (UNORDERED_EXPR
, type
, arg0
, arg1
);
8490 code
= MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
8492 return fold_build1 (TRUTH_NOT_EXPR
, type
,
8493 fold_build2 (code
, type
, arg0
, arg1
));
8496 /* Used by constant folding to simplify calls to builtin functions. EXP is
8497 the CALL_EXPR of a call to a builtin function. IGNORE is true if the
8498 result of the function call is ignored. This function returns NULL_TREE
8499 if no simplification was possible. */
8502 fold_builtin_1 (tree fndecl
, tree arglist
, bool ignore
)
8504 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
8505 enum built_in_function fcode
;
8507 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
8508 return targetm
.fold_builtin (fndecl
, arglist
, ignore
);
8510 fcode
= DECL_FUNCTION_CODE (fndecl
);
8513 case BUILT_IN_FPUTS
:
8514 return fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
8516 case BUILT_IN_FPUTS_UNLOCKED
:
8517 return fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
8519 case BUILT_IN_STRSTR
:
8520 return fold_builtin_strstr (arglist
, type
);
8522 case BUILT_IN_STRCAT
:
8523 return fold_builtin_strcat (arglist
);
8525 case BUILT_IN_STRNCAT
:
8526 return fold_builtin_strncat (arglist
);
8528 case BUILT_IN_STRSPN
:
8529 return fold_builtin_strspn (arglist
);
8531 case BUILT_IN_STRCSPN
:
8532 return fold_builtin_strcspn (arglist
);
8534 case BUILT_IN_STRCHR
:
8535 case BUILT_IN_INDEX
:
8536 return fold_builtin_strchr (arglist
, type
);
8538 case BUILT_IN_STRRCHR
:
8539 case BUILT_IN_RINDEX
:
8540 return fold_builtin_strrchr (arglist
, type
);
8542 case BUILT_IN_STRCPY
:
8543 return fold_builtin_strcpy (fndecl
, arglist
, NULL_TREE
);
8545 case BUILT_IN_STRNCPY
:
8546 return fold_builtin_strncpy (fndecl
, arglist
, NULL_TREE
);
8548 case BUILT_IN_STRCMP
:
8549 return fold_builtin_strcmp (arglist
);
8551 case BUILT_IN_STRNCMP
:
8552 return fold_builtin_strncmp (arglist
);
8554 case BUILT_IN_STRPBRK
:
8555 return fold_builtin_strpbrk (arglist
, type
);
8558 case BUILT_IN_MEMCMP
:
8559 return fold_builtin_memcmp (arglist
);
8561 case BUILT_IN_SPRINTF
:
8562 return fold_builtin_sprintf (arglist
, ignore
);
8564 case BUILT_IN_CONSTANT_P
:
8568 val
= fold_builtin_constant_p (arglist
);
8569 /* Gimplification will pull the CALL_EXPR for the builtin out of
8570 an if condition. When not optimizing, we'll not CSE it back.
8571 To avoid link error types of regressions, return false now. */
8572 if (!val
&& !optimize
)
8573 val
= integer_zero_node
;
8578 case BUILT_IN_EXPECT
:
8579 return fold_builtin_expect (arglist
);
8581 case BUILT_IN_CLASSIFY_TYPE
:
8582 return fold_builtin_classify_type (arglist
);
8584 case BUILT_IN_STRLEN
:
8585 return fold_builtin_strlen (arglist
);
8587 CASE_FLT_FN (BUILT_IN_FABS
):
8588 return fold_builtin_fabs (arglist
, type
);
8592 case BUILT_IN_LLABS
:
8593 case BUILT_IN_IMAXABS
:
8594 return fold_builtin_abs (arglist
, type
);
8596 CASE_FLT_FN (BUILT_IN_CONJ
):
8597 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8598 return fold_build1 (CONJ_EXPR
, type
, TREE_VALUE (arglist
));
8601 CASE_FLT_FN (BUILT_IN_CREAL
):
8602 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8603 return non_lvalue (fold_build1 (REALPART_EXPR
, type
,
8604 TREE_VALUE (arglist
)));
8607 CASE_FLT_FN (BUILT_IN_CIMAG
):
8608 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
8609 return non_lvalue (fold_build1 (IMAGPART_EXPR
, type
,
8610 TREE_VALUE (arglist
)));
8613 CASE_FLT_FN (BUILT_IN_CABS
):
8614 return fold_builtin_cabs (arglist
, type
);
8616 CASE_FLT_FN (BUILT_IN_SQRT
):
8617 return fold_builtin_sqrt (arglist
, type
);
8619 CASE_FLT_FN (BUILT_IN_CBRT
):
8620 return fold_builtin_cbrt (arglist
, type
);
8622 CASE_FLT_FN (BUILT_IN_SIN
):
8623 return fold_builtin_sin (arglist
);
8625 CASE_FLT_FN (BUILT_IN_COS
):
8626 return fold_builtin_cos (arglist
, type
, fndecl
);
8628 CASE_FLT_FN (BUILT_IN_EXP
):
8629 return fold_builtin_exponent (fndecl
, arglist
, &dconste
);
8631 CASE_FLT_FN (BUILT_IN_EXP2
):
8632 return fold_builtin_exponent (fndecl
, arglist
, &dconst2
);
8634 CASE_FLT_FN (BUILT_IN_EXP10
):
8635 CASE_FLT_FN (BUILT_IN_POW10
):
8636 return fold_builtin_exponent (fndecl
, arglist
, &dconst10
);
8638 CASE_FLT_FN (BUILT_IN_LOG
):
8639 return fold_builtin_logarithm (fndecl
, arglist
, &dconste
);
8641 CASE_FLT_FN (BUILT_IN_LOG2
):
8642 return fold_builtin_logarithm (fndecl
, arglist
, &dconst2
);
8644 CASE_FLT_FN (BUILT_IN_LOG10
):
8645 return fold_builtin_logarithm (fndecl
, arglist
, &dconst10
);
8647 CASE_FLT_FN (BUILT_IN_TAN
):
8648 return fold_builtin_tan (arglist
);
8650 CASE_FLT_FN (BUILT_IN_ATAN
):
8651 return fold_builtin_atan (arglist
, type
);
8653 CASE_FLT_FN (BUILT_IN_POW
):
8654 return fold_builtin_pow (fndecl
, arglist
, type
);
8656 CASE_FLT_FN (BUILT_IN_POWI
):
8657 return fold_builtin_powi (fndecl
, arglist
, type
);
8659 CASE_FLT_FN (BUILT_IN_INF
):
8660 case BUILT_IN_INFD32
:
8661 case BUILT_IN_INFD64
:
8662 case BUILT_IN_INFD128
:
8663 return fold_builtin_inf (type
, true);
8665 CASE_FLT_FN (BUILT_IN_HUGE_VAL
):
8666 return fold_builtin_inf (type
, false);
8668 CASE_FLT_FN (BUILT_IN_NAN
):
8669 case BUILT_IN_NAND32
:
8670 case BUILT_IN_NAND64
:
8671 case BUILT_IN_NAND128
:
8672 return fold_builtin_nan (arglist
, type
, true);
8674 CASE_FLT_FN (BUILT_IN_NANS
):
8675 return fold_builtin_nan (arglist
, type
, false);
8677 CASE_FLT_FN (BUILT_IN_FLOOR
):
8678 return fold_builtin_floor (fndecl
, arglist
);
8680 CASE_FLT_FN (BUILT_IN_CEIL
):
8681 return fold_builtin_ceil (fndecl
, arglist
);
8683 CASE_FLT_FN (BUILT_IN_TRUNC
):
8684 return fold_builtin_trunc (fndecl
, arglist
);
8686 CASE_FLT_FN (BUILT_IN_ROUND
):
8687 return fold_builtin_round (fndecl
, arglist
);
8689 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
8690 CASE_FLT_FN (BUILT_IN_RINT
):
8691 return fold_trunc_transparent_mathfn (fndecl
, arglist
);
8693 CASE_FLT_FN (BUILT_IN_LCEIL
):
8694 CASE_FLT_FN (BUILT_IN_LLCEIL
):
8695 CASE_FLT_FN (BUILT_IN_LFLOOR
):
8696 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
8697 CASE_FLT_FN (BUILT_IN_LROUND
):
8698 CASE_FLT_FN (BUILT_IN_LLROUND
):
8699 return fold_builtin_int_roundingfn (fndecl
, arglist
);
8701 CASE_FLT_FN (BUILT_IN_LRINT
):
8702 CASE_FLT_FN (BUILT_IN_LLRINT
):
8703 return fold_fixed_mathfn (fndecl
, arglist
);
8705 CASE_INT_FN (BUILT_IN_FFS
):
8706 CASE_INT_FN (BUILT_IN_CLZ
):
8707 CASE_INT_FN (BUILT_IN_CTZ
):
8708 CASE_INT_FN (BUILT_IN_POPCOUNT
):
8709 CASE_INT_FN (BUILT_IN_PARITY
):
8710 return fold_builtin_bitop (fndecl
, arglist
);
8712 case BUILT_IN_MEMCPY
:
8713 return fold_builtin_memcpy (fndecl
, arglist
);
8715 case BUILT_IN_MEMPCPY
:
8716 return fold_builtin_mempcpy (arglist
, type
, /*endp=*/1);
8718 case BUILT_IN_MEMMOVE
:
8719 return fold_builtin_memmove (arglist
, type
);
8721 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
8722 return fold_builtin_signbit (fndecl
, arglist
);
8724 case BUILT_IN_ISASCII
:
8725 return fold_builtin_isascii (arglist
);
8727 case BUILT_IN_TOASCII
:
8728 return fold_builtin_toascii (arglist
);
8730 case BUILT_IN_ISDIGIT
:
8731 return fold_builtin_isdigit (arglist
);
8733 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
8734 return fold_builtin_copysign (fndecl
, arglist
, type
);
8736 CASE_FLT_FN (BUILT_IN_FINITE
):
8737 case BUILT_IN_FINITED32
:
8738 case BUILT_IN_FINITED64
:
8739 case BUILT_IN_FINITED128
:
8740 return fold_builtin_classify (fndecl
, arglist
, BUILT_IN_FINITE
);
8742 CASE_FLT_FN (BUILT_IN_ISINF
):
8743 case BUILT_IN_ISINFD32
:
8744 case BUILT_IN_ISINFD64
:
8745 case BUILT_IN_ISINFD128
:
8746 return fold_builtin_classify (fndecl
, arglist
, BUILT_IN_ISINF
);
8748 CASE_FLT_FN (BUILT_IN_ISNAN
):
8749 case BUILT_IN_ISNAND32
:
8750 case BUILT_IN_ISNAND64
:
8751 case BUILT_IN_ISNAND128
:
8752 return fold_builtin_classify (fndecl
, arglist
, BUILT_IN_ISNAN
);
8754 case BUILT_IN_ISGREATER
:
8755 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNLE_EXPR
, LE_EXPR
);
8756 case BUILT_IN_ISGREATEREQUAL
:
8757 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNLT_EXPR
, LT_EXPR
);
8758 case BUILT_IN_ISLESS
:
8759 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNGE_EXPR
, GE_EXPR
);
8760 case BUILT_IN_ISLESSEQUAL
:
8761 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNGT_EXPR
, GT_EXPR
);
8762 case BUILT_IN_ISLESSGREATER
:
8763 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNEQ_EXPR
, EQ_EXPR
);
8764 case BUILT_IN_ISUNORDERED
:
8765 return fold_builtin_unordered_cmp (fndecl
, arglist
, UNORDERED_EXPR
,
8768 /* We do the folding for va_start in the expander. */
8769 case BUILT_IN_VA_START
:
8772 case BUILT_IN_OBJECT_SIZE
:
8773 return fold_builtin_object_size (arglist
);
8774 case BUILT_IN_MEMCPY_CHK
:
8775 case BUILT_IN_MEMPCPY_CHK
:
8776 case BUILT_IN_MEMMOVE_CHK
:
8777 case BUILT_IN_MEMSET_CHK
:
8778 return fold_builtin_memory_chk (fndecl
, arglist
, NULL_TREE
, ignore
,
8779 DECL_FUNCTION_CODE (fndecl
));
8780 case BUILT_IN_STRCPY_CHK
:
8781 case BUILT_IN_STPCPY_CHK
:
8782 return fold_builtin_stxcpy_chk (fndecl
, arglist
, NULL_TREE
, ignore
,
8783 DECL_FUNCTION_CODE (fndecl
));
8784 case BUILT_IN_STRNCPY_CHK
:
8785 return fold_builtin_strncpy_chk (arglist
, NULL_TREE
);
8786 case BUILT_IN_STRCAT_CHK
:
8787 return fold_builtin_strcat_chk (fndecl
, arglist
);
8788 case BUILT_IN_STRNCAT_CHK
:
8789 return fold_builtin_strncat_chk (fndecl
, arglist
);
8790 case BUILT_IN_SPRINTF_CHK
:
8791 case BUILT_IN_VSPRINTF_CHK
:
8792 return fold_builtin_sprintf_chk (arglist
, DECL_FUNCTION_CODE (fndecl
));
8793 case BUILT_IN_SNPRINTF_CHK
:
8794 case BUILT_IN_VSNPRINTF_CHK
:
8795 return fold_builtin_snprintf_chk (arglist
, NULL_TREE
,
8796 DECL_FUNCTION_CODE (fndecl
));
8798 case BUILT_IN_PRINTF
:
8799 case BUILT_IN_PRINTF_UNLOCKED
:
8800 case BUILT_IN_VPRINTF
:
8801 case BUILT_IN_PRINTF_CHK
:
8802 case BUILT_IN_VPRINTF_CHK
:
8803 return fold_builtin_printf (fndecl
, arglist
, ignore
,
8804 DECL_FUNCTION_CODE (fndecl
));
8806 case BUILT_IN_FPRINTF
:
8807 case BUILT_IN_FPRINTF_UNLOCKED
:
8808 case BUILT_IN_VFPRINTF
:
8809 case BUILT_IN_FPRINTF_CHK
:
8810 case BUILT_IN_VFPRINTF_CHK
:
8811 return fold_builtin_fprintf (fndecl
, arglist
, ignore
,
8812 DECL_FUNCTION_CODE (fndecl
));
8821 /* A wrapper function for builtin folding that prevents warnings for
8822 "statement without effect" and the like, caused by removing the
8823 call node earlier than the warning is generated. */
8826 fold_builtin (tree fndecl
, tree arglist
, bool ignore
)
8828 tree exp
= fold_builtin_1 (fndecl
, arglist
, ignore
);
8831 exp
= build1 (NOP_EXPR
, TREE_TYPE (exp
), exp
);
8832 TREE_NO_WARNING (exp
) = 1;
8838 /* Conveniently construct a function call expression. */
8841 build_function_call_expr (tree fn
, tree arglist
)
8845 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
8846 return fold_build3 (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
8847 call_expr
, arglist
, NULL_TREE
);
8850 /* This function validates the types of a function call argument list
8851 represented as a tree chain of parameters against a specified list
8852 of tree_codes. If the last specifier is a 0, that represents an
8853 ellipses, otherwise the last specifier must be a VOID_TYPE. */
8856 validate_arglist (tree arglist
, ...)
8858 enum tree_code code
;
8862 va_start (ap
, arglist
);
8866 code
= va_arg (ap
, enum tree_code
);
8870 /* This signifies an ellipses, any further arguments are all ok. */
8874 /* This signifies an endlink, if no arguments remain, return
8875 true, otherwise return false. */
8879 /* If no parameters remain or the parameter's code does not
8880 match the specified code, return false. Otherwise continue
8881 checking any remaining arguments. */
8884 if (code
== POINTER_TYPE
)
8886 if (! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
))))
8889 else if (code
!= TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))))
8893 arglist
= TREE_CHAIN (arglist
);
8897 /* We need gotos here since we can only have one VA_CLOSE in a
8905 /* Default target-specific builtin expander that does nothing. */
8908 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
8909 rtx target ATTRIBUTE_UNUSED
,
8910 rtx subtarget ATTRIBUTE_UNUSED
,
8911 enum machine_mode mode ATTRIBUTE_UNUSED
,
8912 int ignore ATTRIBUTE_UNUSED
)
8917 /* Returns true is EXP represents data that would potentially reside
8918 in a readonly section. */
8921 readonly_data_expr (tree exp
)
8925 if (TREE_CODE (exp
) != ADDR_EXPR
)
8928 exp
= get_base_address (TREE_OPERAND (exp
, 0));
8932 /* Make sure we call decl_readonly_section only for trees it
8933 can handle (since it returns true for everything it doesn't
8935 if (TREE_CODE (exp
) == STRING_CST
8936 || TREE_CODE (exp
) == CONSTRUCTOR
8937 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
8938 return decl_readonly_section (exp
, 0);
8943 /* Simplify a call to the strstr builtin.
8945 Return 0 if no simplification was possible, otherwise return the
8946 simplified form of the call as a tree.
8948 The simplified form may be a constant or other expression which
8949 computes the same value, but in a more efficient manner (including
8950 calls to other builtin functions).
8952 The call may contain arguments which need to be evaluated, but
8953 which are not useful to determine the result of the call. In
8954 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8955 COMPOUND_EXPR will be an argument which must be evaluated.
8956 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8957 COMPOUND_EXPR in the chain will contain the tree for the simplified
8958 form of the builtin function call. */
8961 fold_builtin_strstr (tree arglist
, tree type
)
8963 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8967 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8969 const char *p1
, *p2
;
8978 const char *r
= strstr (p1
, p2
);
8982 return build_int_cst (TREE_TYPE (s1
), 0);
8984 /* Return an offset into the constant string argument. */
8985 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8986 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
8987 return fold_convert (type
, tem
);
8990 /* The argument is const char *, and the result is char *, so we need
8991 a type conversion here to avoid a warning. */
8993 return fold_convert (type
, s1
);
8998 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
9002 /* New argument list transforming strstr(s1, s2) to
9003 strchr(s1, s2[0]). */
9004 arglist
= build_tree_list (NULL_TREE
,
9005 build_int_cst (NULL_TREE
, p2
[0]));
9006 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
9007 return build_function_call_expr (fn
, arglist
);
9011 /* Simplify a call to the strchr builtin.
9013 Return 0 if no simplification was possible, otherwise return the
9014 simplified form of the call as a tree.
9016 The simplified form may be a constant or other expression which
9017 computes the same value, but in a more efficient manner (including
9018 calls to other builtin functions).
9020 The call may contain arguments which need to be evaluated, but
9021 which are not useful to determine the result of the call. In
9022 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9023 COMPOUND_EXPR will be an argument which must be evaluated.
9024 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9025 COMPOUND_EXPR in the chain will contain the tree for the simplified
9026 form of the builtin function call. */
9029 fold_builtin_strchr (tree arglist
, tree type
)
9031 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9035 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9038 if (TREE_CODE (s2
) != INTEGER_CST
)
9048 if (target_char_cast (s2
, &c
))
9054 return build_int_cst (TREE_TYPE (s1
), 0);
9056 /* Return an offset into the constant string argument. */
9057 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9058 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9059 return fold_convert (type
, tem
);
9065 /* Simplify a call to the strrchr builtin.
9067 Return 0 if no simplification was possible, otherwise return the
9068 simplified form of the call as a tree.
9070 The simplified form may be a constant or other expression which
9071 computes the same value, but in a more efficient manner (including
9072 calls to other builtin functions).
9074 The call may contain arguments which need to be evaluated, but
9075 which are not useful to determine the result of the call. In
9076 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9077 COMPOUND_EXPR will be an argument which must be evaluated.
9078 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9079 COMPOUND_EXPR in the chain will contain the tree for the simplified
9080 form of the builtin function call. */
9083 fold_builtin_strrchr (tree arglist
, tree type
)
9085 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9089 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9093 if (TREE_CODE (s2
) != INTEGER_CST
)
9103 if (target_char_cast (s2
, &c
))
9106 r
= strrchr (p1
, c
);
9109 return build_int_cst (TREE_TYPE (s1
), 0);
9111 /* Return an offset into the constant string argument. */
9112 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9113 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9114 return fold_convert (type
, tem
);
9117 if (! integer_zerop (s2
))
9120 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
9124 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
9125 return build_function_call_expr (fn
, arglist
);
9129 /* Simplify a call to the strpbrk builtin.
9131 Return 0 if no simplification was possible, otherwise return the
9132 simplified form of the call as a tree.
9134 The simplified form may be a constant or other expression which
9135 computes the same value, but in a more efficient manner (including
9136 calls to other builtin functions).
9138 The call may contain arguments which need to be evaluated, but
9139 which are not useful to determine the result of the call. In
9140 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9141 COMPOUND_EXPR will be an argument which must be evaluated.
9142 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9143 COMPOUND_EXPR in the chain will contain the tree for the simplified
9144 form of the builtin function call. */
9147 fold_builtin_strpbrk (tree arglist
, tree type
)
9149 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9153 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9155 const char *p1
, *p2
;
9164 const char *r
= strpbrk (p1
, p2
);
9168 return build_int_cst (TREE_TYPE (s1
), 0);
9170 /* Return an offset into the constant string argument. */
9171 tem
= fold_build2 (PLUS_EXPR
, TREE_TYPE (s1
),
9172 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
));
9173 return fold_convert (type
, tem
);
9177 /* strpbrk(x, "") == NULL.
9178 Evaluate and ignore s1 in case it had side-effects. */
9179 return omit_one_operand (TREE_TYPE (s1
), integer_zero_node
, s1
);
9182 return 0; /* Really call strpbrk. */
9184 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
9188 /* New argument list transforming strpbrk(s1, s2) to
9189 strchr(s1, s2[0]). */
9190 arglist
= build_tree_list (NULL_TREE
,
9191 build_int_cst (NULL_TREE
, p2
[0]));
9192 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
9193 return build_function_call_expr (fn
, arglist
);
9197 /* Simplify a call to the strcat builtin.
9199 Return 0 if no simplification was possible, otherwise return the
9200 simplified form of the call as a tree.
9202 The simplified form may be a constant or other expression which
9203 computes the same value, but in a more efficient manner (including
9204 calls to other builtin functions).
9206 The call may contain arguments which need to be evaluated, but
9207 which are not useful to determine the result of the call. In
9208 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9209 COMPOUND_EXPR will be an argument which must be evaluated.
9210 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9211 COMPOUND_EXPR in the chain will contain the tree for the simplified
9212 form of the builtin function call. */
9215 fold_builtin_strcat (tree arglist
)
9217 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9221 tree dst
= TREE_VALUE (arglist
),
9222 src
= TREE_VALUE (TREE_CHAIN (arglist
));
9223 const char *p
= c_getstr (src
);
9225 /* If the string length is zero, return the dst parameter. */
9226 if (p
&& *p
== '\0')
9233 /* Simplify a call to the strncat builtin.
9235 Return 0 if no simplification was possible, otherwise return the
9236 simplified form of the call as a tree.
9238 The simplified form may be a constant or other expression which
9239 computes the same value, but in a more efficient manner (including
9240 calls to other builtin functions).
9242 The call may contain arguments which need to be evaluated, but
9243 which are not useful to determine the result of the call. In
9244 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9245 COMPOUND_EXPR will be an argument which must be evaluated.
9246 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9247 COMPOUND_EXPR in the chain will contain the tree for the simplified
9248 form of the builtin function call. */
9251 fold_builtin_strncat (tree arglist
)
9253 if (!validate_arglist (arglist
,
9254 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9258 tree dst
= TREE_VALUE (arglist
);
9259 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
9260 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9261 const char *p
= c_getstr (src
);
9263 /* If the requested length is zero, or the src parameter string
9264 length is zero, return the dst parameter. */
9265 if (integer_zerop (len
) || (p
&& *p
== '\0'))
9266 return omit_two_operands (TREE_TYPE (dst
), dst
, src
, len
);
9268 /* If the requested len is greater than or equal to the string
9269 length, call strcat. */
9270 if (TREE_CODE (len
) == INTEGER_CST
&& p
9271 && compare_tree_int (len
, strlen (p
)) >= 0)
9274 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
9275 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
9277 /* If the replacement _DECL isn't initialized, don't do the
9282 return build_function_call_expr (fn
, newarglist
);
9288 /* Simplify a call to the strspn builtin.
9290 Return 0 if no simplification was possible, otherwise return the
9291 simplified form of the call as a tree.
9293 The simplified form may be a constant or other expression which
9294 computes the same value, but in a more efficient manner (including
9295 calls to other builtin functions).
9297 The call may contain arguments which need to be evaluated, but
9298 which are not useful to determine the result of the call. In
9299 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9300 COMPOUND_EXPR will be an argument which must be evaluated.
9301 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9302 COMPOUND_EXPR in the chain will contain the tree for the simplified
9303 form of the builtin function call. */
9306 fold_builtin_strspn (tree arglist
)
9308 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9312 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9313 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9315 /* If both arguments are constants, evaluate at compile-time. */
9318 const size_t r
= strspn (p1
, p2
);
9319 return size_int (r
);
9322 /* If either argument is "", return 0. */
9323 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
9324 /* Evaluate and ignore both arguments in case either one has
9326 return omit_two_operands (integer_type_node
, integer_zero_node
,
9332 /* Simplify a call to the strcspn builtin.
9334 Return 0 if no simplification was possible, otherwise return the
9335 simplified form of the call as a tree.
9337 The simplified form may be a constant or other expression which
9338 computes the same value, but in a more efficient manner (including
9339 calls to other builtin functions).
9341 The call may contain arguments which need to be evaluated, but
9342 which are not useful to determine the result of the call. In
9343 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9344 COMPOUND_EXPR will be an argument which must be evaluated.
9345 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9346 COMPOUND_EXPR in the chain will contain the tree for the simplified
9347 form of the builtin function call. */
9350 fold_builtin_strcspn (tree arglist
)
9352 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9356 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
9357 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
9359 /* If both arguments are constants, evaluate at compile-time. */
9362 const size_t r
= strcspn (p1
, p2
);
9363 return size_int (r
);
9366 /* If the first argument is "", return 0. */
9367 if (p1
&& *p1
== '\0')
9369 /* Evaluate and ignore argument s2 in case it has
9371 return omit_one_operand (integer_type_node
,
9372 integer_zero_node
, s2
);
9375 /* If the second argument is "", return __builtin_strlen(s1). */
9376 if (p2
&& *p2
== '\0')
9378 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
9379 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
9381 /* If the replacement _DECL isn't initialized, don't do the
9386 return build_function_call_expr (fn
, newarglist
);
9392 /* Fold a call to the fputs builtin. IGNORE is true if the value returned
9393 by the builtin will be ignored. UNLOCKED is true is true if this
9394 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
9395 the known length of the string. Return NULL_TREE if no simplification
9399 fold_builtin_fputs (tree arglist
, bool ignore
, bool unlocked
, tree len
)
9402 /* If we're using an unlocked function, assume the other unlocked
9403 functions exist explicitly. */
9404 tree
const fn_fputc
= unlocked
? built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
9405 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
9406 tree
const fn_fwrite
= unlocked
? built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
9407 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
9409 /* If the return value is used, don't do the transformation. */
9413 /* Verify the arguments in the original call. */
9414 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
9418 len
= c_strlen (TREE_VALUE (arglist
), 0);
9420 /* Get the length of the string passed to fputs. If the length
9421 can't be determined, punt. */
9423 || TREE_CODE (len
) != INTEGER_CST
)
9426 switch (compare_tree_int (len
, 1))
9428 case -1: /* length is 0, delete the call entirely . */
9429 return omit_one_operand (integer_type_node
, integer_zero_node
,
9430 TREE_VALUE (TREE_CHAIN (arglist
)));
9432 case 0: /* length is 1, call fputc. */
9434 const char *p
= c_getstr (TREE_VALUE (arglist
));
9438 /* New argument list transforming fputs(string, stream) to
9439 fputc(string[0], stream). */
9440 arglist
= build_tree_list (NULL_TREE
,
9441 TREE_VALUE (TREE_CHAIN (arglist
)));
9442 arglist
= tree_cons (NULL_TREE
,
9443 build_int_cst (NULL_TREE
, p
[0]),
9450 case 1: /* length is greater than 1, call fwrite. */
9454 /* If optimizing for size keep fputs. */
9457 string_arg
= TREE_VALUE (arglist
);
9458 /* New argument list transforming fputs(string, stream) to
9459 fwrite(string, 1, len, stream). */
9460 arglist
= build_tree_list (NULL_TREE
,
9461 TREE_VALUE (TREE_CHAIN (arglist
)));
9462 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
9463 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
9464 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
9472 /* If the replacement _DECL isn't initialized, don't do the
9477 /* These optimizations are only performed when the result is ignored,
9478 hence there's no need to cast the result to integer_type_node. */
9479 return build_function_call_expr (fn
, arglist
);
9482 /* Fold the new_arg's arguments (ARGLIST). Returns true if there was an error
9483 produced. False otherwise. This is done so that we don't output the error
9484 or warning twice or three times. */
9486 fold_builtin_next_arg (tree arglist
)
9488 tree fntype
= TREE_TYPE (current_function_decl
);
9490 if (TYPE_ARG_TYPES (fntype
) == 0
9491 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
9494 error ("%<va_start%> used in function with fixed args");
9499 /* Evidently an out of date version of <stdarg.h>; can't validate
9500 va_start's second argument, but can still work as intended. */
9501 warning (0, "%<__builtin_next_arg%> called without an argument");
9504 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
9505 when we checked the arguments and if needed issued a warning. */
9506 else if (!TREE_CHAIN (arglist
)
9507 || !integer_zerop (TREE_VALUE (arglist
))
9508 || !integer_zerop (TREE_VALUE (TREE_CHAIN (arglist
)))
9509 || TREE_CHAIN (TREE_CHAIN (arglist
)))
9511 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
9512 tree arg
= TREE_VALUE (arglist
);
9514 if (TREE_CHAIN (arglist
))
9516 error ("%<va_start%> used with too many arguments");
9520 /* Strip off all nops for the sake of the comparison. This
9521 is not quite the same as STRIP_NOPS. It does more.
9522 We must also strip off INDIRECT_EXPR for C++ reference
9524 while (TREE_CODE (arg
) == NOP_EXPR
9525 || TREE_CODE (arg
) == CONVERT_EXPR
9526 || TREE_CODE (arg
) == NON_LVALUE_EXPR
9527 || TREE_CODE (arg
) == INDIRECT_REF
)
9528 arg
= TREE_OPERAND (arg
, 0);
9529 if (arg
!= last_parm
)
9531 /* FIXME: Sometimes with the tree optimizers we can get the
9532 not the last argument even though the user used the last
9533 argument. We just warn and set the arg to be the last
9534 argument so that we will get wrong-code because of
9536 warning (0, "second parameter of %<va_start%> not last named argument");
9538 /* We want to verify the second parameter just once before the tree
9539 optimizers are run and then avoid keeping it in the tree,
9540 as otherwise we could warn even for correct code like:
9541 void foo (int i, ...)
9542 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
9543 TREE_VALUE (arglist
) = integer_zero_node
;
9544 TREE_CHAIN (arglist
) = build_tree_list (NULL
, integer_zero_node
);
9550 /* Simplify a call to the sprintf builtin.
9552 Return 0 if no simplification was possible, otherwise return the
9553 simplified form of the call as a tree. If IGNORED is true, it means that
9554 the caller does not use the returned value of the function. */
9557 fold_builtin_sprintf (tree arglist
, int ignored
)
9559 tree call
, retval
, dest
, fmt
;
9560 const char *fmt_str
= NULL
;
9562 /* Verify the required arguments in the original call. We deal with two
9563 types of sprintf() calls: 'sprintf (str, fmt)' and
9564 'sprintf (dest, "%s", orig)'. */
9565 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
)
9566 && !validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, POINTER_TYPE
,
9570 /* Get the destination string and the format specifier. */
9571 dest
= TREE_VALUE (arglist
);
9572 fmt
= TREE_VALUE (TREE_CHAIN (arglist
));
9574 /* Check whether the format is a literal string constant. */
9575 fmt_str
= c_getstr (fmt
);
9576 if (fmt_str
== NULL
)
9582 if (!init_target_chars())
9585 /* If the format doesn't contain % args or %%, use strcpy. */
9586 if (strchr (fmt_str
, target_percent
) == NULL
)
9588 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9593 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
9594 'format' is known to contain no % formats. */
9595 arglist
= build_tree_list (NULL_TREE
, fmt
);
9596 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9597 call
= build_function_call_expr (fn
, arglist
);
9599 retval
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
9602 /* If the format is "%s", use strcpy if the result isn't used. */
9603 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
9606 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
9611 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
9612 orig
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9613 arglist
= build_tree_list (NULL_TREE
, orig
);
9614 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9617 retval
= c_strlen (orig
, 1);
9618 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
9621 call
= build_function_call_expr (fn
, arglist
);
9627 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls
[BUILT_IN_SPRINTF
])),
9629 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);
9635 /* Expand a call to __builtin_object_size. */
9638 expand_builtin_object_size (tree exp
)
9641 int object_size_type
;
9642 tree fndecl
= get_callee_fndecl (exp
);
9643 tree arglist
= TREE_OPERAND (exp
, 1);
9644 location_t locus
= EXPR_LOCATION (exp
);
9646 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9648 error ("%Hfirst argument of %D must be a pointer, second integer constant",
9650 expand_builtin_trap ();
9654 ost
= TREE_VALUE (TREE_CHAIN (arglist
));
9657 if (TREE_CODE (ost
) != INTEGER_CST
9658 || tree_int_cst_sgn (ost
) < 0
9659 || compare_tree_int (ost
, 3) > 0)
9661 error ("%Hlast argument of %D is not integer constant between 0 and 3",
9663 expand_builtin_trap ();
9667 object_size_type
= tree_low_cst (ost
, 0);
9669 return object_size_type
< 2 ? constm1_rtx
: const0_rtx
;
9672 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9673 FCODE is the BUILT_IN_* to use.
9674 Return 0 if we failed; the caller should emit a normal call,
9675 otherwise try to get the result in TARGET, if convenient (and in
9676 mode MODE if that's convenient). */
9679 expand_builtin_memory_chk (tree exp
, rtx target
, enum machine_mode mode
,
9680 enum built_in_function fcode
)
9682 tree arglist
= TREE_OPERAND (exp
, 1);
9683 tree dest
, src
, len
, size
;
9685 if (!validate_arglist (arglist
,
9687 fcode
== BUILT_IN_MEMSET_CHK
9688 ? INTEGER_TYPE
: POINTER_TYPE
,
9689 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9692 dest
= TREE_VALUE (arglist
);
9693 src
= TREE_VALUE (TREE_CHAIN (arglist
));
9694 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
9695 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
9697 if (! host_integerp (size
, 1))
9700 if (host_integerp (len
, 1) || integer_all_onesp (size
))
9704 if (! integer_all_onesp (size
) && tree_int_cst_lt (size
, len
))
9706 location_t locus
= EXPR_LOCATION (exp
);
9707 warning (0, "%Hcall to %D will always overflow destination buffer",
9708 &locus
, get_callee_fndecl (exp
));
9712 arglist
= build_tree_list (NULL_TREE
, len
);
9713 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
9714 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
9717 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9718 mem{cpy,pcpy,move,set} is available. */
9721 case BUILT_IN_MEMCPY_CHK
:
9722 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
9724 case BUILT_IN_MEMPCPY_CHK
:
9725 fn
= built_in_decls
[BUILT_IN_MEMPCPY
];
9727 case BUILT_IN_MEMMOVE_CHK
:
9728 fn
= built_in_decls
[BUILT_IN_MEMMOVE
];
9730 case BUILT_IN_MEMSET_CHK
:
9731 fn
= built_in_decls
[BUILT_IN_MEMSET
];
9740 fn
= build_function_call_expr (fn
, arglist
);
9741 if (TREE_CODE (fn
) == CALL_EXPR
)
9742 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
9743 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
9745 else if (fcode
== BUILT_IN_MEMSET_CHK
)
9749 unsigned int dest_align
9750 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
9752 /* If DEST is not a pointer type, call the normal function. */
9753 if (dest_align
== 0)
9756 /* If SRC and DEST are the same (and not volatile), do nothing. */
9757 if (operand_equal_p (src
, dest
, 0))
9761 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
9763 /* Evaluate and ignore LEN in case it has side-effects. */
9764 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
9765 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
9768 len
= fold_convert (TREE_TYPE (dest
), len
);
9769 expr
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
);
9770 return expand_expr (expr
, target
, mode
, EXPAND_NORMAL
);
9773 /* __memmove_chk special case. */
9774 if (fcode
== BUILT_IN_MEMMOVE_CHK
)
9776 unsigned int src_align
9777 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
9782 /* If src is categorized for a readonly section we can use
9783 normal __memcpy_chk. */
9784 if (readonly_data_expr (src
))
9786 tree fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
9789 fn
= build_function_call_expr (fn
, arglist
);
9790 if (TREE_CODE (fn
) == CALL_EXPR
)
9791 CALL_EXPR_TAILCALL (fn
) = CALL_EXPR_TAILCALL (exp
);
9792 return expand_expr (fn
, target
, mode
, EXPAND_NORMAL
);
9799 /* Emit warning if a buffer overflow is detected at compile time. */
9802 maybe_emit_chk_warning (tree exp
, enum built_in_function fcode
)
9804 int arg_mask
, is_strlen
= 0;
9805 tree arglist
= TREE_OPERAND (exp
, 1), a
;
9811 case BUILT_IN_STRCPY_CHK
:
9812 case BUILT_IN_STPCPY_CHK
:
9813 /* For __strcat_chk the warning will be emitted only if overflowing
9814 by at least strlen (dest) + 1 bytes. */
9815 case BUILT_IN_STRCAT_CHK
:
9819 case BUILT_IN_STRNCPY_CHK
:
9822 case BUILT_IN_SNPRINTF_CHK
:
9823 case BUILT_IN_VSNPRINTF_CHK
:
9832 for (a
= arglist
; a
&& arg_mask
; a
= TREE_CHAIN (a
), arg_mask
>>= 1)
9844 len
= TREE_VALUE (len
);
9845 size
= TREE_VALUE (size
);
9847 if (! host_integerp (size
, 1) || integer_all_onesp (size
))
9852 len
= c_strlen (len
, 1);
9853 if (! len
|| ! host_integerp (len
, 1) || tree_int_cst_lt (len
, size
))
9856 else if (! host_integerp (len
, 1) || ! tree_int_cst_lt (size
, len
))
9859 locus
= EXPR_LOCATION (exp
);
9860 warning (0, "%Hcall to %D will always overflow destination buffer",
9861 &locus
, get_callee_fndecl (exp
));
9864 /* Emit warning if a buffer overflow is detected at compile time
9865 in __sprintf_chk/__vsprintf_chk calls. */
9868 maybe_emit_sprintf_chk_warning (tree exp
, enum built_in_function fcode
)
9870 tree arglist
= TREE_OPERAND (exp
, 1);
9871 tree dest
, size
, len
, fmt
, flag
;
9872 const char *fmt_str
;
9874 /* Verify the required arguments in the original call. */
9877 dest
= TREE_VALUE (arglist
);
9878 arglist
= TREE_CHAIN (arglist
);
9881 flag
= TREE_VALUE (arglist
);
9882 arglist
= TREE_CHAIN (arglist
);
9885 size
= TREE_VALUE (arglist
);
9886 arglist
= TREE_CHAIN (arglist
);
9889 fmt
= TREE_VALUE (arglist
);
9890 arglist
= TREE_CHAIN (arglist
);
9892 if (! host_integerp (size
, 1) || integer_all_onesp (size
))
9895 /* Check whether the format is a literal string constant. */
9896 fmt_str
= c_getstr (fmt
);
9897 if (fmt_str
== NULL
)
9900 if (!init_target_chars())
9903 /* If the format doesn't contain % args or %%, we know its size. */
9904 if (strchr (fmt_str
, target_percent
) == 0)
9905 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
9906 /* If the format is "%s" and first ... argument is a string literal,
9908 else if (fcode
== BUILT_IN_SPRINTF_CHK
&& strcmp (fmt_str
, target_percent_s
) == 0)
9914 arg
= TREE_VALUE (arglist
);
9915 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
9918 len
= c_strlen (arg
, 1);
9919 if (!len
|| ! host_integerp (len
, 1))
9925 if (! tree_int_cst_lt (len
, size
))
9927 location_t locus
= EXPR_LOCATION (exp
);
9928 warning (0, "%Hcall to %D will always overflow destination buffer",
9929 &locus
, get_callee_fndecl (exp
));
9933 /* Fold a call to __builtin_object_size, if possible. */
9936 fold_builtin_object_size (tree arglist
)
9938 tree ptr
, ost
, ret
= 0;
9939 int object_size_type
;
9941 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
9944 ptr
= TREE_VALUE (arglist
);
9945 ost
= TREE_VALUE (TREE_CHAIN (arglist
));
9948 if (TREE_CODE (ost
) != INTEGER_CST
9949 || tree_int_cst_sgn (ost
) < 0
9950 || compare_tree_int (ost
, 3) > 0)
9953 object_size_type
= tree_low_cst (ost
, 0);
9955 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
9956 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
9957 and (size_t) 0 for types 2 and 3. */
9958 if (TREE_SIDE_EFFECTS (ptr
))
9959 return fold_convert (size_type_node
,
9960 object_size_type
< 2
9961 ? integer_minus_one_node
: integer_zero_node
);
9963 if (TREE_CODE (ptr
) == ADDR_EXPR
)
9964 ret
= build_int_cstu (size_type_node
,
9965 compute_builtin_object_size (ptr
, object_size_type
));
9967 else if (TREE_CODE (ptr
) == SSA_NAME
)
9969 unsigned HOST_WIDE_INT bytes
;
9971 /* If object size is not known yet, delay folding until
9972 later. Maybe subsequent passes will help determining
9974 bytes
= compute_builtin_object_size (ptr
, object_size_type
);
9975 if (bytes
!= (unsigned HOST_WIDE_INT
) (object_size_type
< 2
9977 ret
= build_int_cstu (size_type_node
, bytes
);
9982 ret
= force_fit_type (ret
, -1, false, false);
9983 if (TREE_CONSTANT_OVERFLOW (ret
))
9990 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9991 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
9992 code of the builtin. If MAXLEN is not NULL, it is maximum length
9993 passed as third argument. */
9996 fold_builtin_memory_chk (tree fndecl
, tree arglist
, tree maxlen
, bool ignore
,
9997 enum built_in_function fcode
)
9999 tree dest
, src
, len
, size
, fn
;
10001 if (!validate_arglist (arglist
,
10003 fcode
== BUILT_IN_MEMSET_CHK
10004 ? INTEGER_TYPE
: POINTER_TYPE
,
10005 INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
10008 dest
= TREE_VALUE (arglist
);
10009 /* Actually val for __memset_chk, but it doesn't matter. */
10010 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10011 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10012 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
10014 /* If SRC and DEST are the same (and not volatile), return DEST
10015 (resp. DEST+LEN for __mempcpy_chk). */
10016 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
10018 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
10019 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
10022 tree temp
= fold_convert (TREE_TYPE (dest
), len
);
10023 temp
= fold_build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, temp
);
10024 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), temp
);
10028 if (! host_integerp (size
, 1))
10031 if (! integer_all_onesp (size
))
10033 if (! host_integerp (len
, 1))
10035 /* If LEN is not constant, try MAXLEN too.
10036 For MAXLEN only allow optimizing into non-_ocs function
10037 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10038 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10040 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
10042 /* (void) __mempcpy_chk () can be optimized into
10043 (void) __memcpy_chk (). */
10044 fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
10048 return build_function_call_expr (fn
, arglist
);
10056 if (tree_int_cst_lt (size
, maxlen
))
10060 arglist
= build_tree_list (NULL_TREE
, len
);
10061 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10062 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10065 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
10066 mem{cpy,pcpy,move,set} is available. */
10069 case BUILT_IN_MEMCPY_CHK
:
10070 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
10072 case BUILT_IN_MEMPCPY_CHK
:
10073 fn
= built_in_decls
[BUILT_IN_MEMPCPY
];
10075 case BUILT_IN_MEMMOVE_CHK
:
10076 fn
= built_in_decls
[BUILT_IN_MEMMOVE
];
10078 case BUILT_IN_MEMSET_CHK
:
10079 fn
= built_in_decls
[BUILT_IN_MEMSET
];
10088 return build_function_call_expr (fn
, arglist
);
10091 /* Fold a call to the __st[rp]cpy_chk builtin.
10092 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
10093 code of the builtin. If MAXLEN is not NULL, it is maximum length of
10094 strings passed as second argument. */
10097 fold_builtin_stxcpy_chk (tree fndecl
, tree arglist
, tree maxlen
, bool ignore
,
10098 enum built_in_function fcode
)
10100 tree dest
, src
, size
, len
, fn
;
10102 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10106 dest
= TREE_VALUE (arglist
);
10107 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10108 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10110 /* If SRC and DEST are the same (and not volatile), return DEST. */
10111 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
10112 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), dest
);
10114 if (! host_integerp (size
, 1))
10117 if (! integer_all_onesp (size
))
10119 len
= c_strlen (src
, 1);
10120 if (! len
|| ! host_integerp (len
, 1))
10122 /* If LEN is not constant, try MAXLEN too.
10123 For MAXLEN only allow optimizing into non-_ocs function
10124 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10125 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10127 if (fcode
== BUILT_IN_STPCPY_CHK
)
10132 /* If return value of __stpcpy_chk is ignored,
10133 optimize into __strcpy_chk. */
10134 fn
= built_in_decls
[BUILT_IN_STRCPY_CHK
];
10138 return build_function_call_expr (fn
, arglist
);
10141 if (! len
|| TREE_SIDE_EFFECTS (len
))
10144 /* If c_strlen returned something, but not a constant,
10145 transform __strcpy_chk into __memcpy_chk. */
10146 fn
= built_in_decls
[BUILT_IN_MEMCPY_CHK
];
10150 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
10151 arglist
= build_tree_list (NULL_TREE
, size
);
10152 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
10153 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10154 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10155 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)),
10156 build_function_call_expr (fn
, arglist
));
10162 if (! tree_int_cst_lt (maxlen
, size
))
10166 arglist
= build_tree_list (NULL_TREE
, src
);
10167 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10169 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
10170 fn
= built_in_decls
[fcode
== BUILT_IN_STPCPY_CHK
10171 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
];
10175 return build_function_call_expr (fn
, arglist
);
10178 /* Fold a call to the __strncpy_chk builtin.
10179 If MAXLEN is not NULL, it is maximum length passed as third argument. */
10182 fold_builtin_strncpy_chk (tree arglist
, tree maxlen
)
10184 tree dest
, src
, size
, len
, fn
;
10186 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10187 INTEGER_TYPE
, VOID_TYPE
))
10190 dest
= TREE_VALUE (arglist
);
10191 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10192 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10193 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
10195 if (! host_integerp (size
, 1))
10198 if (! integer_all_onesp (size
))
10200 if (! host_integerp (len
, 1))
10202 /* If LEN is not constant, try MAXLEN too.
10203 For MAXLEN only allow optimizing into non-_ocs function
10204 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10205 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10211 if (tree_int_cst_lt (size
, maxlen
))
10215 arglist
= build_tree_list (NULL_TREE
, len
);
10216 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10217 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10219 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
10220 fn
= built_in_decls
[BUILT_IN_STRNCPY
];
10224 return build_function_call_expr (fn
, arglist
);
10227 /* Fold a call to the __strcat_chk builtin FNDECL with ARGLIST. */
10230 fold_builtin_strcat_chk (tree fndecl
, tree arglist
)
10232 tree dest
, src
, size
, fn
;
10235 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10239 dest
= TREE_VALUE (arglist
);
10240 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10241 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10243 p
= c_getstr (src
);
10244 /* If the SRC parameter is "", return DEST. */
10245 if (p
&& *p
== '\0')
10246 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
10248 if (! host_integerp (size
, 1) || ! integer_all_onesp (size
))
10251 arglist
= build_tree_list (NULL_TREE
, src
);
10252 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10254 /* If __builtin_strcat_chk is used, assume strcat is available. */
10255 fn
= built_in_decls
[BUILT_IN_STRCAT
];
10259 return build_function_call_expr (fn
, arglist
);
10262 /* Fold a call to the __strncat_chk builtin EXP. */
10265 fold_builtin_strncat_chk (tree fndecl
, tree arglist
)
10267 tree dest
, src
, size
, len
, fn
;
10270 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
,
10271 INTEGER_TYPE
, VOID_TYPE
))
10274 dest
= TREE_VALUE (arglist
);
10275 src
= TREE_VALUE (TREE_CHAIN (arglist
));
10276 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
10277 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist
))));
10279 p
= c_getstr (src
);
10280 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
10281 if (p
&& *p
== '\0')
10282 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, len
);
10283 else if (integer_zerop (len
))
10284 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl
)), dest
, src
);
10286 if (! host_integerp (size
, 1))
10289 if (! integer_all_onesp (size
))
10291 tree src_len
= c_strlen (src
, 1);
10293 && host_integerp (src_len
, 1)
10294 && host_integerp (len
, 1)
10295 && ! tree_int_cst_lt (len
, src_len
))
10297 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
10298 fn
= built_in_decls
[BUILT_IN_STRCAT_CHK
];
10302 arglist
= build_tree_list (NULL_TREE
, size
);
10303 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10304 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10305 return build_function_call_expr (fn
, arglist
);
10310 arglist
= build_tree_list (NULL_TREE
, len
);
10311 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
10312 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10314 /* If __builtin_strncat_chk is used, assume strncat is available. */
10315 fn
= built_in_decls
[BUILT_IN_STRNCAT
];
10319 return build_function_call_expr (fn
, arglist
);
10322 /* Fold a call to __{,v}sprintf_chk with argument list ARGLIST. Return 0 if
10323 a normal call should be emitted rather than expanding the function
10324 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
10327 fold_builtin_sprintf_chk (tree arglist
, enum built_in_function fcode
)
10329 tree dest
, size
, len
, fn
, fmt
, flag
;
10330 const char *fmt_str
;
10332 /* Verify the required arguments in the original call. */
10335 dest
= TREE_VALUE (arglist
);
10336 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
10338 arglist
= TREE_CHAIN (arglist
);
10341 flag
= TREE_VALUE (arglist
);
10342 if (TREE_CODE (TREE_TYPE (flag
)) != INTEGER_TYPE
)
10344 arglist
= TREE_CHAIN (arglist
);
10347 size
= TREE_VALUE (arglist
);
10348 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
)
10350 arglist
= TREE_CHAIN (arglist
);
10353 fmt
= TREE_VALUE (arglist
);
10354 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10356 arglist
= TREE_CHAIN (arglist
);
10358 if (! host_integerp (size
, 1))
10363 if (!init_target_chars())
10366 /* Check whether the format is a literal string constant. */
10367 fmt_str
= c_getstr (fmt
);
10368 if (fmt_str
!= NULL
)
10370 /* If the format doesn't contain % args or %%, we know the size. */
10371 if (strchr (fmt_str
, target_percent
) == 0)
10373 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| arglist
== NULL_TREE
)
10374 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
10376 /* If the format is "%s" and first ... argument is a string literal,
10377 we know the size too. */
10378 else if (fcode
== BUILT_IN_SPRINTF_CHK
&& strcmp (fmt_str
, target_percent_s
) == 0)
10382 if (arglist
&& !TREE_CHAIN (arglist
))
10384 arg
= TREE_VALUE (arglist
);
10385 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
10387 len
= c_strlen (arg
, 1);
10388 if (! len
|| ! host_integerp (len
, 1))
10395 if (! integer_all_onesp (size
))
10397 if (! len
|| ! tree_int_cst_lt (len
, size
))
10401 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
10402 or if format doesn't contain % chars or is "%s". */
10403 if (! integer_zerop (flag
))
10405 if (fmt_str
== NULL
)
10407 if (strchr (fmt_str
, target_percent
) != NULL
&& strcmp (fmt_str
, target_percent_s
))
10411 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
10412 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10414 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
10415 fn
= built_in_decls
[fcode
== BUILT_IN_VSPRINTF_CHK
10416 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
];
10420 return build_function_call_expr (fn
, arglist
);
10423 /* Fold a call to {,v}snprintf with argument list ARGLIST. Return 0 if
10424 a normal call should be emitted rather than expanding the function
10425 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
10426 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
10427 passed as second argument. */
10430 fold_builtin_snprintf_chk (tree arglist
, tree maxlen
,
10431 enum built_in_function fcode
)
10433 tree dest
, size
, len
, fn
, fmt
, flag
;
10434 const char *fmt_str
;
10436 /* Verify the required arguments in the original call. */
10439 dest
= TREE_VALUE (arglist
);
10440 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
10442 arglist
= TREE_CHAIN (arglist
);
10445 len
= TREE_VALUE (arglist
);
10446 if (TREE_CODE (TREE_TYPE (len
)) != INTEGER_TYPE
)
10448 arglist
= TREE_CHAIN (arglist
);
10451 flag
= TREE_VALUE (arglist
);
10452 if (TREE_CODE (TREE_TYPE (len
)) != INTEGER_TYPE
)
10454 arglist
= TREE_CHAIN (arglist
);
10457 size
= TREE_VALUE (arglist
);
10458 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
)
10460 arglist
= TREE_CHAIN (arglist
);
10463 fmt
= TREE_VALUE (arglist
);
10464 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10466 arglist
= TREE_CHAIN (arglist
);
10468 if (! host_integerp (size
, 1))
10471 if (! integer_all_onesp (size
))
10473 if (! host_integerp (len
, 1))
10475 /* If LEN is not constant, try MAXLEN too.
10476 For MAXLEN only allow optimizing into non-_ocs function
10477 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10478 if (maxlen
== NULL_TREE
|| ! host_integerp (maxlen
, 1))
10484 if (tree_int_cst_lt (size
, maxlen
))
10488 if (!init_target_chars())
10491 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
10492 or if format doesn't contain % chars or is "%s". */
10493 if (! integer_zerop (flag
))
10495 fmt_str
= c_getstr (fmt
);
10496 if (fmt_str
== NULL
)
10498 if (strchr (fmt_str
, target_percent
) != NULL
&& strcmp (fmt_str
, target_percent_s
))
10502 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
10503 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
10504 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
10506 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
10508 fn
= built_in_decls
[fcode
== BUILT_IN_VSNPRINTF_CHK
10509 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
];
10513 return build_function_call_expr (fn
, arglist
);
10516 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
10518 Return 0 if no simplification was possible, otherwise return the
10519 simplified form of the call as a tree. FCODE is the BUILT_IN_*
10520 code of the function to be simplified. */
10523 fold_builtin_printf (tree fndecl
, tree arglist
, bool ignore
,
10524 enum built_in_function fcode
)
10526 tree fmt
, fn
= NULL_TREE
, fn_putchar
, fn_puts
, arg
, call
;
10527 const char *fmt_str
= NULL
;
10529 /* If the return value is used, don't do the transformation. */
10533 /* Verify the required arguments in the original call. */
10534 if (fcode
== BUILT_IN_PRINTF_CHK
|| fcode
== BUILT_IN_VPRINTF_CHK
)
10540 flag
= TREE_VALUE (arglist
);
10541 if (TREE_CODE (TREE_TYPE (flag
)) != INTEGER_TYPE
10542 || TREE_SIDE_EFFECTS (flag
))
10544 arglist
= TREE_CHAIN (arglist
);
10549 fmt
= TREE_VALUE (arglist
);
10550 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10552 arglist
= TREE_CHAIN (arglist
);
10554 /* Check whether the format is a literal string constant. */
10555 fmt_str
= c_getstr (fmt
);
10556 if (fmt_str
== NULL
)
10559 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
10561 /* If we're using an unlocked function, assume the other
10562 unlocked functions exist explicitly. */
10563 fn_putchar
= built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
];
10564 fn_puts
= built_in_decls
[BUILT_IN_PUTS_UNLOCKED
];
10568 fn_putchar
= implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
10569 fn_puts
= implicit_built_in_decls
[BUILT_IN_PUTS
];
10572 if (!init_target_chars())
10575 if (strcmp (fmt_str
, target_percent_s
) == 0 || strchr (fmt_str
, target_percent
) == NULL
)
10579 if (strcmp (fmt_str
, target_percent_s
) == 0)
10581 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
10585 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
10586 || TREE_CHAIN (arglist
))
10589 str
= c_getstr (TREE_VALUE (arglist
));
10595 /* The format specifier doesn't contain any '%' characters. */
10596 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
10602 /* If the string was "", printf does nothing. */
10603 if (str
[0] == '\0')
10604 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
10606 /* If the string has length of 1, call putchar. */
10607 if (str
[1] == '\0')
10609 /* Given printf("c"), (where c is any one character,)
10610 convert "c"[0] to an int and pass that to the replacement
10612 arg
= build_int_cst (NULL_TREE
, str
[0]);
10613 arglist
= build_tree_list (NULL_TREE
, arg
);
10618 /* If the string was "string\n", call puts("string"). */
10619 size_t len
= strlen (str
);
10620 if ((unsigned char)str
[len
- 1] == target_newline
)
10622 /* Create a NUL-terminated string that's one char shorter
10623 than the original, stripping off the trailing '\n'. */
10624 char *newstr
= alloca (len
);
10625 memcpy (newstr
, str
, len
- 1);
10626 newstr
[len
- 1] = 0;
10628 arg
= build_string_literal (len
, newstr
);
10629 arglist
= build_tree_list (NULL_TREE
, arg
);
10633 /* We'd like to arrange to call fputs(string,stdout) here,
10634 but we need stdout and don't have a way to get it yet. */
10639 /* The other optimizations can be done only on the non-va_list variants. */
10640 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
10643 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
10644 else if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
10647 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
10648 || TREE_CHAIN (arglist
))
10653 /* If the format specifier was "%c", call __builtin_putchar(arg). */
10654 else if (strcmp (fmt_str
, target_percent_c
) == 0)
10657 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
10658 || TREE_CHAIN (arglist
))
10666 call
= build_function_call_expr (fn
, arglist
);
10667 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), call
);
10670 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
10672 Return 0 if no simplification was possible, otherwise return the
10673 simplified form of the call as a tree. FCODE is the BUILT_IN_*
10674 code of the function to be simplified. */
10677 fold_builtin_fprintf (tree fndecl
, tree arglist
, bool ignore
,
10678 enum built_in_function fcode
)
10680 tree fp
, fmt
, fn
= NULL_TREE
, fn_fputc
, fn_fputs
, arg
, call
;
10681 const char *fmt_str
= NULL
;
10683 /* If the return value is used, don't do the transformation. */
10687 /* Verify the required arguments in the original call. */
10690 fp
= TREE_VALUE (arglist
);
10691 if (! POINTER_TYPE_P (TREE_TYPE (fp
)))
10693 arglist
= TREE_CHAIN (arglist
);
10695 if (fcode
== BUILT_IN_FPRINTF_CHK
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
10701 flag
= TREE_VALUE (arglist
);
10702 if (TREE_CODE (TREE_TYPE (flag
)) != INTEGER_TYPE
10703 || TREE_SIDE_EFFECTS (flag
))
10705 arglist
= TREE_CHAIN (arglist
);
10710 fmt
= TREE_VALUE (arglist
);
10711 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
10713 arglist
= TREE_CHAIN (arglist
);
10715 /* Check whether the format is a literal string constant. */
10716 fmt_str
= c_getstr (fmt
);
10717 if (fmt_str
== NULL
)
10720 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
10722 /* If we're using an unlocked function, assume the other
10723 unlocked functions exist explicitly. */
10724 fn_fputc
= built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
];
10725 fn_fputs
= built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
];
10729 fn_fputc
= implicit_built_in_decls
[BUILT_IN_FPUTC
];
10730 fn_fputs
= implicit_built_in_decls
[BUILT_IN_FPUTS
];
10733 if (!init_target_chars())
10736 /* If the format doesn't contain % args or %%, use strcpy. */
10737 if (strchr (fmt_str
, target_percent
) == NULL
)
10739 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
10743 /* If the format specifier was "", fprintf does nothing. */
10744 if (fmt_str
[0] == '\0')
10746 /* If FP has side-effects, just wait until gimplification is
10748 if (TREE_SIDE_EFFECTS (fp
))
10751 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
10754 /* When "string" doesn't contain %, replace all cases of
10755 fprintf (fp, string) with fputs (string, fp). The fputs
10756 builtin will take care of special cases like length == 1. */
10757 arglist
= build_tree_list (NULL_TREE
, fp
);
10758 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
10762 /* The other optimizations can be done only on the non-va_list variants. */
10763 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
10766 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
10767 else if (strcmp (fmt_str
, target_percent_s
) == 0)
10770 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
10771 || TREE_CHAIN (arglist
))
10773 arg
= TREE_VALUE (arglist
);
10774 arglist
= build_tree_list (NULL_TREE
, fp
);
10775 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
10779 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
10780 else if (strcmp (fmt_str
, target_percent_c
) == 0)
10783 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
10784 || TREE_CHAIN (arglist
))
10786 arg
= TREE_VALUE (arglist
);
10787 arglist
= build_tree_list (NULL_TREE
, fp
);
10788 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
10795 call
= build_function_call_expr (fn
, arglist
);
10796 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl
)), call
);
10799 /* Initialize format string characters in the target charset. */
10802 init_target_chars (void)
10807 target_newline
= lang_hooks
.to_target_charset ('\n');
10808 target_percent
= lang_hooks
.to_target_charset ('%');
10809 target_c
= lang_hooks
.to_target_charset ('c');
10810 target_s
= lang_hooks
.to_target_charset ('s');
10811 if (target_newline
== 0 || target_percent
== 0 || target_c
== 0
10815 target_percent_c
[0] = target_percent
;
10816 target_percent_c
[1] = target_c
;
10817 target_percent_c
[2] = '\0';
10819 target_percent_s
[0] = target_percent
;
10820 target_percent_s
[1] = target_s
;
10821 target_percent_s
[2] = '\0';
10823 target_percent_s_newline
[0] = target_percent
;
10824 target_percent_s_newline
[1] = target_s
;
10825 target_percent_s_newline
[2] = target_newline
;
10826 target_percent_s_newline
[3] = '\0';