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, 59 Temple Place - Suite 330, 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 #define CALLED_AS_BUILT_IN(NODE) \
52 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
54 #ifndef PAD_VARARGS_DOWN
55 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
58 /* Define the names of the builtin function types and codes. */
59 const char *const built_in_class_names
[4]
60 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
62 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
63 const char * built_in_names
[(int) END_BUILTINS
] =
65 #include "builtins.def"
69 /* Setup an array of _DECL trees, make sure each element is
70 initialized to NULL_TREE. */
71 tree built_in_decls
[(int) END_BUILTINS
];
72 /* Declarations used when constructing the builtin implicitly in the compiler.
73 It may be NULL_TREE when this is invalid (for instance runtime is not
74 required to implement the function call in all cases). */
75 tree implicit_built_in_decls
[(int) END_BUILTINS
];
77 static int get_pointer_alignment (tree
, unsigned int);
78 static const char *c_getstr (tree
);
79 static rtx
c_readstr (const char *, enum machine_mode
);
80 static int target_char_cast (tree
, char *);
81 static rtx
get_memory_rtx (tree
);
82 static tree
build_string_literal (int, const char *);
83 static int apply_args_size (void);
84 static int apply_result_size (void);
85 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
86 static rtx
result_vector (int, rtx
);
88 static rtx
expand_builtin_setjmp (tree
, rtx
);
89 static void expand_builtin_update_setjmp_buf (rtx
);
90 static void expand_builtin_prefetch (tree
);
91 static rtx
expand_builtin_apply_args (void);
92 static rtx
expand_builtin_apply_args_1 (void);
93 static rtx
expand_builtin_apply (rtx
, rtx
, rtx
);
94 static void expand_builtin_return (rtx
);
95 static enum type_class
type_to_class (tree
);
96 static rtx
expand_builtin_classify_type (tree
);
97 static void expand_errno_check (tree
, rtx
);
98 static rtx
expand_builtin_mathfn (tree
, rtx
, rtx
);
99 static rtx
expand_builtin_mathfn_2 (tree
, rtx
, rtx
);
100 static rtx
expand_builtin_mathfn_3 (tree
, rtx
, rtx
);
101 static rtx
expand_builtin_args_info (tree
);
102 static rtx
expand_builtin_next_arg (void);
103 static rtx
expand_builtin_va_start (tree
);
104 static rtx
expand_builtin_va_end (tree
);
105 static rtx
expand_builtin_va_copy (tree
);
106 static rtx
expand_builtin_memcmp (tree
, tree
, rtx
, enum machine_mode
);
107 static rtx
expand_builtin_strcmp (tree
, rtx
, enum machine_mode
);
108 static rtx
expand_builtin_strncmp (tree
, rtx
, enum machine_mode
);
109 static rtx
builtin_memcpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
110 static rtx
expand_builtin_strcat (tree
, tree
, rtx
, enum machine_mode
);
111 static rtx
expand_builtin_strncat (tree
, rtx
, enum machine_mode
);
112 static rtx
expand_builtin_strspn (tree
, rtx
, enum machine_mode
);
113 static rtx
expand_builtin_strcspn (tree
, rtx
, enum machine_mode
);
114 static rtx
expand_builtin_memcpy (tree
, rtx
, enum machine_mode
);
115 static rtx
expand_builtin_mempcpy (tree
, tree
, rtx
, enum machine_mode
, int);
116 static rtx
expand_builtin_memmove (tree
, tree
, rtx
, enum machine_mode
);
117 static rtx
expand_builtin_bcopy (tree
, tree
);
118 static rtx
expand_builtin_strcpy (tree
, rtx
, enum machine_mode
);
119 static rtx
expand_builtin_stpcpy (tree
, rtx
, enum machine_mode
);
120 static rtx
builtin_strncpy_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
121 static rtx
expand_builtin_strncpy (tree
, rtx
, enum machine_mode
);
122 static rtx
builtin_memset_read_str (void *, HOST_WIDE_INT
, enum machine_mode
);
123 static rtx
builtin_memset_gen_str (void *, HOST_WIDE_INT
, enum machine_mode
);
124 static rtx
expand_builtin_memset (tree
, rtx
, enum machine_mode
);
125 static rtx
expand_builtin_bzero (tree
);
126 static rtx
expand_builtin_strlen (tree
, rtx
, enum machine_mode
);
127 static rtx
expand_builtin_strstr (tree
, tree
, rtx
, enum machine_mode
);
128 static rtx
expand_builtin_strpbrk (tree
, tree
, rtx
, enum machine_mode
);
129 static rtx
expand_builtin_strchr (tree
, tree
, rtx
, enum machine_mode
);
130 static rtx
expand_builtin_strrchr (tree
, tree
, rtx
, enum machine_mode
);
131 static rtx
expand_builtin_alloca (tree
, rtx
);
132 static rtx
expand_builtin_unop (enum machine_mode
, tree
, rtx
, rtx
, optab
);
133 static rtx
expand_builtin_frame_address (tree
, tree
);
134 static rtx
expand_builtin_fputs (tree
, rtx
, bool);
135 static rtx
expand_builtin_printf (tree
, rtx
, enum machine_mode
, bool);
136 static rtx
expand_builtin_fprintf (tree
, rtx
, enum machine_mode
, bool);
137 static rtx
expand_builtin_sprintf (tree
, rtx
, enum machine_mode
);
138 static tree
stabilize_va_list (tree
, int);
139 static rtx
expand_builtin_expect (tree
, rtx
);
140 static tree
fold_builtin_constant_p (tree
);
141 static tree
fold_builtin_classify_type (tree
);
142 static tree
fold_builtin_strlen (tree
);
143 static tree
fold_builtin_inf (tree
, int);
144 static tree
fold_builtin_nan (tree
, tree
, int);
145 static int validate_arglist (tree
, ...);
146 static bool integer_valued_real_p (tree
);
147 static tree
fold_trunc_transparent_mathfn (tree
);
148 static bool readonly_data_expr (tree
);
149 static rtx
expand_builtin_fabs (tree
, rtx
, rtx
);
150 static rtx
expand_builtin_signbit (tree
, rtx
);
151 static tree
fold_builtin_cabs (tree
, tree
);
152 static tree
fold_builtin_sqrt (tree
, tree
);
153 static tree
fold_builtin_cbrt (tree
, tree
);
154 static tree
fold_builtin_pow (tree
, tree
, tree
);
155 static tree
fold_builtin_powi (tree
, tree
, tree
);
156 static tree
fold_builtin_sin (tree
);
157 static tree
fold_builtin_cos (tree
, tree
, tree
);
158 static tree
fold_builtin_tan (tree
);
159 static tree
fold_builtin_atan (tree
, tree
);
160 static tree
fold_builtin_trunc (tree
);
161 static tree
fold_builtin_floor (tree
);
162 static tree
fold_builtin_ceil (tree
);
163 static tree
fold_builtin_round (tree
);
164 static tree
fold_builtin_bitop (tree
);
165 static tree
fold_builtin_memcpy (tree
);
166 static tree
fold_builtin_mempcpy (tree
, tree
, int);
167 static tree
fold_builtin_memmove (tree
, tree
);
168 static tree
fold_builtin_strchr (tree
, tree
);
169 static tree
fold_builtin_memcmp (tree
);
170 static tree
fold_builtin_strcmp (tree
);
171 static tree
fold_builtin_strncmp (tree
);
172 static tree
fold_builtin_signbit (tree
);
173 static tree
fold_builtin_copysign (tree
, tree
, tree
);
174 static tree
fold_builtin_isascii (tree
);
175 static tree
fold_builtin_toascii (tree
);
176 static tree
fold_builtin_isdigit (tree
);
177 static tree
fold_builtin_fabs (tree
, tree
);
178 static tree
fold_builtin_abs (tree
, tree
);
179 static tree
fold_builtin_unordered_cmp (tree
, enum tree_code
, enum tree_code
);
180 static tree
fold_builtin_1 (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);
192 /* Return the alignment in bits of EXP, a pointer valued expression.
193 But don't return more than MAX_ALIGN no matter what.
194 The alignment returned is, by default, the alignment of the thing that
195 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
197 Otherwise, look at the expression to see if we can do better, i.e., if the
198 expression is actually pointing at an object whose alignment is tighter. */
201 get_pointer_alignment (tree exp
, unsigned int max_align
)
203 unsigned int align
, inner
;
205 if (! POINTER_TYPE_P (TREE_TYPE (exp
)))
208 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
209 align
= MIN (align
, max_align
);
213 switch (TREE_CODE (exp
))
217 case NON_LVALUE_EXPR
:
218 exp
= TREE_OPERAND (exp
, 0);
219 if (! POINTER_TYPE_P (TREE_TYPE (exp
)))
222 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
223 align
= MIN (inner
, max_align
);
227 /* If sum of pointer + int, restrict our maximum alignment to that
228 imposed by the integer. If not, we can't do any better than
230 if (! host_integerp (TREE_OPERAND (exp
, 1), 1))
233 while (((tree_low_cst (TREE_OPERAND (exp
, 1), 1))
234 & (max_align
/ BITS_PER_UNIT
- 1))
238 exp
= TREE_OPERAND (exp
, 0);
242 /* See what we are pointing at and look at its alignment. */
243 exp
= TREE_OPERAND (exp
, 0);
244 if (TREE_CODE (exp
) == FUNCTION_DECL
)
245 align
= FUNCTION_BOUNDARY
;
246 else if (DECL_P (exp
))
247 align
= DECL_ALIGN (exp
);
248 #ifdef CONSTANT_ALIGNMENT
249 else if (CONSTANT_CLASS_P (exp
))
250 align
= CONSTANT_ALIGNMENT (exp
, align
);
252 return MIN (align
, max_align
);
260 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
261 way, because it could contain a zero byte in the middle.
262 TREE_STRING_LENGTH is the size of the character array, not the string.
264 ONLY_VALUE should be nonzero if the result is not going to be emitted
265 into the instruction stream and zero if it is going to be expanded.
266 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
267 is returned, otherwise NULL, since
268 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
269 evaluate the side-effects.
271 The value returned is of type `ssizetype'.
273 Unfortunately, string_constant can't access the values of const char
274 arrays with initializers, so neither can we do so here. */
277 c_strlen (tree src
, int only_value
)
280 HOST_WIDE_INT offset
;
285 if (TREE_CODE (src
) == COND_EXPR
286 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
290 len1
= c_strlen (TREE_OPERAND (src
, 1), only_value
);
291 len2
= c_strlen (TREE_OPERAND (src
, 2), only_value
);
292 if (tree_int_cst_equal (len1
, len2
))
296 if (TREE_CODE (src
) == COMPOUND_EXPR
297 && (only_value
|| !TREE_SIDE_EFFECTS (TREE_OPERAND (src
, 0))))
298 return c_strlen (TREE_OPERAND (src
, 1), only_value
);
300 src
= string_constant (src
, &offset_node
);
304 max
= TREE_STRING_LENGTH (src
) - 1;
305 ptr
= TREE_STRING_POINTER (src
);
307 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
309 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
310 compute the offset to the following null if we don't know where to
311 start searching for it. */
314 for (i
= 0; i
< max
; i
++)
318 /* We don't know the starting offset, but we do know that the string
319 has no internal zero bytes. We can assume that the offset falls
320 within the bounds of the string; otherwise, the programmer deserves
321 what he gets. Subtract the offset from the length of the string,
322 and return that. This would perhaps not be valid if we were dealing
323 with named arrays in addition to literal string constants. */
325 return size_diffop (size_int (max
), offset_node
);
328 /* We have a known offset into the string. Start searching there for
329 a null character if we can represent it as a single HOST_WIDE_INT. */
330 if (offset_node
== 0)
332 else if (! host_integerp (offset_node
, 0))
335 offset
= tree_low_cst (offset_node
, 0);
337 /* If the offset is known to be out of bounds, warn, and call strlen at
339 if (offset
< 0 || offset
> max
)
341 warning ("offset outside bounds of constant string");
345 /* Use strlen to search for the first zero byte. Since any strings
346 constructed with build_string will have nulls appended, we win even
347 if we get handed something like (char[4])"abcd".
349 Since OFFSET is our starting index into the string, no further
350 calculation is needed. */
351 return ssize_int (strlen (ptr
+ offset
));
354 /* Return a char pointer for a C string if it is a string constant
355 or sum of string constant and integer constant. */
362 src
= string_constant (src
, &offset_node
);
366 if (offset_node
== 0)
367 return TREE_STRING_POINTER (src
);
368 else if (!host_integerp (offset_node
, 1)
369 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
372 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
375 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
376 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
379 c_readstr (const char *str
, enum machine_mode mode
)
385 gcc_assert (GET_MODE_CLASS (mode
) == MODE_INT
);
390 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
393 if (WORDS_BIG_ENDIAN
)
394 j
= GET_MODE_SIZE (mode
) - i
- 1;
395 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
396 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
397 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
399 gcc_assert (j
<= 2 * HOST_BITS_PER_WIDE_INT
);
402 ch
= (unsigned char) str
[i
];
403 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
405 return immed_double_const (c
[0], c
[1], mode
);
408 /* Cast a target constant CST to target CHAR and if that value fits into
409 host char type, return zero and put that value into variable pointed by
413 target_char_cast (tree cst
, char *p
)
415 unsigned HOST_WIDE_INT val
, hostval
;
417 if (!host_integerp (cst
, 1)
418 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
421 val
= tree_low_cst (cst
, 1);
422 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
423 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
426 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
427 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
436 /* Similar to save_expr, but assumes that arbitrary code is not executed
437 in between the multiple evaluations. In particular, we assume that a
438 non-addressable local variable will not be modified. */
441 builtin_save_expr (tree exp
)
443 if (TREE_ADDRESSABLE (exp
) == 0
444 && (TREE_CODE (exp
) == PARM_DECL
445 || (TREE_CODE (exp
) == VAR_DECL
&& !TREE_STATIC (exp
))))
448 return save_expr (exp
);
451 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
452 times to get the address of either a higher stack frame, or a return
453 address located within it (depending on FNDECL_CODE). */
456 expand_builtin_return_addr (enum built_in_function fndecl_code
, int count
)
460 #ifdef INITIAL_FRAME_ADDRESS_RTX
461 rtx tem
= INITIAL_FRAME_ADDRESS_RTX
;
463 rtx tem
= hard_frame_pointer_rtx
;
466 /* Some machines need special handling before we can access
467 arbitrary frames. For example, on the sparc, we must first flush
468 all register windows to the stack. */
469 #ifdef SETUP_FRAME_ADDRESSES
471 SETUP_FRAME_ADDRESSES ();
474 /* On the sparc, the return address is not in the frame, it is in a
475 register. There is no way to access it off of the current frame
476 pointer, but it can be accessed off the previous frame pointer by
477 reading the value from the register window save area. */
478 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
479 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
483 /* Scan back COUNT frames to the specified frame. */
484 for (i
= 0; i
< count
; i
++)
486 /* Assume the dynamic chain pointer is in the word that the
487 frame address points to, unless otherwise specified. */
488 #ifdef DYNAMIC_CHAIN_ADDRESS
489 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
491 tem
= memory_address (Pmode
, tem
);
492 tem
= gen_rtx_MEM (Pmode
, tem
);
493 set_mem_alias_set (tem
, get_frame_alias_set ());
494 tem
= copy_to_reg (tem
);
497 /* For __builtin_frame_address, return what we've got. */
498 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
501 /* For __builtin_return_address, Get the return address from that
503 #ifdef RETURN_ADDR_RTX
504 tem
= RETURN_ADDR_RTX (count
, tem
);
506 tem
= memory_address (Pmode
,
507 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
508 tem
= gen_rtx_MEM (Pmode
, tem
);
509 set_mem_alias_set (tem
, get_frame_alias_set ());
514 /* Alias set used for setjmp buffer. */
515 static HOST_WIDE_INT setjmp_alias_set
= -1;
517 /* Construct the leading half of a __builtin_setjmp call. Control will
518 return to RECEIVER_LABEL. This is used directly by sjlj exception
522 expand_builtin_setjmp_setup (rtx buf_addr
, rtx receiver_label
)
524 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
528 if (setjmp_alias_set
== -1)
529 setjmp_alias_set
= new_alias_set ();
531 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
533 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
535 /* We store the frame pointer and the address of receiver_label in
536 the buffer and use the rest of it for the stack save area, which
537 is machine-dependent. */
539 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
540 set_mem_alias_set (mem
, setjmp_alias_set
);
541 emit_move_insn (mem
, targetm
.builtin_setjmp_frame_value ());
543 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
544 set_mem_alias_set (mem
, setjmp_alias_set
);
546 emit_move_insn (validize_mem (mem
),
547 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
549 stack_save
= gen_rtx_MEM (sa_mode
,
550 plus_constant (buf_addr
,
551 2 * GET_MODE_SIZE (Pmode
)));
552 set_mem_alias_set (stack_save
, setjmp_alias_set
);
553 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
555 /* If there is further processing to do, do it. */
556 #ifdef HAVE_builtin_setjmp_setup
557 if (HAVE_builtin_setjmp_setup
)
558 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
561 /* Tell optimize_save_area_alloca that extra work is going to
562 need to go on during alloca. */
563 current_function_calls_setjmp
= 1;
565 /* Set this so all the registers get saved in our frame; we need to be
566 able to copy the saved values for any registers from frames we unwind. */
567 current_function_has_nonlocal_label
= 1;
570 /* Construct the trailing part of a __builtin_setjmp call.
571 This is used directly by sjlj exception handling code. */
574 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED
)
576 /* Clobber the FP when we get here, so we have to make sure it's
577 marked as used by this function. */
578 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
580 /* Mark the static chain as clobbered here so life information
581 doesn't get messed up for it. */
582 emit_insn (gen_rtx_CLOBBER (VOIDmode
, static_chain_rtx
));
584 /* Now put in the code to restore the frame pointer, and argument
585 pointer, if needed. */
586 #ifdef HAVE_nonlocal_goto
587 if (! HAVE_nonlocal_goto
)
589 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
591 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
592 if (fixed_regs
[ARG_POINTER_REGNUM
])
594 #ifdef ELIMINABLE_REGS
596 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
598 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
599 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
600 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
603 if (i
== ARRAY_SIZE (elim_regs
))
606 /* Now restore our arg pointer from the address at which it
607 was saved in our stack frame. */
608 emit_move_insn (virtual_incoming_args_rtx
,
609 copy_to_reg (get_arg_pointer_save_area (cfun
)));
614 #ifdef HAVE_builtin_setjmp_receiver
615 if (HAVE_builtin_setjmp_receiver
)
616 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
619 #ifdef HAVE_nonlocal_goto_receiver
620 if (HAVE_nonlocal_goto_receiver
)
621 emit_insn (gen_nonlocal_goto_receiver ());
626 /* @@@ This is a kludge. Not all machine descriptions define a blockage
627 insn, but we must not allow the code we just generated to be reordered
628 by scheduling. Specifically, the update of the frame pointer must
629 happen immediately, not later. So emit an ASM_INPUT to act as blockage
631 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
634 /* __builtin_setjmp is passed a pointer to an array of five words (not
635 all will be used on all machines). It operates similarly to the C
636 library function of the same name, but is more efficient. Much of
637 the code below (and for longjmp) is copied from the handling of
640 NOTE: This is intended for use by GNAT and the exception handling
641 scheme in the compiler and will only work in the method used by
645 expand_builtin_setjmp (tree arglist
, rtx target
)
647 rtx buf_addr
, next_lab
, cont_lab
;
649 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
652 if (target
== 0 || !REG_P (target
)
653 || REGNO (target
) < FIRST_PSEUDO_REGISTER
)
654 target
= gen_reg_rtx (TYPE_MODE (integer_type_node
));
656 buf_addr
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
658 next_lab
= gen_label_rtx ();
659 cont_lab
= gen_label_rtx ();
661 expand_builtin_setjmp_setup (buf_addr
, next_lab
);
663 /* Set TARGET to zero and branch to the continue label. Use emit_jump to
664 ensure that pending stack adjustments are flushed. */
665 emit_move_insn (target
, const0_rtx
);
666 emit_jump (cont_lab
);
668 emit_label (next_lab
);
670 expand_builtin_setjmp_receiver (next_lab
);
672 /* Set TARGET to one. */
673 emit_move_insn (target
, const1_rtx
);
674 emit_label (cont_lab
);
676 /* Tell flow about the strange goings on. Putting `next_lab' on
677 `nonlocal_goto_handler_labels' to indicates that function
678 calls may traverse the arc back to this label. */
680 current_function_has_nonlocal_label
= 1;
681 nonlocal_goto_handler_labels
682 = gen_rtx_EXPR_LIST (VOIDmode
, next_lab
, nonlocal_goto_handler_labels
);
687 /* __builtin_longjmp is passed a pointer to an array of five words (not
688 all will be used on all machines). It operates similarly to the C
689 library function of the same name, but is more efficient. Much of
690 the code below is copied from the handling of non-local gotos.
692 NOTE: This is intended for use by GNAT and the exception handling
693 scheme in the compiler and will only work in the method used by
697 expand_builtin_longjmp (rtx buf_addr
, rtx value
)
699 rtx fp
, lab
, stack
, insn
, last
;
700 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
702 if (setjmp_alias_set
== -1)
703 setjmp_alias_set
= new_alias_set ();
705 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
707 buf_addr
= force_reg (Pmode
, buf_addr
);
709 /* We used to store value in static_chain_rtx, but that fails if pointers
710 are smaller than integers. We instead require that the user must pass
711 a second argument of 1, because that is what builtin_setjmp will
712 return. This also makes EH slightly more efficient, since we are no
713 longer copying around a value that we don't care about. */
714 gcc_assert (value
== const1_rtx
);
716 last
= get_last_insn ();
717 #ifdef HAVE_builtin_longjmp
718 if (HAVE_builtin_longjmp
)
719 emit_insn (gen_builtin_longjmp (buf_addr
));
723 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
724 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
725 GET_MODE_SIZE (Pmode
)));
727 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
728 2 * GET_MODE_SIZE (Pmode
)));
729 set_mem_alias_set (fp
, setjmp_alias_set
);
730 set_mem_alias_set (lab
, setjmp_alias_set
);
731 set_mem_alias_set (stack
, setjmp_alias_set
);
733 /* Pick up FP, label, and SP from the block and jump. This code is
734 from expand_goto in stmt.c; see there for detailed comments. */
735 #if HAVE_nonlocal_goto
736 if (HAVE_nonlocal_goto
)
737 /* We have to pass a value to the nonlocal_goto pattern that will
738 get copied into the static_chain pointer, but it does not matter
739 what that value is, because builtin_setjmp does not use it. */
740 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
744 lab
= copy_to_reg (lab
);
746 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
747 gen_rtx_MEM (BLKmode
,
748 gen_rtx_SCRATCH (VOIDmode
))));
749 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
750 gen_rtx_MEM (BLKmode
,
751 hard_frame_pointer_rtx
)));
753 emit_move_insn (hard_frame_pointer_rtx
, fp
);
754 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
756 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
757 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
758 emit_indirect_jump (lab
);
762 /* Search backwards and mark the jump insn as a non-local goto.
763 Note that this precludes the use of __builtin_longjmp to a
764 __builtin_setjmp target in the same function. However, we've
765 already cautioned the user that these functions are for
766 internal exception handling use only. */
767 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
769 gcc_assert (insn
!= last
);
773 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
, const0_rtx
,
777 else if (CALL_P (insn
))
782 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
783 and the address of the save area. */
786 expand_builtin_nonlocal_goto (tree arglist
)
788 tree t_label
, t_save_area
;
789 rtx r_label
, r_save_area
, r_fp
, r_sp
, insn
;
791 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
794 t_label
= TREE_VALUE (arglist
);
795 arglist
= TREE_CHAIN (arglist
);
796 t_save_area
= TREE_VALUE (arglist
);
798 r_label
= expand_expr (t_label
, NULL_RTX
, VOIDmode
, 0);
799 r_label
= convert_memory_address (Pmode
, r_label
);
800 r_save_area
= expand_expr (t_save_area
, NULL_RTX
, VOIDmode
, 0);
801 r_save_area
= convert_memory_address (Pmode
, r_save_area
);
802 r_fp
= gen_rtx_MEM (Pmode
, r_save_area
);
803 r_sp
= gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
),
804 plus_constant (r_save_area
, GET_MODE_SIZE (Pmode
)));
806 current_function_has_nonlocal_goto
= 1;
808 #if HAVE_nonlocal_goto
809 /* ??? We no longer need to pass the static chain value, afaik. */
810 if (HAVE_nonlocal_goto
)
811 emit_insn (gen_nonlocal_goto (const0_rtx
, r_label
, r_sp
, r_fp
));
815 r_label
= copy_to_reg (r_label
);
817 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
818 gen_rtx_MEM (BLKmode
,
819 gen_rtx_SCRATCH (VOIDmode
))));
821 emit_insn (gen_rtx_CLOBBER (VOIDmode
,
822 gen_rtx_MEM (BLKmode
,
823 hard_frame_pointer_rtx
)));
825 /* Restore frame pointer for containing function.
826 This sets the actual hard register used for the frame pointer
827 to the location of the function's incoming static chain info.
828 The non-local goto handler will then adjust it to contain the
829 proper value and reload the argument pointer, if needed. */
830 emit_move_insn (hard_frame_pointer_rtx
, r_fp
);
831 emit_stack_restore (SAVE_NONLOCAL
, r_sp
, NULL_RTX
);
833 /* USE of hard_frame_pointer_rtx added for consistency;
834 not clear if really needed. */
835 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
836 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
837 emit_indirect_jump (r_label
);
840 /* Search backwards to the jump insn and mark it as a
842 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
846 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
,
847 const0_rtx
, REG_NOTES (insn
));
850 else if (CALL_P (insn
))
857 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
858 (not all will be used on all machines) that was passed to __builtin_setjmp.
859 It updates the stack pointer in that block to correspond to the current
863 expand_builtin_update_setjmp_buf (rtx buf_addr
)
865 enum machine_mode sa_mode
= Pmode
;
869 #ifdef HAVE_save_stack_nonlocal
870 if (HAVE_save_stack_nonlocal
)
871 sa_mode
= insn_data
[(int) CODE_FOR_save_stack_nonlocal
].operand
[0].mode
;
873 #ifdef STACK_SAVEAREA_MODE
874 sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
878 = gen_rtx_MEM (sa_mode
,
881 plus_constant (buf_addr
, 2 * GET_MODE_SIZE (Pmode
))));
885 emit_insn (gen_setjmp ());
888 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
891 /* Expand a call to __builtin_prefetch. For a target that does not support
892 data prefetch, evaluate the memory address argument in case it has side
896 expand_builtin_prefetch (tree arglist
)
898 tree arg0
, arg1
, arg2
;
901 if (!validate_arglist (arglist
, POINTER_TYPE
, 0))
904 arg0
= TREE_VALUE (arglist
);
905 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
906 zero (read) and argument 2 (locality) defaults to 3 (high degree of
908 if (TREE_CHAIN (arglist
))
910 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
911 if (TREE_CHAIN (TREE_CHAIN (arglist
)))
912 arg2
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
914 arg2
= build_int_cst (NULL_TREE
, 3);
918 arg1
= integer_zero_node
;
919 arg2
= build_int_cst (NULL_TREE
, 3);
922 /* Argument 0 is an address. */
923 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
925 /* Argument 1 (read/write flag) must be a compile-time constant int. */
926 if (TREE_CODE (arg1
) != INTEGER_CST
)
928 error ("second argument to %<__builtin_prefetch%> must be a constant");
929 arg1
= integer_zero_node
;
931 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
932 /* Argument 1 must be either zero or one. */
933 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
935 warning ("invalid second argument to %<__builtin_prefetch%>;"
940 /* Argument 2 (locality) must be a compile-time constant int. */
941 if (TREE_CODE (arg2
) != INTEGER_CST
)
943 error ("third argument to %<__builtin_prefetch%> must be a constant");
944 arg2
= integer_zero_node
;
946 op2
= expand_expr (arg2
, NULL_RTX
, VOIDmode
, 0);
947 /* Argument 2 must be 0, 1, 2, or 3. */
948 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
950 warning ("invalid third argument to %<__builtin_prefetch%>; using zero");
957 if ((! (*insn_data
[(int) CODE_FOR_prefetch
].operand
[0].predicate
)
959 insn_data
[(int) CODE_FOR_prefetch
].operand
[0].mode
))
960 || (GET_MODE (op0
) != Pmode
))
962 op0
= convert_memory_address (Pmode
, op0
);
963 op0
= force_reg (Pmode
, op0
);
965 emit_insn (gen_prefetch (op0
, op1
, op2
));
969 /* Don't do anything with direct references to volatile memory, but
970 generate code to handle other side effects. */
971 if (!MEM_P (op0
) && side_effects_p (op0
))
975 /* Get a MEM rtx for expression EXP which is the address of an operand
976 to be used to be used in a string instruction (cmpstrsi, movmemsi, ..). */
979 get_memory_rtx (tree exp
)
981 rtx addr
= expand_expr (exp
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
984 addr
= convert_memory_address (Pmode
, addr
);
986 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
988 /* Get an expression we can use to find the attributes to assign to MEM.
989 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
990 we can. First remove any nops. */
991 while ((TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
992 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
993 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
994 exp
= TREE_OPERAND (exp
, 0);
996 if (TREE_CODE (exp
) == ADDR_EXPR
)
997 exp
= TREE_OPERAND (exp
, 0);
998 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
999 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
1003 /* Honor attributes derived from exp, except for the alias set
1004 (as builtin stringops may alias with anything) and the size
1005 (as stringops may access multiple array elements). */
1008 set_mem_attributes (mem
, exp
, 0);
1009 set_mem_alias_set (mem
, 0);
1010 set_mem_size (mem
, NULL_RTX
);
1016 /* Built-in functions to perform an untyped call and return. */
1018 /* For each register that may be used for calling a function, this
1019 gives a mode used to copy the register's value. VOIDmode indicates
1020 the register is not used for calling a function. If the machine
1021 has register windows, this gives only the outbound registers.
1022 INCOMING_REGNO gives the corresponding inbound register. */
1023 static enum machine_mode apply_args_mode
[FIRST_PSEUDO_REGISTER
];
1025 /* For each register that may be used for returning values, this gives
1026 a mode used to copy the register's value. VOIDmode indicates the
1027 register is not used for returning values. If the machine has
1028 register windows, this gives only the outbound registers.
1029 INCOMING_REGNO gives the corresponding inbound register. */
1030 static enum machine_mode apply_result_mode
[FIRST_PSEUDO_REGISTER
];
1032 /* For each register that may be used for calling a function, this
1033 gives the offset of that register into the block returned by
1034 __builtin_apply_args. 0 indicates that the register is not
1035 used for calling a function. */
1036 static int apply_args_reg_offset
[FIRST_PSEUDO_REGISTER
];
1038 /* Return the size required for the block returned by __builtin_apply_args,
1039 and initialize apply_args_mode. */
1042 apply_args_size (void)
1044 static int size
= -1;
1047 enum machine_mode mode
;
1049 /* The values computed by this function never change. */
1052 /* The first value is the incoming arg-pointer. */
1053 size
= GET_MODE_SIZE (Pmode
);
1055 /* The second value is the structure value address unless this is
1056 passed as an "invisible" first argument. */
1057 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1058 size
+= GET_MODE_SIZE (Pmode
);
1060 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1061 if (FUNCTION_ARG_REGNO_P (regno
))
1063 mode
= reg_raw_mode
[regno
];
1065 gcc_assert (mode
!= VOIDmode
);
1067 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1068 if (size
% align
!= 0)
1069 size
= CEIL (size
, align
) * align
;
1070 apply_args_reg_offset
[regno
] = size
;
1071 size
+= GET_MODE_SIZE (mode
);
1072 apply_args_mode
[regno
] = mode
;
1076 apply_args_mode
[regno
] = VOIDmode
;
1077 apply_args_reg_offset
[regno
] = 0;
1083 /* Return the size required for the block returned by __builtin_apply,
1084 and initialize apply_result_mode. */
1087 apply_result_size (void)
1089 static int size
= -1;
1091 enum machine_mode mode
;
1093 /* The values computed by this function never change. */
1098 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1099 if (FUNCTION_VALUE_REGNO_P (regno
))
1101 mode
= reg_raw_mode
[regno
];
1103 gcc_assert (mode
!= VOIDmode
);
1105 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1106 if (size
% align
!= 0)
1107 size
= CEIL (size
, align
) * align
;
1108 size
+= GET_MODE_SIZE (mode
);
1109 apply_result_mode
[regno
] = mode
;
1112 apply_result_mode
[regno
] = VOIDmode
;
1114 /* Allow targets that use untyped_call and untyped_return to override
1115 the size so that machine-specific information can be stored here. */
1116 #ifdef APPLY_RESULT_SIZE
1117 size
= APPLY_RESULT_SIZE
;
1123 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1124 /* Create a vector describing the result block RESULT. If SAVEP is true,
1125 the result block is used to save the values; otherwise it is used to
1126 restore the values. */
1129 result_vector (int savep
, rtx result
)
1131 int regno
, size
, align
, nelts
;
1132 enum machine_mode mode
;
1134 rtx
*savevec
= alloca (FIRST_PSEUDO_REGISTER
* sizeof (rtx
));
1137 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1138 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1140 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1141 if (size
% align
!= 0)
1142 size
= CEIL (size
, align
) * align
;
1143 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1144 mem
= adjust_address (result
, mode
, size
);
1145 savevec
[nelts
++] = (savep
1146 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1147 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1148 size
+= GET_MODE_SIZE (mode
);
1150 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1152 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1154 /* Save the state required to perform an untyped call with the same
1155 arguments as were passed to the current function. */
1158 expand_builtin_apply_args_1 (void)
1161 int size
, align
, regno
;
1162 enum machine_mode mode
;
1163 rtx struct_incoming_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 1);
1165 /* Create a block where the arg-pointer, structure value address,
1166 and argument registers can be saved. */
1167 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1169 /* Walk past the arg-pointer and structure value address. */
1170 size
= GET_MODE_SIZE (Pmode
);
1171 if (targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0))
1172 size
+= GET_MODE_SIZE (Pmode
);
1174 /* Save each register used in calling a function to the block. */
1175 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1176 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1178 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1179 if (size
% align
!= 0)
1180 size
= CEIL (size
, align
) * align
;
1182 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1184 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1185 size
+= GET_MODE_SIZE (mode
);
1188 /* Save the arg pointer to the block. */
1189 tem
= copy_to_reg (virtual_incoming_args_rtx
);
1190 #ifdef STACK_GROWS_DOWNWARD
1191 /* We need the pointer as the caller actually passed them to us, not
1192 as we might have pretended they were passed. Make sure it's a valid
1193 operand, as emit_move_insn isn't expected to handle a PLUS. */
1195 = force_operand (plus_constant (tem
, current_function_pretend_args_size
),
1198 emit_move_insn (adjust_address (registers
, Pmode
, 0), tem
);
1200 size
= GET_MODE_SIZE (Pmode
);
1202 /* Save the structure value address unless this is passed as an
1203 "invisible" first argument. */
1204 if (struct_incoming_value
)
1206 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1207 copy_to_reg (struct_incoming_value
));
1208 size
+= GET_MODE_SIZE (Pmode
);
1211 /* Return the address of the block. */
1212 return copy_addr_to_reg (XEXP (registers
, 0));
1215 /* __builtin_apply_args returns block of memory allocated on
1216 the stack into which is stored the arg pointer, structure
1217 value address, static chain, and all the registers that might
1218 possibly be used in performing a function call. The code is
1219 moved to the start of the function so the incoming values are
1223 expand_builtin_apply_args (void)
1225 /* Don't do __builtin_apply_args more than once in a function.
1226 Save the result of the first call and reuse it. */
1227 if (apply_args_value
!= 0)
1228 return apply_args_value
;
1230 /* When this function is called, it means that registers must be
1231 saved on entry to this function. So we migrate the
1232 call to the first insn of this function. */
1237 temp
= expand_builtin_apply_args_1 ();
1241 apply_args_value
= temp
;
1243 /* Put the insns after the NOTE that starts the function.
1244 If this is inside a start_sequence, make the outer-level insn
1245 chain current, so the code is placed at the start of the
1247 push_topmost_sequence ();
1248 emit_insn_before (seq
, NEXT_INSN (entry_of_function ()));
1249 pop_topmost_sequence ();
1254 /* Perform an untyped call and save the state required to perform an
1255 untyped return of whatever value was returned by the given function. */
1258 expand_builtin_apply (rtx function
, rtx arguments
, rtx argsize
)
1260 int size
, align
, regno
;
1261 enum machine_mode mode
;
1262 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1263 rtx old_stack_level
= 0;
1264 rtx call_fusage
= 0;
1265 rtx struct_value
= targetm
.calls
.struct_value_rtx (cfun
? TREE_TYPE (cfun
->decl
) : 0, 0);
1267 arguments
= convert_memory_address (Pmode
, arguments
);
1269 /* Create a block where the return registers can be saved. */
1270 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1272 /* Fetch the arg pointer from the ARGUMENTS block. */
1273 incoming_args
= gen_reg_rtx (Pmode
);
1274 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1275 #ifndef STACK_GROWS_DOWNWARD
1276 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1277 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1280 /* Push a new argument block and copy the arguments. Do not allow
1281 the (potential) memcpy call below to interfere with our stack
1283 do_pending_stack_adjust ();
1286 /* Save the stack with nonlocal if available. */
1287 #ifdef HAVE_save_stack_nonlocal
1288 if (HAVE_save_stack_nonlocal
)
1289 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1292 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1294 /* Allocate a block of memory onto the stack and copy the memory
1295 arguments to the outgoing arguments address. */
1296 allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
);
1297 dest
= virtual_outgoing_args_rtx
;
1298 #ifndef STACK_GROWS_DOWNWARD
1299 if (GET_CODE (argsize
) == CONST_INT
)
1300 dest
= plus_constant (dest
, -INTVAL (argsize
));
1302 dest
= gen_rtx_PLUS (Pmode
, dest
, negate_rtx (Pmode
, argsize
));
1304 dest
= gen_rtx_MEM (BLKmode
, dest
);
1305 set_mem_align (dest
, PARM_BOUNDARY
);
1306 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1307 set_mem_align (src
, PARM_BOUNDARY
);
1308 emit_block_move (dest
, src
, argsize
, BLOCK_OP_NORMAL
);
1310 /* Refer to the argument block. */
1312 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1313 set_mem_align (arguments
, PARM_BOUNDARY
);
1315 /* Walk past the arg-pointer and structure value address. */
1316 size
= GET_MODE_SIZE (Pmode
);
1318 size
+= GET_MODE_SIZE (Pmode
);
1320 /* Restore each of the registers previously saved. Make USE insns
1321 for each of these registers for use in making the call. */
1322 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1323 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1325 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1326 if (size
% align
!= 0)
1327 size
= CEIL (size
, align
) * align
;
1328 reg
= gen_rtx_REG (mode
, regno
);
1329 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1330 use_reg (&call_fusage
, reg
);
1331 size
+= GET_MODE_SIZE (mode
);
1334 /* Restore the structure value address unless this is passed as an
1335 "invisible" first argument. */
1336 size
= GET_MODE_SIZE (Pmode
);
1339 rtx value
= gen_reg_rtx (Pmode
);
1340 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1341 emit_move_insn (struct_value
, value
);
1342 if (REG_P (struct_value
))
1343 use_reg (&call_fusage
, struct_value
);
1344 size
+= GET_MODE_SIZE (Pmode
);
1347 /* All arguments and registers used for the call are set up by now! */
1348 function
= prepare_call_address (function
, NULL
, &call_fusage
, 0, 0);
1350 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1351 and we don't want to load it into a register as an optimization,
1352 because prepare_call_address already did it if it should be done. */
1353 if (GET_CODE (function
) != SYMBOL_REF
)
1354 function
= memory_address (FUNCTION_MODE
, function
);
1356 /* Generate the actual call instruction and save the return value. */
1357 #ifdef HAVE_untyped_call
1358 if (HAVE_untyped_call
)
1359 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1360 result
, result_vector (1, result
)));
1363 #ifdef HAVE_call_value
1364 if (HAVE_call_value
)
1368 /* Locate the unique return register. It is not possible to
1369 express a call that sets more than one return register using
1370 call_value; use untyped_call for that. In fact, untyped_call
1371 only needs to save the return registers in the given block. */
1372 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1373 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1375 gcc_assert (!valreg
); /* HAVE_untyped_call required. */
1377 valreg
= gen_rtx_REG (mode
, regno
);
1380 emit_call_insn (GEN_CALL_VALUE (valreg
,
1381 gen_rtx_MEM (FUNCTION_MODE
, function
),
1382 const0_rtx
, NULL_RTX
, const0_rtx
));
1384 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1390 /* Find the CALL insn we just emitted, and attach the register usage
1392 call_insn
= last_call_insn ();
1393 add_function_usage_to (call_insn
, call_fusage
);
1395 /* Restore the stack. */
1396 #ifdef HAVE_save_stack_nonlocal
1397 if (HAVE_save_stack_nonlocal
)
1398 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1401 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1405 /* Return the address of the result block. */
1406 result
= copy_addr_to_reg (XEXP (result
, 0));
1407 return convert_memory_address (ptr_mode
, result
);
1410 /* Perform an untyped return. */
1413 expand_builtin_return (rtx result
)
1415 int size
, align
, regno
;
1416 enum machine_mode mode
;
1418 rtx call_fusage
= 0;
1420 result
= convert_memory_address (Pmode
, result
);
1422 apply_result_size ();
1423 result
= gen_rtx_MEM (BLKmode
, result
);
1425 #ifdef HAVE_untyped_return
1426 if (HAVE_untyped_return
)
1428 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1434 /* Restore the return value and note that each value is used. */
1436 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1437 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1439 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1440 if (size
% align
!= 0)
1441 size
= CEIL (size
, align
) * align
;
1442 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1443 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1445 push_to_sequence (call_fusage
);
1446 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1447 call_fusage
= get_insns ();
1449 size
+= GET_MODE_SIZE (mode
);
1452 /* Put the USE insns before the return. */
1453 emit_insn (call_fusage
);
1455 /* Return whatever values was restored by jumping directly to the end
1457 expand_naked_return ();
1460 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1462 static enum type_class
1463 type_to_class (tree type
)
1465 switch (TREE_CODE (type
))
1467 case VOID_TYPE
: return void_type_class
;
1468 case INTEGER_TYPE
: return integer_type_class
;
1469 case CHAR_TYPE
: return char_type_class
;
1470 case ENUMERAL_TYPE
: return enumeral_type_class
;
1471 case BOOLEAN_TYPE
: return boolean_type_class
;
1472 case POINTER_TYPE
: return pointer_type_class
;
1473 case REFERENCE_TYPE
: return reference_type_class
;
1474 case OFFSET_TYPE
: return offset_type_class
;
1475 case REAL_TYPE
: return real_type_class
;
1476 case COMPLEX_TYPE
: return complex_type_class
;
1477 case FUNCTION_TYPE
: return function_type_class
;
1478 case METHOD_TYPE
: return method_type_class
;
1479 case RECORD_TYPE
: return record_type_class
;
1481 case QUAL_UNION_TYPE
: return union_type_class
;
1482 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1483 ? string_type_class
: array_type_class
);
1484 case FILE_TYPE
: return file_type_class
;
1485 case LANG_TYPE
: return lang_type_class
;
1486 default: return no_type_class
;
1490 /* Expand a call to __builtin_classify_type with arguments found in
1494 expand_builtin_classify_type (tree arglist
)
1497 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
1498 return GEN_INT (no_type_class
);
1501 /* This helper macro, meant to be used in mathfn_built_in below,
1502 determines which among a set of three builtin math functions is
1503 appropriate for a given type mode. The `F' and `L' cases are
1504 automatically generated from the `double' case. */
1505 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1506 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1507 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1508 fcodel = BUILT_IN_MATHFN##L ; break;
1510 /* Return mathematic function equivalent to FN but operating directly
1511 on TYPE, if available. If we can't do the conversion, return zero. */
1513 mathfn_built_in (tree type
, enum built_in_function fn
)
1515 enum built_in_function fcode
, fcodef
, fcodel
;
1519 CASE_MATHFN (BUILT_IN_ACOS
)
1520 CASE_MATHFN (BUILT_IN_ACOSH
)
1521 CASE_MATHFN (BUILT_IN_ASIN
)
1522 CASE_MATHFN (BUILT_IN_ASINH
)
1523 CASE_MATHFN (BUILT_IN_ATAN
)
1524 CASE_MATHFN (BUILT_IN_ATAN2
)
1525 CASE_MATHFN (BUILT_IN_ATANH
)
1526 CASE_MATHFN (BUILT_IN_CBRT
)
1527 CASE_MATHFN (BUILT_IN_CEIL
)
1528 CASE_MATHFN (BUILT_IN_COPYSIGN
)
1529 CASE_MATHFN (BUILT_IN_COS
)
1530 CASE_MATHFN (BUILT_IN_COSH
)
1531 CASE_MATHFN (BUILT_IN_DREM
)
1532 CASE_MATHFN (BUILT_IN_ERF
)
1533 CASE_MATHFN (BUILT_IN_ERFC
)
1534 CASE_MATHFN (BUILT_IN_EXP
)
1535 CASE_MATHFN (BUILT_IN_EXP10
)
1536 CASE_MATHFN (BUILT_IN_EXP2
)
1537 CASE_MATHFN (BUILT_IN_EXPM1
)
1538 CASE_MATHFN (BUILT_IN_FABS
)
1539 CASE_MATHFN (BUILT_IN_FDIM
)
1540 CASE_MATHFN (BUILT_IN_FLOOR
)
1541 CASE_MATHFN (BUILT_IN_FMA
)
1542 CASE_MATHFN (BUILT_IN_FMAX
)
1543 CASE_MATHFN (BUILT_IN_FMIN
)
1544 CASE_MATHFN (BUILT_IN_FMOD
)
1545 CASE_MATHFN (BUILT_IN_FREXP
)
1546 CASE_MATHFN (BUILT_IN_GAMMA
)
1547 CASE_MATHFN (BUILT_IN_HUGE_VAL
)
1548 CASE_MATHFN (BUILT_IN_HYPOT
)
1549 CASE_MATHFN (BUILT_IN_ILOGB
)
1550 CASE_MATHFN (BUILT_IN_INF
)
1551 CASE_MATHFN (BUILT_IN_J0
)
1552 CASE_MATHFN (BUILT_IN_J1
)
1553 CASE_MATHFN (BUILT_IN_JN
)
1554 CASE_MATHFN (BUILT_IN_LDEXP
)
1555 CASE_MATHFN (BUILT_IN_LGAMMA
)
1556 CASE_MATHFN (BUILT_IN_LLRINT
)
1557 CASE_MATHFN (BUILT_IN_LLROUND
)
1558 CASE_MATHFN (BUILT_IN_LOG
)
1559 CASE_MATHFN (BUILT_IN_LOG10
)
1560 CASE_MATHFN (BUILT_IN_LOG1P
)
1561 CASE_MATHFN (BUILT_IN_LOG2
)
1562 CASE_MATHFN (BUILT_IN_LOGB
)
1563 CASE_MATHFN (BUILT_IN_LRINT
)
1564 CASE_MATHFN (BUILT_IN_LROUND
)
1565 CASE_MATHFN (BUILT_IN_MODF
)
1566 CASE_MATHFN (BUILT_IN_NAN
)
1567 CASE_MATHFN (BUILT_IN_NANS
)
1568 CASE_MATHFN (BUILT_IN_NEARBYINT
)
1569 CASE_MATHFN (BUILT_IN_NEXTAFTER
)
1570 CASE_MATHFN (BUILT_IN_NEXTTOWARD
)
1571 CASE_MATHFN (BUILT_IN_POW
)
1572 CASE_MATHFN (BUILT_IN_POWI
)
1573 CASE_MATHFN (BUILT_IN_POW10
)
1574 CASE_MATHFN (BUILT_IN_REMAINDER
)
1575 CASE_MATHFN (BUILT_IN_REMQUO
)
1576 CASE_MATHFN (BUILT_IN_RINT
)
1577 CASE_MATHFN (BUILT_IN_ROUND
)
1578 CASE_MATHFN (BUILT_IN_SCALB
)
1579 CASE_MATHFN (BUILT_IN_SCALBLN
)
1580 CASE_MATHFN (BUILT_IN_SCALBN
)
1581 CASE_MATHFN (BUILT_IN_SIGNIFICAND
)
1582 CASE_MATHFN (BUILT_IN_SIN
)
1583 CASE_MATHFN (BUILT_IN_SINCOS
)
1584 CASE_MATHFN (BUILT_IN_SINH
)
1585 CASE_MATHFN (BUILT_IN_SQRT
)
1586 CASE_MATHFN (BUILT_IN_TAN
)
1587 CASE_MATHFN (BUILT_IN_TANH
)
1588 CASE_MATHFN (BUILT_IN_TGAMMA
)
1589 CASE_MATHFN (BUILT_IN_TRUNC
)
1590 CASE_MATHFN (BUILT_IN_Y0
)
1591 CASE_MATHFN (BUILT_IN_Y1
)
1592 CASE_MATHFN (BUILT_IN_YN
)
1598 if (TYPE_MAIN_VARIANT (type
) == double_type_node
)
1599 return implicit_built_in_decls
[fcode
];
1600 else if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
1601 return implicit_built_in_decls
[fcodef
];
1602 else if (TYPE_MAIN_VARIANT (type
) == long_double_type_node
)
1603 return implicit_built_in_decls
[fcodel
];
1608 /* If errno must be maintained, expand the RTL to check if the result,
1609 TARGET, of a built-in function call, EXP, is NaN, and if so set
1613 expand_errno_check (tree exp
, rtx target
)
1615 rtx lab
= gen_label_rtx ();
1617 /* Test the result; if it is NaN, set errno=EDOM because
1618 the argument was not in the domain. */
1619 emit_cmp_and_jump_insns (target
, target
, EQ
, 0, GET_MODE (target
),
1623 /* If this built-in doesn't throw an exception, set errno directly. */
1624 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
1626 #ifdef GEN_ERRNO_RTX
1627 rtx errno_rtx
= GEN_ERRNO_RTX
;
1630 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1632 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1638 /* We can't set errno=EDOM directly; let the library call do it.
1639 Pop the arguments right away in case the call gets deleted. */
1641 expand_call (exp
, target
, 0);
1647 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1648 Return 0 if a normal call should be emitted rather than expanding the
1649 function in-line. EXP is the expression that is a call to the builtin
1650 function; if convenient, the result should be placed in TARGET.
1651 SUBTARGET may be used as the target for computing one of EXP's operands. */
1654 expand_builtin_mathfn (tree exp
, rtx target
, rtx subtarget
)
1656 optab builtin_optab
;
1657 rtx op0
, insns
, before_call
;
1658 tree fndecl
= get_callee_fndecl (exp
);
1659 tree arglist
= TREE_OPERAND (exp
, 1);
1660 enum machine_mode mode
;
1661 bool errno_set
= false;
1664 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1667 arg
= TREE_VALUE (arglist
);
1669 switch (DECL_FUNCTION_CODE (fndecl
))
1672 case BUILT_IN_SQRTF
:
1673 case BUILT_IN_SQRTL
:
1674 errno_set
= ! tree_expr_nonnegative_p (arg
);
1675 builtin_optab
= sqrt_optab
;
1680 errno_set
= true; builtin_optab
= exp_optab
; break;
1681 case BUILT_IN_EXP10
:
1682 case BUILT_IN_EXP10F
:
1683 case BUILT_IN_EXP10L
:
1684 case BUILT_IN_POW10
:
1685 case BUILT_IN_POW10F
:
1686 case BUILT_IN_POW10L
:
1687 errno_set
= true; builtin_optab
= exp10_optab
; break;
1689 case BUILT_IN_EXP2F
:
1690 case BUILT_IN_EXP2L
:
1691 errno_set
= true; builtin_optab
= exp2_optab
; break;
1692 case BUILT_IN_EXPM1
:
1693 case BUILT_IN_EXPM1F
:
1694 case BUILT_IN_EXPM1L
:
1695 errno_set
= true; builtin_optab
= expm1_optab
; break;
1697 case BUILT_IN_LOGBF
:
1698 case BUILT_IN_LOGBL
:
1699 errno_set
= true; builtin_optab
= logb_optab
; break;
1700 case BUILT_IN_ILOGB
:
1701 case BUILT_IN_ILOGBF
:
1702 case BUILT_IN_ILOGBL
:
1703 errno_set
= true; builtin_optab
= ilogb_optab
; break;
1707 errno_set
= true; builtin_optab
= log_optab
; break;
1708 case BUILT_IN_LOG10
:
1709 case BUILT_IN_LOG10F
:
1710 case BUILT_IN_LOG10L
:
1711 errno_set
= true; builtin_optab
= log10_optab
; break;
1713 case BUILT_IN_LOG2F
:
1714 case BUILT_IN_LOG2L
:
1715 errno_set
= true; builtin_optab
= log2_optab
; break;
1716 case BUILT_IN_LOG1P
:
1717 case BUILT_IN_LOG1PF
:
1718 case BUILT_IN_LOG1PL
:
1719 errno_set
= true; builtin_optab
= log1p_optab
; break;
1721 case BUILT_IN_ASINF
:
1722 case BUILT_IN_ASINL
:
1723 builtin_optab
= asin_optab
; break;
1725 case BUILT_IN_ACOSF
:
1726 case BUILT_IN_ACOSL
:
1727 builtin_optab
= acos_optab
; break;
1731 builtin_optab
= tan_optab
; break;
1733 case BUILT_IN_ATANF
:
1734 case BUILT_IN_ATANL
:
1735 builtin_optab
= atan_optab
; break;
1736 case BUILT_IN_FLOOR
:
1737 case BUILT_IN_FLOORF
:
1738 case BUILT_IN_FLOORL
:
1739 builtin_optab
= floor_optab
; break;
1741 case BUILT_IN_CEILF
:
1742 case BUILT_IN_CEILL
:
1743 builtin_optab
= ceil_optab
; break;
1744 case BUILT_IN_TRUNC
:
1745 case BUILT_IN_TRUNCF
:
1746 case BUILT_IN_TRUNCL
:
1747 builtin_optab
= btrunc_optab
; break;
1748 case BUILT_IN_ROUND
:
1749 case BUILT_IN_ROUNDF
:
1750 case BUILT_IN_ROUNDL
:
1751 builtin_optab
= round_optab
; break;
1752 case BUILT_IN_NEARBYINT
:
1753 case BUILT_IN_NEARBYINTF
:
1754 case BUILT_IN_NEARBYINTL
:
1755 builtin_optab
= nearbyint_optab
; break;
1757 case BUILT_IN_RINTF
:
1758 case BUILT_IN_RINTL
:
1759 builtin_optab
= rint_optab
; break;
1764 /* Make a suitable register to place result in. */
1765 mode
= TYPE_MODE (TREE_TYPE (exp
));
1767 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1770 /* Before working hard, check whether the instruction is available. */
1771 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
1773 target
= gen_reg_rtx (mode
);
1775 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1776 need to expand the argument again. This way, we will not perform
1777 side-effects more the once. */
1778 narg
= builtin_save_expr (arg
);
1782 arglist
= build_tree_list (NULL_TREE
, arg
);
1783 exp
= build_function_call_expr (fndecl
, arglist
);
1786 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
1790 /* Compute into TARGET.
1791 Set TARGET to wherever the result comes back. */
1792 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
1797 expand_errno_check (exp
, target
);
1799 /* Output the entire sequence. */
1800 insns
= get_insns ();
1806 /* If we were unable to expand via the builtin, stop the sequence
1807 (without outputting the insns) and call to the library function
1808 with the stabilized argument list. */
1812 before_call
= get_last_insn ();
1814 target
= expand_call (exp
, target
, target
== const0_rtx
);
1816 /* If this is a sqrt operation and we don't care about errno, try to
1817 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1818 This allows the semantics of the libcall to be visible to the RTL
1820 if (builtin_optab
== sqrt_optab
&& !errno_set
)
1822 /* Search backwards through the insns emitted by expand_call looking
1823 for the instruction with the REG_RETVAL note. */
1824 rtx last
= get_last_insn ();
1825 while (last
!= before_call
)
1827 if (find_reg_note (last
, REG_RETVAL
, NULL
))
1829 rtx note
= find_reg_note (last
, REG_EQUAL
, NULL
);
1830 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1831 two elements, i.e. symbol_ref(sqrt) and the operand. */
1833 && GET_CODE (note
) == EXPR_LIST
1834 && GET_CODE (XEXP (note
, 0)) == EXPR_LIST
1835 && XEXP (XEXP (note
, 0), 1) != NULL_RTX
1836 && XEXP (XEXP (XEXP (note
, 0), 1), 1) == NULL_RTX
)
1838 rtx operand
= XEXP (XEXP (XEXP (note
, 0), 1), 0);
1839 /* Check operand is a register with expected mode. */
1842 && GET_MODE (operand
) == mode
)
1844 /* Replace the REG_EQUAL note with a SQRT rtx. */
1845 rtx equiv
= gen_rtx_SQRT (mode
, operand
);
1846 set_unique_reg_note (last
, REG_EQUAL
, equiv
);
1851 last
= PREV_INSN (last
);
1858 /* Expand a call to the builtin binary math functions (pow and atan2).
1859 Return 0 if a normal call should be emitted rather than expanding the
1860 function in-line. EXP is the expression that is a call to the builtin
1861 function; if convenient, the result should be placed in TARGET.
1862 SUBTARGET may be used as the target for computing one of EXP's
1866 expand_builtin_mathfn_2 (tree exp
, rtx target
, rtx subtarget
)
1868 optab builtin_optab
;
1869 rtx op0
, op1
, insns
;
1870 int op1_type
= REAL_TYPE
;
1871 tree fndecl
= get_callee_fndecl (exp
);
1872 tree arglist
= TREE_OPERAND (exp
, 1);
1873 tree arg0
, arg1
, temp
, narg
;
1874 enum machine_mode mode
;
1875 bool errno_set
= true;
1878 if ((DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXP
)
1879 || (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXPF
)
1880 || (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_LDEXPL
))
1881 op1_type
= INTEGER_TYPE
;
1883 if (!validate_arglist (arglist
, REAL_TYPE
, op1_type
, VOID_TYPE
))
1886 arg0
= TREE_VALUE (arglist
);
1887 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
1889 switch (DECL_FUNCTION_CODE (fndecl
))
1894 builtin_optab
= pow_optab
; break;
1895 case BUILT_IN_ATAN2
:
1896 case BUILT_IN_ATAN2F
:
1897 case BUILT_IN_ATAN2L
:
1898 builtin_optab
= atan2_optab
; break;
1899 case BUILT_IN_LDEXP
:
1900 case BUILT_IN_LDEXPF
:
1901 case BUILT_IN_LDEXPL
:
1902 builtin_optab
= ldexp_optab
; break;
1904 case BUILT_IN_FMODF
:
1905 case BUILT_IN_FMODL
:
1906 builtin_optab
= fmod_optab
; break;
1908 case BUILT_IN_DREMF
:
1909 case BUILT_IN_DREML
:
1910 builtin_optab
= drem_optab
; break;
1915 /* Make a suitable register to place result in. */
1916 mode
= TYPE_MODE (TREE_TYPE (exp
));
1918 /* Before working hard, check whether the instruction is available. */
1919 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
)
1922 target
= gen_reg_rtx (mode
);
1924 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
1927 /* Always stabilize the argument list. */
1928 narg
= builtin_save_expr (arg1
);
1932 temp
= build_tree_list (NULL_TREE
, narg
);
1936 temp
= TREE_CHAIN (arglist
);
1938 narg
= builtin_save_expr (arg0
);
1942 arglist
= tree_cons (NULL_TREE
, narg
, temp
);
1946 arglist
= tree_cons (NULL_TREE
, arg0
, temp
);
1949 exp
= build_function_call_expr (fndecl
, arglist
);
1951 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
1952 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
1956 /* Compute into TARGET.
1957 Set TARGET to wherever the result comes back. */
1958 target
= expand_binop (mode
, builtin_optab
, op0
, op1
,
1959 target
, 0, OPTAB_DIRECT
);
1961 /* If we were unable to expand via the builtin, stop the sequence
1962 (without outputting the insns) and call to the library function
1963 with the stabilized argument list. */
1967 return expand_call (exp
, target
, target
== const0_rtx
);
1971 expand_errno_check (exp
, target
);
1973 /* Output the entire sequence. */
1974 insns
= get_insns ();
1981 /* Expand a call to the builtin sin and cos math functions.
1982 Return 0 if a normal call should be emitted rather than expanding the
1983 function in-line. EXP is the expression that is a call to the builtin
1984 function; if convenient, the result should be placed in TARGET.
1985 SUBTARGET may be used as the target for computing one of EXP's
1989 expand_builtin_mathfn_3 (tree exp
, rtx target
, rtx subtarget
)
1991 optab builtin_optab
;
1992 rtx op0
, insns
, before_call
;
1993 tree fndecl
= get_callee_fndecl (exp
);
1994 tree arglist
= TREE_OPERAND (exp
, 1);
1995 enum machine_mode mode
;
1996 bool errno_set
= false;
1999 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
2002 arg
= TREE_VALUE (arglist
);
2004 switch (DECL_FUNCTION_CODE (fndecl
))
2012 builtin_optab
= sincos_optab
; break;
2017 /* Make a suitable register to place result in. */
2018 mode
= TYPE_MODE (TREE_TYPE (exp
));
2020 if (! flag_errno_math
|| ! HONOR_NANS (mode
))
2023 /* Check if sincos insn is available, otherwise fallback
2024 to sin or cos insn. */
2025 if (builtin_optab
->handlers
[(int) mode
].insn_code
== CODE_FOR_nothing
) {
2026 switch (DECL_FUNCTION_CODE (fndecl
))
2031 builtin_optab
= sin_optab
; break;
2035 builtin_optab
= cos_optab
; break;
2041 /* Before working hard, check whether the instruction is available. */
2042 if (builtin_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2044 target
= gen_reg_rtx (mode
);
2046 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2047 need to expand the argument again. This way, we will not perform
2048 side-effects more the once. */
2049 narg
= save_expr (arg
);
2053 arglist
= build_tree_list (NULL_TREE
, arg
);
2054 exp
= build_function_call_expr (fndecl
, arglist
);
2057 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
2061 /* Compute into TARGET.
2062 Set TARGET to wherever the result comes back. */
2063 if (builtin_optab
== sincos_optab
)
2067 switch (DECL_FUNCTION_CODE (fndecl
))
2072 result
= expand_twoval_unop (builtin_optab
, op0
, 0, target
, 0);
2077 result
= expand_twoval_unop (builtin_optab
, op0
, target
, 0, 0);
2082 gcc_assert (result
);
2086 target
= expand_unop (mode
, builtin_optab
, op0
, target
, 0);
2092 expand_errno_check (exp
, target
);
2094 /* Output the entire sequence. */
2095 insns
= get_insns ();
2101 /* If we were unable to expand via the builtin, stop the sequence
2102 (without outputting the insns) and call to the library function
2103 with the stabilized argument list. */
2107 before_call
= get_last_insn ();
2109 target
= expand_call (exp
, target
, target
== const0_rtx
);
2114 /* To evaluate powi(x,n), the floating point value x raised to the
2115 constant integer exponent n, we use a hybrid algorithm that
2116 combines the "window method" with look-up tables. For an
2117 introduction to exponentiation algorithms and "addition chains",
2118 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2119 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2120 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2121 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2123 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2124 multiplications to inline before calling the system library's pow
2125 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2126 so this default never requires calling pow, powf or powl. */
2128 #ifndef POWI_MAX_MULTS
2129 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2132 /* The size of the "optimal power tree" lookup table. All
2133 exponents less than this value are simply looked up in the
2134 powi_table below. This threshold is also used to size the
2135 cache of pseudo registers that hold intermediate results. */
2136 #define POWI_TABLE_SIZE 256
2138 /* The size, in bits of the window, used in the "window method"
2139 exponentiation algorithm. This is equivalent to a radix of
2140 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2141 #define POWI_WINDOW_SIZE 3
2143 /* The following table is an efficient representation of an
2144 "optimal power tree". For each value, i, the corresponding
2145 value, j, in the table states than an optimal evaluation
2146 sequence for calculating pow(x,i) can be found by evaluating
2147 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2148 100 integers is given in Knuth's "Seminumerical algorithms". */
2150 static const unsigned char powi_table
[POWI_TABLE_SIZE
] =
2152 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2153 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2154 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2155 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2156 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2157 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2158 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2159 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2160 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2161 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2162 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2163 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2164 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2165 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2166 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2167 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2168 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2169 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2170 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2171 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2172 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2173 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2174 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2175 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2176 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2177 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2178 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2179 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2180 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2181 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2182 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2183 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2187 /* Return the number of multiplications required to calculate
2188 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2189 subroutine of powi_cost. CACHE is an array indicating
2190 which exponents have already been calculated. */
2193 powi_lookup_cost (unsigned HOST_WIDE_INT n
, bool *cache
)
2195 /* If we've already calculated this exponent, then this evaluation
2196 doesn't require any additional multiplications. */
2201 return powi_lookup_cost (n
- powi_table
[n
], cache
)
2202 + powi_lookup_cost (powi_table
[n
], cache
) + 1;
2205 /* Return the number of multiplications required to calculate
2206 powi(x,n) for an arbitrary x, given the exponent N. This
2207 function needs to be kept in sync with expand_powi below. */
2210 powi_cost (HOST_WIDE_INT n
)
2212 bool cache
[POWI_TABLE_SIZE
];
2213 unsigned HOST_WIDE_INT digit
;
2214 unsigned HOST_WIDE_INT val
;
2220 /* Ignore the reciprocal when calculating the cost. */
2221 val
= (n
< 0) ? -n
: n
;
2223 /* Initialize the exponent cache. */
2224 memset (cache
, 0, POWI_TABLE_SIZE
* sizeof (bool));
2229 while (val
>= POWI_TABLE_SIZE
)
2233 digit
= val
& ((1 << POWI_WINDOW_SIZE
) - 1);
2234 result
+= powi_lookup_cost (digit
, cache
)
2235 + POWI_WINDOW_SIZE
+ 1;
2236 val
>>= POWI_WINDOW_SIZE
;
2245 return result
+ powi_lookup_cost (val
, cache
);
2248 /* Recursive subroutine of expand_powi. This function takes the array,
2249 CACHE, of already calculated exponents and an exponent N and returns
2250 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2253 expand_powi_1 (enum machine_mode mode
, unsigned HOST_WIDE_INT n
, rtx
*cache
)
2255 unsigned HOST_WIDE_INT digit
;
2259 if (n
< POWI_TABLE_SIZE
)
2264 target
= gen_reg_rtx (mode
);
2267 op0
= expand_powi_1 (mode
, n
- powi_table
[n
], cache
);
2268 op1
= expand_powi_1 (mode
, powi_table
[n
], cache
);
2272 target
= gen_reg_rtx (mode
);
2273 digit
= n
& ((1 << POWI_WINDOW_SIZE
) - 1);
2274 op0
= expand_powi_1 (mode
, n
- digit
, cache
);
2275 op1
= expand_powi_1 (mode
, digit
, cache
);
2279 target
= gen_reg_rtx (mode
);
2280 op0
= expand_powi_1 (mode
, n
>> 1, cache
);
2284 result
= expand_mult (mode
, op0
, op1
, target
, 0);
2285 if (result
!= target
)
2286 emit_move_insn (target
, result
);
2290 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2291 floating point operand in mode MODE, and N is the exponent. This
2292 function needs to be kept in sync with powi_cost above. */
2295 expand_powi (rtx x
, enum machine_mode mode
, HOST_WIDE_INT n
)
2297 unsigned HOST_WIDE_INT val
;
2298 rtx cache
[POWI_TABLE_SIZE
];
2302 return CONST1_RTX (mode
);
2304 val
= (n
< 0) ? -n
: n
;
2306 memset (cache
, 0, sizeof (cache
));
2309 result
= expand_powi_1 (mode
, (n
< 0) ? -n
: n
, cache
);
2311 /* If the original exponent was negative, reciprocate the result. */
2313 result
= expand_binop (mode
, sdiv_optab
, CONST1_RTX (mode
),
2314 result
, NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2319 /* Expand a call to the pow built-in mathematical function. Return 0 if
2320 a normal call should be emitted rather than expanding the function
2321 in-line. EXP is the expression that is a call to the builtin
2322 function; if convenient, the result should be placed in TARGET. */
2325 expand_builtin_pow (tree exp
, rtx target
, rtx subtarget
)
2327 tree arglist
= TREE_OPERAND (exp
, 1);
2330 if (! validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
2333 arg0
= TREE_VALUE (arglist
);
2334 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2336 if (TREE_CODE (arg1
) == REAL_CST
2337 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2339 REAL_VALUE_TYPE cint
;
2343 c
= TREE_REAL_CST (arg1
);
2344 n
= real_to_integer (&c
);
2345 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
2346 if (real_identical (&c
, &cint
))
2348 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2349 Otherwise, check the number of multiplications required.
2350 Note that pow never sets errno for an integer exponent. */
2351 if ((n
>= -1 && n
<= 2)
2352 || (flag_unsafe_math_optimizations
2354 && powi_cost (n
) <= POWI_MAX_MULTS
))
2356 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2357 rtx op
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2358 op
= force_reg (mode
, op
);
2359 return expand_powi (op
, mode
, n
);
2364 if (! flag_unsafe_math_optimizations
)
2366 return expand_builtin_mathfn_2 (exp
, target
, subtarget
);
2369 /* Expand a call to the powi built-in mathematical function. Return 0 if
2370 a normal call should be emitted rather than expanding the function
2371 in-line. EXP is the expression that is a call to the builtin
2372 function; if convenient, the result should be placed in TARGET. */
2375 expand_builtin_powi (tree exp
, rtx target
, rtx subtarget
)
2377 tree arglist
= TREE_OPERAND (exp
, 1);
2380 enum machine_mode mode
;
2382 if (! validate_arglist (arglist
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2385 arg0
= TREE_VALUE (arglist
);
2386 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
2387 mode
= TYPE_MODE (TREE_TYPE (exp
));
2389 /* Handle constant power. */
2391 if (TREE_CODE (arg1
) == INTEGER_CST
2392 && ! TREE_CONSTANT_OVERFLOW (arg1
))
2394 HOST_WIDE_INT n
= TREE_INT_CST_LOW (arg1
);
2396 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2397 Otherwise, check the number of multiplications required. */
2398 if ((TREE_INT_CST_HIGH (arg1
) == 0
2399 || TREE_INT_CST_HIGH (arg1
) == -1)
2400 && ((n
>= -1 && n
<= 2)
2402 && powi_cost (n
) <= POWI_MAX_MULTS
)))
2404 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
2405 op0
= force_reg (mode
, op0
);
2406 return expand_powi (op0
, mode
, n
);
2410 /* Emit a libcall to libgcc. */
2412 if (target
== NULL_RTX
)
2413 target
= gen_reg_rtx (mode
);
2415 op0
= expand_expr (arg0
, subtarget
, mode
, 0);
2416 if (GET_MODE (op0
) != mode
)
2417 op0
= convert_to_mode (mode
, op0
, 0);
2418 op1
= expand_expr (arg1
, 0, word_mode
, 0);
2419 if (GET_MODE (op1
) != word_mode
)
2420 op1
= convert_to_mode (word_mode
, op1
, 0);
2422 target
= emit_library_call_value (powi_optab
->handlers
[(int) mode
].libfunc
,
2423 target
, LCT_CONST_MAKE_BLOCK
, mode
, 2,
2424 op0
, mode
, op1
, word_mode
);
2429 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2430 if we failed the caller should emit a normal call, otherwise
2431 try to get the result in TARGET, if convenient. */
2434 expand_builtin_strlen (tree arglist
, rtx target
,
2435 enum machine_mode target_mode
)
2437 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
2442 tree len
, src
= TREE_VALUE (arglist
);
2443 rtx result
, src_reg
, char_rtx
, before_strlen
;
2444 enum machine_mode insn_mode
= target_mode
, char_mode
;
2445 enum insn_code icode
= CODE_FOR_nothing
;
2448 /* If the length can be computed at compile-time, return it. */
2449 len
= c_strlen (src
, 0);
2451 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2453 /* If the length can be computed at compile-time and is constant
2454 integer, but there are side-effects in src, evaluate
2455 src for side-effects, then return len.
2456 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2457 can be optimized into: i++; x = 3; */
2458 len
= c_strlen (src
, 1);
2459 if (len
&& TREE_CODE (len
) == INTEGER_CST
)
2461 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2462 return expand_expr (len
, target
, target_mode
, EXPAND_NORMAL
);
2465 align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2467 /* If SRC is not a pointer type, don't do this operation inline. */
2471 /* Bail out if we can't compute strlen in the right mode. */
2472 while (insn_mode
!= VOIDmode
)
2474 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
2475 if (icode
!= CODE_FOR_nothing
)
2478 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
2480 if (insn_mode
== VOIDmode
)
2483 /* Make a place to write the result of the instruction. */
2487 && GET_MODE (result
) == insn_mode
2488 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
2489 result
= gen_reg_rtx (insn_mode
);
2491 /* Make a place to hold the source address. We will not expand
2492 the actual source until we are sure that the expansion will
2493 not fail -- there are trees that cannot be expanded twice. */
2494 src_reg
= gen_reg_rtx (Pmode
);
2496 /* Mark the beginning of the strlen sequence so we can emit the
2497 source operand later. */
2498 before_strlen
= get_last_insn ();
2500 char_rtx
= const0_rtx
;
2501 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
2502 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
2504 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
2506 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
2507 char_rtx
, GEN_INT (align
));
2512 /* Now that we are assured of success, expand the source. */
2514 pat
= expand_expr (src
, src_reg
, ptr_mode
, EXPAND_NORMAL
);
2516 emit_move_insn (src_reg
, pat
);
2521 emit_insn_after (pat
, before_strlen
);
2523 emit_insn_before (pat
, get_insns ());
2525 /* Return the value in the proper mode for this function. */
2526 if (GET_MODE (result
) == target_mode
)
2528 else if (target
!= 0)
2529 convert_move (target
, result
, 0);
2531 target
= convert_to_mode (target_mode
, result
, 0);
2537 /* Expand a call to the strstr builtin. Return 0 if we failed the
2538 caller should emit a normal call, otherwise try to get the result
2539 in TARGET, if convenient (and in mode MODE if that's convenient). */
2542 expand_builtin_strstr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2544 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2546 tree result
= fold_builtin_strstr (arglist
, type
);
2548 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2553 /* Expand a call to the strchr builtin. Return 0 if we failed the
2554 caller should emit a normal call, otherwise try to get the result
2555 in TARGET, if convenient (and in mode MODE if that's convenient). */
2558 expand_builtin_strchr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2560 if (validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2562 tree result
= fold_builtin_strchr (arglist
, type
);
2564 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2566 /* FIXME: Should use strchrM optab so that ports can optimize this. */
2571 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2572 caller should emit a normal call, otherwise try to get the result
2573 in TARGET, if convenient (and in mode MODE if that's convenient). */
2576 expand_builtin_strrchr (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2578 if (validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2580 tree result
= fold_builtin_strrchr (arglist
, type
);
2582 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2587 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2588 caller should emit a normal call, otherwise try to get the result
2589 in TARGET, if convenient (and in mode MODE if that's convenient). */
2592 expand_builtin_strpbrk (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
2594 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2596 tree result
= fold_builtin_strpbrk (arglist
, type
);
2598 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2603 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2604 bytes from constant string DATA + OFFSET and return it as target
2608 builtin_memcpy_read_str (void *data
, HOST_WIDE_INT offset
,
2609 enum machine_mode mode
)
2611 const char *str
= (const char *) data
;
2613 gcc_assert (offset
>= 0
2614 && ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
2615 <= strlen (str
) + 1));
2617 return c_readstr (str
+ offset
, mode
);
2620 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2621 Return 0 if we failed, the caller should emit a normal call,
2622 otherwise try to get the result in TARGET, if convenient (and in
2623 mode MODE if that's convenient). */
2625 expand_builtin_memcpy (tree exp
, rtx target
, enum machine_mode mode
)
2627 tree arglist
= TREE_OPERAND (exp
, 1);
2628 if (!validate_arglist (arglist
,
2629 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2633 tree dest
= TREE_VALUE (arglist
);
2634 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2635 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2636 const char *src_str
;
2637 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2638 unsigned int dest_align
2639 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2640 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
2641 tree result
= fold_builtin_memcpy (exp
);
2644 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2646 /* If DEST is not a pointer type, call the normal function. */
2647 if (dest_align
== 0)
2650 /* If either SRC is not a pointer type, don't do this
2651 operation in-line. */
2655 dest_mem
= get_memory_rtx (dest
);
2656 set_mem_align (dest_mem
, dest_align
);
2657 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2658 src_str
= c_getstr (src
);
2660 /* If SRC is a string constant and block move would be done
2661 by pieces, we can avoid loading the string from memory
2662 and only stored the computed constants. */
2664 && GET_CODE (len_rtx
) == CONST_INT
2665 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2666 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2667 (void *) src_str
, dest_align
))
2669 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2670 builtin_memcpy_read_str
,
2671 (void *) src_str
, dest_align
, 0);
2672 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2673 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2677 src_mem
= get_memory_rtx (src
);
2678 set_mem_align (src_mem
, src_align
);
2680 /* Copy word part most expediently. */
2681 dest_addr
= emit_block_move (dest_mem
, src_mem
, len_rtx
,
2686 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2687 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
2693 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2694 Return 0 if we failed the caller should emit a normal call,
2695 otherwise try to get the result in TARGET, if convenient (and in
2696 mode MODE if that's convenient). If ENDP is 0 return the
2697 destination pointer, if ENDP is 1 return the end pointer ala
2698 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2702 expand_builtin_mempcpy (tree arglist
, tree type
, rtx target
, enum machine_mode mode
,
2705 if (!validate_arglist (arglist
,
2706 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2708 /* If return value is ignored, transform mempcpy into memcpy. */
2709 else if (target
== const0_rtx
)
2711 tree fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2716 return expand_expr (build_function_call_expr (fn
, arglist
),
2717 target
, mode
, EXPAND_NORMAL
);
2721 tree dest
= TREE_VALUE (arglist
);
2722 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2723 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2724 const char *src_str
;
2725 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2726 unsigned int dest_align
2727 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2728 rtx dest_mem
, src_mem
, len_rtx
;
2729 tree result
= fold_builtin_mempcpy (arglist
, type
, endp
);
2732 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2734 /* If either SRC or DEST is not a pointer type, don't do this
2735 operation in-line. */
2736 if (dest_align
== 0 || src_align
== 0)
2739 /* If LEN is not constant, call the normal function. */
2740 if (! host_integerp (len
, 1))
2743 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2744 src_str
= c_getstr (src
);
2746 /* If SRC is a string constant and block move would be done
2747 by pieces, we can avoid loading the string from memory
2748 and only stored the computed constants. */
2750 && GET_CODE (len_rtx
) == CONST_INT
2751 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
2752 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
2753 (void *) src_str
, dest_align
))
2755 dest_mem
= get_memory_rtx (dest
);
2756 set_mem_align (dest_mem
, dest_align
);
2757 dest_mem
= store_by_pieces (dest_mem
, INTVAL (len_rtx
),
2758 builtin_memcpy_read_str
,
2759 (void *) src_str
, dest_align
, endp
);
2760 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2761 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2765 if (GET_CODE (len_rtx
) == CONST_INT
2766 && can_move_by_pieces (INTVAL (len_rtx
),
2767 MIN (dest_align
, src_align
)))
2769 dest_mem
= get_memory_rtx (dest
);
2770 set_mem_align (dest_mem
, dest_align
);
2771 src_mem
= get_memory_rtx (src
);
2772 set_mem_align (src_mem
, src_align
);
2773 dest_mem
= move_by_pieces (dest_mem
, src_mem
, INTVAL (len_rtx
),
2774 MIN (dest_align
, src_align
), endp
);
2775 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2776 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
2784 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2785 if we failed the caller should emit a normal call. */
2788 expand_builtin_memmove (tree arglist
, tree type
, rtx target
,
2789 enum machine_mode mode
)
2791 if (!validate_arglist (arglist
,
2792 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2796 tree dest
= TREE_VALUE (arglist
);
2797 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
2798 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2800 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
2801 unsigned int dest_align
2802 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2803 tree result
= fold_builtin_memmove (arglist
, type
);
2806 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2808 /* If DEST is not a pointer type, call the normal function. */
2809 if (dest_align
== 0)
2812 /* If either SRC is not a pointer type, don't do this
2813 operation in-line. */
2817 /* If src is categorized for a readonly section we can use
2819 if (readonly_data_expr (src
))
2821 tree
const fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
2824 return expand_expr (build_function_call_expr (fn
, arglist
),
2825 target
, mode
, EXPAND_NORMAL
);
2828 /* If length is 1 and we can expand memcpy call inline,
2829 it is ok to use memcpy as well. */
2830 if (integer_onep (len
))
2832 rtx ret
= expand_builtin_mempcpy (arglist
, type
, target
, mode
,
2838 /* Otherwise, call the normal function. */
2843 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
2844 if we failed the caller should emit a normal call. */
2847 expand_builtin_bcopy (tree arglist
, tree type
)
2849 tree src
, dest
, size
, newarglist
;
2851 if (!validate_arglist (arglist
,
2852 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2855 src
= TREE_VALUE (arglist
);
2856 dest
= TREE_VALUE (TREE_CHAIN (arglist
));
2857 size
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2859 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
2860 memmove(ptr y, ptr x, size_t z). This is done this way
2861 so that if it isn't expanded inline, we fallback to
2862 calling bcopy instead of memmove. */
2864 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
2865 newarglist
= tree_cons (NULL_TREE
, src
, newarglist
);
2866 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
2868 return expand_builtin_memmove (newarglist
, type
, const0_rtx
, VOIDmode
);
2872 # define HAVE_movstr 0
2873 # define CODE_FOR_movstr CODE_FOR_nothing
2876 /* Expand into a movstr instruction, if one is available. Return 0 if
2877 we failed, the caller should emit a normal call, otherwise try to
2878 get the result in TARGET, if convenient. If ENDP is 0 return the
2879 destination pointer, if ENDP is 1 return the end pointer ala
2880 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2884 expand_movstr (tree dest
, tree src
, rtx target
, int endp
)
2890 const struct insn_data
* data
;
2895 dest_mem
= get_memory_rtx (dest
);
2896 src_mem
= get_memory_rtx (src
);
2899 target
= force_reg (Pmode
, XEXP (dest_mem
, 0));
2900 dest_mem
= replace_equiv_address (dest_mem
, target
);
2901 end
= gen_reg_rtx (Pmode
);
2905 if (target
== 0 || target
== const0_rtx
)
2907 end
= gen_reg_rtx (Pmode
);
2915 data
= insn_data
+ CODE_FOR_movstr
;
2917 if (data
->operand
[0].mode
!= VOIDmode
)
2918 end
= gen_lowpart (data
->operand
[0].mode
, end
);
2920 insn
= data
->genfun (end
, dest_mem
, src_mem
);
2926 /* movstr is supposed to set end to the address of the NUL
2927 terminator. If the caller requested a mempcpy-like return value,
2929 if (endp
== 1 && target
!= const0_rtx
)
2931 rtx tem
= plus_constant (gen_lowpart (GET_MODE (target
), end
), 1);
2932 emit_move_insn (target
, force_operand (tem
, NULL_RTX
));
2938 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
2939 if we failed the caller should emit a normal call, otherwise try to get
2940 the result in TARGET, if convenient (and in mode MODE if that's
2944 expand_builtin_strcpy (tree exp
, rtx target
, enum machine_mode mode
)
2946 tree arglist
= TREE_OPERAND (exp
, 1);
2947 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2949 tree result
= fold_builtin_strcpy (exp
, 0);
2951 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2953 return expand_movstr (TREE_VALUE (arglist
),
2954 TREE_VALUE (TREE_CHAIN (arglist
)),
2955 target
, /*endp=*/0);
2960 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
2961 Return 0 if we failed the caller should emit a normal call,
2962 otherwise try to get the result in TARGET, if convenient (and in
2963 mode MODE if that's convenient). */
2966 expand_builtin_stpcpy (tree exp
, rtx target
, enum machine_mode mode
)
2968 tree arglist
= TREE_OPERAND (exp
, 1);
2969 /* If return value is ignored, transform stpcpy into strcpy. */
2970 if (target
== const0_rtx
)
2972 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
2976 return expand_expr (build_function_call_expr (fn
, arglist
),
2977 target
, mode
, EXPAND_NORMAL
);
2980 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2984 tree dst
, src
, len
, lenp1
;
2988 /* Ensure we get an actual string whose length can be evaluated at
2989 compile-time, not an expression containing a string. This is
2990 because the latter will potentially produce pessimized code
2991 when used to produce the return value. */
2992 src
= TREE_VALUE (TREE_CHAIN (arglist
));
2993 if (! c_getstr (src
) || ! (len
= c_strlen (src
, 0)))
2994 return expand_movstr (TREE_VALUE (arglist
),
2995 TREE_VALUE (TREE_CHAIN (arglist
)),
2996 target
, /*endp=*/2);
2998 dst
= TREE_VALUE (arglist
);
2999 lenp1
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
3000 narglist
= build_tree_list (NULL_TREE
, lenp1
);
3001 narglist
= tree_cons (NULL_TREE
, src
, narglist
);
3002 narglist
= tree_cons (NULL_TREE
, dst
, narglist
);
3003 ret
= expand_builtin_mempcpy (narglist
, TREE_TYPE (exp
),
3004 target
, mode
, /*endp=*/2);
3009 if (TREE_CODE (len
) == INTEGER_CST
)
3011 rtx len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3013 if (GET_CODE (len_rtx
) == CONST_INT
)
3015 ret
= expand_builtin_strcpy (exp
, target
, mode
);
3021 if (mode
!= VOIDmode
)
3022 target
= gen_reg_rtx (mode
);
3024 target
= gen_reg_rtx (GET_MODE (ret
));
3026 if (GET_MODE (target
) != GET_MODE (ret
))
3027 ret
= gen_lowpart (GET_MODE (target
), ret
);
3029 ret
= plus_constant (ret
, INTVAL (len_rtx
));
3030 ret
= emit_move_insn (target
, force_operand (ret
, NULL_RTX
));
3038 return expand_movstr (TREE_VALUE (arglist
),
3039 TREE_VALUE (TREE_CHAIN (arglist
)),
3040 target
, /*endp=*/2);
3044 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3045 bytes from constant string DATA + OFFSET and return it as target
3049 builtin_strncpy_read_str (void *data
, HOST_WIDE_INT offset
,
3050 enum machine_mode mode
)
3052 const char *str
= (const char *) data
;
3054 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
3057 return c_readstr (str
+ offset
, mode
);
3060 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
3061 if we failed the caller should emit a normal call. */
3064 expand_builtin_strncpy (tree exp
, rtx target
, enum machine_mode mode
)
3066 tree arglist
= TREE_OPERAND (exp
, 1);
3067 if (validate_arglist (arglist
,
3068 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3070 tree slen
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)), 1);
3071 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3072 tree result
= fold_builtin_strncpy (exp
, slen
);
3075 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3077 /* We must be passed a constant len and src parameter. */
3078 if (!host_integerp (len
, 1) || !slen
|| !host_integerp (slen
, 1))
3081 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
3083 /* We're required to pad with trailing zeros if the requested
3084 len is greater than strlen(s2)+1. In that case try to
3085 use store_by_pieces, if it fails, punt. */
3086 if (tree_int_cst_lt (slen
, len
))
3088 tree dest
= TREE_VALUE (arglist
);
3089 unsigned int dest_align
3090 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3091 const char *p
= c_getstr (TREE_VALUE (TREE_CHAIN (arglist
)));
3094 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
3095 || !can_store_by_pieces (tree_low_cst (len
, 1),
3096 builtin_strncpy_read_str
,
3097 (void *) p
, dest_align
))
3100 dest_mem
= get_memory_rtx (dest
);
3101 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3102 builtin_strncpy_read_str
,
3103 (void *) p
, dest_align
, 0);
3104 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3105 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3112 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3113 bytes from constant string DATA + OFFSET and return it as target
3117 builtin_memset_read_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3118 enum machine_mode mode
)
3120 const char *c
= (const char *) data
;
3121 char *p
= alloca (GET_MODE_SIZE (mode
));
3123 memset (p
, *c
, GET_MODE_SIZE (mode
));
3125 return c_readstr (p
, mode
);
3128 /* Callback routine for store_by_pieces. Return the RTL of a register
3129 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3130 char value given in the RTL register data. For example, if mode is
3131 4 bytes wide, return the RTL for 0x01010101*data. */
3134 builtin_memset_gen_str (void *data
, HOST_WIDE_INT offset ATTRIBUTE_UNUSED
,
3135 enum machine_mode mode
)
3141 size
= GET_MODE_SIZE (mode
);
3146 memset (p
, 1, size
);
3147 coeff
= c_readstr (p
, mode
);
3149 target
= convert_to_mode (mode
, (rtx
) data
, 1);
3150 target
= expand_mult (mode
, target
, coeff
, NULL_RTX
, 1);
3151 return force_reg (mode
, target
);
3154 /* Expand expression EXP, which is a call to the memset builtin. Return 0
3155 if we failed the caller should emit a normal call, otherwise try to get
3156 the result in TARGET, if convenient (and in mode MODE if that's
3160 expand_builtin_memset (tree arglist
, rtx target
, enum machine_mode mode
)
3162 if (!validate_arglist (arglist
,
3163 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3167 tree dest
= TREE_VALUE (arglist
);
3168 tree val
= TREE_VALUE (TREE_CHAIN (arglist
));
3169 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3172 unsigned int dest_align
3173 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
3174 rtx dest_mem
, dest_addr
, len_rtx
;
3176 /* If DEST is not a pointer type, don't do this
3177 operation in-line. */
3178 if (dest_align
== 0)
3181 /* If the LEN parameter is zero, return DEST. */
3182 if (integer_zerop (len
))
3184 /* Evaluate and ignore VAL in case it has side-effects. */
3185 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3186 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
3189 if (TREE_CODE (val
) != INTEGER_CST
)
3193 if (!host_integerp (len
, 1))
3196 if (optimize_size
&& tree_low_cst (len
, 1) > 1)
3199 /* Assume that we can memset by pieces if we can store the
3200 * the coefficients by pieces (in the required modes).
3201 * We can't pass builtin_memset_gen_str as that emits RTL. */
3203 if (!can_store_by_pieces (tree_low_cst (len
, 1),
3204 builtin_memset_read_str
,
3208 val
= fold (build1 (CONVERT_EXPR
, unsigned_char_type_node
, val
));
3209 val_rtx
= expand_expr (val
, NULL_RTX
, VOIDmode
, 0);
3210 val_rtx
= force_reg (TYPE_MODE (unsigned_char_type_node
),
3212 dest_mem
= get_memory_rtx (dest
);
3213 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3214 builtin_memset_gen_str
,
3215 val_rtx
, dest_align
, 0);
3216 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3217 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3221 if (target_char_cast (val
, &c
))
3226 if (!host_integerp (len
, 1))
3228 if (!can_store_by_pieces (tree_low_cst (len
, 1),
3229 builtin_memset_read_str
, &c
,
3233 dest_mem
= get_memory_rtx (dest
);
3234 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
3235 builtin_memset_read_str
,
3237 dest_mem
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3238 dest_mem
= convert_memory_address (ptr_mode
, dest_mem
);
3242 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3244 dest_mem
= get_memory_rtx (dest
);
3245 set_mem_align (dest_mem
, dest_align
);
3246 dest_addr
= clear_storage (dest_mem
, len_rtx
);
3250 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
3251 dest_addr
= convert_memory_address (ptr_mode
, dest_addr
);
3258 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3259 if we failed the caller should emit a normal call. */
3262 expand_builtin_bzero (tree arglist
)
3264 tree dest
, size
, newarglist
;
3266 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3269 dest
= TREE_VALUE (arglist
);
3270 size
= TREE_VALUE (TREE_CHAIN (arglist
));
3272 /* New argument list transforming bzero(ptr x, int y) to
3273 memset(ptr x, int 0, size_t y). This is done this way
3274 so that if it isn't expanded inline, we fallback to
3275 calling bzero instead of memset. */
3277 newarglist
= build_tree_list (NULL_TREE
, fold_convert (sizetype
, size
));
3278 newarglist
= tree_cons (NULL_TREE
, integer_zero_node
, newarglist
);
3279 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
3281 return expand_builtin_memset (newarglist
, const0_rtx
, VOIDmode
);
3284 /* Expand expression EXP, which is a call to the memcmp built-in function.
3285 ARGLIST is the argument list for this call. Return 0 if we failed and the
3286 caller should emit a normal call, otherwise try to get the result in
3287 TARGET, if convenient (and in mode MODE, if that's convenient). */
3290 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED
, tree arglist
, rtx target
,
3291 enum machine_mode mode
)
3293 if (!validate_arglist (arglist
,
3294 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3298 tree result
= fold_builtin_memcmp (arglist
);
3300 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3303 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrsi
3305 tree arg1
= TREE_VALUE (arglist
);
3306 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3307 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3308 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3313 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3315 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3316 enum machine_mode insn_mode
;
3318 #ifdef HAVE_cmpmemsi
3320 insn_mode
= insn_data
[(int) CODE_FOR_cmpmemsi
].operand
[0].mode
;
3323 #ifdef HAVE_cmpstrsi
3325 insn_mode
= insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3330 /* If we don't have POINTER_TYPE, call the function. */
3331 if (arg1_align
== 0 || arg2_align
== 0)
3334 /* Make a place to write the result of the instruction. */
3337 && REG_P (result
) && GET_MODE (result
) == insn_mode
3338 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3339 result
= gen_reg_rtx (insn_mode
);
3341 arg1_rtx
= get_memory_rtx (arg1
);
3342 arg2_rtx
= get_memory_rtx (arg2
);
3343 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3345 /* Set MEM_SIZE as appropriate. */
3346 if (GET_CODE (arg3_rtx
) == CONST_INT
)
3348 set_mem_size (arg1_rtx
, arg3_rtx
);
3349 set_mem_size (arg2_rtx
, arg3_rtx
);
3352 #ifdef HAVE_cmpmemsi
3354 insn
= gen_cmpmemsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3355 GEN_INT (MIN (arg1_align
, arg2_align
)));
3358 #ifdef HAVE_cmpstrsi
3360 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3361 GEN_INT (MIN (arg1_align
, arg2_align
)));
3369 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE_MAKE_BLOCK
,
3370 TYPE_MODE (integer_type_node
), 3,
3371 XEXP (arg1_rtx
, 0), Pmode
,
3372 XEXP (arg2_rtx
, 0), Pmode
,
3373 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
3374 TYPE_UNSIGNED (sizetype
)),
3375 TYPE_MODE (sizetype
));
3377 /* Return the value in the proper mode for this function. */
3378 mode
= TYPE_MODE (TREE_TYPE (exp
));
3379 if (GET_MODE (result
) == mode
)
3381 else if (target
!= 0)
3383 convert_move (target
, result
, 0);
3387 return convert_to_mode (mode
, result
, 0);
3394 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3395 if we failed the caller should emit a normal call, otherwise try to get
3396 the result in TARGET, if convenient. */
3399 expand_builtin_strcmp (tree exp
, rtx target
, enum machine_mode mode
)
3401 tree arglist
= TREE_OPERAND (exp
, 1);
3403 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3407 tree result
= fold_builtin_strcmp (arglist
);
3409 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3412 #ifdef HAVE_cmpstrsi
3415 tree arg1
= TREE_VALUE (arglist
);
3416 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3417 tree len
, len1
, len2
;
3418 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3423 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3425 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3426 enum machine_mode insn_mode
3427 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3429 len1
= c_strlen (arg1
, 1);
3430 len2
= c_strlen (arg2
, 1);
3433 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3435 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3437 /* If we don't have a constant length for the first, use the length
3438 of the second, if we know it. We don't require a constant for
3439 this case; some cost analysis could be done if both are available
3440 but neither is constant. For now, assume they're equally cheap,
3441 unless one has side effects. If both strings have constant lengths,
3448 else if (TREE_SIDE_EFFECTS (len1
))
3450 else if (TREE_SIDE_EFFECTS (len2
))
3452 else if (TREE_CODE (len1
) != INTEGER_CST
)
3454 else if (TREE_CODE (len2
) != INTEGER_CST
)
3456 else if (tree_int_cst_lt (len1
, len2
))
3461 /* If both arguments have side effects, we cannot optimize. */
3462 if (!len
|| TREE_SIDE_EFFECTS (len
))
3465 /* If we don't have POINTER_TYPE, call the function. */
3466 if (arg1_align
== 0 || arg2_align
== 0)
3469 /* Make a place to write the result of the instruction. */
3472 && REG_P (result
) && GET_MODE (result
) == insn_mode
3473 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3474 result
= gen_reg_rtx (insn_mode
);
3476 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3477 arg1
= builtin_save_expr (arg1
);
3478 arg2
= builtin_save_expr (arg2
);
3480 arg1_rtx
= get_memory_rtx (arg1
);
3481 arg2_rtx
= get_memory_rtx (arg2
);
3482 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3483 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3484 GEN_INT (MIN (arg1_align
, arg2_align
)));
3489 /* Return the value in the proper mode for this function. */
3490 mode
= TYPE_MODE (TREE_TYPE (exp
));
3491 if (GET_MODE (result
) == mode
)
3494 return convert_to_mode (mode
, result
, 0);
3495 convert_move (target
, result
, 0);
3499 /* Expand the library call ourselves using a stabilized argument
3500 list to avoid re-evaluating the function's arguments twice. */
3501 arglist
= build_tree_list (NULL_TREE
, arg2
);
3502 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3503 fndecl
= get_callee_fndecl (exp
);
3504 exp
= build_function_call_expr (fndecl
, arglist
);
3505 return expand_call (exp
, target
, target
== const0_rtx
);
3511 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3512 if we failed the caller should emit a normal call, otherwise try to get
3513 the result in TARGET, if convenient. */
3516 expand_builtin_strncmp (tree exp
, rtx target
, enum machine_mode mode
)
3518 tree arglist
= TREE_OPERAND (exp
, 1);
3520 if (!validate_arglist (arglist
,
3521 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3525 tree result
= fold_builtin_strncmp (arglist
);
3527 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3530 /* If c_strlen can determine an expression for one of the string
3531 lengths, and it doesn't have side effects, then emit cmpstrsi
3532 using length MIN(strlen(string)+1, arg3). */
3533 #ifdef HAVE_cmpstrsi
3536 tree arg1
= TREE_VALUE (arglist
);
3537 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
3538 tree arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
3539 tree len
, len1
, len2
;
3540 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
3545 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3547 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
3548 enum machine_mode insn_mode
3549 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
3551 len1
= c_strlen (arg1
, 1);
3552 len2
= c_strlen (arg2
, 1);
3555 len1
= size_binop (PLUS_EXPR
, ssize_int (1), len1
);
3557 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
3559 /* If we don't have a constant length for the first, use the length
3560 of the second, if we know it. We don't require a constant for
3561 this case; some cost analysis could be done if both are available
3562 but neither is constant. For now, assume they're equally cheap,
3563 unless one has side effects. If both strings have constant lengths,
3570 else if (TREE_SIDE_EFFECTS (len1
))
3572 else if (TREE_SIDE_EFFECTS (len2
))
3574 else if (TREE_CODE (len1
) != INTEGER_CST
)
3576 else if (TREE_CODE (len2
) != INTEGER_CST
)
3578 else if (tree_int_cst_lt (len1
, len2
))
3583 /* If both arguments have side effects, we cannot optimize. */
3584 if (!len
|| TREE_SIDE_EFFECTS (len
))
3587 /* The actual new length parameter is MIN(len,arg3). */
3588 len
= fold (build2 (MIN_EXPR
, TREE_TYPE (len
), len
,
3589 fold_convert (TREE_TYPE (len
), arg3
)));
3591 /* If we don't have POINTER_TYPE, call the function. */
3592 if (arg1_align
== 0 || arg2_align
== 0)
3595 /* Make a place to write the result of the instruction. */
3598 && REG_P (result
) && GET_MODE (result
) == insn_mode
3599 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
3600 result
= gen_reg_rtx (insn_mode
);
3602 /* Stabilize the arguments in case gen_cmpstrsi fails. */
3603 arg1
= builtin_save_expr (arg1
);
3604 arg2
= builtin_save_expr (arg2
);
3605 len
= builtin_save_expr (len
);
3607 arg1_rtx
= get_memory_rtx (arg1
);
3608 arg2_rtx
= get_memory_rtx (arg2
);
3609 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
3610 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
3611 GEN_INT (MIN (arg1_align
, arg2_align
)));
3616 /* Return the value in the proper mode for this function. */
3617 mode
= TYPE_MODE (TREE_TYPE (exp
));
3618 if (GET_MODE (result
) == mode
)
3621 return convert_to_mode (mode
, result
, 0);
3622 convert_move (target
, result
, 0);
3626 /* Expand the library call ourselves using a stabilized argument
3627 list to avoid re-evaluating the function's arguments twice. */
3628 arglist
= build_tree_list (NULL_TREE
, len
);
3629 arglist
= tree_cons (NULL_TREE
, arg2
, arglist
);
3630 arglist
= tree_cons (NULL_TREE
, arg1
, arglist
);
3631 fndecl
= get_callee_fndecl (exp
);
3632 exp
= build_function_call_expr (fndecl
, arglist
);
3633 return expand_call (exp
, target
, target
== const0_rtx
);
3639 /* Expand expression EXP, which is a call to the strcat builtin.
3640 Return 0 if we failed the caller should emit a normal call,
3641 otherwise try to get the result in TARGET, if convenient. */
3644 expand_builtin_strcat (tree arglist
, tree type
, rtx target
, enum machine_mode mode
)
3646 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3650 tree dst
= TREE_VALUE (arglist
),
3651 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3652 const char *p
= c_getstr (src
);
3656 /* If the string length is zero, return the dst parameter. */
3658 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3659 else if (!optimize_size
)
3661 /* Otherwise if !optimize_size, see if we can store by
3662 pieces into (dst + strlen(dst)). */
3663 tree newdst
, arglist
,
3664 strlen_fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
3666 /* This is the length argument. */
3667 arglist
= build_tree_list (NULL_TREE
,
3668 fold (size_binop (PLUS_EXPR
,
3671 /* Prepend src argument. */
3672 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
3674 /* We're going to use dst more than once. */
3675 dst
= builtin_save_expr (dst
);
3677 /* Create strlen (dst). */
3679 fold (build_function_call_expr (strlen_fn
,
3680 build_tree_list (NULL_TREE
,
3682 /* Create (dst + strlen (dst)). */
3683 newdst
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dst
), dst
, newdst
));
3685 /* Prepend the new dst argument. */
3686 arglist
= tree_cons (NULL_TREE
, newdst
, arglist
);
3688 /* We don't want to get turned into a memcpy if the
3689 target is const0_rtx, i.e. when the return value
3690 isn't used. That would produce pessimized code so
3691 pass in a target of zero, it should never actually be
3692 used. If this was successful return the original
3693 dst, not the result of mempcpy. */
3694 if (expand_builtin_mempcpy (arglist
, type
, /*target=*/0, mode
, /*endp=*/0))
3695 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
3705 /* Expand expression EXP, which is a call to the strncat builtin.
3706 Return 0 if we failed the caller should emit a normal call,
3707 otherwise try to get the result in TARGET, if convenient. */
3710 expand_builtin_strncat (tree arglist
, rtx target
, enum machine_mode mode
)
3712 if (validate_arglist (arglist
,
3713 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3715 tree result
= fold_builtin_strncat (arglist
);
3717 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3722 /* Expand expression EXP, which is a call to the strspn builtin.
3723 Return 0 if we failed the caller should emit a normal call,
3724 otherwise try to get the result in TARGET, if convenient. */
3727 expand_builtin_strspn (tree arglist
, rtx target
, enum machine_mode mode
)
3729 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3731 tree result
= fold_builtin_strspn (arglist
);
3733 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3738 /* Expand expression EXP, which is a call to the strcspn builtin.
3739 Return 0 if we failed the caller should emit a normal call,
3740 otherwise try to get the result in TARGET, if convenient. */
3743 expand_builtin_strcspn (tree arglist
, rtx target
, enum machine_mode mode
)
3745 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3747 tree result
= fold_builtin_strcspn (arglist
);
3749 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
3754 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
3755 if that's convenient. */
3758 expand_builtin_saveregs (void)
3762 /* Don't do __builtin_saveregs more than once in a function.
3763 Save the result of the first call and reuse it. */
3764 if (saveregs_value
!= 0)
3765 return saveregs_value
;
3767 /* When this function is called, it means that registers must be
3768 saved on entry to this function. So we migrate the call to the
3769 first insn of this function. */
3773 /* Do whatever the machine needs done in this case. */
3774 val
= targetm
.calls
.expand_builtin_saveregs ();
3779 saveregs_value
= val
;
3781 /* Put the insns after the NOTE that starts the function. If this
3782 is inside a start_sequence, make the outer-level insn chain current, so
3783 the code is placed at the start of the function. */
3784 push_topmost_sequence ();
3785 emit_insn_after (seq
, entry_of_function ());
3786 pop_topmost_sequence ();
3791 /* __builtin_args_info (N) returns word N of the arg space info
3792 for the current function. The number and meanings of words
3793 is controlled by the definition of CUMULATIVE_ARGS. */
3796 expand_builtin_args_info (tree arglist
)
3798 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
3799 int *word_ptr
= (int *) ¤t_function_args_info
;
3801 gcc_assert (sizeof (CUMULATIVE_ARGS
) % sizeof (int) == 0);
3805 if (!host_integerp (TREE_VALUE (arglist
), 0))
3806 error ("argument of %<__builtin_args_info%> must be constant");
3809 HOST_WIDE_INT wordnum
= tree_low_cst (TREE_VALUE (arglist
), 0);
3811 if (wordnum
< 0 || wordnum
>= nwords
)
3812 error ("argument of %<__builtin_args_info%> out of range");
3814 return GEN_INT (word_ptr
[wordnum
]);
3818 error ("missing argument in %<__builtin_args_info%>");
3823 /* Expand a call to __builtin_next_arg. */
3826 expand_builtin_next_arg (void)
3828 /* Checking arguments is already done in fold_builtin_next_arg
3829 that must be called before this function. */
3830 return expand_binop (Pmode
, add_optab
,
3831 current_function_internal_arg_pointer
,
3832 current_function_arg_offset_rtx
,
3833 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
3836 /* Make it easier for the backends by protecting the valist argument
3837 from multiple evaluations. */
3840 stabilize_va_list (tree valist
, int needs_lvalue
)
3842 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3844 if (TREE_SIDE_EFFECTS (valist
))
3845 valist
= save_expr (valist
);
3847 /* For this case, the backends will be expecting a pointer to
3848 TREE_TYPE (va_list_type_node), but it's possible we've
3849 actually been given an array (an actual va_list_type_node).
3851 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
3853 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
3854 valist
= build_fold_addr_expr_with_type (valist
, p1
);
3863 if (! TREE_SIDE_EFFECTS (valist
))
3866 pt
= build_pointer_type (va_list_type_node
);
3867 valist
= fold (build1 (ADDR_EXPR
, pt
, valist
));
3868 TREE_SIDE_EFFECTS (valist
) = 1;
3871 if (TREE_SIDE_EFFECTS (valist
))
3872 valist
= save_expr (valist
);
3873 valist
= build_fold_indirect_ref (valist
);
3879 /* The "standard" definition of va_list is void*. */
3882 std_build_builtin_va_list (void)
3884 return ptr_type_node
;
3887 /* The "standard" implementation of va_start: just assign `nextarg' to
3891 std_expand_builtin_va_start (tree valist
, rtx nextarg
)
3895 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
3896 make_tree (ptr_type_node
, nextarg
));
3897 TREE_SIDE_EFFECTS (t
) = 1;
3899 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3902 /* Expand ARGLIST, from a call to __builtin_va_start. */
3905 expand_builtin_va_start (tree arglist
)
3910 chain
= TREE_CHAIN (arglist
);
3914 error ("too few arguments to function %<va_start%>");
3918 if (fold_builtin_next_arg (chain
))
3921 nextarg
= expand_builtin_next_arg ();
3922 valist
= stabilize_va_list (TREE_VALUE (arglist
), 1);
3924 #ifdef EXPAND_BUILTIN_VA_START
3925 EXPAND_BUILTIN_VA_START (valist
, nextarg
);
3927 std_expand_builtin_va_start (valist
, nextarg
);
3933 /* The "standard" implementation of va_arg: read the value from the
3934 current (padded) address and increment by the (padded) size. */
3937 std_gimplify_va_arg_expr (tree valist
, tree type
, tree
*pre_p
, tree
*post_p
)
3939 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
3940 unsigned HOST_WIDE_INT align
, boundary
;
3943 #ifdef ARGS_GROW_DOWNWARD
3944 /* All of the alignment and movement below is for args-grow-up machines.
3945 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
3946 implement their own specialized gimplify_va_arg_expr routines. */
3950 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
3952 type
= build_pointer_type (type
);
3954 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
3955 boundary
= FUNCTION_ARG_BOUNDARY (TYPE_MODE (type
), type
) / BITS_PER_UNIT
;
3957 /* Hoist the valist value into a temporary for the moment. */
3958 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
3960 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
3961 requires greater alignment, we must perform dynamic alignment. */
3962 if (boundary
> align
)
3964 t
= fold_convert (TREE_TYPE (valist
), size_int (boundary
- 1));
3965 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
3966 build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
3967 gimplify_and_add (t
, pre_p
);
3969 t
= fold_convert (TREE_TYPE (valist
), size_int (-boundary
));
3970 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
3971 build2 (BIT_AND_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
));
3972 gimplify_and_add (t
, pre_p
);
3977 /* If the actual alignment is less than the alignment of the type,
3978 adjust the type accordingly so that we don't assume strict alignment
3979 when deferencing the pointer. */
3980 boundary
*= BITS_PER_UNIT
;
3981 if (boundary
< TYPE_ALIGN (type
))
3983 type
= build_variant_type_copy (type
);
3984 TYPE_ALIGN (type
) = boundary
;
3987 /* Compute the rounded size of the type. */
3988 type_size
= size_in_bytes (type
);
3989 rounded_size
= round_up (type_size
, align
);
3991 /* Reduce rounded_size so it's sharable with the postqueue. */
3992 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
3996 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
3998 /* Small args are padded downward. */
3999 t
= fold (build2 (GT_EXPR
, sizetype
, rounded_size
, size_int (align
)));
4000 t
= fold (build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
4001 size_binop (MINUS_EXPR
, rounded_size
, type_size
)));
4002 t
= fold_convert (TREE_TYPE (addr
), t
);
4003 addr
= fold (build2 (PLUS_EXPR
, TREE_TYPE (addr
), addr
, t
));
4006 /* Compute new value for AP. */
4007 t
= fold_convert (TREE_TYPE (valist
), rounded_size
);
4008 t
= build2 (PLUS_EXPR
, TREE_TYPE (valist
), valist_tmp
, t
);
4009 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
4010 gimplify_and_add (t
, pre_p
);
4012 addr
= fold_convert (build_pointer_type (type
), addr
);
4015 addr
= build_va_arg_indirect_ref (addr
);
4017 return build_va_arg_indirect_ref (addr
);
4020 /* Build an indirect-ref expression over the given TREE, which represents a
4021 piece of a va_arg() expansion. */
4023 build_va_arg_indirect_ref (tree addr
)
4025 addr
= build_fold_indirect_ref (addr
);
4027 if (flag_mudflap
) /* Don't instrument va_arg INDIRECT_REF. */
4033 /* Return a dummy expression of type TYPE in order to keep going after an
4037 dummy_object (tree type
)
4039 tree t
= convert (build_pointer_type (type
), null_pointer_node
);
4040 return build1 (INDIRECT_REF
, type
, t
);
4043 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4044 builtin function, but a very special sort of operator. */
4046 enum gimplify_status
4047 gimplify_va_arg_expr (tree
*expr_p
, tree
*pre_p
, tree
*post_p
)
4049 tree promoted_type
, want_va_type
, have_va_type
;
4050 tree valist
= TREE_OPERAND (*expr_p
, 0);
4051 tree type
= TREE_TYPE (*expr_p
);
4054 /* Verify that valist is of the proper type. */
4055 want_va_type
= va_list_type_node
;
4056 have_va_type
= TREE_TYPE (valist
);
4058 if (have_va_type
== error_mark_node
)
4061 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
4063 /* If va_list is an array type, the argument may have decayed
4064 to a pointer type, e.g. by being passed to another function.
4065 In that case, unwrap both types so that we can compare the
4066 underlying records. */
4067 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
4068 || POINTER_TYPE_P (have_va_type
))
4070 want_va_type
= TREE_TYPE (want_va_type
);
4071 have_va_type
= TREE_TYPE (have_va_type
);
4075 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
4077 error ("first argument to %<va_arg%> not of type %<va_list%>");
4081 /* Generate a diagnostic for requesting data of a type that cannot
4082 be passed through `...' due to type promotion at the call site. */
4083 else if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
4086 static bool gave_help
;
4088 /* Unfortunately, this is merely undefined, rather than a constraint
4089 violation, so we cannot make this an error. If this call is never
4090 executed, the program is still strictly conforming. */
4091 warning ("%qT is promoted to %qT when passed through %<...%>",
4092 type
, promoted_type
);
4096 warning ("(so you should pass %qT not %qT to %<va_arg%>)",
4097 promoted_type
, type
);
4100 /* We can, however, treat "undefined" any way we please.
4101 Call abort to encourage the user to fix the program. */
4102 inform ("if this code is reached, the program will abort");
4103 t
= build_function_call_expr (implicit_built_in_decls
[BUILT_IN_TRAP
],
4105 append_to_statement_list (t
, pre_p
);
4107 /* This is dead code, but go ahead and finish so that the
4108 mode of the result comes out right. */
4109 *expr_p
= dummy_object (type
);
4114 /* Make it easier for the backends by protecting the valist argument
4115 from multiple evaluations. */
4116 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4118 /* For this case, the backends will be expecting a pointer to
4119 TREE_TYPE (va_list_type_node), but it's possible we've
4120 actually been given an array (an actual va_list_type_node).
4122 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
4124 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
4125 valist
= build_fold_addr_expr_with_type (valist
, p1
);
4127 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
4130 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
4132 if (!targetm
.gimplify_va_arg_expr
)
4133 /* Once most targets are converted this should abort. */
4136 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
4141 /* Expand ARGLIST, from a call to __builtin_va_end. */
4144 expand_builtin_va_end (tree arglist
)
4146 tree valist
= TREE_VALUE (arglist
);
4148 /* Evaluate for side effects, if needed. I hate macros that don't
4150 if (TREE_SIDE_EFFECTS (valist
))
4151 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4156 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4157 builtin rather than just as an assignment in stdarg.h because of the
4158 nastiness of array-type va_list types. */
4161 expand_builtin_va_copy (tree arglist
)
4165 dst
= TREE_VALUE (arglist
);
4166 src
= TREE_VALUE (TREE_CHAIN (arglist
));
4168 dst
= stabilize_va_list (dst
, 1);
4169 src
= stabilize_va_list (src
, 0);
4171 if (TREE_CODE (va_list_type_node
) != ARRAY_TYPE
)
4173 t
= build2 (MODIFY_EXPR
, va_list_type_node
, dst
, src
);
4174 TREE_SIDE_EFFECTS (t
) = 1;
4175 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4179 rtx dstb
, srcb
, size
;
4181 /* Evaluate to pointers. */
4182 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4183 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
4184 size
= expand_expr (TYPE_SIZE_UNIT (va_list_type_node
), NULL_RTX
,
4185 VOIDmode
, EXPAND_NORMAL
);
4187 dstb
= convert_memory_address (Pmode
, dstb
);
4188 srcb
= convert_memory_address (Pmode
, srcb
);
4190 /* "Dereference" to BLKmode memories. */
4191 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
4192 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
4193 set_mem_align (dstb
, TYPE_ALIGN (va_list_type_node
));
4194 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
4195 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
4196 set_mem_align (srcb
, TYPE_ALIGN (va_list_type_node
));
4199 emit_block_move (dstb
, srcb
, size
, BLOCK_OP_NORMAL
);
4205 /* Expand a call to one of the builtin functions __builtin_frame_address or
4206 __builtin_return_address. */
4209 expand_builtin_frame_address (tree fndecl
, tree arglist
)
4211 /* The argument must be a nonnegative integer constant.
4212 It counts the number of frames to scan up the stack.
4213 The value is the return address saved in that frame. */
4215 /* Warning about missing arg was already issued. */
4217 else if (! host_integerp (TREE_VALUE (arglist
), 1))
4219 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4220 error ("invalid argument to %<__builtin_frame_address%>");
4222 error ("invalid argument to %<__builtin_return_address%>");
4228 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
4229 tree_low_cst (TREE_VALUE (arglist
), 1));
4231 /* Some ports cannot access arbitrary stack frames. */
4234 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4235 warning ("unsupported argument to %<__builtin_frame_address%>");
4237 warning ("unsupported argument to %<__builtin_return_address%>");
4241 /* For __builtin_frame_address, return what we've got. */
4242 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
4246 && ! CONSTANT_P (tem
))
4247 tem
= copy_to_mode_reg (Pmode
, tem
);
4252 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4253 we failed and the caller should emit a normal call, otherwise try to get
4254 the result in TARGET, if convenient. */
4257 expand_builtin_alloca (tree arglist
, rtx target
)
4262 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4263 should always expand to function calls. These can be intercepted
4268 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4271 /* Compute the argument. */
4272 op0
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
4274 /* Allocate the desired space. */
4275 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
4276 result
= convert_memory_address (ptr_mode
, result
);
4281 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4282 Return 0 if a normal call should be emitted rather than expanding the
4283 function in-line. If convenient, the result should be placed in TARGET.
4284 SUBTARGET may be used as the target for computing one of EXP's operands. */
4287 expand_builtin_unop (enum machine_mode target_mode
, tree arglist
, rtx target
,
4288 rtx subtarget
, optab op_optab
)
4291 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
4294 /* Compute the argument. */
4295 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4296 /* Compute op, into TARGET if possible.
4297 Set TARGET to wherever the result comes back. */
4298 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4299 op_optab
, op0
, target
, 1);
4300 gcc_assert (target
);
4302 return convert_to_mode (target_mode
, target
, 0);
4305 /* If the string passed to fputs is a constant and is one character
4306 long, we attempt to transform this call into __builtin_fputc(). */
4309 expand_builtin_fputs (tree arglist
, rtx target
, bool unlocked
)
4311 /* Verify the arguments in the original call. */
4312 if (validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
4314 tree result
= fold_builtin_fputs (arglist
, (target
== const0_rtx
),
4315 unlocked
, NULL_TREE
);
4317 return expand_expr (result
, target
, VOIDmode
, EXPAND_NORMAL
);
4322 /* Expand a call to __builtin_expect. We return our argument and emit a
4323 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4324 a non-jump context. */
4327 expand_builtin_expect (tree arglist
, rtx target
)
4332 if (arglist
== NULL_TREE
4333 || TREE_CHAIN (arglist
) == NULL_TREE
)
4335 exp
= TREE_VALUE (arglist
);
4336 c
= TREE_VALUE (TREE_CHAIN (arglist
));
4338 if (TREE_CODE (c
) != INTEGER_CST
)
4340 error ("second argument to %<__builtin_expect%> must be a constant");
4341 c
= integer_zero_node
;
4344 target
= expand_expr (exp
, target
, VOIDmode
, EXPAND_NORMAL
);
4346 /* Don't bother with expected value notes for integral constants. */
4347 if (flag_guess_branch_prob
&& GET_CODE (target
) != CONST_INT
)
4349 /* We do need to force this into a register so that we can be
4350 moderately sure to be able to correctly interpret the branch
4352 target
= force_reg (GET_MODE (target
), target
);
4354 rtx_c
= expand_expr (c
, NULL_RTX
, GET_MODE (target
), EXPAND_NORMAL
);
4356 note
= emit_note (NOTE_INSN_EXPECTED_VALUE
);
4357 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, target
, rtx_c
);
4363 /* Like expand_builtin_expect, except do this in a jump context. This is
4364 called from do_jump if the conditional is a __builtin_expect. Return either
4365 a list of insns to emit the jump or NULL if we cannot optimize
4366 __builtin_expect. We need to optimize this at jump time so that machines
4367 like the PowerPC don't turn the test into a SCC operation, and then jump
4368 based on the test being 0/1. */
4371 expand_builtin_expect_jump (tree exp
, rtx if_false_label
, rtx if_true_label
)
4373 tree arglist
= TREE_OPERAND (exp
, 1);
4374 tree arg0
= TREE_VALUE (arglist
);
4375 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
4378 /* Only handle __builtin_expect (test, 0) and
4379 __builtin_expect (test, 1). */
4380 if (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
4381 && (integer_zerop (arg1
) || integer_onep (arg1
)))
4383 rtx insn
, drop_through_label
, temp
;
4385 /* Expand the jump insns. */
4387 do_jump (arg0
, if_false_label
, if_true_label
);
4390 drop_through_label
= get_last_insn ();
4391 if (drop_through_label
&& NOTE_P (drop_through_label
))
4392 drop_through_label
= prev_nonnote_insn (drop_through_label
);
4393 if (drop_through_label
&& !LABEL_P (drop_through_label
))
4394 drop_through_label
= NULL_RTX
;
4397 if (! if_true_label
)
4398 if_true_label
= drop_through_label
;
4399 if (! if_false_label
)
4400 if_false_label
= drop_through_label
;
4402 /* Go through and add the expect's to each of the conditional jumps. */
4404 while (insn
!= NULL_RTX
)
4406 rtx next
= NEXT_INSN (insn
);
4408 if (JUMP_P (insn
) && any_condjump_p (insn
))
4410 rtx ifelse
= SET_SRC (pc_set (insn
));
4411 rtx then_dest
= XEXP (ifelse
, 1);
4412 rtx else_dest
= XEXP (ifelse
, 2);
4415 /* First check if we recognize any of the labels. */
4416 if (GET_CODE (then_dest
) == LABEL_REF
4417 && XEXP (then_dest
, 0) == if_true_label
)
4419 else if (GET_CODE (then_dest
) == LABEL_REF
4420 && XEXP (then_dest
, 0) == if_false_label
)
4422 else if (GET_CODE (else_dest
) == LABEL_REF
4423 && XEXP (else_dest
, 0) == if_false_label
)
4425 else if (GET_CODE (else_dest
) == LABEL_REF
4426 && XEXP (else_dest
, 0) == if_true_label
)
4428 /* Otherwise check where we drop through. */
4429 else if (else_dest
== pc_rtx
)
4431 if (next
&& NOTE_P (next
))
4432 next
= next_nonnote_insn (next
);
4434 if (next
&& JUMP_P (next
)
4435 && any_uncondjump_p (next
))
4436 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4440 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4441 else that can't possibly match either target label. */
4442 if (temp
== if_false_label
)
4444 else if (temp
== if_true_label
)
4447 else if (then_dest
== pc_rtx
)
4449 if (next
&& NOTE_P (next
))
4450 next
= next_nonnote_insn (next
);
4452 if (next
&& JUMP_P (next
)
4453 && any_uncondjump_p (next
))
4454 temp
= XEXP (SET_SRC (pc_set (next
)), 0);
4458 if (temp
== if_false_label
)
4460 else if (temp
== if_true_label
)
4466 /* If the test is expected to fail, reverse the
4468 if (integer_zerop (arg1
))
4470 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, taken
);
4482 expand_builtin_trap (void)
4486 emit_insn (gen_trap ());
4489 emit_library_call (abort_libfunc
, LCT_NORETURN
, VOIDmode
, 0);
4493 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4494 Return 0 if a normal call should be emitted rather than expanding
4495 the function inline. If convenient, the result should be placed
4496 in TARGET. SUBTARGET may be used as the target for computing
4500 expand_builtin_fabs (tree arglist
, rtx target
, rtx subtarget
)
4502 enum machine_mode mode
;
4506 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
4509 arg
= TREE_VALUE (arglist
);
4510 mode
= TYPE_MODE (TREE_TYPE (arg
));
4511 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4512 return expand_abs (mode
, op0
, target
, 0, safe_from_p (target
, arg
, 1));
4515 /* Expand a call to copysign, copysignf, or copysignl with arguments ARGLIST.
4516 Return NULL is a normal call should be emitted rather than expanding the
4517 function inline. If convenient, the result should be placed in TARGET.
4518 SUBTARGET may be used as the target for computing the operand. */
4521 expand_builtin_copysign (tree arglist
, rtx target
, rtx subtarget
)
4526 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
4529 arg
= TREE_VALUE (arglist
);
4530 op0
= expand_expr (arg
, subtarget
, VOIDmode
, 0);
4532 arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4533 op1
= expand_expr (arg
, NULL
, VOIDmode
, 0);
4535 return expand_copysign (op0
, op1
, target
);
4538 /* Create a new constant string literal and return a char* pointer to it.
4539 The STRING_CST value is the LEN characters at STR. */
4541 build_string_literal (int len
, const char *str
)
4543 tree t
, elem
, index
, type
;
4545 t
= build_string (len
, str
);
4546 elem
= build_type_variant (char_type_node
, 1, 0);
4547 index
= build_index_type (build_int_cst (NULL_TREE
, len
- 1));
4548 type
= build_array_type (elem
, index
);
4549 TREE_TYPE (t
) = type
;
4550 TREE_CONSTANT (t
) = 1;
4551 TREE_INVARIANT (t
) = 1;
4552 TREE_READONLY (t
) = 1;
4553 TREE_STATIC (t
) = 1;
4555 type
= build_pointer_type (type
);
4556 t
= build1 (ADDR_EXPR
, type
, t
);
4558 type
= build_pointer_type (elem
);
4559 t
= build1 (NOP_EXPR
, type
, t
);
4563 /* Expand a call to printf or printf_unlocked with argument list ARGLIST.
4564 Return 0 if a normal call should be emitted rather than transforming
4565 the function inline. If convenient, the result should be placed in
4566 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4569 expand_builtin_printf (tree arglist
, rtx target
, enum machine_mode mode
,
4572 tree fn_putchar
= unlocked
4573 ? implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
]
4574 : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4575 tree fn_puts
= unlocked
? implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
]
4576 : implicit_built_in_decls
[BUILT_IN_PUTS
];
4577 const char *fmt_str
;
4580 /* If the return value is used, don't do the transformation. */
4581 if (target
!= const0_rtx
)
4584 /* Verify the required arguments in the original call. */
4587 fmt
= TREE_VALUE (arglist
);
4588 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4590 arglist
= TREE_CHAIN (arglist
);
4592 /* Check whether the format is a literal string constant. */
4593 fmt_str
= c_getstr (fmt
);
4594 if (fmt_str
== NULL
)
4597 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4598 if (strcmp (fmt_str
, "%s\n") == 0)
4601 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
4602 || TREE_CHAIN (arglist
))
4606 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4607 else if (strcmp (fmt_str
, "%c") == 0)
4610 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
4611 || TREE_CHAIN (arglist
))
4617 /* We can't handle anything else with % args or %% ... yet. */
4618 if (strchr (fmt_str
, '%'))
4624 /* If the format specifier was "", printf does nothing. */
4625 if (fmt_str
[0] == '\0')
4627 /* If the format specifier has length of 1, call putchar. */
4628 if (fmt_str
[1] == '\0')
4630 /* Given printf("c"), (where c is any one character,)
4631 convert "c"[0] to an int and pass that to the replacement
4633 arg
= build_int_cst (NULL_TREE
, fmt_str
[0]);
4634 arglist
= build_tree_list (NULL_TREE
, arg
);
4639 /* If the format specifier was "string\n", call puts("string"). */
4640 size_t len
= strlen (fmt_str
);
4641 if (fmt_str
[len
- 1] == '\n')
4643 /* Create a NUL-terminated string that's one char shorter
4644 than the original, stripping off the trailing '\n'. */
4645 char *newstr
= alloca (len
);
4646 memcpy (newstr
, fmt_str
, len
- 1);
4647 newstr
[len
- 1] = 0;
4649 arg
= build_string_literal (len
, newstr
);
4650 arglist
= build_tree_list (NULL_TREE
, arg
);
4654 /* We'd like to arrange to call fputs(string,stdout) here,
4655 but we need stdout and don't have a way to get it yet. */
4662 return expand_expr (build_function_call_expr (fn
, arglist
),
4663 target
, mode
, EXPAND_NORMAL
);
4666 /* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST.
4667 Return 0 if a normal call should be emitted rather than transforming
4668 the function inline. If convenient, the result should be placed in
4669 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4672 expand_builtin_fprintf (tree arglist
, rtx target
, enum machine_mode mode
,
4675 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
4676 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4677 tree fn_fputs
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
]
4678 : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4679 const char *fmt_str
;
4680 tree fn
, fmt
, fp
, arg
;
4682 /* If the return value is used, don't do the transformation. */
4683 if (target
!= const0_rtx
)
4686 /* Verify the required arguments in the original call. */
4689 fp
= TREE_VALUE (arglist
);
4690 if (! POINTER_TYPE_P (TREE_TYPE (fp
)))
4692 arglist
= TREE_CHAIN (arglist
);
4695 fmt
= TREE_VALUE (arglist
);
4696 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4698 arglist
= TREE_CHAIN (arglist
);
4700 /* Check whether the format is a literal string constant. */
4701 fmt_str
= c_getstr (fmt
);
4702 if (fmt_str
== NULL
)
4705 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
4706 if (strcmp (fmt_str
, "%s") == 0)
4709 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
)))
4710 || TREE_CHAIN (arglist
))
4712 arg
= TREE_VALUE (arglist
);
4713 arglist
= build_tree_list (NULL_TREE
, fp
);
4714 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
4717 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
4718 else if (strcmp (fmt_str
, "%c") == 0)
4721 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
4722 || TREE_CHAIN (arglist
))
4724 arg
= TREE_VALUE (arglist
);
4725 arglist
= build_tree_list (NULL_TREE
, fp
);
4726 arglist
= tree_cons (NULL_TREE
, arg
, arglist
);
4731 /* We can't handle anything else with % args or %% ... yet. */
4732 if (strchr (fmt_str
, '%'))
4738 /* If the format specifier was "", fprintf does nothing. */
4739 if (fmt_str
[0] == '\0')
4741 /* Evaluate and ignore FILE* argument for side-effects. */
4742 expand_expr (fp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4746 /* When "string" doesn't contain %, replace all cases of
4747 fprintf(stream,string) with fputs(string,stream). The fputs
4748 builtin will take care of special cases like length == 1. */
4749 arglist
= build_tree_list (NULL_TREE
, fp
);
4750 arglist
= tree_cons (NULL_TREE
, fmt
, arglist
);
4756 return expand_expr (build_function_call_expr (fn
, arglist
),
4757 target
, mode
, EXPAND_NORMAL
);
4760 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
4761 a normal call should be emitted rather than expanding the function
4762 inline. If convenient, the result should be placed in TARGET with
4766 expand_builtin_sprintf (tree arglist
, rtx target
, enum machine_mode mode
)
4768 tree orig_arglist
, dest
, fmt
;
4769 const char *fmt_str
;
4771 orig_arglist
= arglist
;
4773 /* Verify the required arguments in the original call. */
4776 dest
= TREE_VALUE (arglist
);
4777 if (! POINTER_TYPE_P (TREE_TYPE (dest
)))
4779 arglist
= TREE_CHAIN (arglist
);
4782 fmt
= TREE_VALUE (arglist
);
4783 if (! POINTER_TYPE_P (TREE_TYPE (fmt
)))
4785 arglist
= TREE_CHAIN (arglist
);
4787 /* Check whether the format is a literal string constant. */
4788 fmt_str
= c_getstr (fmt
);
4789 if (fmt_str
== NULL
)
4792 /* If the format doesn't contain % args or %%, use strcpy. */
4793 if (strchr (fmt_str
, '%') == 0)
4795 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
4798 if (arglist
|| ! fn
)
4800 expand_expr (build_function_call_expr (fn
, orig_arglist
),
4801 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4802 if (target
== const0_rtx
)
4804 exp
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
4805 return expand_expr (exp
, target
, mode
, EXPAND_NORMAL
);
4807 /* If the format is "%s", use strcpy if the result isn't used. */
4808 else if (strcmp (fmt_str
, "%s") == 0)
4811 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
4816 if (! arglist
|| TREE_CHAIN (arglist
))
4818 arg
= TREE_VALUE (arglist
);
4819 if (! POINTER_TYPE_P (TREE_TYPE (arg
)))
4822 if (target
!= const0_rtx
)
4824 len
= c_strlen (arg
, 1);
4825 if (! len
|| TREE_CODE (len
) != INTEGER_CST
)
4831 arglist
= build_tree_list (NULL_TREE
, arg
);
4832 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
4833 expand_expr (build_function_call_expr (fn
, arglist
),
4834 const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
4836 if (target
== const0_rtx
)
4838 return expand_expr (len
, target
, mode
, EXPAND_NORMAL
);
4844 /* Expand a call to either the entry or exit function profiler. */
4847 expand_builtin_profile_func (bool exitp
)
4851 this = DECL_RTL (current_function_decl
);
4852 gcc_assert (MEM_P (this));
4853 this = XEXP (this, 0);
4856 which
= profile_function_exit_libfunc
;
4858 which
= profile_function_entry_libfunc
;
4860 emit_library_call (which
, LCT_NORMAL
, VOIDmode
, 2, this, Pmode
,
4861 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
4868 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
4871 round_trampoline_addr (rtx tramp
)
4873 rtx temp
, addend
, mask
;
4875 /* If we don't need too much alignment, we'll have been guaranteed
4876 proper alignment by get_trampoline_type. */
4877 if (TRAMPOLINE_ALIGNMENT
<= STACK_BOUNDARY
)
4880 /* Round address up to desired boundary. */
4881 temp
= gen_reg_rtx (Pmode
);
4882 addend
= GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1);
4883 mask
= GEN_INT (-TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
4885 temp
= expand_simple_binop (Pmode
, PLUS
, tramp
, addend
,
4886 temp
, 0, OPTAB_LIB_WIDEN
);
4887 tramp
= expand_simple_binop (Pmode
, AND
, temp
, mask
,
4888 temp
, 0, OPTAB_LIB_WIDEN
);
4894 expand_builtin_init_trampoline (tree arglist
)
4896 tree t_tramp
, t_func
, t_chain
;
4897 rtx r_tramp
, r_func
, r_chain
;
4898 #ifdef TRAMPOLINE_TEMPLATE
4902 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
,
4903 POINTER_TYPE
, VOID_TYPE
))
4906 t_tramp
= TREE_VALUE (arglist
);
4907 arglist
= TREE_CHAIN (arglist
);
4908 t_func
= TREE_VALUE (arglist
);
4909 arglist
= TREE_CHAIN (arglist
);
4910 t_chain
= TREE_VALUE (arglist
);
4912 r_tramp
= expand_expr (t_tramp
, NULL_RTX
, VOIDmode
, 0);
4913 r_func
= expand_expr (t_func
, NULL_RTX
, VOIDmode
, 0);
4914 r_chain
= expand_expr (t_chain
, NULL_RTX
, VOIDmode
, 0);
4916 /* Generate insns to initialize the trampoline. */
4917 r_tramp
= round_trampoline_addr (r_tramp
);
4918 #ifdef TRAMPOLINE_TEMPLATE
4919 blktramp
= gen_rtx_MEM (BLKmode
, r_tramp
);
4920 set_mem_align (blktramp
, TRAMPOLINE_ALIGNMENT
);
4921 emit_block_move (blktramp
, assemble_trampoline_template (),
4922 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
4924 trampolines_created
= 1;
4925 INITIALIZE_TRAMPOLINE (r_tramp
, r_func
, r_chain
);
4931 expand_builtin_adjust_trampoline (tree arglist
)
4935 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
4938 tramp
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
4939 tramp
= round_trampoline_addr (tramp
);
4940 #ifdef TRAMPOLINE_ADJUST_ADDRESS
4941 TRAMPOLINE_ADJUST_ADDRESS (tramp
);
4947 /* Expand a call to the built-in signbit, signbitf or signbitl function.
4948 Return NULL_RTX if a normal call should be emitted rather than expanding
4949 the function in-line. EXP is the expression that is a call to the builtin
4950 function; if convenient, the result should be placed in TARGET. */
4953 expand_builtin_signbit (tree exp
, rtx target
)
4955 const struct real_format
*fmt
;
4956 enum machine_mode fmode
, imode
, rmode
;
4957 HOST_WIDE_INT hi
, lo
;
4962 arglist
= TREE_OPERAND (exp
, 1);
4963 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
4966 arg
= TREE_VALUE (arglist
);
4967 fmode
= TYPE_MODE (TREE_TYPE (arg
));
4968 rmode
= TYPE_MODE (TREE_TYPE (exp
));
4969 fmt
= REAL_MODE_FORMAT (fmode
);
4971 /* For floating point formats without a sign bit, implement signbit
4973 if (fmt
->signbit
< 0)
4975 /* But we can't do this if the format supports signed zero. */
4976 if (fmt
->has_signed_zero
&& HONOR_SIGNED_ZEROS (fmode
))
4979 arg
= fold (build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
4980 build_real (TREE_TYPE (arg
), dconst0
)));
4981 return expand_expr (arg
, target
, VOIDmode
, EXPAND_NORMAL
);
4984 imode
= int_mode_for_mode (fmode
);
4985 if (imode
== BLKmode
)
4988 bitpos
= fmt
->signbit
;
4989 /* Handle targets with different FP word orders. */
4990 if (FLOAT_WORDS_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
4992 int nwords
= GET_MODE_BITSIZE (fmode
) / BITS_PER_WORD
;
4993 int word
= nwords
- (bitpos
/ BITS_PER_WORD
) - 1;
4994 bitpos
= word
* BITS_PER_WORD
+ bitpos
% BITS_PER_WORD
;
4997 /* If the sign bit is not in the lowpart and the floating point format
4998 is wider than an integer, check that is twice the size of an integer
4999 so that we can use gen_highpart below. */
5000 if (bitpos
>= GET_MODE_BITSIZE (rmode
)
5001 && GET_MODE_BITSIZE (imode
) != 2 * GET_MODE_BITSIZE (rmode
))
5004 temp
= expand_expr (arg
, NULL_RTX
, VOIDmode
, 0);
5005 temp
= gen_lowpart (imode
, temp
);
5007 if (GET_MODE_BITSIZE (imode
) > GET_MODE_BITSIZE (rmode
))
5009 if (BYTES_BIG_ENDIAN
)
5010 bitpos
= GET_MODE_BITSIZE (imode
) - 1 - bitpos
;
5011 temp
= copy_to_mode_reg (imode
, temp
);
5012 temp
= extract_bit_field (temp
, 1, bitpos
, 1,
5013 NULL_RTX
, rmode
, rmode
);
5017 if (GET_MODE_BITSIZE (imode
) < GET_MODE_BITSIZE (rmode
))
5018 temp
= gen_lowpart (rmode
, temp
);
5019 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
5022 lo
= (HOST_WIDE_INT
) 1 << bitpos
;
5026 hi
= (HOST_WIDE_INT
) 1 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
5030 temp
= force_reg (rmode
, temp
);
5031 temp
= expand_binop (rmode
, and_optab
, temp
,
5032 immed_double_const (lo
, hi
, rmode
),
5033 target
, 1, OPTAB_LIB_WIDEN
);
5038 /* Expand fork or exec calls. TARGET is the desired target of the
5039 call. ARGLIST is the list of arguments of the call. FN is the
5040 identificator of the actual function. IGNORE is nonzero if the
5041 value is to be ignored. */
5044 expand_builtin_fork_or_exec (tree fn
, tree arglist
, rtx target
, int ignore
)
5049 /* If we are not profiling, just call the function. */
5050 if (!profile_arc_flag
)
5053 /* Otherwise call the wrapper. This should be equivalent for the rest of
5054 compiler, so the code does not diverge, and the wrapper may run the
5055 code necessary for keeping the profiling sane. */
5057 switch (DECL_FUNCTION_CODE (fn
))
5060 id
= get_identifier ("__gcov_fork");
5063 case BUILT_IN_EXECL
:
5064 id
= get_identifier ("__gcov_execl");
5067 case BUILT_IN_EXECV
:
5068 id
= get_identifier ("__gcov_execv");
5071 case BUILT_IN_EXECLP
:
5072 id
= get_identifier ("__gcov_execlp");
5075 case BUILT_IN_EXECLE
:
5076 id
= get_identifier ("__gcov_execle");
5079 case BUILT_IN_EXECVP
:
5080 id
= get_identifier ("__gcov_execvp");
5083 case BUILT_IN_EXECVE
:
5084 id
= get_identifier ("__gcov_execve");
5091 decl
= build_decl (FUNCTION_DECL
, id
, TREE_TYPE (fn
));
5092 DECL_EXTERNAL (decl
) = 1;
5093 TREE_PUBLIC (decl
) = 1;
5094 DECL_ARTIFICIAL (decl
) = 1;
5095 TREE_NOTHROW (decl
) = 1;
5096 call
= build_function_call_expr (decl
, arglist
);
5098 return expand_call (call
, target
, ignore
);
5101 /* Expand an expression EXP that calls a built-in function,
5102 with result going to TARGET if that's convenient
5103 (and in mode MODE if that's convenient).
5104 SUBTARGET may be used as the target for computing one of EXP's operands.
5105 IGNORE is nonzero if the value is to be ignored. */
5108 expand_builtin (tree exp
, rtx target
, rtx subtarget
, enum machine_mode mode
,
5111 tree fndecl
= get_callee_fndecl (exp
);
5112 tree arglist
= TREE_OPERAND (exp
, 1);
5113 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
5114 enum machine_mode target_mode
= TYPE_MODE (TREE_TYPE (exp
));
5116 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5117 return targetm
.expand_builtin (exp
, target
, subtarget
, mode
, ignore
);
5119 /* When not optimizing, generate calls to library functions for a certain
5122 && !CALLED_AS_BUILT_IN (fndecl
)
5123 && DECL_ASSEMBLER_NAME_SET_P (fndecl
)
5124 && fcode
!= BUILT_IN_ALLOCA
)
5125 return expand_call (exp
, target
, ignore
);
5127 /* The built-in function expanders test for target == const0_rtx
5128 to determine whether the function's result will be ignored. */
5130 target
= const0_rtx
;
5132 /* If the result of a pure or const built-in function is ignored, and
5133 none of its arguments are volatile, we can avoid expanding the
5134 built-in call and just evaluate the arguments for side-effects. */
5135 if (target
== const0_rtx
5136 && (DECL_IS_PURE (fndecl
) || TREE_READONLY (fndecl
)))
5138 bool volatilep
= false;
5141 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5142 if (TREE_THIS_VOLATILE (TREE_VALUE (arg
)))
5150 for (arg
= arglist
; arg
; arg
= TREE_CHAIN (arg
))
5151 expand_expr (TREE_VALUE (arg
), const0_rtx
,
5152 VOIDmode
, EXPAND_NORMAL
);
5160 case BUILT_IN_FABSF
:
5161 case BUILT_IN_FABSL
:
5162 target
= expand_builtin_fabs (arglist
, target
, subtarget
);
5167 case BUILT_IN_COPYSIGN
:
5168 case BUILT_IN_COPYSIGNF
:
5169 case BUILT_IN_COPYSIGNL
:
5170 target
= expand_builtin_copysign (arglist
, target
, subtarget
);
5175 /* Just do a normal library call if we were unable to fold
5178 case BUILT_IN_CABSF
:
5179 case BUILT_IN_CABSL
:
5185 case BUILT_IN_EXP10
:
5186 case BUILT_IN_EXP10F
:
5187 case BUILT_IN_EXP10L
:
5188 case BUILT_IN_POW10
:
5189 case BUILT_IN_POW10F
:
5190 case BUILT_IN_POW10L
:
5192 case BUILT_IN_EXP2F
:
5193 case BUILT_IN_EXP2L
:
5194 case BUILT_IN_EXPM1
:
5195 case BUILT_IN_EXPM1F
:
5196 case BUILT_IN_EXPM1L
:
5198 case BUILT_IN_LOGBF
:
5199 case BUILT_IN_LOGBL
:
5200 case BUILT_IN_ILOGB
:
5201 case BUILT_IN_ILOGBF
:
5202 case BUILT_IN_ILOGBL
:
5206 case BUILT_IN_LOG10
:
5207 case BUILT_IN_LOG10F
:
5208 case BUILT_IN_LOG10L
:
5210 case BUILT_IN_LOG2F
:
5211 case BUILT_IN_LOG2L
:
5212 case BUILT_IN_LOG1P
:
5213 case BUILT_IN_LOG1PF
:
5214 case BUILT_IN_LOG1PL
:
5219 case BUILT_IN_ASINF
:
5220 case BUILT_IN_ASINL
:
5222 case BUILT_IN_ACOSF
:
5223 case BUILT_IN_ACOSL
:
5225 case BUILT_IN_ATANF
:
5226 case BUILT_IN_ATANL
:
5227 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5228 because of possible accuracy problems. */
5229 if (! flag_unsafe_math_optimizations
)
5232 case BUILT_IN_SQRTF
:
5233 case BUILT_IN_SQRTL
:
5234 case BUILT_IN_FLOOR
:
5235 case BUILT_IN_FLOORF
:
5236 case BUILT_IN_FLOORL
:
5238 case BUILT_IN_CEILF
:
5239 case BUILT_IN_CEILL
:
5240 case BUILT_IN_TRUNC
:
5241 case BUILT_IN_TRUNCF
:
5242 case BUILT_IN_TRUNCL
:
5243 case BUILT_IN_ROUND
:
5244 case BUILT_IN_ROUNDF
:
5245 case BUILT_IN_ROUNDL
:
5246 case BUILT_IN_NEARBYINT
:
5247 case BUILT_IN_NEARBYINTF
:
5248 case BUILT_IN_NEARBYINTL
:
5250 case BUILT_IN_RINTF
:
5251 case BUILT_IN_RINTL
:
5252 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
5260 target
= expand_builtin_pow (exp
, target
, subtarget
);
5266 case BUILT_IN_POWIF
:
5267 case BUILT_IN_POWIL
:
5268 target
= expand_builtin_powi (exp
, target
, subtarget
);
5273 case BUILT_IN_ATAN2
:
5274 case BUILT_IN_ATAN2F
:
5275 case BUILT_IN_ATAN2L
:
5276 case BUILT_IN_LDEXP
:
5277 case BUILT_IN_LDEXPF
:
5278 case BUILT_IN_LDEXPL
:
5280 case BUILT_IN_FMODF
:
5281 case BUILT_IN_FMODL
:
5283 case BUILT_IN_DREMF
:
5284 case BUILT_IN_DREML
:
5285 if (! flag_unsafe_math_optimizations
)
5287 target
= expand_builtin_mathfn_2 (exp
, target
, subtarget
);
5298 if (! flag_unsafe_math_optimizations
)
5300 target
= expand_builtin_mathfn_3 (exp
, target
, subtarget
);
5305 case BUILT_IN_APPLY_ARGS
:
5306 return expand_builtin_apply_args ();
5308 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5309 FUNCTION with a copy of the parameters described by
5310 ARGUMENTS, and ARGSIZE. It returns a block of memory
5311 allocated on the stack into which is stored all the registers
5312 that might possibly be used for returning the result of a
5313 function. ARGUMENTS is the value returned by
5314 __builtin_apply_args. ARGSIZE is the number of bytes of
5315 arguments that must be copied. ??? How should this value be
5316 computed? We'll also need a safe worst case value for varargs
5318 case BUILT_IN_APPLY
:
5319 if (!validate_arglist (arglist
, POINTER_TYPE
,
5320 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
5321 && !validate_arglist (arglist
, REFERENCE_TYPE
,
5322 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5330 for (t
= arglist
, i
= 0; t
; t
= TREE_CHAIN (t
), i
++)
5331 ops
[i
] = expand_expr (TREE_VALUE (t
), NULL_RTX
, VOIDmode
, 0);
5333 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
5336 /* __builtin_return (RESULT) causes the function to return the
5337 value described by RESULT. RESULT is address of the block of
5338 memory returned by __builtin_apply. */
5339 case BUILT_IN_RETURN
:
5340 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5341 expand_builtin_return (expand_expr (TREE_VALUE (arglist
),
5342 NULL_RTX
, VOIDmode
, 0));
5345 case BUILT_IN_SAVEREGS
:
5346 return expand_builtin_saveregs ();
5348 case BUILT_IN_ARGS_INFO
:
5349 return expand_builtin_args_info (arglist
);
5351 /* Return the address of the first anonymous stack arg. */
5352 case BUILT_IN_NEXT_ARG
:
5353 if (fold_builtin_next_arg (arglist
))
5355 return expand_builtin_next_arg ();
5357 case BUILT_IN_CLASSIFY_TYPE
:
5358 return expand_builtin_classify_type (arglist
);
5360 case BUILT_IN_CONSTANT_P
:
5363 case BUILT_IN_FRAME_ADDRESS
:
5364 case BUILT_IN_RETURN_ADDRESS
:
5365 return expand_builtin_frame_address (fndecl
, arglist
);
5367 /* Returns the address of the area where the structure is returned.
5369 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
5371 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
5372 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl
))))
5375 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
5377 case BUILT_IN_ALLOCA
:
5378 target
= expand_builtin_alloca (arglist
, target
);
5383 case BUILT_IN_STACK_SAVE
:
5384 return expand_stack_save ();
5386 case BUILT_IN_STACK_RESTORE
:
5387 expand_stack_restore (TREE_VALUE (arglist
));
5392 case BUILT_IN_FFSLL
:
5393 case BUILT_IN_FFSIMAX
:
5394 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5395 subtarget
, ffs_optab
);
5402 case BUILT_IN_CLZLL
:
5403 case BUILT_IN_CLZIMAX
:
5404 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5405 subtarget
, clz_optab
);
5412 case BUILT_IN_CTZLL
:
5413 case BUILT_IN_CTZIMAX
:
5414 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5415 subtarget
, ctz_optab
);
5420 case BUILT_IN_POPCOUNT
:
5421 case BUILT_IN_POPCOUNTL
:
5422 case BUILT_IN_POPCOUNTLL
:
5423 case BUILT_IN_POPCOUNTIMAX
:
5424 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5425 subtarget
, popcount_optab
);
5430 case BUILT_IN_PARITY
:
5431 case BUILT_IN_PARITYL
:
5432 case BUILT_IN_PARITYLL
:
5433 case BUILT_IN_PARITYIMAX
:
5434 target
= expand_builtin_unop (target_mode
, arglist
, target
,
5435 subtarget
, parity_optab
);
5440 case BUILT_IN_STRLEN
:
5441 target
= expand_builtin_strlen (arglist
, target
, target_mode
);
5446 case BUILT_IN_STRCPY
:
5447 target
= expand_builtin_strcpy (exp
, target
, mode
);
5452 case BUILT_IN_STRNCPY
:
5453 target
= expand_builtin_strncpy (exp
, target
, mode
);
5458 case BUILT_IN_STPCPY
:
5459 target
= expand_builtin_stpcpy (exp
, target
, mode
);
5464 case BUILT_IN_STRCAT
:
5465 target
= expand_builtin_strcat (arglist
, TREE_TYPE (exp
), target
, mode
);
5470 case BUILT_IN_STRNCAT
:
5471 target
= expand_builtin_strncat (arglist
, target
, mode
);
5476 case BUILT_IN_STRSPN
:
5477 target
= expand_builtin_strspn (arglist
, target
, mode
);
5482 case BUILT_IN_STRCSPN
:
5483 target
= expand_builtin_strcspn (arglist
, target
, mode
);
5488 case BUILT_IN_STRSTR
:
5489 target
= expand_builtin_strstr (arglist
, TREE_TYPE (exp
), target
, mode
);
5494 case BUILT_IN_STRPBRK
:
5495 target
= expand_builtin_strpbrk (arglist
, TREE_TYPE (exp
), target
, mode
);
5500 case BUILT_IN_INDEX
:
5501 case BUILT_IN_STRCHR
:
5502 target
= expand_builtin_strchr (arglist
, TREE_TYPE (exp
), target
, mode
);
5507 case BUILT_IN_RINDEX
:
5508 case BUILT_IN_STRRCHR
:
5509 target
= expand_builtin_strrchr (arglist
, TREE_TYPE (exp
), target
, mode
);
5514 case BUILT_IN_MEMCPY
:
5515 target
= expand_builtin_memcpy (exp
, target
, mode
);
5520 case BUILT_IN_MEMPCPY
:
5521 target
= expand_builtin_mempcpy (arglist
, TREE_TYPE (exp
), target
, mode
, /*endp=*/ 1);
5526 case BUILT_IN_MEMMOVE
:
5527 target
= expand_builtin_memmove (arglist
, TREE_TYPE (exp
), target
, mode
);
5532 case BUILT_IN_BCOPY
:
5533 target
= expand_builtin_bcopy (arglist
, TREE_TYPE (exp
));
5538 case BUILT_IN_MEMSET
:
5539 target
= expand_builtin_memset (arglist
, target
, mode
);
5544 case BUILT_IN_BZERO
:
5545 target
= expand_builtin_bzero (arglist
);
5550 case BUILT_IN_STRCMP
:
5551 target
= expand_builtin_strcmp (exp
, target
, mode
);
5556 case BUILT_IN_STRNCMP
:
5557 target
= expand_builtin_strncmp (exp
, target
, mode
);
5563 case BUILT_IN_MEMCMP
:
5564 target
= expand_builtin_memcmp (exp
, arglist
, target
, mode
);
5569 case BUILT_IN_SETJMP
:
5570 target
= expand_builtin_setjmp (arglist
, target
);
5575 /* __builtin_longjmp is passed a pointer to an array of five words.
5576 It's similar to the C library longjmp function but works with
5577 __builtin_setjmp above. */
5578 case BUILT_IN_LONGJMP
:
5579 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
5583 rtx buf_addr
= expand_expr (TREE_VALUE (arglist
), subtarget
,
5585 rtx value
= expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)),
5586 NULL_RTX
, VOIDmode
, 0);
5588 if (value
!= const1_rtx
)
5590 error ("%<__builtin_longjmp%> second argument must be 1");
5594 expand_builtin_longjmp (buf_addr
, value
);
5598 case BUILT_IN_NONLOCAL_GOTO
:
5599 target
= expand_builtin_nonlocal_goto (arglist
);
5604 /* This updates the setjmp buffer that is its argument with the value
5605 of the current stack pointer. */
5606 case BUILT_IN_UPDATE_SETJMP_BUF
:
5607 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5610 = expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
5612 expand_builtin_update_setjmp_buf (buf_addr
);
5618 expand_builtin_trap ();
5621 case BUILT_IN_PRINTF
:
5622 target
= expand_builtin_printf (arglist
, target
, mode
, false);
5627 case BUILT_IN_PRINTF_UNLOCKED
:
5628 target
= expand_builtin_printf (arglist
, target
, mode
, true);
5633 case BUILT_IN_FPUTS
:
5634 target
= expand_builtin_fputs (arglist
, target
, false);
5638 case BUILT_IN_FPUTS_UNLOCKED
:
5639 target
= expand_builtin_fputs (arglist
, target
, true);
5644 case BUILT_IN_FPRINTF
:
5645 target
= expand_builtin_fprintf (arglist
, target
, mode
, false);
5650 case BUILT_IN_FPRINTF_UNLOCKED
:
5651 target
= expand_builtin_fprintf (arglist
, target
, mode
, true);
5656 case BUILT_IN_SPRINTF
:
5657 target
= expand_builtin_sprintf (arglist
, target
, mode
);
5662 case BUILT_IN_SIGNBIT
:
5663 case BUILT_IN_SIGNBITF
:
5664 case BUILT_IN_SIGNBITL
:
5665 target
= expand_builtin_signbit (exp
, target
);
5670 /* Various hooks for the DWARF 2 __throw routine. */
5671 case BUILT_IN_UNWIND_INIT
:
5672 expand_builtin_unwind_init ();
5674 case BUILT_IN_DWARF_CFA
:
5675 return virtual_cfa_rtx
;
5676 #ifdef DWARF2_UNWIND_INFO
5677 case BUILT_IN_DWARF_SP_COLUMN
:
5678 return expand_builtin_dwarf_sp_column ();
5679 case BUILT_IN_INIT_DWARF_REG_SIZES
:
5680 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist
));
5683 case BUILT_IN_FROB_RETURN_ADDR
:
5684 return expand_builtin_frob_return_addr (TREE_VALUE (arglist
));
5685 case BUILT_IN_EXTRACT_RETURN_ADDR
:
5686 return expand_builtin_extract_return_addr (TREE_VALUE (arglist
));
5687 case BUILT_IN_EH_RETURN
:
5688 expand_builtin_eh_return (TREE_VALUE (arglist
),
5689 TREE_VALUE (TREE_CHAIN (arglist
)));
5691 #ifdef EH_RETURN_DATA_REGNO
5692 case BUILT_IN_EH_RETURN_DATA_REGNO
:
5693 return expand_builtin_eh_return_data_regno (arglist
);
5695 case BUILT_IN_EXTEND_POINTER
:
5696 return expand_builtin_extend_pointer (TREE_VALUE (arglist
));
5698 case BUILT_IN_VA_START
:
5699 case BUILT_IN_STDARG_START
:
5700 return expand_builtin_va_start (arglist
);
5701 case BUILT_IN_VA_END
:
5702 return expand_builtin_va_end (arglist
);
5703 case BUILT_IN_VA_COPY
:
5704 return expand_builtin_va_copy (arglist
);
5705 case BUILT_IN_EXPECT
:
5706 return expand_builtin_expect (arglist
, target
);
5707 case BUILT_IN_PREFETCH
:
5708 expand_builtin_prefetch (arglist
);
5711 case BUILT_IN_PROFILE_FUNC_ENTER
:
5712 return expand_builtin_profile_func (false);
5713 case BUILT_IN_PROFILE_FUNC_EXIT
:
5714 return expand_builtin_profile_func (true);
5716 case BUILT_IN_INIT_TRAMPOLINE
:
5717 return expand_builtin_init_trampoline (arglist
);
5718 case BUILT_IN_ADJUST_TRAMPOLINE
:
5719 return expand_builtin_adjust_trampoline (arglist
);
5722 case BUILT_IN_EXECL
:
5723 case BUILT_IN_EXECV
:
5724 case BUILT_IN_EXECLP
:
5725 case BUILT_IN_EXECLE
:
5726 case BUILT_IN_EXECVP
:
5727 case BUILT_IN_EXECVE
:
5728 target
= expand_builtin_fork_or_exec (fndecl
, arglist
, target
, ignore
);
5733 default: /* just do library call, if unknown builtin */
5737 /* The switch statement above can drop through to cause the function
5738 to be called normally. */
5739 return expand_call (exp
, target
, ignore
);
5742 /* Determine whether a tree node represents a call to a built-in
5743 function. If the tree T is a call to a built-in function with
5744 the right number of arguments of the appropriate types, return
5745 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
5746 Otherwise the return value is END_BUILTINS. */
5748 enum built_in_function
5749 builtin_mathfn_code (tree t
)
5751 tree fndecl
, arglist
, parmlist
;
5752 tree argtype
, parmtype
;
5754 if (TREE_CODE (t
) != CALL_EXPR
5755 || TREE_CODE (TREE_OPERAND (t
, 0)) != ADDR_EXPR
)
5756 return END_BUILTINS
;
5758 fndecl
= get_callee_fndecl (t
);
5759 if (fndecl
== NULL_TREE
5760 || TREE_CODE (fndecl
) != FUNCTION_DECL
5761 || ! DECL_BUILT_IN (fndecl
)
5762 || DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
5763 return END_BUILTINS
;
5765 arglist
= TREE_OPERAND (t
, 1);
5766 parmlist
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5767 for (; parmlist
; parmlist
= TREE_CHAIN (parmlist
))
5769 /* If a function doesn't take a variable number of arguments,
5770 the last element in the list will have type `void'. */
5771 parmtype
= TREE_VALUE (parmlist
);
5772 if (VOID_TYPE_P (parmtype
))
5775 return END_BUILTINS
;
5776 return DECL_FUNCTION_CODE (fndecl
);
5780 return END_BUILTINS
;
5782 argtype
= TREE_TYPE (TREE_VALUE (arglist
));
5784 if (SCALAR_FLOAT_TYPE_P (parmtype
))
5786 if (! SCALAR_FLOAT_TYPE_P (argtype
))
5787 return END_BUILTINS
;
5789 else if (COMPLEX_FLOAT_TYPE_P (parmtype
))
5791 if (! COMPLEX_FLOAT_TYPE_P (argtype
))
5792 return END_BUILTINS
;
5794 else if (POINTER_TYPE_P (parmtype
))
5796 if (! POINTER_TYPE_P (argtype
))
5797 return END_BUILTINS
;
5799 else if (INTEGRAL_TYPE_P (parmtype
))
5801 if (! INTEGRAL_TYPE_P (argtype
))
5802 return END_BUILTINS
;
5805 return END_BUILTINS
;
5807 arglist
= TREE_CHAIN (arglist
);
5810 /* Variable-length argument list. */
5811 return DECL_FUNCTION_CODE (fndecl
);
5814 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
5815 constant. ARGLIST is the argument list of the call. */
5818 fold_builtin_constant_p (tree arglist
)
5823 arglist
= TREE_VALUE (arglist
);
5825 /* We return 1 for a numeric type that's known to be a constant
5826 value at compile-time or for an aggregate type that's a
5827 literal constant. */
5828 STRIP_NOPS (arglist
);
5830 /* If we know this is a constant, emit the constant of one. */
5831 if (CONSTANT_CLASS_P (arglist
)
5832 || (TREE_CODE (arglist
) == CONSTRUCTOR
5833 && TREE_CONSTANT (arglist
))
5834 || (TREE_CODE (arglist
) == ADDR_EXPR
5835 && TREE_CODE (TREE_OPERAND (arglist
, 0)) == STRING_CST
))
5836 return integer_one_node
;
5838 /* If this expression has side effects, show we don't know it to be a
5839 constant. Likewise if it's a pointer or aggregate type since in
5840 those case we only want literals, since those are only optimized
5841 when generating RTL, not later.
5842 And finally, if we are compiling an initializer, not code, we
5843 need to return a definite result now; there's not going to be any
5844 more optimization done. */
5845 if (TREE_SIDE_EFFECTS (arglist
)
5846 || AGGREGATE_TYPE_P (TREE_TYPE (arglist
))
5847 || POINTER_TYPE_P (TREE_TYPE (arglist
))
5849 return integer_zero_node
;
5854 /* Fold a call to __builtin_expect, if we expect that a comparison against
5855 the argument will fold to a constant. In practice, this means a true
5856 constant or the address of a non-weak symbol. ARGLIST is the argument
5857 list of the call. */
5860 fold_builtin_expect (tree arglist
)
5867 arg
= TREE_VALUE (arglist
);
5869 /* If the argument isn't invariant, then there's nothing we can do. */
5870 if (!TREE_INVARIANT (arg
))
5873 /* If we're looking at an address of a weak decl, then do not fold. */
5876 if (TREE_CODE (inner
) == ADDR_EXPR
)
5880 inner
= TREE_OPERAND (inner
, 0);
5882 while (TREE_CODE (inner
) == COMPONENT_REF
5883 || TREE_CODE (inner
) == ARRAY_REF
);
5884 if (DECL_P (inner
) && DECL_WEAK (inner
))
5888 /* Otherwise, ARG already has the proper type for the return value. */
5892 /* Fold a call to __builtin_classify_type. */
5895 fold_builtin_classify_type (tree arglist
)
5898 return build_int_cst (NULL_TREE
, no_type_class
);
5900 return build_int_cst (NULL_TREE
,
5901 type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
5904 /* Fold a call to __builtin_strlen. */
5907 fold_builtin_strlen (tree arglist
)
5909 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5913 tree len
= c_strlen (TREE_VALUE (arglist
), 0);
5917 /* Convert from the internal "sizetype" type to "size_t". */
5919 len
= fold_convert (size_type_node
, len
);
5927 /* Fold a call to __builtin_inf or __builtin_huge_val. */
5930 fold_builtin_inf (tree type
, int warn
)
5932 REAL_VALUE_TYPE real
;
5934 /* __builtin_inff is intended to be usable to define INFINITY on all
5935 targets. If an infinity is not available, INFINITY expands "to a
5936 positive constant of type float that overflows at translation
5937 time", footnote "In this case, using INFINITY will violate the
5938 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
5939 Thus we pedwarn to ensure this constraint violation is
5941 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)) && warn
)
5942 pedwarn ("target format does not support infinity");
5945 return build_real (type
, real
);
5948 /* Fold a call to __builtin_nan or __builtin_nans. */
5951 fold_builtin_nan (tree arglist
, tree type
, int quiet
)
5953 REAL_VALUE_TYPE real
;
5956 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
5958 str
= c_getstr (TREE_VALUE (arglist
));
5962 if (!real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
5965 return build_real (type
, real
);
5968 /* Return true if the floating point expression T has an integer value.
5969 We also allow +Inf, -Inf and NaN to be considered integer values. */
5972 integer_valued_real_p (tree t
)
5974 switch (TREE_CODE (t
))
5981 case NON_LVALUE_EXPR
:
5982 return integer_valued_real_p (TREE_OPERAND (t
, 0));
5987 return integer_valued_real_p (TREE_OPERAND (t
, 1));
5994 return integer_valued_real_p (TREE_OPERAND (t
, 0))
5995 && integer_valued_real_p (TREE_OPERAND (t
, 1));
5998 return integer_valued_real_p (TREE_OPERAND (t
, 1))
5999 && integer_valued_real_p (TREE_OPERAND (t
, 2));
6002 if (! TREE_CONSTANT_OVERFLOW (t
))
6004 REAL_VALUE_TYPE c
, cint
;
6006 c
= TREE_REAL_CST (t
);
6007 real_trunc (&cint
, TYPE_MODE (TREE_TYPE (t
)), &c
);
6008 return real_identical (&c
, &cint
);
6013 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
6014 if (TREE_CODE (type
) == INTEGER_TYPE
)
6016 if (TREE_CODE (type
) == REAL_TYPE
)
6017 return integer_valued_real_p (TREE_OPERAND (t
, 0));
6022 switch (builtin_mathfn_code (t
))
6025 case BUILT_IN_CEILF
:
6026 case BUILT_IN_CEILL
:
6027 case BUILT_IN_FLOOR
:
6028 case BUILT_IN_FLOORF
:
6029 case BUILT_IN_FLOORL
:
6030 case BUILT_IN_NEARBYINT
:
6031 case BUILT_IN_NEARBYINTF
:
6032 case BUILT_IN_NEARBYINTL
:
6034 case BUILT_IN_RINTF
:
6035 case BUILT_IN_RINTL
:
6036 case BUILT_IN_ROUND
:
6037 case BUILT_IN_ROUNDF
:
6038 case BUILT_IN_ROUNDL
:
6039 case BUILT_IN_TRUNC
:
6040 case BUILT_IN_TRUNCF
:
6041 case BUILT_IN_TRUNCL
:
6055 /* EXP is assumed to be builtin call where truncation can be propagated
6056 across (for instance floor((double)f) == (double)floorf (f).
6057 Do the transformation. */
6060 fold_trunc_transparent_mathfn (tree exp
)
6062 tree fndecl
= get_callee_fndecl (exp
);
6063 tree arglist
= TREE_OPERAND (exp
, 1);
6064 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6067 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6070 arg
= TREE_VALUE (arglist
);
6071 /* Integer rounding functions are idempotent. */
6072 if (fcode
== builtin_mathfn_code (arg
))
6075 /* If argument is already integer valued, and we don't need to worry
6076 about setting errno, there's no need to perform rounding. */
6077 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6082 tree arg0
= strip_float_extensions (arg
);
6083 tree ftype
= TREE_TYPE (exp
);
6084 tree newtype
= TREE_TYPE (arg0
);
6087 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6088 && (decl
= mathfn_built_in (newtype
, fcode
)))
6091 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6092 return fold_convert (ftype
,
6093 build_function_call_expr (decl
, arglist
));
6099 /* EXP is assumed to be builtin call which can narrow the FP type of
6100 the argument, for instance lround((double)f) -> lroundf (f). */
6103 fold_fixed_mathfn (tree exp
)
6105 tree fndecl
= get_callee_fndecl (exp
);
6106 tree arglist
= TREE_OPERAND (exp
, 1);
6107 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
6110 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6113 arg
= TREE_VALUE (arglist
);
6115 /* If argument is already integer valued, and we don't need to worry
6116 about setting errno, there's no need to perform rounding. */
6117 if (! flag_errno_math
&& integer_valued_real_p (arg
))
6118 return fold (build1 (FIX_TRUNC_EXPR
, TREE_TYPE (exp
), arg
));
6122 tree ftype
= TREE_TYPE (arg
);
6123 tree arg0
= strip_float_extensions (arg
);
6124 tree newtype
= TREE_TYPE (arg0
);
6127 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (ftype
)
6128 && (decl
= mathfn_built_in (newtype
, fcode
)))
6131 build_tree_list (NULL_TREE
, fold_convert (newtype
, arg0
));
6132 return build_function_call_expr (decl
, arglist
);
6138 /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
6139 is the argument list and TYPE is the return type. Return
6140 NULL_TREE if no if no simplification can be made. */
6143 fold_builtin_cabs (tree arglist
, tree type
)
6147 if (!arglist
|| TREE_CHAIN (arglist
))
6150 arg
= TREE_VALUE (arglist
);
6151 if (TREE_CODE (TREE_TYPE (arg
)) != COMPLEX_TYPE
6152 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != REAL_TYPE
)
6155 /* Evaluate cabs of a constant at compile-time. */
6156 if (flag_unsafe_math_optimizations
6157 && TREE_CODE (arg
) == COMPLEX_CST
6158 && TREE_CODE (TREE_REALPART (arg
)) == REAL_CST
6159 && TREE_CODE (TREE_IMAGPART (arg
)) == REAL_CST
6160 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg
))
6161 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg
)))
6163 REAL_VALUE_TYPE r
, i
;
6165 r
= TREE_REAL_CST (TREE_REALPART (arg
));
6166 i
= TREE_REAL_CST (TREE_IMAGPART (arg
));
6168 real_arithmetic (&r
, MULT_EXPR
, &r
, &r
);
6169 real_arithmetic (&i
, MULT_EXPR
, &i
, &i
);
6170 real_arithmetic (&r
, PLUS_EXPR
, &r
, &i
);
6171 if (real_sqrt (&r
, TYPE_MODE (type
), &r
)
6172 || ! flag_trapping_math
)
6173 return build_real (type
, r
);
6176 /* If either part is zero, cabs is fabs of the other. */
6177 if (TREE_CODE (arg
) == COMPLEX_EXPR
6178 && real_zerop (TREE_OPERAND (arg
, 0)))
6179 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 1)));
6180 if (TREE_CODE (arg
) == COMPLEX_EXPR
6181 && real_zerop (TREE_OPERAND (arg
, 1)))
6182 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (arg
, 0)));
6184 /* Don't do this when optimizing for size. */
6185 if (flag_unsafe_math_optimizations
6186 && optimize
&& !optimize_size
)
6188 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
6190 if (sqrtfn
!= NULL_TREE
)
6192 tree rpart
, ipart
, result
, arglist
;
6194 arg
= builtin_save_expr (arg
);
6196 rpart
= fold (build1 (REALPART_EXPR
, type
, arg
));
6197 ipart
= fold (build1 (IMAGPART_EXPR
, type
, arg
));
6199 rpart
= builtin_save_expr (rpart
);
6200 ipart
= builtin_save_expr (ipart
);
6202 result
= fold (build2 (PLUS_EXPR
, type
,
6203 fold (build2 (MULT_EXPR
, type
,
6205 fold (build2 (MULT_EXPR
, type
,
6208 arglist
= build_tree_list (NULL_TREE
, result
);
6209 return build_function_call_expr (sqrtfn
, arglist
);
6216 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl. Return
6217 NULL_TREE if no simplification can be made. */
6220 fold_builtin_sqrt (tree arglist
, tree type
)
6223 enum built_in_function fcode
;
6224 tree arg
= TREE_VALUE (arglist
);
6226 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6229 /* Optimize sqrt of constant value. */
6230 if (TREE_CODE (arg
) == REAL_CST
6231 && ! TREE_CONSTANT_OVERFLOW (arg
))
6233 REAL_VALUE_TYPE r
, x
;
6235 x
= TREE_REAL_CST (arg
);
6236 if (real_sqrt (&r
, TYPE_MODE (type
), &x
)
6237 || (!flag_trapping_math
&& !flag_errno_math
))
6238 return build_real (type
, r
);
6241 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
6242 fcode
= builtin_mathfn_code (arg
);
6243 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6245 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6246 arg
= fold (build2 (MULT_EXPR
, type
,
6247 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6248 build_real (type
, dconsthalf
)));
6249 arglist
= build_tree_list (NULL_TREE
, arg
);
6250 return build_function_call_expr (expfn
, arglist
);
6253 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
6254 if (flag_unsafe_math_optimizations
&& BUILTIN_ROOT_P (fcode
))
6256 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6260 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6262 /* The inner root was either sqrt or cbrt. */
6263 REAL_VALUE_TYPE dconstroot
=
6264 BUILTIN_SQRT_P (fcode
) ? dconsthalf
: dconstthird
;
6266 /* Adjust for the outer root. */
6267 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6268 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6269 tree_root
= build_real (type
, dconstroot
);
6270 arglist
= tree_cons (NULL_TREE
, arg0
,
6271 build_tree_list (NULL_TREE
, tree_root
));
6272 return build_function_call_expr (powfn
, arglist
);
6276 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
6277 if (flag_unsafe_math_optimizations
6278 && (fcode
== BUILT_IN_POW
6279 || fcode
== BUILT_IN_POWF
6280 || fcode
== BUILT_IN_POWL
))
6282 tree powfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6283 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6284 tree arg1
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
6286 if (!tree_expr_nonnegative_p (arg0
))
6287 arg0
= build1 (ABS_EXPR
, type
, arg0
);
6288 narg1
= fold (build2 (MULT_EXPR
, type
, arg1
,
6289 build_real (type
, dconsthalf
)));
6290 arglist
= tree_cons (NULL_TREE
, arg0
,
6291 build_tree_list (NULL_TREE
, narg1
));
6292 return build_function_call_expr (powfn
, arglist
);
6298 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl. Return
6299 NULL_TREE if no simplification can be made. */
6301 fold_builtin_cbrt (tree arglist
, tree type
)
6303 tree arg
= TREE_VALUE (arglist
);
6304 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
6306 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6309 /* Optimize cbrt of constant value. */
6310 if (real_zerop (arg
) || real_onep (arg
) || real_minus_onep (arg
))
6313 /* Optimize cbrt(expN(x)) -> expN(x/3). */
6314 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6316 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
6317 const REAL_VALUE_TYPE third_trunc
=
6318 real_value_truncate (TYPE_MODE (type
), dconstthird
);
6319 arg
= fold (build2 (MULT_EXPR
, type
,
6320 TREE_VALUE (TREE_OPERAND (arg
, 1)),
6321 build_real (type
, third_trunc
)));
6322 arglist
= build_tree_list (NULL_TREE
, arg
);
6323 return build_function_call_expr (expfn
, arglist
);
6326 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
6327 /* We don't optimize cbrt(cbrt(x)) -> pow(x,1/9) because if
6328 x is negative pow will error but cbrt won't. */
6329 if (flag_unsafe_math_optimizations
&& BUILTIN_SQRT_P (fcode
))
6331 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
6335 tree arg0
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6337 REAL_VALUE_TYPE dconstroot
= dconstthird
;
6339 SET_REAL_EXP (&dconstroot
, REAL_EXP (&dconstroot
) - 1);
6340 dconstroot
= real_value_truncate (TYPE_MODE (type
), dconstroot
);
6341 tree_root
= build_real (type
, dconstroot
);
6342 arglist
= tree_cons (NULL_TREE
, arg0
,
6343 build_tree_list (NULL_TREE
, tree_root
));
6344 return build_function_call_expr (powfn
, arglist
);
6351 /* Fold function call to builtin sin, sinf, or sinl. Return
6352 NULL_TREE if no simplification can be made. */
6354 fold_builtin_sin (tree arglist
)
6356 tree arg
= TREE_VALUE (arglist
);
6358 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6361 /* Optimize sin (0.0) = 0.0. */
6362 if (real_zerop (arg
))
6368 /* Fold function call to builtin cos, cosf, or cosl. Return
6369 NULL_TREE if no simplification can be made. */
6371 fold_builtin_cos (tree arglist
, tree type
, tree fndecl
)
6373 tree arg
= TREE_VALUE (arglist
);
6375 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6378 /* Optimize cos (0.0) = 1.0. */
6379 if (real_zerop (arg
))
6380 return build_real (type
, dconst1
);
6382 /* Optimize cos(-x) into cos (x). */
6383 if (TREE_CODE (arg
) == NEGATE_EXPR
)
6385 tree args
= build_tree_list (NULL_TREE
,
6386 TREE_OPERAND (arg
, 0));
6387 return build_function_call_expr (fndecl
, args
);
6393 /* Fold function call to builtin tan, tanf, or tanl. Return
6394 NULL_TREE if no simplification can be made. */
6396 fold_builtin_tan (tree arglist
)
6398 enum built_in_function fcode
;
6399 tree arg
= TREE_VALUE (arglist
);
6401 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6404 /* Optimize tan(0.0) = 0.0. */
6405 if (real_zerop (arg
))
6408 /* Optimize tan(atan(x)) = x. */
6409 fcode
= builtin_mathfn_code (arg
);
6410 if (flag_unsafe_math_optimizations
6411 && (fcode
== BUILT_IN_ATAN
6412 || fcode
== BUILT_IN_ATANF
6413 || fcode
== BUILT_IN_ATANL
))
6414 return TREE_VALUE (TREE_OPERAND (arg
, 1));
6419 /* Fold function call to builtin atan, atanf, or atanl. Return
6420 NULL_TREE if no simplification can be made. */
6423 fold_builtin_atan (tree arglist
, tree type
)
6426 tree arg
= TREE_VALUE (arglist
);
6428 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6431 /* Optimize atan(0.0) = 0.0. */
6432 if (real_zerop (arg
))
6435 /* Optimize atan(1.0) = pi/4. */
6436 if (real_onep (arg
))
6438 REAL_VALUE_TYPE cst
;
6440 real_convert (&cst
, TYPE_MODE (type
), &dconstpi
);
6441 SET_REAL_EXP (&cst
, REAL_EXP (&cst
) - 2);
6442 return build_real (type
, cst
);
6448 /* Fold function call to builtin trunc, truncf or truncl. Return
6449 NULL_TREE if no simplification can be made. */
6452 fold_builtin_trunc (tree exp
)
6454 tree arglist
= TREE_OPERAND (exp
, 1);
6457 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6460 /* Optimize trunc of constant value. */
6461 arg
= TREE_VALUE (arglist
);
6462 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6464 REAL_VALUE_TYPE r
, x
;
6465 tree type
= TREE_TYPE (exp
);
6467 x
= TREE_REAL_CST (arg
);
6468 real_trunc (&r
, TYPE_MODE (type
), &x
);
6469 return build_real (type
, r
);
6472 return fold_trunc_transparent_mathfn (exp
);
6475 /* Fold function call to builtin floor, floorf or floorl. Return
6476 NULL_TREE if no simplification can be made. */
6479 fold_builtin_floor (tree exp
)
6481 tree arglist
= TREE_OPERAND (exp
, 1);
6484 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6487 /* Optimize floor of constant value. */
6488 arg
= TREE_VALUE (arglist
);
6489 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6493 x
= TREE_REAL_CST (arg
);
6494 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6496 tree type
= TREE_TYPE (exp
);
6499 real_floor (&r
, TYPE_MODE (type
), &x
);
6500 return build_real (type
, r
);
6504 return fold_trunc_transparent_mathfn (exp
);
6507 /* Fold function call to builtin ceil, ceilf or ceill. Return
6508 NULL_TREE if no simplification can be made. */
6511 fold_builtin_ceil (tree exp
)
6513 tree arglist
= TREE_OPERAND (exp
, 1);
6516 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6519 /* Optimize ceil of constant value. */
6520 arg
= TREE_VALUE (arglist
);
6521 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6525 x
= TREE_REAL_CST (arg
);
6526 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6528 tree type
= TREE_TYPE (exp
);
6531 real_ceil (&r
, TYPE_MODE (type
), &x
);
6532 return build_real (type
, r
);
6536 return fold_trunc_transparent_mathfn (exp
);
6539 /* Fold function call to builtin round, roundf or roundl. Return
6540 NULL_TREE if no simplification can be made. */
6543 fold_builtin_round (tree exp
)
6545 tree arglist
= TREE_OPERAND (exp
, 1);
6548 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6551 /* Optimize round of constant value. */
6552 arg
= TREE_VALUE (arglist
);
6553 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6557 x
= TREE_REAL_CST (arg
);
6558 if (! REAL_VALUE_ISNAN (x
) || ! flag_errno_math
)
6560 tree type
= TREE_TYPE (exp
);
6563 real_round (&r
, TYPE_MODE (type
), &x
);
6564 return build_real (type
, r
);
6568 return fold_trunc_transparent_mathfn (exp
);
6571 /* Fold function call to builtin lround, lroundf or lroundl (or the
6572 corresponding long long versions). Return NULL_TREE if no
6573 simplification can be made. */
6576 fold_builtin_lround (tree exp
)
6578 tree arglist
= TREE_OPERAND (exp
, 1);
6581 if (! validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6584 /* Optimize lround of constant value. */
6585 arg
= TREE_VALUE (arglist
);
6586 if (TREE_CODE (arg
) == REAL_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6588 const REAL_VALUE_TYPE x
= TREE_REAL_CST (arg
);
6590 if (! REAL_VALUE_ISNAN (x
) && ! REAL_VALUE_ISINF (x
))
6592 tree itype
= TREE_TYPE (exp
), ftype
= TREE_TYPE (arg
), result
;
6593 HOST_WIDE_INT hi
, lo
;
6596 real_round (&r
, TYPE_MODE (ftype
), &x
);
6597 REAL_VALUE_TO_INT (&lo
, &hi
, r
);
6598 result
= build_int_cst_wide (NULL_TREE
, lo
, hi
);
6599 if (int_fits_type_p (result
, itype
))
6600 return fold_convert (itype
, result
);
6604 return fold_fixed_mathfn (exp
);
6607 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
6608 and their long and long long variants (i.e. ffsl and ffsll).
6609 Return NULL_TREE if no simplification can be made. */
6612 fold_builtin_bitop (tree exp
)
6614 tree fndecl
= get_callee_fndecl (exp
);
6615 tree arglist
= TREE_OPERAND (exp
, 1);
6618 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
6621 /* Optimize for constant argument. */
6622 arg
= TREE_VALUE (arglist
);
6623 if (TREE_CODE (arg
) == INTEGER_CST
&& ! TREE_CONSTANT_OVERFLOW (arg
))
6625 HOST_WIDE_INT hi
, width
, result
;
6626 unsigned HOST_WIDE_INT lo
;
6629 type
= TREE_TYPE (arg
);
6630 width
= TYPE_PRECISION (type
);
6631 lo
= TREE_INT_CST_LOW (arg
);
6633 /* Clear all the bits that are beyond the type's precision. */
6634 if (width
> HOST_BITS_PER_WIDE_INT
)
6636 hi
= TREE_INT_CST_HIGH (arg
);
6637 if (width
< 2 * HOST_BITS_PER_WIDE_INT
)
6638 hi
&= ~((HOST_WIDE_INT
) (-1) >> (width
- HOST_BITS_PER_WIDE_INT
));
6643 if (width
< HOST_BITS_PER_WIDE_INT
)
6644 lo
&= ~((unsigned HOST_WIDE_INT
) (-1) << width
);
6647 switch (DECL_FUNCTION_CODE (fndecl
))
6651 case BUILT_IN_FFSLL
:
6653 result
= exact_log2 (lo
& -lo
) + 1;
6655 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
) + 1;
6662 case BUILT_IN_CLZLL
:
6664 result
= width
- floor_log2 (hi
) - 1 - HOST_BITS_PER_WIDE_INT
;
6666 result
= width
- floor_log2 (lo
) - 1;
6667 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
6673 case BUILT_IN_CTZLL
:
6675 result
= exact_log2 (lo
& -lo
);
6677 result
= HOST_BITS_PER_WIDE_INT
+ exact_log2 (hi
& -hi
);
6678 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type
), result
))
6682 case BUILT_IN_POPCOUNT
:
6683 case BUILT_IN_POPCOUNTL
:
6684 case BUILT_IN_POPCOUNTLL
:
6687 result
++, lo
&= lo
- 1;
6689 result
++, hi
&= hi
- 1;
6692 case BUILT_IN_PARITY
:
6693 case BUILT_IN_PARITYL
:
6694 case BUILT_IN_PARITYLL
:
6697 result
++, lo
&= lo
- 1;
6699 result
++, hi
&= hi
- 1;
6707 return build_int_cst (TREE_TYPE (exp
), result
);
6713 /* Return true if EXPR is the real constant contained in VALUE. */
6716 real_dconstp (tree expr
, const REAL_VALUE_TYPE
*value
)
6720 return ((TREE_CODE (expr
) == REAL_CST
6721 && ! TREE_CONSTANT_OVERFLOW (expr
)
6722 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), *value
))
6723 || (TREE_CODE (expr
) == COMPLEX_CST
6724 && real_dconstp (TREE_REALPART (expr
), value
)
6725 && real_zerop (TREE_IMAGPART (expr
))));
6728 /* A subroutine of fold_builtin to fold the various logarithmic
6729 functions. EXP is the CALL_EXPR of a call to a builtin logN
6730 function. VALUE is the base of the logN function. */
6733 fold_builtin_logarithm (tree exp
, const REAL_VALUE_TYPE
*value
)
6735 tree arglist
= TREE_OPERAND (exp
, 1);
6737 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
6739 tree fndecl
= get_callee_fndecl (exp
);
6740 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
6741 tree arg
= TREE_VALUE (arglist
);
6742 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
6744 /* Optimize logN(1.0) = 0.0. */
6745 if (real_onep (arg
))
6746 return build_real (type
, dconst0
);
6748 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
6749 exactly, then only do this if flag_unsafe_math_optimizations. */
6750 if (exact_real_truncate (TYPE_MODE (type
), value
)
6751 || flag_unsafe_math_optimizations
)
6753 const REAL_VALUE_TYPE value_truncate
=
6754 real_value_truncate (TYPE_MODE (type
), *value
);
6755 if (real_dconstp (arg
, &value_truncate
))
6756 return build_real (type
, dconst1
);
6759 /* Special case, optimize logN(expN(x)) = x. */
6760 if (flag_unsafe_math_optimizations
6761 && ((value
== &dconste
6762 && (fcode
== BUILT_IN_EXP
6763 || fcode
== BUILT_IN_EXPF
6764 || fcode
== BUILT_IN_EXPL
))
6765 || (value
== &dconst2
6766 && (fcode
== BUILT_IN_EXP2
6767 || fcode
== BUILT_IN_EXP2F
6768 || fcode
== BUILT_IN_EXP2L
))
6769 || (value
== &dconst10
&& (BUILTIN_EXP10_P (fcode
)))))
6770 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
6772 /* Optimize logN(func()) for various exponential functions. We
6773 want to determine the value "x" and the power "exponent" in
6774 order to transform logN(x**exponent) into exponent*logN(x). */
6775 if (flag_unsafe_math_optimizations
)
6777 tree exponent
= 0, x
= 0;
6784 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
6785 x
= build_real (type
,
6786 real_value_truncate (TYPE_MODE (type
), dconste
));
6787 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6790 case BUILT_IN_EXP2F
:
6791 case BUILT_IN_EXP2L
:
6792 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
6793 x
= build_real (type
, dconst2
);
6794 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6796 case BUILT_IN_EXP10
:
6797 case BUILT_IN_EXP10F
:
6798 case BUILT_IN_EXP10L
:
6799 case BUILT_IN_POW10
:
6800 case BUILT_IN_POW10F
:
6801 case BUILT_IN_POW10L
:
6802 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
6803 x
= build_real (type
, dconst10
);
6804 exponent
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6807 case BUILT_IN_SQRTF
:
6808 case BUILT_IN_SQRTL
:
6809 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
6810 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6811 exponent
= build_real (type
, dconsthalf
);
6814 case BUILT_IN_CBRTF
:
6815 case BUILT_IN_CBRTL
:
6816 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
6817 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6818 exponent
= build_real (type
, real_value_truncate (TYPE_MODE (type
),
6824 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
6825 x
= TREE_VALUE (TREE_OPERAND (arg
, 1));
6826 exponent
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg
, 1)));
6832 /* Now perform the optimization. */
6836 arglist
= build_tree_list (NULL_TREE
, x
);
6837 logfn
= build_function_call_expr (fndecl
, arglist
);
6838 return fold (build2 (MULT_EXPR
, type
, exponent
, logfn
));
6846 /* Fold a builtin function call to pow, powf, or powl. Return
6847 NULL_TREE if no simplification can be made. */
6849 fold_builtin_pow (tree fndecl
, tree arglist
, tree type
)
6851 enum built_in_function fcode
;
6852 tree arg0
= TREE_VALUE (arglist
);
6853 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
6855 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
6858 /* Optimize pow(1.0,y) = 1.0. */
6859 if (real_onep (arg0
))
6860 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
6862 if (TREE_CODE (arg1
) == REAL_CST
6863 && ! TREE_CONSTANT_OVERFLOW (arg1
))
6865 REAL_VALUE_TYPE cint
;
6869 c
= TREE_REAL_CST (arg1
);
6871 /* Optimize pow(x,0.0) = 1.0. */
6872 if (REAL_VALUES_EQUAL (c
, dconst0
))
6873 return omit_one_operand (type
, build_real (type
, dconst1
),
6876 /* Optimize pow(x,1.0) = x. */
6877 if (REAL_VALUES_EQUAL (c
, dconst1
))
6880 /* Optimize pow(x,-1.0) = 1.0/x. */
6881 if (REAL_VALUES_EQUAL (c
, dconstm1
))
6882 return fold (build2 (RDIV_EXPR
, type
,
6883 build_real (type
, dconst1
), arg0
));
6885 /* Optimize pow(x,0.5) = sqrt(x). */
6886 if (flag_unsafe_math_optimizations
6887 && REAL_VALUES_EQUAL (c
, dconsthalf
))
6889 tree sqrtfn
= mathfn_built_in (type
, BUILT_IN_SQRT
);
6891 if (sqrtfn
!= NULL_TREE
)
6893 tree arglist
= build_tree_list (NULL_TREE
, arg0
);
6894 return build_function_call_expr (sqrtfn
, arglist
);
6898 /* Check for an integer exponent. */
6899 n
= real_to_integer (&c
);
6900 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
6901 if (real_identical (&c
, &cint
))
6903 /* Attempt to evaluate pow at compile-time. */
6904 if (TREE_CODE (arg0
) == REAL_CST
6905 && ! TREE_CONSTANT_OVERFLOW (arg0
))
6910 x
= TREE_REAL_CST (arg0
);
6911 inexact
= real_powi (&x
, TYPE_MODE (type
), &x
, n
);
6912 if (flag_unsafe_math_optimizations
|| !inexact
)
6913 return build_real (type
, x
);
6916 /* Strip sign ops from even integer powers. */
6917 if ((n
& 1) == 0 && flag_unsafe_math_optimizations
)
6919 tree narg0
= fold_strip_sign_ops (arg0
);
6922 arglist
= build_tree_list (NULL_TREE
, arg1
);
6923 arglist
= tree_cons (NULL_TREE
, narg0
, arglist
);
6924 return build_function_call_expr (fndecl
, arglist
);
6930 /* Optimize pow(expN(x),y) = expN(x*y). */
6931 fcode
= builtin_mathfn_code (arg0
);
6932 if (flag_unsafe_math_optimizations
&& BUILTIN_EXPONENT_P (fcode
))
6934 tree expfn
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
6935 tree arg
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
6936 arg
= fold (build2 (MULT_EXPR
, type
, arg
, arg1
));
6937 arglist
= build_tree_list (NULL_TREE
, arg
);
6938 return build_function_call_expr (expfn
, arglist
);
6941 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
6942 if (flag_unsafe_math_optimizations
&& BUILTIN_SQRT_P (fcode
))
6944 tree narg0
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
6945 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg1
,
6946 build_real (type
, dconsthalf
)));
6948 arglist
= tree_cons (NULL_TREE
, narg0
,
6949 build_tree_list (NULL_TREE
, narg1
));
6950 return build_function_call_expr (fndecl
, arglist
);
6953 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
6954 if (flag_unsafe_math_optimizations
6955 && (fcode
== BUILT_IN_POW
6956 || fcode
== BUILT_IN_POWF
6957 || fcode
== BUILT_IN_POWL
))
6959 tree arg00
= TREE_VALUE (TREE_OPERAND (arg0
, 1));
6960 tree arg01
= TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0
, 1)));
6961 tree narg1
= fold (build2 (MULT_EXPR
, type
, arg01
, arg1
));
6962 arglist
= tree_cons (NULL_TREE
, arg00
,
6963 build_tree_list (NULL_TREE
, narg1
));
6964 return build_function_call_expr (fndecl
, arglist
);
6969 /* Fold a builtin function call to powi, powif, or powil. Return
6970 NULL_TREE if no simplification can be made. */
6972 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED
, tree arglist
, tree type
)
6974 tree arg0
= TREE_VALUE (arglist
);
6975 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
6977 if (!validate_arglist (arglist
, REAL_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
6980 /* Optimize pow(1.0,y) = 1.0. */
6981 if (real_onep (arg0
))
6982 return omit_one_operand (type
, build_real (type
, dconst1
), arg1
);
6984 if (host_integerp (arg1
, 0))
6986 HOST_WIDE_INT c
= TREE_INT_CST_LOW (arg1
);
6988 /* Evaluate powi at compile-time. */
6989 if (TREE_CODE (arg0
) == REAL_CST
6990 && ! TREE_CONSTANT_OVERFLOW (arg0
))
6993 x
= TREE_REAL_CST (arg0
);
6994 real_powi (&x
, TYPE_MODE (type
), &x
, c
);
6995 return build_real (type
, x
);
6998 /* Optimize pow(x,0) = 1.0. */
7000 return omit_one_operand (type
, build_real (type
, dconst1
),
7003 /* Optimize pow(x,1) = x. */
7007 /* Optimize pow(x,-1) = 1.0/x. */
7009 return fold (build2 (RDIV_EXPR
, type
,
7010 build_real (type
, dconst1
), arg0
));
7016 /* A subroutine of fold_builtin to fold the various exponent
7017 functions. EXP is the CALL_EXPR of a call to a builtin function.
7018 VALUE is the value which will be raised to a power. */
7021 fold_builtin_exponent (tree exp
, const REAL_VALUE_TYPE
*value
)
7023 tree arglist
= TREE_OPERAND (exp
, 1);
7025 if (validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7027 tree fndecl
= get_callee_fndecl (exp
);
7028 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7029 tree arg
= TREE_VALUE (arglist
);
7031 /* Optimize exp*(0.0) = 1.0. */
7032 if (real_zerop (arg
))
7033 return build_real (type
, dconst1
);
7035 /* Optimize expN(1.0) = N. */
7036 if (real_onep (arg
))
7038 REAL_VALUE_TYPE cst
;
7040 real_convert (&cst
, TYPE_MODE (type
), value
);
7041 return build_real (type
, cst
);
7044 /* Attempt to evaluate expN(integer) at compile-time. */
7045 if (flag_unsafe_math_optimizations
7046 && TREE_CODE (arg
) == REAL_CST
7047 && ! TREE_CONSTANT_OVERFLOW (arg
))
7049 REAL_VALUE_TYPE cint
;
7053 c
= TREE_REAL_CST (arg
);
7054 n
= real_to_integer (&c
);
7055 real_from_integer (&cint
, VOIDmode
, n
,
7057 if (real_identical (&c
, &cint
))
7061 real_powi (&x
, TYPE_MODE (type
), value
, n
);
7062 return build_real (type
, x
);
7066 /* Optimize expN(logN(x)) = x. */
7067 if (flag_unsafe_math_optimizations
)
7069 const enum built_in_function fcode
= builtin_mathfn_code (arg
);
7071 if ((value
== &dconste
7072 && (fcode
== BUILT_IN_LOG
7073 || fcode
== BUILT_IN_LOGF
7074 || fcode
== BUILT_IN_LOGL
))
7075 || (value
== &dconst2
7076 && (fcode
== BUILT_IN_LOG2
7077 || fcode
== BUILT_IN_LOG2F
7078 || fcode
== BUILT_IN_LOG2L
))
7079 || (value
== &dconst10
7080 && (fcode
== BUILT_IN_LOG10
7081 || fcode
== BUILT_IN_LOG10F
7082 || fcode
== BUILT_IN_LOG10L
)))
7083 return fold_convert (type
, TREE_VALUE (TREE_OPERAND (arg
, 1)));
7090 /* Fold function call to builtin memcpy. Return
7091 NULL_TREE if no simplification can be made. */
7094 fold_builtin_memcpy (tree exp
)
7096 tree arglist
= TREE_OPERAND (exp
, 1);
7097 tree dest
, src
, len
;
7099 if (!validate_arglist (arglist
,
7100 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7103 dest
= TREE_VALUE (arglist
);
7104 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7105 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7107 /* If the LEN parameter is zero, return DEST. */
7108 if (integer_zerop (len
))
7109 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7111 /* If SRC and DEST are the same (and not volatile), return DEST. */
7112 if (operand_equal_p (src
, dest
, 0))
7113 return omit_one_operand (TREE_TYPE (exp
), dest
, len
);
7118 /* Fold function call to builtin mempcpy. Return
7119 NULL_TREE if no simplification can be made. */
7122 fold_builtin_mempcpy (tree arglist
, tree type
, int endp
)
7124 if (validate_arglist (arglist
,
7125 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7127 tree dest
= TREE_VALUE (arglist
);
7128 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
7129 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7131 /* If the LEN parameter is zero, return DEST. */
7132 if (integer_zerop (len
))
7133 return omit_one_operand (type
, dest
, src
);
7135 /* If SRC and DEST are the same (and not volatile), return DEST+LEN. */
7136 if (operand_equal_p (src
, dest
, 0))
7139 return omit_one_operand (type
, dest
, len
);
7142 len
= fold (build2 (MINUS_EXPR
, TREE_TYPE (len
), len
,
7145 len
= fold_convert (TREE_TYPE (dest
), len
);
7146 len
= fold (build2 (PLUS_EXPR
, TREE_TYPE (dest
), dest
, len
));
7147 return fold_convert (type
, len
);
7153 /* Fold function call to builtin memmove. Return
7154 NULL_TREE if no simplification can be made. */
7157 fold_builtin_memmove (tree arglist
, tree type
)
7159 tree dest
, src
, len
;
7161 if (!validate_arglist (arglist
,
7162 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7165 dest
= TREE_VALUE (arglist
);
7166 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7167 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7169 /* If the LEN parameter is zero, return DEST. */
7170 if (integer_zerop (len
))
7171 return omit_one_operand (type
, dest
, src
);
7173 /* If SRC and DEST are the same (and not volatile), return DEST. */
7174 if (operand_equal_p (src
, dest
, 0))
7175 return omit_one_operand (type
, dest
, len
);
7180 /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
7181 the length of the string to be copied. Return NULL_TREE if no
7182 simplification can be made. */
7185 fold_builtin_strcpy (tree exp
, tree len
)
7187 tree arglist
= TREE_OPERAND (exp
, 1);
7190 if (!validate_arglist (arglist
,
7191 POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7194 dest
= TREE_VALUE (arglist
);
7195 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7197 /* If SRC and DEST are the same (and not volatile), return DEST. */
7198 if (operand_equal_p (src
, dest
, 0))
7199 return fold_convert (TREE_TYPE (exp
), dest
);
7204 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7210 len
= c_strlen (src
, 1);
7211 if (! len
|| TREE_SIDE_EFFECTS (len
))
7215 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
7216 arglist
= build_tree_list (NULL_TREE
, len
);
7217 arglist
= tree_cons (NULL_TREE
, src
, arglist
);
7218 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
7219 return fold_convert (TREE_TYPE (exp
),
7220 build_function_call_expr (fn
, arglist
));
7223 /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
7224 the length of the source string. Return NULL_TREE if no simplification
7228 fold_builtin_strncpy (tree exp
, tree slen
)
7230 tree arglist
= TREE_OPERAND (exp
, 1);
7231 tree dest
, src
, len
, fn
;
7233 if (!validate_arglist (arglist
,
7234 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7237 dest
= TREE_VALUE (arglist
);
7238 src
= TREE_VALUE (TREE_CHAIN (arglist
));
7239 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7241 /* If the LEN parameter is zero, return DEST. */
7242 if (integer_zerop (len
))
7243 return omit_one_operand (TREE_TYPE (exp
), dest
, src
);
7245 /* We can't compare slen with len as constants below if len is not a
7247 if (len
== 0 || TREE_CODE (len
) != INTEGER_CST
)
7251 slen
= c_strlen (src
, 1);
7253 /* Now, we must be passed a constant src ptr parameter. */
7254 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
7257 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
7259 /* We do not support simplification of this case, though we do
7260 support it when expanding trees into RTL. */
7261 /* FIXME: generate a call to __builtin_memset. */
7262 if (tree_int_cst_lt (slen
, len
))
7265 /* OK transform into builtin memcpy. */
7266 fn
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
7269 return fold_convert (TREE_TYPE (exp
),
7270 build_function_call_expr (fn
, arglist
));
7273 /* Fold function call to builtin memcmp. Return
7274 NULL_TREE if no simplification can be made. */
7277 fold_builtin_memcmp (tree arglist
)
7279 tree arg1
, arg2
, len
;
7280 const char *p1
, *p2
;
7282 if (!validate_arglist (arglist
,
7283 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7286 arg1
= TREE_VALUE (arglist
);
7287 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7288 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7290 /* If the LEN parameter is zero, return zero. */
7291 if (integer_zerop (len
))
7292 return omit_two_operands (integer_type_node
, integer_zero_node
,
7295 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7296 if (operand_equal_p (arg1
, arg2
, 0))
7297 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
7299 p1
= c_getstr (arg1
);
7300 p2
= c_getstr (arg2
);
7302 /* If all arguments are constant, and the value of len is not greater
7303 than the lengths of arg1 and arg2, evaluate at compile-time. */
7304 if (host_integerp (len
, 1) && p1
&& p2
7305 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
7306 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
7308 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
7311 return integer_one_node
;
7313 return integer_minus_one_node
;
7315 return integer_zero_node
;
7318 /* If len parameter is one, return an expression corresponding to
7319 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7320 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
7322 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7323 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7324 tree ind1
= fold_convert (integer_type_node
,
7325 build1 (INDIRECT_REF
, cst_uchar_node
,
7326 fold_convert (cst_uchar_ptr_node
,
7328 tree ind2
= fold_convert (integer_type_node
,
7329 build1 (INDIRECT_REF
, cst_uchar_node
,
7330 fold_convert (cst_uchar_ptr_node
,
7332 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
7338 /* Fold function call to builtin strcmp. Return
7339 NULL_TREE if no simplification can be made. */
7342 fold_builtin_strcmp (tree arglist
)
7345 const char *p1
, *p2
;
7347 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
7350 arg1
= TREE_VALUE (arglist
);
7351 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7353 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7354 if (operand_equal_p (arg1
, arg2
, 0))
7355 return integer_zero_node
;
7357 p1
= c_getstr (arg1
);
7358 p2
= c_getstr (arg2
);
7362 const int i
= strcmp (p1
, p2
);
7364 return integer_minus_one_node
;
7366 return integer_one_node
;
7368 return integer_zero_node
;
7371 /* If the second arg is "", return *(const unsigned char*)arg1. */
7372 if (p2
&& *p2
== '\0')
7374 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7375 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7376 return fold_convert (integer_type_node
,
7377 build1 (INDIRECT_REF
, cst_uchar_node
,
7378 fold_convert (cst_uchar_ptr_node
,
7382 /* If the first arg is "", return -*(const unsigned char*)arg2. */
7383 if (p1
&& *p1
== '\0')
7385 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7386 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7387 tree temp
= fold_convert (integer_type_node
,
7388 build1 (INDIRECT_REF
, cst_uchar_node
,
7389 fold_convert (cst_uchar_ptr_node
,
7391 return fold (build1 (NEGATE_EXPR
, integer_type_node
, temp
));
7397 /* Fold function call to builtin strncmp. Return
7398 NULL_TREE if no simplification can be made. */
7401 fold_builtin_strncmp (tree arglist
)
7403 tree arg1
, arg2
, len
;
7404 const char *p1
, *p2
;
7406 if (!validate_arglist (arglist
,
7407 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
7410 arg1
= TREE_VALUE (arglist
);
7411 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7412 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
7414 /* If the LEN parameter is zero, return zero. */
7415 if (integer_zerop (len
))
7416 return omit_two_operands (integer_type_node
, integer_zero_node
,
7419 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
7420 if (operand_equal_p (arg1
, arg2
, 0))
7421 return omit_one_operand (integer_type_node
, integer_zero_node
, len
);
7423 p1
= c_getstr (arg1
);
7424 p2
= c_getstr (arg2
);
7426 if (host_integerp (len
, 1) && p1
&& p2
)
7428 const int i
= strncmp (p1
, p2
, tree_low_cst (len
, 1));
7430 return integer_one_node
;
7432 return integer_minus_one_node
;
7434 return integer_zero_node
;
7437 /* If the second arg is "", and the length is greater than zero,
7438 return *(const unsigned char*)arg1. */
7439 if (p2
&& *p2
== '\0'
7440 && TREE_CODE (len
) == INTEGER_CST
7441 && tree_int_cst_sgn (len
) == 1)
7443 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7444 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7445 return fold_convert (integer_type_node
,
7446 build1 (INDIRECT_REF
, cst_uchar_node
,
7447 fold_convert (cst_uchar_ptr_node
,
7451 /* If the first arg is "", and the length is greater than zero,
7452 return -*(const unsigned char*)arg2. */
7453 if (p1
&& *p1
== '\0'
7454 && TREE_CODE (len
) == INTEGER_CST
7455 && tree_int_cst_sgn (len
) == 1)
7457 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7458 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7459 tree temp
= fold_convert (integer_type_node
,
7460 build1 (INDIRECT_REF
, cst_uchar_node
,
7461 fold_convert (cst_uchar_ptr_node
,
7463 return fold (build1 (NEGATE_EXPR
, integer_type_node
, temp
));
7466 /* If len parameter is one, return an expression corresponding to
7467 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
7468 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
7470 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
7471 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
7472 tree ind1
= fold_convert (integer_type_node
,
7473 build1 (INDIRECT_REF
, cst_uchar_node
,
7474 fold_convert (cst_uchar_ptr_node
,
7476 tree ind2
= fold_convert (integer_type_node
,
7477 build1 (INDIRECT_REF
, cst_uchar_node
,
7478 fold_convert (cst_uchar_ptr_node
,
7480 return fold (build2 (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
7486 /* Fold function call to builtin signbit, signbitf or signbitl. Return
7487 NULL_TREE if no simplification can be made. */
7490 fold_builtin_signbit (tree exp
)
7492 tree arglist
= TREE_OPERAND (exp
, 1);
7495 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7498 arg
= TREE_VALUE (arglist
);
7500 /* If ARG is a compile-time constant, determine the result. */
7501 if (TREE_CODE (arg
) == REAL_CST
7502 && !TREE_CONSTANT_OVERFLOW (arg
))
7506 c
= TREE_REAL_CST (arg
);
7507 temp
= REAL_VALUE_NEGATIVE (c
) ? integer_one_node
: integer_zero_node
;
7508 return fold_convert (TREE_TYPE (exp
), temp
);
7511 /* If ARG is non-negative, the result is always zero. */
7512 if (tree_expr_nonnegative_p (arg
))
7513 return omit_one_operand (TREE_TYPE (exp
), integer_zero_node
, arg
);
7515 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
7516 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg
))))
7517 return fold (build2 (LT_EXPR
, TREE_TYPE (exp
), arg
,
7518 build_real (TREE_TYPE (arg
), dconst0
)));
7523 /* Fold function call to builtin copysign, copysignf or copysignl.
7524 Return NULL_TREE if no simplification can be made. */
7527 fold_builtin_copysign (tree fndecl
, tree arglist
, tree type
)
7529 tree arg1
, arg2
, tem
;
7531 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7534 arg1
= TREE_VALUE (arglist
);
7535 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
7537 /* copysign(X,X) is X. */
7538 if (operand_equal_p (arg1
, arg2
, 0))
7539 return fold_convert (type
, arg1
);
7541 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
7542 if (TREE_CODE (arg1
) == REAL_CST
7543 && TREE_CODE (arg2
) == REAL_CST
7544 && !TREE_CONSTANT_OVERFLOW (arg1
)
7545 && !TREE_CONSTANT_OVERFLOW (arg2
))
7547 REAL_VALUE_TYPE c1
, c2
;
7549 c1
= TREE_REAL_CST (arg1
);
7550 c2
= TREE_REAL_CST (arg2
);
7551 real_copysign (&c1
, &c2
);
7552 return build_real (type
, c1
);
7556 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
7557 Remember to evaluate Y for side-effects. */
7558 if (tree_expr_nonnegative_p (arg2
))
7559 return omit_one_operand (type
,
7560 fold (build1 (ABS_EXPR
, type
, arg1
)),
7563 /* Strip sign changing operations for the first argument. */
7564 tem
= fold_strip_sign_ops (arg1
);
7567 arglist
= tree_cons (NULL_TREE
, tem
, TREE_CHAIN (arglist
));
7568 return build_function_call_expr (fndecl
, arglist
);
7574 /* Fold a call to builtin isascii. */
7577 fold_builtin_isascii (tree arglist
)
7579 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7583 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
7584 tree arg
= TREE_VALUE (arglist
);
7586 arg
= build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
7587 build_int_cst (NULL_TREE
,
7588 ~ (unsigned HOST_WIDE_INT
) 0x7f));
7589 arg
= fold (build2 (EQ_EXPR
, integer_type_node
,
7590 arg
, integer_zero_node
));
7592 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
7599 /* Fold a call to builtin toascii. */
7602 fold_builtin_toascii (tree arglist
)
7604 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7608 /* Transform toascii(c) -> (c & 0x7f). */
7609 tree arg
= TREE_VALUE (arglist
);
7611 return fold (build2 (BIT_AND_EXPR
, integer_type_node
, arg
,
7612 build_int_cst (NULL_TREE
, 0x7f)));
7616 /* Fold a call to builtin isdigit. */
7619 fold_builtin_isdigit (tree arglist
)
7621 if (! validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7625 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
7626 /* According to the C standard, isdigit is unaffected by locale. */
7627 tree arg
= TREE_VALUE (arglist
);
7628 arg
= fold_convert (unsigned_type_node
, arg
);
7629 arg
= build2 (MINUS_EXPR
, unsigned_type_node
, arg
,
7630 build_int_cst (unsigned_type_node
, TARGET_DIGIT0
));
7631 arg
= build2 (LE_EXPR
, integer_type_node
, arg
,
7632 build_int_cst (unsigned_type_node
, 9));
7634 if (in_gimple_form
&& !TREE_CONSTANT (arg
))
7641 /* Fold a call to fabs, fabsf or fabsl. */
7644 fold_builtin_fabs (tree arglist
, tree type
)
7648 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7651 arg
= TREE_VALUE (arglist
);
7652 arg
= fold_convert (type
, arg
);
7653 if (TREE_CODE (arg
) == REAL_CST
)
7654 return fold_abs_const (arg
, type
);
7655 return fold (build1 (ABS_EXPR
, type
, arg
));
7658 /* Fold a call to abs, labs, llabs or imaxabs. */
7661 fold_builtin_abs (tree arglist
, tree type
)
7665 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
7668 arg
= TREE_VALUE (arglist
);
7669 arg
= fold_convert (type
, arg
);
7670 if (TREE_CODE (arg
) == INTEGER_CST
)
7671 return fold_abs_const (arg
, type
);
7672 return fold (build1 (ABS_EXPR
, type
, arg
));
7675 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
7676 EXP is the CALL_EXPR for the call. */
7679 fold_builtin_classify (tree exp
, int builtin_index
)
7681 tree fndecl
= get_callee_fndecl (exp
);
7682 tree arglist
= TREE_OPERAND (exp
, 1);
7683 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7687 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
7689 /* Check that we have exactly one argument. */
7692 error ("too few arguments to function %qs",
7693 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7694 return error_mark_node
;
7696 else if (TREE_CHAIN (arglist
) != 0)
7698 error ("too many arguments to function %qs",
7699 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7700 return error_mark_node
;
7704 error ("non-floating-point argument to function %qs",
7705 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7706 return error_mark_node
;
7710 arg
= TREE_VALUE (arglist
);
7711 switch (builtin_index
)
7713 case BUILT_IN_ISINF
:
7714 if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
7715 return omit_one_operand (type
, integer_zero_node
, arg
);
7717 if (TREE_CODE (arg
) == REAL_CST
)
7719 r
= TREE_REAL_CST (arg
);
7720 if (real_isinf (&r
))
7721 return real_compare (GT_EXPR
, &r
, &dconst0
)
7722 ? integer_one_node
: integer_minus_one_node
;
7724 return integer_zero_node
;
7729 case BUILT_IN_FINITE
:
7730 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
)))
7731 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg
))))
7732 return omit_one_operand (type
, integer_zero_node
, arg
);
7734 if (TREE_CODE (arg
) == REAL_CST
)
7736 r
= TREE_REAL_CST (arg
);
7737 return real_isinf (&r
) || real_isnan (&r
)
7738 ? integer_zero_node
: integer_one_node
;
7743 case BUILT_IN_ISNAN
:
7744 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg
))))
7745 return omit_one_operand (type
, integer_zero_node
, arg
);
7747 if (TREE_CODE (arg
) == REAL_CST
)
7749 r
= TREE_REAL_CST (arg
);
7750 return real_isnan (&r
) ? integer_one_node
: integer_zero_node
;
7753 arg
= builtin_save_expr (arg
);
7754 return fold (build2 (UNORDERED_EXPR
, type
, arg
, arg
));
7761 /* Fold a call to an unordered comparison function such as
7762 __builtin_isgreater(). EXP is the CALL_EXPR for the call.
7763 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
7764 the opposite of the desired result. UNORDERED_CODE is used
7765 for modes that can hold NaNs and ORDERED_CODE is used for
7769 fold_builtin_unordered_cmp (tree exp
,
7770 enum tree_code unordered_code
,
7771 enum tree_code ordered_code
)
7773 tree fndecl
= get_callee_fndecl (exp
);
7774 tree arglist
= TREE_OPERAND (exp
, 1);
7775 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7776 enum tree_code code
;
7779 enum tree_code code0
, code1
;
7780 tree cmp_type
= NULL_TREE
;
7782 if (!validate_arglist (arglist
, REAL_TYPE
, REAL_TYPE
, VOID_TYPE
))
7784 /* Check that we have exactly two arguments. */
7785 if (arglist
== 0 || TREE_CHAIN (arglist
) == 0)
7787 error ("too few arguments to function %qs",
7788 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7789 return error_mark_node
;
7791 else if (TREE_CHAIN (TREE_CHAIN (arglist
)) != 0)
7793 error ("too many arguments to function %qs",
7794 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7795 return error_mark_node
;
7799 arg0
= TREE_VALUE (arglist
);
7800 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
7802 type0
= TREE_TYPE (arg0
);
7803 type1
= TREE_TYPE (arg1
);
7805 code0
= TREE_CODE (type0
);
7806 code1
= TREE_CODE (type1
);
7808 if (code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
7809 /* Choose the wider of two real types. */
7810 cmp_type
= TYPE_PRECISION (type0
) >= TYPE_PRECISION (type1
)
7812 else if (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
7814 else if (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)
7818 error ("non-floating-point argument to function %qs",
7819 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
7820 return error_mark_node
;
7823 arg0
= fold_convert (cmp_type
, arg0
);
7824 arg1
= fold_convert (cmp_type
, arg1
);
7826 if (unordered_code
== UNORDERED_EXPR
)
7828 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
7829 return omit_two_operands (type
, integer_zero_node
, arg0
, arg1
);
7830 return fold (build2 (UNORDERED_EXPR
, type
, arg0
, arg1
));
7833 code
= MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0
))) ? unordered_code
7835 return fold (build1 (TRUTH_NOT_EXPR
, type
,
7836 fold (build2 (code
, type
, arg0
, arg1
))));
7839 /* Used by constant folding to simplify calls to builtin functions. EXP is
7840 the CALL_EXPR of a call to a builtin function. IGNORE is true if the
7841 result of the function call is ignored. This function returns NULL_TREE
7842 if no simplification was possible. */
7845 fold_builtin_1 (tree exp
, bool ignore
)
7847 tree fndecl
= get_callee_fndecl (exp
);
7848 tree arglist
= TREE_OPERAND (exp
, 1);
7849 tree type
= TREE_TYPE (TREE_TYPE (fndecl
));
7851 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
7852 return targetm
.fold_builtin (exp
, ignore
);
7854 switch (DECL_FUNCTION_CODE (fndecl
))
7856 case BUILT_IN_FPUTS
:
7857 return fold_builtin_fputs (arglist
, ignore
, false, NULL_TREE
);
7859 case BUILT_IN_FPUTS_UNLOCKED
:
7860 return fold_builtin_fputs (arglist
, ignore
, true, NULL_TREE
);
7862 case BUILT_IN_STRSTR
:
7863 return fold_builtin_strstr (arglist
, type
);
7865 case BUILT_IN_STRCAT
:
7866 return fold_builtin_strcat (arglist
);
7868 case BUILT_IN_STRNCAT
:
7869 return fold_builtin_strncat (arglist
);
7871 case BUILT_IN_STRSPN
:
7872 return fold_builtin_strspn (arglist
);
7874 case BUILT_IN_STRCSPN
:
7875 return fold_builtin_strcspn (arglist
);
7877 case BUILT_IN_STRCHR
:
7878 case BUILT_IN_INDEX
:
7879 return fold_builtin_strchr (arglist
, type
);
7881 case BUILT_IN_STRRCHR
:
7882 case BUILT_IN_RINDEX
:
7883 return fold_builtin_strrchr (arglist
, type
);
7885 case BUILT_IN_STRCPY
:
7886 return fold_builtin_strcpy (exp
, NULL_TREE
);
7888 case BUILT_IN_STRNCPY
:
7889 return fold_builtin_strncpy (exp
, NULL_TREE
);
7891 case BUILT_IN_STRCMP
:
7892 return fold_builtin_strcmp (arglist
);
7894 case BUILT_IN_STRNCMP
:
7895 return fold_builtin_strncmp (arglist
);
7897 case BUILT_IN_STRPBRK
:
7898 return fold_builtin_strpbrk (arglist
, type
);
7901 case BUILT_IN_MEMCMP
:
7902 return fold_builtin_memcmp (arglist
);
7904 case BUILT_IN_SPRINTF
:
7905 return fold_builtin_sprintf (arglist
, ignore
);
7907 case BUILT_IN_CONSTANT_P
:
7911 val
= fold_builtin_constant_p (arglist
);
7912 /* Gimplification will pull the CALL_EXPR for the builtin out of
7913 an if condition. When not optimizing, we'll not CSE it back.
7914 To avoid link error types of regressions, return false now. */
7915 if (!val
&& !optimize
)
7916 val
= integer_zero_node
;
7921 case BUILT_IN_EXPECT
:
7922 return fold_builtin_expect (arglist
);
7924 case BUILT_IN_CLASSIFY_TYPE
:
7925 return fold_builtin_classify_type (arglist
);
7927 case BUILT_IN_STRLEN
:
7928 return fold_builtin_strlen (arglist
);
7931 case BUILT_IN_FABSF
:
7932 case BUILT_IN_FABSL
:
7933 return fold_builtin_fabs (arglist
, type
);
7937 case BUILT_IN_LLABS
:
7938 case BUILT_IN_IMAXABS
:
7939 return fold_builtin_abs (arglist
, type
);
7942 case BUILT_IN_CONJF
:
7943 case BUILT_IN_CONJL
:
7944 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
7945 return fold (build1 (CONJ_EXPR
, type
, TREE_VALUE (arglist
)));
7948 case BUILT_IN_CREAL
:
7949 case BUILT_IN_CREALF
:
7950 case BUILT_IN_CREALL
:
7951 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
7952 return non_lvalue (fold (build1 (REALPART_EXPR
, type
,
7953 TREE_VALUE (arglist
))));
7956 case BUILT_IN_CIMAG
:
7957 case BUILT_IN_CIMAGF
:
7958 case BUILT_IN_CIMAGL
:
7959 if (validate_arglist (arglist
, COMPLEX_TYPE
, VOID_TYPE
))
7960 return non_lvalue (fold (build1 (IMAGPART_EXPR
, type
,
7961 TREE_VALUE (arglist
))));
7965 case BUILT_IN_CABSF
:
7966 case BUILT_IN_CABSL
:
7967 return fold_builtin_cabs (arglist
, type
);
7970 case BUILT_IN_SQRTF
:
7971 case BUILT_IN_SQRTL
:
7972 return fold_builtin_sqrt (arglist
, type
);
7975 case BUILT_IN_CBRTF
:
7976 case BUILT_IN_CBRTL
:
7977 return fold_builtin_cbrt (arglist
, type
);
7982 return fold_builtin_sin (arglist
);
7987 return fold_builtin_cos (arglist
, type
, fndecl
);
7992 return fold_builtin_exponent (exp
, &dconste
);
7995 case BUILT_IN_EXP2F
:
7996 case BUILT_IN_EXP2L
:
7997 return fold_builtin_exponent (exp
, &dconst2
);
7999 case BUILT_IN_EXP10
:
8000 case BUILT_IN_EXP10F
:
8001 case BUILT_IN_EXP10L
:
8002 case BUILT_IN_POW10
:
8003 case BUILT_IN_POW10F
:
8004 case BUILT_IN_POW10L
:
8005 return fold_builtin_exponent (exp
, &dconst10
);
8010 return fold_builtin_logarithm (exp
, &dconste
);
8013 case BUILT_IN_LOG2F
:
8014 case BUILT_IN_LOG2L
:
8015 return fold_builtin_logarithm (exp
, &dconst2
);
8017 case BUILT_IN_LOG10
:
8018 case BUILT_IN_LOG10F
:
8019 case BUILT_IN_LOG10L
:
8020 return fold_builtin_logarithm (exp
, &dconst10
);
8025 return fold_builtin_tan (arglist
);
8028 case BUILT_IN_ATANF
:
8029 case BUILT_IN_ATANL
:
8030 return fold_builtin_atan (arglist
, type
);
8035 return fold_builtin_pow (fndecl
, arglist
, type
);
8038 case BUILT_IN_POWIF
:
8039 case BUILT_IN_POWIL
:
8040 return fold_builtin_powi (fndecl
, arglist
, type
);
8045 return fold_builtin_inf (type
, true);
8047 case BUILT_IN_HUGE_VAL
:
8048 case BUILT_IN_HUGE_VALF
:
8049 case BUILT_IN_HUGE_VALL
:
8050 return fold_builtin_inf (type
, false);
8055 return fold_builtin_nan (arglist
, type
, true);
8058 case BUILT_IN_NANSF
:
8059 case BUILT_IN_NANSL
:
8060 return fold_builtin_nan (arglist
, type
, false);
8062 case BUILT_IN_FLOOR
:
8063 case BUILT_IN_FLOORF
:
8064 case BUILT_IN_FLOORL
:
8065 return fold_builtin_floor (exp
);
8068 case BUILT_IN_CEILF
:
8069 case BUILT_IN_CEILL
:
8070 return fold_builtin_ceil (exp
);
8072 case BUILT_IN_TRUNC
:
8073 case BUILT_IN_TRUNCF
:
8074 case BUILT_IN_TRUNCL
:
8075 return fold_builtin_trunc (exp
);
8077 case BUILT_IN_ROUND
:
8078 case BUILT_IN_ROUNDF
:
8079 case BUILT_IN_ROUNDL
:
8080 return fold_builtin_round (exp
);
8082 case BUILT_IN_NEARBYINT
:
8083 case BUILT_IN_NEARBYINTF
:
8084 case BUILT_IN_NEARBYINTL
:
8086 case BUILT_IN_RINTF
:
8087 case BUILT_IN_RINTL
:
8088 return fold_trunc_transparent_mathfn (exp
);
8090 case BUILT_IN_LROUND
:
8091 case BUILT_IN_LROUNDF
:
8092 case BUILT_IN_LROUNDL
:
8093 case BUILT_IN_LLROUND
:
8094 case BUILT_IN_LLROUNDF
:
8095 case BUILT_IN_LLROUNDL
:
8096 return fold_builtin_lround (exp
);
8098 case BUILT_IN_LRINT
:
8099 case BUILT_IN_LRINTF
:
8100 case BUILT_IN_LRINTL
:
8101 case BUILT_IN_LLRINT
:
8102 case BUILT_IN_LLRINTF
:
8103 case BUILT_IN_LLRINTL
:
8104 return fold_fixed_mathfn (exp
);
8108 case BUILT_IN_FFSLL
:
8111 case BUILT_IN_CLZLL
:
8114 case BUILT_IN_CTZLL
:
8115 case BUILT_IN_POPCOUNT
:
8116 case BUILT_IN_POPCOUNTL
:
8117 case BUILT_IN_POPCOUNTLL
:
8118 case BUILT_IN_PARITY
:
8119 case BUILT_IN_PARITYL
:
8120 case BUILT_IN_PARITYLL
:
8121 return fold_builtin_bitop (exp
);
8123 case BUILT_IN_MEMCPY
:
8124 return fold_builtin_memcpy (exp
);
8126 case BUILT_IN_MEMPCPY
:
8127 return fold_builtin_mempcpy (arglist
, type
, /*endp=*/1);
8129 case BUILT_IN_MEMMOVE
:
8130 return fold_builtin_memmove (arglist
, type
);
8132 case BUILT_IN_SIGNBIT
:
8133 case BUILT_IN_SIGNBITF
:
8134 case BUILT_IN_SIGNBITL
:
8135 return fold_builtin_signbit (exp
);
8137 case BUILT_IN_ISASCII
:
8138 return fold_builtin_isascii (arglist
);
8140 case BUILT_IN_TOASCII
:
8141 return fold_builtin_toascii (arglist
);
8143 case BUILT_IN_ISDIGIT
:
8144 return fold_builtin_isdigit (arglist
);
8146 case BUILT_IN_COPYSIGN
:
8147 case BUILT_IN_COPYSIGNF
:
8148 case BUILT_IN_COPYSIGNL
:
8149 return fold_builtin_copysign (fndecl
, arglist
, type
);
8151 case BUILT_IN_FINITE
:
8152 case BUILT_IN_FINITEF
:
8153 case BUILT_IN_FINITEL
:
8154 return fold_builtin_classify (exp
, BUILT_IN_FINITE
);
8156 case BUILT_IN_ISINF
:
8157 case BUILT_IN_ISINFF
:
8158 case BUILT_IN_ISINFL
:
8159 return fold_builtin_classify (exp
, BUILT_IN_ISINF
);
8161 case BUILT_IN_ISNAN
:
8162 case BUILT_IN_ISNANF
:
8163 case BUILT_IN_ISNANL
:
8164 return fold_builtin_classify (exp
, BUILT_IN_ISNAN
);
8166 case BUILT_IN_ISGREATER
:
8167 return fold_builtin_unordered_cmp (exp
, UNLE_EXPR
, LE_EXPR
);
8168 case BUILT_IN_ISGREATEREQUAL
:
8169 return fold_builtin_unordered_cmp (exp
, UNLT_EXPR
, LT_EXPR
);
8170 case BUILT_IN_ISLESS
:
8171 return fold_builtin_unordered_cmp (exp
, UNGE_EXPR
, GE_EXPR
);
8172 case BUILT_IN_ISLESSEQUAL
:
8173 return fold_builtin_unordered_cmp (exp
, UNGT_EXPR
, GT_EXPR
);
8174 case BUILT_IN_ISLESSGREATER
:
8175 return fold_builtin_unordered_cmp (exp
, UNEQ_EXPR
, EQ_EXPR
);
8176 case BUILT_IN_ISUNORDERED
:
8177 return fold_builtin_unordered_cmp (exp
, UNORDERED_EXPR
, NOP_EXPR
);
8179 /* We do the folding for va_start in the expander. */
8180 case BUILT_IN_VA_START
:
8190 /* A wrapper function for builtin folding that prevents warnings for
8191 "statement without effect" and the like, caused by removing the
8192 call node earlier than the warning is generated. */
8195 fold_builtin (tree exp
, bool ignore
)
8197 exp
= fold_builtin_1 (exp
, ignore
);
8200 /* ??? Don't clobber shared nodes such as integer_zero_node. */
8201 if (CONSTANT_CLASS_P (exp
))
8202 exp
= build1 (NOP_EXPR
, TREE_TYPE (exp
), exp
);
8203 TREE_NO_WARNING (exp
) = 1;
8209 /* Conveniently construct a function call expression. */
8212 build_function_call_expr (tree fn
, tree arglist
)
8216 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
8217 call_expr
= build3 (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
8218 call_expr
, arglist
, NULL_TREE
);
8219 return fold (call_expr
);
8222 /* This function validates the types of a function call argument list
8223 represented as a tree chain of parameters against a specified list
8224 of tree_codes. If the last specifier is a 0, that represents an
8225 ellipses, otherwise the last specifier must be a VOID_TYPE. */
8228 validate_arglist (tree arglist
, ...)
8230 enum tree_code code
;
8234 va_start (ap
, arglist
);
8238 code
= va_arg (ap
, enum tree_code
);
8242 /* This signifies an ellipses, any further arguments are all ok. */
8246 /* This signifies an endlink, if no arguments remain, return
8247 true, otherwise return false. */
8251 /* If no parameters remain or the parameter's code does not
8252 match the specified code, return false. Otherwise continue
8253 checking any remaining arguments. */
8256 if (code
== POINTER_TYPE
)
8258 if (! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist
))))
8261 else if (code
!= TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))))
8265 arglist
= TREE_CHAIN (arglist
);
8269 /* We need gotos here since we can only have one VA_CLOSE in a
8277 /* Default target-specific builtin expander that does nothing. */
8280 default_expand_builtin (tree exp ATTRIBUTE_UNUSED
,
8281 rtx target ATTRIBUTE_UNUSED
,
8282 rtx subtarget ATTRIBUTE_UNUSED
,
8283 enum machine_mode mode ATTRIBUTE_UNUSED
,
8284 int ignore ATTRIBUTE_UNUSED
)
8289 /* Returns true is EXP represents data that would potentially reside
8290 in a readonly section. */
8293 readonly_data_expr (tree exp
)
8297 if (TREE_CODE (exp
) != ADDR_EXPR
)
8300 exp
= get_base_address (TREE_OPERAND (exp
, 0));
8304 /* Make sure we call decl_readonly_section only for trees it
8305 can handle (since it returns true for everything it doesn't
8307 if (TREE_CODE (exp
) == STRING_CST
8308 || TREE_CODE (exp
) == CONSTRUCTOR
8309 || (TREE_CODE (exp
) == VAR_DECL
&& TREE_STATIC (exp
)))
8310 return decl_readonly_section (exp
, 0);
8315 /* Simplify a call to the strstr builtin.
8317 Return 0 if no simplification was possible, otherwise return the
8318 simplified form of the call as a tree.
8320 The simplified form may be a constant or other expression which
8321 computes the same value, but in a more efficient manner (including
8322 calls to other builtin functions).
8324 The call may contain arguments which need to be evaluated, but
8325 which are not useful to determine the result of the call. In
8326 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8327 COMPOUND_EXPR will be an argument which must be evaluated.
8328 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8329 COMPOUND_EXPR in the chain will contain the tree for the simplified
8330 form of the builtin function call. */
8333 fold_builtin_strstr (tree arglist
, tree type
)
8335 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8339 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8341 const char *p1
, *p2
;
8350 const char *r
= strstr (p1
, p2
);
8354 return build_int_cst (TREE_TYPE (s1
), 0);
8356 /* Return an offset into the constant string argument. */
8357 tem
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8358 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8359 return fold_convert (type
, tem
);
8368 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8372 /* New argument list transforming strstr(s1, s2) to
8373 strchr(s1, s2[0]). */
8374 arglist
= build_tree_list (NULL_TREE
,
8375 build_int_cst (NULL_TREE
, p2
[0]));
8376 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
8377 return build_function_call_expr (fn
, arglist
);
8381 /* Simplify a call to the strchr builtin.
8383 Return 0 if no simplification was possible, otherwise return the
8384 simplified form of the call as a tree.
8386 The simplified form may be a constant or other expression which
8387 computes the same value, but in a more efficient manner (including
8388 calls to other builtin functions).
8390 The call may contain arguments which need to be evaluated, but
8391 which are not useful to determine the result of the call. In
8392 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8393 COMPOUND_EXPR will be an argument which must be evaluated.
8394 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8395 COMPOUND_EXPR in the chain will contain the tree for the simplified
8396 form of the builtin function call. */
8399 fold_builtin_strchr (tree arglist
, tree type
)
8401 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8405 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8408 if (TREE_CODE (s2
) != INTEGER_CST
)
8418 if (target_char_cast (s2
, &c
))
8424 return build_int_cst (TREE_TYPE (s1
), 0);
8426 /* Return an offset into the constant string argument. */
8427 tem
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8428 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8429 return fold_convert (type
, tem
);
8435 /* Simplify a call to the strrchr builtin.
8437 Return 0 if no simplification was possible, otherwise return the
8438 simplified form of the call as a tree.
8440 The simplified form may be a constant or other expression which
8441 computes the same value, but in a more efficient manner (including
8442 calls to other builtin functions).
8444 The call may contain arguments which need to be evaluated, but
8445 which are not useful to determine the result of the call. In
8446 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8447 COMPOUND_EXPR will be an argument which must be evaluated.
8448 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8449 COMPOUND_EXPR in the chain will contain the tree for the simplified
8450 form of the builtin function call. */
8453 fold_builtin_strrchr (tree arglist
, tree type
)
8455 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8459 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8463 if (TREE_CODE (s2
) != INTEGER_CST
)
8473 if (target_char_cast (s2
, &c
))
8476 r
= strrchr (p1
, c
);
8479 return build_int_cst (TREE_TYPE (s1
), 0);
8481 /* Return an offset into the constant string argument. */
8482 tem
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8483 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8484 return fold_convert (type
, tem
);
8487 if (! integer_zerop (s2
))
8490 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8494 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
8495 return build_function_call_expr (fn
, arglist
);
8499 /* Simplify a call to the strpbrk builtin.
8501 Return 0 if no simplification was possible, otherwise return the
8502 simplified form of the call as a tree.
8504 The simplified form may be a constant or other expression which
8505 computes the same value, but in a more efficient manner (including
8506 calls to other builtin functions).
8508 The call may contain arguments which need to be evaluated, but
8509 which are not useful to determine the result of the call. In
8510 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8511 COMPOUND_EXPR will be an argument which must be evaluated.
8512 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8513 COMPOUND_EXPR in the chain will contain the tree for the simplified
8514 form of the builtin function call. */
8517 fold_builtin_strpbrk (tree arglist
, tree type
)
8519 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8523 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8525 const char *p1
, *p2
;
8534 const char *r
= strpbrk (p1
, p2
);
8538 return build_int_cst (TREE_TYPE (s1
), 0);
8540 /* Return an offset into the constant string argument. */
8541 tem
= fold (build2 (PLUS_EXPR
, TREE_TYPE (s1
),
8542 s1
, build_int_cst (TREE_TYPE (s1
), r
- p1
)));
8543 return fold_convert (type
, tem
);
8547 /* strpbrk(x, "") == NULL.
8548 Evaluate and ignore s1 in case it had side-effects. */
8549 return omit_one_operand (TREE_TYPE (s1
), integer_zero_node
, s1
);
8552 return 0; /* Really call strpbrk. */
8554 fn
= implicit_built_in_decls
[BUILT_IN_STRCHR
];
8558 /* New argument list transforming strpbrk(s1, s2) to
8559 strchr(s1, s2[0]). */
8560 arglist
= build_tree_list (NULL_TREE
,
8561 build_int_cst (NULL_TREE
, p2
[0]));
8562 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
8563 return build_function_call_expr (fn
, arglist
);
8567 /* Simplify a call to the strcat builtin.
8569 Return 0 if no simplification was possible, otherwise return the
8570 simplified form of the call as a tree.
8572 The simplified form may be a constant or other expression which
8573 computes the same value, but in a more efficient manner (including
8574 calls to other builtin functions).
8576 The call may contain arguments which need to be evaluated, but
8577 which are not useful to determine the result of the call. In
8578 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8579 COMPOUND_EXPR will be an argument which must be evaluated.
8580 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8581 COMPOUND_EXPR in the chain will contain the tree for the simplified
8582 form of the builtin function call. */
8585 fold_builtin_strcat (tree arglist
)
8587 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8591 tree dst
= TREE_VALUE (arglist
),
8592 src
= TREE_VALUE (TREE_CHAIN (arglist
));
8593 const char *p
= c_getstr (src
);
8595 /* If the string length is zero, return the dst parameter. */
8596 if (p
&& *p
== '\0')
8603 /* Simplify a call to the strncat builtin.
8605 Return 0 if no simplification was possible, otherwise return the
8606 simplified form of the call as a tree.
8608 The simplified form may be a constant or other expression which
8609 computes the same value, but in a more efficient manner (including
8610 calls to other builtin functions).
8612 The call may contain arguments which need to be evaluated, but
8613 which are not useful to determine the result of the call. In
8614 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8615 COMPOUND_EXPR will be an argument which must be evaluated.
8616 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8617 COMPOUND_EXPR in the chain will contain the tree for the simplified
8618 form of the builtin function call. */
8621 fold_builtin_strncat (tree arglist
)
8623 if (!validate_arglist (arglist
,
8624 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
8628 tree dst
= TREE_VALUE (arglist
);
8629 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
8630 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
8631 const char *p
= c_getstr (src
);
8633 /* If the requested length is zero, or the src parameter string
8634 length is zero, return the dst parameter. */
8635 if (integer_zerop (len
) || (p
&& *p
== '\0'))
8636 return omit_two_operands (TREE_TYPE (dst
), dst
, src
, len
);
8638 /* If the requested len is greater than or equal to the string
8639 length, call strcat. */
8640 if (TREE_CODE (len
) == INTEGER_CST
&& p
8641 && compare_tree_int (len
, strlen (p
)) >= 0)
8644 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
8645 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCAT
];
8647 /* If the replacement _DECL isn't initialized, don't do the
8652 return build_function_call_expr (fn
, newarglist
);
8658 /* Simplify a call to the strspn builtin.
8660 Return 0 if no simplification was possible, otherwise return the
8661 simplified form of the call as a tree.
8663 The simplified form may be a constant or other expression which
8664 computes the same value, but in a more efficient manner (including
8665 calls to other builtin functions).
8667 The call may contain arguments which need to be evaluated, but
8668 which are not useful to determine the result of the call. In
8669 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8670 COMPOUND_EXPR will be an argument which must be evaluated.
8671 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8672 COMPOUND_EXPR in the chain will contain the tree for the simplified
8673 form of the builtin function call. */
8676 fold_builtin_strspn (tree arglist
)
8678 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8682 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8683 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
8685 /* If both arguments are constants, evaluate at compile-time. */
8688 const size_t r
= strspn (p1
, p2
);
8689 return size_int (r
);
8692 /* If either argument is "", return 0. */
8693 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
8694 /* Evaluate and ignore both arguments in case either one has
8696 return omit_two_operands (integer_type_node
, integer_zero_node
,
8702 /* Simplify a call to the strcspn builtin.
8704 Return 0 if no simplification was possible, otherwise return the
8705 simplified form of the call as a tree.
8707 The simplified form may be a constant or other expression which
8708 computes the same value, but in a more efficient manner (including
8709 calls to other builtin functions).
8711 The call may contain arguments which need to be evaluated, but
8712 which are not useful to determine the result of the call. In
8713 this case we return a chain of COMPOUND_EXPRs. The LHS of each
8714 COMPOUND_EXPR will be an argument which must be evaluated.
8715 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
8716 COMPOUND_EXPR in the chain will contain the tree for the simplified
8717 form of the builtin function call. */
8720 fold_builtin_strcspn (tree arglist
)
8722 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8726 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
8727 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
8729 /* If both arguments are constants, evaluate at compile-time. */
8732 const size_t r
= strcspn (p1
, p2
);
8733 return size_int (r
);
8736 /* If the first argument is "", return 0. */
8737 if (p1
&& *p1
== '\0')
8739 /* Evaluate and ignore argument s2 in case it has
8741 return omit_one_operand (integer_type_node
,
8742 integer_zero_node
, s2
);
8745 /* If the second argument is "", return __builtin_strlen(s1). */
8746 if (p2
&& *p2
== '\0')
8748 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
8749 fn
= implicit_built_in_decls
[BUILT_IN_STRLEN
];
8751 /* If the replacement _DECL isn't initialized, don't do the
8756 return build_function_call_expr (fn
, newarglist
);
8762 /* Fold a call to the fputs builtin. IGNORE is true if the value returned
8763 by the builtin will be ignored. UNLOCKED is true is true if this
8764 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
8765 the known length of the string. Return NULL_TREE if no simplification
8769 fold_builtin_fputs (tree arglist
, bool ignore
, bool unlocked
, tree len
)
8772 tree fn_fputc
= unlocked
? implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
8773 : implicit_built_in_decls
[BUILT_IN_FPUTC
];
8774 tree fn_fwrite
= unlocked
? implicit_built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
8775 : implicit_built_in_decls
[BUILT_IN_FWRITE
];
8777 /* If the return value is used, or the replacement _DECL isn't
8778 initialized, don't do the transformation. */
8779 if (!ignore
|| !fn_fputc
|| !fn_fwrite
)
8782 /* Verify the arguments in the original call. */
8783 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
8787 len
= c_strlen (TREE_VALUE (arglist
), 0);
8789 /* Get the length of the string passed to fputs. If the length
8790 can't be determined, punt. */
8792 || TREE_CODE (len
) != INTEGER_CST
)
8795 switch (compare_tree_int (len
, 1))
8797 case -1: /* length is 0, delete the call entirely . */
8798 return omit_one_operand (integer_type_node
, integer_zero_node
,
8799 TREE_VALUE (TREE_CHAIN (arglist
)));
8801 case 0: /* length is 1, call fputc. */
8803 const char *p
= c_getstr (TREE_VALUE (arglist
));
8807 /* New argument list transforming fputs(string, stream) to
8808 fputc(string[0], stream). */
8809 arglist
= build_tree_list (NULL_TREE
,
8810 TREE_VALUE (TREE_CHAIN (arglist
)));
8811 arglist
= tree_cons (NULL_TREE
,
8812 build_int_cst (NULL_TREE
, p
[0]),
8819 case 1: /* length is greater than 1, call fwrite. */
8823 /* If optimizing for size keep fputs. */
8826 string_arg
= TREE_VALUE (arglist
);
8827 /* New argument list transforming fputs(string, stream) to
8828 fwrite(string, 1, len, stream). */
8829 arglist
= build_tree_list (NULL_TREE
,
8830 TREE_VALUE (TREE_CHAIN (arglist
)));
8831 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
8832 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
8833 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
8841 /* These optimizations are only performed when the result is ignored,
8842 hence there's no need to cast the result to integer_type_node. */
8843 return build_function_call_expr (fn
, arglist
);
8846 /* Fold the new_arg's arguments (ARGLIST). Returns true if there was an error
8847 produced. False otherwise. This is done so that we don't output the error
8848 or warning twice or three times. */
8850 fold_builtin_next_arg (tree arglist
)
8852 tree fntype
= TREE_TYPE (current_function_decl
);
8854 if (TYPE_ARG_TYPES (fntype
) == 0
8855 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
8858 error ("%<va_start%> used in function with fixed args");
8863 /* Evidently an out of date version of <stdarg.h>; can't validate
8864 va_start's second argument, but can still work as intended. */
8865 warning ("%<__builtin_next_arg%> called without an argument");
8868 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
8869 when we checked the arguments and if needed issued a warning. */
8870 else if (!TREE_CHAIN (arglist
)
8871 || !integer_zerop (TREE_VALUE (arglist
))
8872 || !integer_zerop (TREE_VALUE (TREE_CHAIN (arglist
)))
8873 || TREE_CHAIN (TREE_CHAIN (arglist
)))
8875 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
8876 tree arg
= TREE_VALUE (arglist
);
8878 if (TREE_CHAIN (arglist
))
8880 error ("%<va_start%> used with too many arguments");
8884 /* Strip off all nops for the sake of the comparison. This
8885 is not quite the same as STRIP_NOPS. It does more.
8886 We must also strip off INDIRECT_EXPR for C++ reference
8888 while (TREE_CODE (arg
) == NOP_EXPR
8889 || TREE_CODE (arg
) == CONVERT_EXPR
8890 || TREE_CODE (arg
) == NON_LVALUE_EXPR
8891 || TREE_CODE (arg
) == INDIRECT_REF
)
8892 arg
= TREE_OPERAND (arg
, 0);
8893 if (arg
!= last_parm
)
8895 /* FIXME: Sometimes with the tree optimizers we can get the
8896 not the last argument even though the user used the last
8897 argument. We just warn and set the arg to be the last
8898 argument so that we will get wrong-code because of
8900 warning ("second parameter of %<va_start%> not last named argument");
8902 /* We want to verify the second parameter just once before the tree
8903 optimizers are run and then avoid keeping it in the tree,
8904 as otherwise we could warn even for correct code like:
8905 void foo (int i, ...)
8906 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
8907 TREE_VALUE (arglist
) = integer_zero_node
;
8908 TREE_CHAIN (arglist
) = build_tree_list (NULL
, integer_zero_node
);
8914 /* Simplify a call to the sprintf builtin.
8916 Return 0 if no simplification was possible, otherwise return the
8917 simplified form of the call as a tree. If IGNORED is true, it means that
8918 the caller does not use the returned value of the function. */
8921 fold_builtin_sprintf (tree arglist
, int ignored
)
8923 tree call
, retval
, dest
, fmt
;
8924 const char *fmt_str
= NULL
;
8926 /* Verify the required arguments in the original call. We deal with two
8927 types of sprintf() calls: 'sprintf (str, fmt)' and
8928 'sprintf (dest, "%s", orig)'. */
8929 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
)
8930 && !validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, POINTER_TYPE
,
8934 /* Get the destination string and the format specifier. */
8935 dest
= TREE_VALUE (arglist
);
8936 fmt
= TREE_VALUE (TREE_CHAIN (arglist
));
8938 /* Check whether the format is a literal string constant. */
8939 fmt_str
= c_getstr (fmt
);
8940 if (fmt_str
== NULL
)
8946 /* If the format doesn't contain % args or %%, use strcpy. */
8947 if (strchr (fmt_str
, '%') == NULL
)
8949 tree fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
8954 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
8955 'format' is known to contain no % formats. */
8956 arglist
= build_tree_list (NULL_TREE
, fmt
);
8957 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
8958 call
= build_function_call_expr (fn
, arglist
);
8960 retval
= build_int_cst (NULL_TREE
, strlen (fmt_str
));
8963 /* If the format is "%s", use strcpy if the result isn't used. */
8964 else if (fmt_str
&& strcmp (fmt_str
, "%s") == 0)
8967 fn
= implicit_built_in_decls
[BUILT_IN_STRCPY
];
8972 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
8973 orig
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
8974 arglist
= build_tree_list (NULL_TREE
, orig
);
8975 arglist
= tree_cons (NULL_TREE
, dest
, arglist
);
8978 retval
= c_strlen (orig
, 1);
8979 if (!retval
|| TREE_CODE (retval
) != INTEGER_CST
)
8982 call
= build_function_call_expr (fn
, arglist
);
8988 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls
[BUILT_IN_SPRINTF
])),
8990 return build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), call
, retval
);